169 files changed, 7556 insertions, 2488 deletions

diff --git a/Documentation/acpi/method-customizing.txt b/Documentation/acpi/method-customizing.txt
index 3e1d25aee3fb..5f55373dd53b 100644
--- a/Documentation/acpi/method-customizing.txt
+++ b/Documentation/acpi/method-customizing.txt
@@ -66,3 +66,8 @@ Note: We can use a kernel with multiple custom ACPI method running,
       But each individual write to debugfs can implement a SINGLE
       method override. i.e. if we want to insert/override multiple
       ACPI methods, we need to redo step c) ~ g) for multiple times.
+
+Note: Be aware that root can mis-use this driver to modify arbitrary
+      memory and gain additional rights, if root's privileges got
+      restricted (for example if root is not allowed to load additional
+      modules after boot).
diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index ff31b1cc50aa..1a9446b59153 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -6,6 +6,42 @@ be removed from this file.
 
 ---------------------------
 
+What:   x86 floppy disable_hlt
+When:   2012
+Why:    ancient workaround of dubious utility clutters the
+        code used by everybody else.
+Who:    Len Brown <len.brown@intel.com>
+
+---------------------------
+
+What:   CONFIG_APM_CPU_IDLE, and its ability to call APM BIOS in idle
+When:   2012
+Why:    This optional sub-feature of APM is of dubious reliability,
+        and ancient APM laptops are likely better served by calling HLT.
+        Deleting CONFIG_APM_CPU_IDLE allows x86 to stop exporting
+        the pm_idle function pointer to modules.
+Who:    Len Brown <len.brown@intel.com>
+
+----------------------------
+
+What:   x86_32 "no-hlt" cmdline param
+When:   2012
+Why:    remove a branch from idle path, simplify code used by everybody.
+        This option disabled the use of HLT in idle and machine_halt()
+        for hardware that was flakey 15-years ago.  Today we have
+        "idle=poll" that removed HLT from idle, and so if such a machine
+        is still running the upstream kernel, "idle=poll" is likely sufficient.
+Who:    Len Brown <len.brown@intel.com>
+
+----------------------------
+
+What:   x86 "idle=mwait" cmdline param
+When:   2012
+Why:    simplify x86 idle code
+Who:    Len Brown <len.brown@intel.com>
+
+----------------------------
+
 What:   PRISM54
 When:   2.6.34
 
diff --git a/Documentation/laptops/acer-wmi.txt b/Documentation/laptops/acer-wmi.txt
deleted file mode 100644
index 4beafa663dd6..000000000000
--- a/Documentation/laptops/acer-wmi.txt
+++ /dev/null
@@ -1,184 +0,0 @@
-Acer Laptop WMI Extras Driver
-http://code.google.com/p/aceracpi
-Version 0.3
-4th April 2009
-
-Copyright 2007-2009 Carlos Corbacho <carlos@strangeworlds.co.uk>
-
-acer-wmi is a driver to allow you to control various parts of your Acer laptop
-hardware under Linux which are exposed via ACPI-WMI.
-
-This driver completely replaces the old out-of-tree acer_acpi, which I am
-currently maintaining for bug fixes only on pre-2.6.25 kernels. All development
-work is now focused solely on acer-wmi.
-
-Disclaimer
-**********
-
-Acer and Wistron have provided nothing towards the development acer_acpi or
-acer-wmi. All information we have has been through the efforts of the developers
-and the users to discover as much as possible about the hardware.
-
-As such, I do warn that this could break your hardware - this is extremely
-unlikely of course, but please bear this in mind.
-
-Background
-**********
-
-acer-wmi is derived from acer_acpi, originally developed by Mark
-Smith in 2005, then taken over by Carlos Corbacho in 2007, in order to activate
-the wireless LAN card under a 64-bit version of Linux, as acerhk[1] (the
-previous solution to the problem) relied on making 32 bit BIOS calls which are
-not possible in kernel space from a 64 bit OS.
-
-[1] acerhk: http://www.cakey.de/acerhk/
-
-Supported Hardware
-******************
-
-NOTE: The Acer Aspire One is not supported hardware. It cannot work with
-acer-wmi until Acer fix their ACPI-WMI implementation on them, so has been
-blacklisted until that happens.
-
-Please see the website for the current list of known working hardware:
-
-http://code.google.com/p/aceracpi/wiki/SupportedHardware
-
-If your laptop is not listed, or listed as unknown, and works with acer-wmi,
-please contact me with a copy of the DSDT.
-
-If your Acer laptop doesn't work with acer-wmi, I would also like to see the
-DSDT.
-
-To send me the DSDT, as root/sudo:
-
-cat /sys/firmware/acpi/tables/DSDT > dsdt
-
-And send me the resulting 'dsdt' file.
-
-Usage
-*****
-
-On Acer laptops, acer-wmi should already be autoloaded based on DMI matching.
-For non-Acer laptops, until WMI based autoloading support is added, you will
-need to manually load acer-wmi.
-
-acer-wmi creates /sys/devices/platform/acer-wmi, and fills it with various
-files whose usage is detailed below, which enables you to control some of the
-following (varies between models):
-
-* the wireless LAN card radio
-* inbuilt Bluetooth adapter
-* inbuilt 3G card
-* mail LED of your laptop
-* brightness of the LCD panel
-
-Wireless
-********
-
-With regards to wireless, all acer-wmi does is enable the radio on the card. It
-is not responsible for the wireless LED - once the radio is enabled, this is
-down to the wireless driver for your card. So the behaviour of the wireless LED,
-once you enable the radio, will depend on your hardware and driver combination.
-
-e.g. With the BCM4318 on the Acer Aspire 5020 series:
-
-ndiswrapper: Light blinks on when transmitting
-b43: Solid light, blinks off when transmitting
-
-Wireless radio control is unconditionally enabled - all Acer laptops that support
-acer-wmi come with built-in wireless. However, should you feel so inclined to
-ever wish to remove the card, or swap it out at some point, please get in touch
-with me, as we may well be able to gain some data on wireless card detection.
-
-The wireless radio is exposed through rfkill.
-
-Bluetooth
-*********
-
-For bluetooth, this is an internal USB dongle, so once enabled, you will get
-a USB device connection event, and a new USB device appears. When you disable
-bluetooth, you get the reverse - a USB device disconnect event, followed by the
-device disappearing again.
-
-Bluetooth is autodetected by acer-wmi, so if you do not have a bluetooth module
-installed in your laptop, this file won't exist (please be aware that it is
-quite common for Acer not to fit bluetooth to their laptops - so just because
-you have a bluetooth button on the laptop, doesn't mean that bluetooth is
-installed).
-
-For the adventurously minded - if you want to buy an internal bluetooth
-module off the internet that is compatible with your laptop and fit it, then
-it will work just fine with acer-wmi.
-
-Bluetooth is exposed through rfkill.
-
-3G
-**
-
-3G is currently not autodetected, so the 'threeg' file is always created under
-sysfs. So far, no-one in possession of an Acer laptop with 3G built-in appears to
-have tried Linux, or reported back, so we don't have any information on this.
-
-If you have an Acer laptop that does have a 3G card in, please contact me so we
-can properly detect these, and find out a bit more about them.
-
-To read the status of the 3G card (0=off, 1=on):
-cat /sys/devices/platform/acer-wmi/threeg
-
-To enable the 3G card:
-echo 1 > /sys/devices/platform/acer-wmi/threeg
-
-To disable the 3G card:
-echo 0 > /sys/devices/platform/acer-wmi/threeg
-
-To set the state of the 3G card when loading acer-wmi, pass:
-threeg=X (where X is 0 or 1)
-
-Mail LED
-********
-
-This can be found in most older Acer laptops supported by acer-wmi, and many
-newer ones - it is built into the 'mail' button, and blinks when active.
-
-On newer (WMID) laptops though, we have no way of detecting the mail LED. If
-your laptop identifies itself in dmesg as a WMID model, then please try loading
-acer_acpi with:
-
-force_series=2490
-
-This will use a known alternative method of reading/ writing the mail LED. If
-it works, please report back to me with the DMI data from your laptop so this
-can be added to acer-wmi.
-
-The LED is exposed through the LED subsystem, and can be found in:
-
-/sys/devices/platform/acer-wmi/leds/acer-wmi::mail/
-
-The mail LED is autodetected, so if you don't have one, the LED device won't
-be registered.
-
-Backlight
-*********
-
-The backlight brightness control is available on all acer-wmi supported
-hardware. The maximum brightness level is usually 15, but on some newer laptops
-it's 10 (this is again autodetected).
-
-The backlight is exposed through the backlight subsystem, and can be found in:
-
-/sys/devices/platform/acer-wmi/backlight/acer-wmi/
-
-Credits
-*******
-
-Olaf Tauber, who did the real hard work when he developed acerhk
-http://www.cakey.de/acerhk/
-All the authors of laptop ACPI modules in the kernel, whose work
-was an inspiration in the early days of acer_acpi
-Mathieu Segaud, who solved the problem with having to modprobe the driver
-twice in acer_acpi 0.2.
-Jim Ramsay, who added support for the WMID interface
-Mark Smith, who started the original acer_acpi
-
-And the many people who have used both acer_acpi and acer-wmi.
diff --git a/MAINTAINERS b/MAINTAINERS
index 2e94220898d7..29801f760b6f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -223,10 +223,8 @@ S:	Maintained
 F:      drivers/platform/x86/acerhdf.c
 
 ACER WMI LAPTOP EXTRAS
-M:      Carlos Corbacho <carlos@strangeworlds.co.uk>
-L:      aceracpi@googlegroups.com (subscribers-only)
+M:      Joey Lee <jlee@novell.com>
 L:      platform-driver-x86@vger.kernel.org
-W:      http://code.google.com/p/aceracpi
 S:      Maintained
 F:      drivers/platform/x86/acer-wmi.c
 
@@ -271,10 +269,8 @@ S:	Supported
 F:      drivers/acpi/video.c
 
 ACPI WMI DRIVER
-M:      Carlos Corbacho <carlos@strangeworlds.co.uk>
 L:      platform-driver-x86@vger.kernel.org
-W:      http://www.lesswatts.org/projects/acpi/
-S:      Maintained
+S:      Orphan
 F:      drivers/platform/x86/wmi.c
 
 AD1889 ALSA SOUND DRIVER
@@ -3033,9 +3029,8 @@ S:	Maintained
 F:      drivers/net/wireless/hostap/
 
 HP COMPAQ TC1100 TABLET WMI EXTRAS DRIVER
-M:      Carlos Corbacho <carlos@strangeworlds.co.uk>
 L:      platform-driver-x86@vger.kernel.org
-S:      Odd Fixes
+S:      Orphan
 F:      drivers/platform/x86/tc1100-wmi.c
 
 HP100:  Driver for HP 10/100 Mbit/s Voice Grade Network Adapter Series
diff --git a/arch/s390/include/asm/pgtable.h b/arch/s390/include/asm/pgtable.h
index c4773a2ef3d3..e4efacfe1b63 100644
--- a/arch/s390/include/asm/pgtable.h
+++ b/arch/s390/include/asm/pgtable.h
@@ -577,16 +577,16 @@ static inline void pgste_set_unlock(pte_t *ptep, pgste_t pgste)
 static inline pgste_t pgste_update_all(pte_t *ptep, pgste_t pgste)
 {
 #ifdef CONFIG_PGSTE
-        unsigned long pfn, bits;
+        unsigned long address, bits;
         unsigned char skey;
 
-        pfn = pte_val(*ptep) >> PAGE_SHIFT;
-        skey = page_get_storage_key(pfn);
+        address = pte_val(*ptep) & PAGE_MASK;
+        skey = page_get_storage_key(address);
         bits = skey & (_PAGE_CHANGED | _PAGE_REFERENCED);
         /* Clear page changed & referenced bit in the storage key */
         if (bits) {
                 skey ^= bits;
-                page_set_storage_key(pfn, skey, 1);
+                page_set_storage_key(address, skey, 1);
         }
         /* Transfer page changed & referenced bit to guest bits in pgste */
         pgste_val(pgste) |= bits << 48;         /* RCP_GR_BIT & RCP_GC_BIT */
@@ -628,16 +628,16 @@ static inline pgste_t pgste_update_young(pte_t *ptep, pgste_t pgste)
 static inline void pgste_set_pte(pte_t *ptep, pgste_t pgste)
 {
 #ifdef CONFIG_PGSTE
-        unsigned long pfn;
+        unsigned long address;
         unsigned long okey, nkey;
 
-        pfn = pte_val(*ptep) >> PAGE_SHIFT;
-        okey = nkey = page_get_storage_key(pfn);
+        address = pte_val(*ptep) & PAGE_MASK;
+        okey = nkey = page_get_storage_key(address);
         nkey &= ~(_PAGE_ACC_BITS | _PAGE_FP_BIT);
         /* Set page access key and fetch protection bit from pgste */
         nkey |= (pgste_val(pgste) & (RCP_ACC_BITS | RCP_FP_BIT)) >> 56;
         if (okey != nkey)
-                page_set_storage_key(pfn, nkey, 1);
+                page_set_storage_key(address, nkey, 1);
 #endif
 }
 
diff --git a/arch/s390/mm/pgtable.c b/arch/s390/mm/pgtable.c
index 14c6fae6fe6b..b09763fe5da1 100644
--- a/arch/s390/mm/pgtable.c
+++ b/arch/s390/mm/pgtable.c
@@ -71,12 +71,15 @@ static void rcu_table_freelist_callback(struct rcu_head *head)
 
 void rcu_table_freelist_finish(void)
 {
-        struct rcu_table_freelist *batch = __get_cpu_var(rcu_table_freelist);
+        struct rcu_table_freelist **batchp = &get_cpu_var(rcu_table_freelist);
+        struct rcu_table_freelist *batch = *batchp;
 
         if (!batch)
-                return;
+                goto out;
         call_rcu(&batch->rcu, rcu_table_freelist_callback);
-        __get_cpu_var(rcu_table_freelist) = NULL;
+        *batchp = NULL;
+out:
+        put_cpu_var(rcu_table_freelist);
 }
 
 static void smp_sync(void *arg)
@@ -141,20 +144,23 @@ void crst_table_free_rcu(struct mm_struct *mm, unsigned long *table)
 {
         struct rcu_table_freelist *batch;
 
+        preempt_disable();
         if (atomic_read(&mm->mm_users) < 2 &&
             cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id()))) {
                 crst_table_free(mm, table);
-                return;
+                goto out;
         }
         batch = rcu_table_freelist_get(mm);
         if (!batch) {
                 smp_call_function(smp_sync, NULL, 1);
                 crst_table_free(mm, table);
-                return;
+                goto out;
         }
         batch->table[--batch->crst_index] = table;
         if (batch->pgt_index >= batch->crst_index)
                 rcu_table_freelist_finish();
+out:
+        preempt_enable();
 }
 
 #ifdef CONFIG_64BIT
@@ -323,16 +329,17 @@ void page_table_free_rcu(struct mm_struct *mm, unsigned long *table)
         struct page *page;
         unsigned long bits;
 
+        preempt_disable();
         if (atomic_read(&mm->mm_users) < 2 &&
             cpumask_equal(mm_cpumask(mm), cpumask_of(smp_processor_id()))) {
                 page_table_free(mm, table);
-                return;
+                goto out;
         }
         batch = rcu_table_freelist_get(mm);
         if (!batch) {
                 smp_call_function(smp_sync, NULL, 1);
                 page_table_free(mm, table);
-                return;
+                goto out;
         }
         bits = (mm->context.has_pgste) ? 3UL : 1UL;
         bits <<= (__pa(table) & (PAGE_SIZE - 1)) / 256 / sizeof(unsigned long);
@@ -345,6 +352,8 @@ void page_table_free_rcu(struct mm_struct *mm, unsigned long *table)
         batch->table[batch->pgt_index++] = table;
         if (batch->pgt_index >= batch->crst_index)
                 rcu_table_freelist_finish();
+out:
+        preempt_enable();
 }
 
 /*
diff --git a/arch/tile/Kconfig b/arch/tile/Kconfig
index e1e50101b3bb..0249b8b4db54 100644
--- a/arch/tile/Kconfig
+++ b/arch/tile/Kconfig
@@ -11,6 +11,7 @@ config TILE
         select GENERIC_IRQ_PROBE
         select GENERIC_PENDING_IRQ if SMP
         select GENERIC_IRQ_SHOW
+        select SYS_HYPERVISOR
 
 # FIXME: investigate whether we need/want these options.
 #       select HAVE_IOREMAP_PROT
diff --git a/arch/tile/include/asm/hardwall.h b/arch/tile/include/asm/hardwall.h
index 0bed3ec7b42c..2ac422848c7d 100644
--- a/arch/tile/include/asm/hardwall.h
+++ b/arch/tile/include/asm/hardwall.h
@@ -40,6 +40,10 @@
 #define HARDWALL_DEACTIVATE \
  _IO(HARDWALL_IOCTL_BASE, _HARDWALL_DEACTIVATE)
 
+#define _HARDWALL_GET_ID 4
+#define HARDWALL_GET_ID \
+ _IO(HARDWALL_IOCTL_BASE, _HARDWALL_GET_ID)
+
 #ifndef __KERNEL__
 
 /* This is the canonical name expected by userspace. */
@@ -47,9 +51,14 @@
 
 #else
 
-/* Hook for /proc/tile/hardwall. */
-struct seq_file;
-int proc_tile_hardwall_show(struct seq_file *sf, void *v);
+/* /proc hooks for hardwall. */
+struct proc_dir_entry;
+#ifdef CONFIG_HARDWALL
+void proc_tile_hardwall_init(struct proc_dir_entry *root);
+int proc_pid_hardwall(struct task_struct *task, char *buffer);
+#else
+static inline void proc_tile_hardwall_init(struct proc_dir_entry *root) {}
+#endif
 
 #endif
 
diff --git a/arch/tile/kernel/Makefile b/arch/tile/kernel/Makefile
index b4c8e8ec45dc..b4dbc057baad 100644
--- a/arch/tile/kernel/Makefile
+++ b/arch/tile/kernel/Makefile
@@ -5,7 +5,7 @@
 extra-y := vmlinux.lds head_$(BITS).o
 obj-y := backtrace.o entry.o init_task.o irq.o messaging.o \
         pci-dma.o proc.o process.o ptrace.o reboot.o \
-        setup.o signal.o single_step.o stack.o sys.o time.o traps.o \
+        setup.o signal.o single_step.o stack.o sys.o sysfs.o time.o traps.o \
         intvec_$(BITS).o regs_$(BITS).o tile-desc_$(BITS).o
 
 obj-$(CONFIG_HARDWALL)          += hardwall.o
diff --git a/arch/tile/kernel/hardwall.c b/arch/tile/kernel/hardwall.c
index 3bddef710de4..8c41891aab34 100644
--- a/arch/tile/kernel/hardwall.c
+++ b/arch/tile/kernel/hardwall.c
@@ -40,16 +40,25 @@
 struct hardwall_info {
         struct list_head list;             /* "rectangles" list */
         struct list_head task_head;        /* head of tasks in this hardwall */
+        struct cpumask cpumask;            /* cpus in the rectangle */
         int ulhc_x;                        /* upper left hand corner x coord */
         int ulhc_y;                        /* upper left hand corner y coord */
         int width;                         /* rectangle width */
         int height;                        /* rectangle height */
+        int id;                            /* integer id for this hardwall */
         int teardown_in_progress;          /* are we tearing this one down? */
 };
 
 /* Currently allocated hardwall rectangles */
 static LIST_HEAD(rectangles);
 
+/* /proc/tile/hardwall */
+static struct proc_dir_entry *hardwall_proc_dir;
+
+/* Functions to manage files in /proc/tile/hardwall. */
+static void hardwall_add_proc(struct hardwall_info *rect);
+static void hardwall_remove_proc(struct hardwall_info *rect);
+
 /*
  * Guard changes to the hardwall data structures.
  * This could be finer grained (e.g. one lock for the list of hardwall
@@ -105,6 +114,8 @@ static int setup_rectangle(struct hardwall_info *r, struct cpumask *mask)
         r->ulhc_y = cpu_y(ulhc);
         r->width = cpu_x(lrhc) - r->ulhc_x + 1;
         r->height = cpu_y(lrhc) - r->ulhc_y + 1;
+        cpumask_copy(&r->cpumask, mask);
+        r->id = ulhc;   /* The ulhc cpu id can be the hardwall id. */
 
         /* Width and height must be positive */
         if (r->width <= 0 || r->height <= 0)
@@ -388,6 +399,9 @@ static struct hardwall_info *hardwall_create(
         /* Set up appropriate hardwalling on all affected cpus. */
         hardwall_setup(rect);
 
+        /* Create a /proc/tile/hardwall entry. */
+        hardwall_add_proc(rect);
+
         return rect;
 }
 
@@ -645,6 +659,9 @@ static void hardwall_destroy(struct hardwall_info *rect)
         /* Restart switch and disable firewall. */
         on_each_cpu_mask(&mask, restart_udn_switch, NULL, 1);
 
+        /* Remove the /proc/tile/hardwall entry. */
+        hardwall_remove_proc(rect);
+
         /* Now free the rectangle from the list. */
         spin_lock_irqsave(&hardwall_lock, flags);
         BUG_ON(!list_empty(&rect->task_head));
@@ -654,35 +671,57 @@ static void hardwall_destroy(struct hardwall_info *rect)
 }
 
 
-/*
- * Dump hardwall state via /proc; initialized in arch/tile/sys/proc.c.
- */
-int proc_tile_hardwall_show(struct seq_file *sf, void *v)
+static int hardwall_proc_show(struct seq_file *sf, void *v)
 {
-        struct hardwall_info *r;
+        struct hardwall_info *rect = sf->private;
+        char buf[256];
 
-        if (udn_disabled) {
-                seq_printf(sf, "%dx%d 0,0 pids:\n", smp_width, smp_height);
-                return 0;
-        }
-
-        spin_lock_irq(&hardwall_lock);
-        list_for_each_entry(r, &rectangles, list) {
-                struct task_struct *p;
-                seq_printf(sf, "%dx%d %d,%d pids:",
-                           r->width, r->height, r->ulhc_x, r->ulhc_y);
-                list_for_each_entry(p, &r->task_head, thread.hardwall_list) {
-                        unsigned int cpu = cpumask_first(&p->cpus_allowed);
-                        unsigned int x = cpu % smp_width;
-                        unsigned int y = cpu / smp_width;
-                        seq_printf(sf, " %d@%d,%d", p->pid, x, y);
-                }
-                seq_printf(sf, "\n");
-        }
-        spin_unlock_irq(&hardwall_lock);
+        int rc = cpulist_scnprintf(buf, sizeof(buf), &rect->cpumask);
+        buf[rc++] = '\n';
+        seq_write(sf, buf, rc);
         return 0;
 }
 
+static int hardwall_proc_open(struct inode *inode,
+                              struct file *file)
+{
+        return single_open(file, hardwall_proc_show, PDE(inode)->data);
+}
+
+static const struct file_operations hardwall_proc_fops = {
+        .open           = hardwall_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static void hardwall_add_proc(struct hardwall_info *rect)
+{
+        char buf[64];
+        snprintf(buf, sizeof(buf), "%d", rect->id);
+        proc_create_data(buf, 0444, hardwall_proc_dir,
+                         &hardwall_proc_fops, rect);
+}
+
+static void hardwall_remove_proc(struct hardwall_info *rect)
+{
+        char buf[64];
+        snprintf(buf, sizeof(buf), "%d", rect->id);
+        remove_proc_entry(buf, hardwall_proc_dir);
+}
+
+int proc_pid_hardwall(struct task_struct *task, char *buffer)
+{
+        struct hardwall_info *rect = task->thread.hardwall;
+        return rect ? sprintf(buffer, "%d\n", rect->id) : 0;
+}
+
+void proc_tile_hardwall_init(struct proc_dir_entry *root)
+{
+        if (!udn_disabled)
+                hardwall_proc_dir = proc_mkdir("hardwall", root);
+}
+
 
 /*
  * Character device support via ioctl/close.
@@ -716,6 +755,9 @@ static long hardwall_ioctl(struct file *file, unsigned int a, unsigned long b)
                         return -EINVAL;
                 return hardwall_deactivate(current);
 
+        case _HARDWALL_GET_ID:
+                return rect ? rect->id : -EINVAL;
+
         default:
                 return -EINVAL;
         }
diff --git a/arch/tile/kernel/proc.c b/arch/tile/kernel/proc.c
index 2e02c41ddf3b..62d820833c68 100644
--- a/arch/tile/kernel/proc.c
+++ b/arch/tile/kernel/proc.c
@@ -27,6 +27,7 @@
 #include <asm/processor.h>
 #include <asm/sections.h>
 #include <asm/homecache.h>
+#include <asm/hardwall.h>
 #include <arch/chip.h>
 
 
@@ -88,3 +89,75 @@ const struct seq_operations cpuinfo_op = {
         .stop   = c_stop,
         .show   = show_cpuinfo,
 };
+
+/*
+ * Support /proc/tile directory
+ */
+
+static int __init proc_tile_init(void)
+{
+        struct proc_dir_entry *root = proc_mkdir("tile", NULL);
+        if (root == NULL)
+                return 0;
+
+        proc_tile_hardwall_init(root);
+
+        return 0;
+}
+
+arch_initcall(proc_tile_init);
+
+/*
+ * Support /proc/sys/tile directory
+ */
+
+#ifndef __tilegx__  /* FIXME: GX: no support for unaligned access yet */
+static ctl_table unaligned_subtable[] = {
+        {
+                .procname       = "enabled",
+                .data           = &unaligned_fixup,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .procname       = "printk",
+                .data           = &unaligned_printk,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {
+                .procname       = "count",
+                .data           = &unaligned_fixup_count,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec
+        },
+        {}
+};
+
+static ctl_table unaligned_table[] = {
+        {
+                .procname       = "unaligned_fixup",
+                .mode           = 0555,
+                .child          = unaligned_subtable
+        },
+        {}
+};
+#endif
+
+static struct ctl_path tile_path[] = {
+        { .procname = "tile" },
+        { }
+};
+
+static int __init proc_sys_tile_init(void)
+{
+#ifndef __tilegx__  /* FIXME: GX: no support for unaligned access yet */
+        register_sysctl_paths(tile_path, unaligned_table);
+#endif
+        return 0;
+}
+
+arch_initcall(proc_sys_tile_init);
diff --git a/arch/tile/kernel/sysfs.c b/arch/tile/kernel/sysfs.c
new file mode 100644
index 000000000000..b671a86f4515
--- /dev/null
+++ b/arch/tile/kernel/sysfs.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2011 Tilera Corporation. All Rights Reserved.
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation, version 2.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ *   NON INFRINGEMENT.  See the GNU General Public License for
+ *   more details.
+ *
+ * /sys entry support.
+ */
+
+#include <linux/sysdev.h>
+#include <linux/cpu.h>
+#include <linux/slab.h>
+#include <linux/smp.h>
+#include <hv/hypervisor.h>
+
+/* Return a string queried from the hypervisor, truncated to page size. */
+static ssize_t get_hv_confstr(char *page, int query)
+{
+        ssize_t n = hv_confstr(query, (unsigned long)page, PAGE_SIZE - 1);
+        n = n < 0 ? 0 : min(n, (ssize_t)PAGE_SIZE - 1) - 1;
+        if (n)
+                page[n++] = '\n';
+        page[n] = '\0';
+        return n;
+}
+
+static ssize_t chip_width_show(struct sysdev_class *dev,
+                               struct sysdev_class_attribute *attr,
+                               char *page)
+{
+        return sprintf(page, "%u\n", smp_width);
+}
+static SYSDEV_CLASS_ATTR(chip_width, 0444, chip_width_show, NULL);
+
+static ssize_t chip_height_show(struct sysdev_class *dev,
+                                struct sysdev_class_attribute *attr,
+                                char *page)
+{
+        return sprintf(page, "%u\n", smp_height);
+}
+static SYSDEV_CLASS_ATTR(chip_height, 0444, chip_height_show, NULL);
+
+static ssize_t chip_serial_show(struct sysdev_class *dev,
+                                struct sysdev_class_attribute *attr,
+                                char *page)
+{
+        return get_hv_confstr(page, HV_CONFSTR_CHIP_SERIAL_NUM);
+}
+static SYSDEV_CLASS_ATTR(chip_serial, 0444, chip_serial_show, NULL);
+
+static ssize_t chip_revision_show(struct sysdev_class *dev,
+                                  struct sysdev_class_attribute *attr,
+                                  char *page)
+{
+        return get_hv_confstr(page, HV_CONFSTR_CHIP_REV);
+}
+static SYSDEV_CLASS_ATTR(chip_revision, 0444, chip_revision_show, NULL);
+
+
+static ssize_t type_show(struct sysdev_class *dev,
+                            struct sysdev_class_attribute *attr,
+                            char *page)
+{
+        return sprintf(page, "tilera\n");
+}
+static SYSDEV_CLASS_ATTR(type, 0444, type_show, NULL);
+
+#define HV_CONF_ATTR(name, conf)                                        \
+        static ssize_t name ## _show(struct sysdev_class *dev,          \
+                                     struct sysdev_class_attribute *attr, \
+                                     char *page)                        \
+        {                                                               \
+                return get_hv_confstr(page, conf);                      \
+        }                                                               \
+        static SYSDEV_CLASS_ATTR(name, 0444, name ## _show, NULL);
+
+HV_CONF_ATTR(version,           HV_CONFSTR_HV_SW_VER)
+HV_CONF_ATTR(config_version,    HV_CONFSTR_HV_CONFIG_VER)
+
+HV_CONF_ATTR(board_part,        HV_CONFSTR_BOARD_PART_NUM)
+HV_CONF_ATTR(board_serial,      HV_CONFSTR_BOARD_SERIAL_NUM)
+HV_CONF_ATTR(board_revision,    HV_CONFSTR_BOARD_REV)
+HV_CONF_ATTR(board_description, HV_CONFSTR_BOARD_DESC)
+HV_CONF_ATTR(mezz_part,         HV_CONFSTR_MEZZ_PART_NUM)
+HV_CONF_ATTR(mezz_serial,       HV_CONFSTR_MEZZ_SERIAL_NUM)
+HV_CONF_ATTR(mezz_revision,     HV_CONFSTR_MEZZ_REV)
+HV_CONF_ATTR(mezz_description,  HV_CONFSTR_MEZZ_DESC)
+HV_CONF_ATTR(switch_control,    HV_CONFSTR_SWITCH_CONTROL)
+
+static struct attribute *board_attrs[] = {
+        &attr_board_part.attr,
+        &attr_board_serial.attr,
+        &attr_board_revision.attr,
+        &attr_board_description.attr,
+        &attr_mezz_part.attr,
+        &attr_mezz_serial.attr,
+        &attr_mezz_revision.attr,
+        &attr_mezz_description.attr,
+        &attr_switch_control.attr,
+        NULL
+};
+
+static struct attribute_group board_attr_group = {
+        .name   = "board",
+        .attrs  = board_attrs,
+};
+
+
+static struct bin_attribute hvconfig_bin;
+
+static ssize_t
+hvconfig_bin_read(struct file *filp, struct kobject *kobj,
+                  struct bin_attribute *bin_attr,
+                  char *buf, loff_t off, size_t count)
+{
+        static size_t size;
+
+        /* Lazily learn the true size (minus the trailing NUL). */
+        if (size == 0)
+                size = hv_confstr(HV_CONFSTR_HV_CONFIG, 0, 0) - 1;
+
+        /* Check and adjust input parameters. */
+        if (off > size)
+                return -EINVAL;
+        if (count > size - off)
+                count = size - off;
+
+        if (count) {
+                /* Get a copy of the hvc and copy out the relevant portion. */
+                char *hvc;
+
+                size = off + count;
+                hvc = kmalloc(size, GFP_KERNEL);
+                if (hvc == NULL)
+                        return -ENOMEM;
+                hv_confstr(HV_CONFSTR_HV_CONFIG, (unsigned long)hvc, size);
+                memcpy(buf, hvc + off, count);
+                kfree(hvc);
+        }
+
+        return count;
+}
+
+static int __init create_sysfs_entries(void)
+{
+        struct sysdev_class *cls = &cpu_sysdev_class;
+        int err = 0;
+
+#define create_cpu_attr(name)                                           \
+        if (!err)                                                       \
+                err = sysfs_create_file(&cls->kset.kobj, &attr_##name.attr);
+        create_cpu_attr(chip_width);
+        create_cpu_attr(chip_height);
+        create_cpu_attr(chip_serial);
+        create_cpu_attr(chip_revision);
+
+#define create_hv_attr(name)                                            \
+        if (!err)                                                       \
+                err = sysfs_create_file(hypervisor_kobj, &attr_##name.attr);
+        create_hv_attr(type);
+        create_hv_attr(version);
+        create_hv_attr(config_version);
+
+        if (!err)
+                err = sysfs_create_group(hypervisor_kobj, &board_attr_group);
+
+        if (!err) {
+                sysfs_bin_attr_init(&hvconfig_bin);
+                hvconfig_bin.attr.name = "hvconfig";
+                hvconfig_bin.attr.mode = S_IRUGO;
+                hvconfig_bin.read = hvconfig_bin_read;
+                hvconfig_bin.size = PAGE_SIZE;
+                err = sysfs_create_bin_file(hypervisor_kobj, &hvconfig_bin);
+        }
+
+        return err;
+}
+subsys_initcall(create_sysfs_entries);
diff --git a/arch/x86/include/asm/acpi.h b/arch/x86/include/asm/acpi.h
index 416d865eae39..610001d385dd 100644
--- a/arch/x86/include/asm/acpi.h
+++ b/arch/x86/include/asm/acpi.h
@@ -139,7 +139,7 @@ static inline unsigned int acpi_processor_cstate_check(unsigned int max_cstate)
             boot_cpu_data.x86_model <= 0x05 &&
             boot_cpu_data.x86_mask < 0x0A)
                 return 1;
-        else if (c1e_detected)
+        else if (amd_e400_c1e_detected)
                 return 1;
         else
                 return max_cstate;
diff --git a/arch/x86/include/asm/idle.h b/arch/x86/include/asm/idle.h
index 38d87379e270..f49253d75710 100644
--- a/arch/x86/include/asm/idle.h
+++ b/arch/x86/include/asm/idle.h
@@ -16,6 +16,6 @@ static inline void enter_idle(void) { }
 static inline void exit_idle(void) { }
 #endif /* CONFIG_X86_64 */
 
-void c1e_remove_cpu(int cpu);
+void amd_e400_remove_cpu(int cpu);
 
 #endif /* _ASM_X86_IDLE_H */
diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h
index 4c25ab48257b..219371546afd 100644
--- a/arch/x86/include/asm/processor.h
+++ b/arch/x86/include/asm/processor.h
@@ -754,10 +754,10 @@ static inline void __sti_mwait(unsigned long eax, unsigned long ecx)
 extern void mwait_idle_with_hints(unsigned long eax, unsigned long ecx);
 
 extern void select_idle_routine(const struct cpuinfo_x86 *c);
-extern void init_c1e_mask(void);
+extern void init_amd_e400_c1e_mask(void);
 
 extern unsigned long            boot_option_idle_override;
-extern bool                     c1e_detected;
+extern bool                     amd_e400_c1e_detected;
 
 enum idle_boot_override {IDLE_NO_OVERRIDE=0, IDLE_HALT, IDLE_NOMWAIT,
                          IDLE_POLL, IDLE_FORCE_MWAIT};
diff --git a/arch/x86/kernel/apm_32.c b/arch/x86/kernel/apm_32.c
index 3bfa02235965..965a7666c283 100644
--- a/arch/x86/kernel/apm_32.c
+++ b/arch/x86/kernel/apm_32.c
@@ -361,6 +361,7 @@ struct apm_user {
  * idle percentage above which bios idle calls are done
  */
 #ifdef CONFIG_APM_CPU_IDLE
+#warning deprecated CONFIG_APM_CPU_IDLE will be deleted in 2012
 #define DEFAULT_IDLE_THRESHOLD  95
 #else
 #define DEFAULT_IDLE_THRESHOLD  100
@@ -904,6 +905,7 @@ static void apm_cpu_idle(void)
         unsigned int jiffies_since_last_check = jiffies - last_jiffies;
         unsigned int bucket;
 
+        WARN_ONCE(1, "deprecated apm_cpu_idle will be deleted in 2012");
 recalc:
         if (jiffies_since_last_check > IDLE_CALC_LIMIT) {
                 use_apm_idle = 0;
diff --git a/arch/x86/kernel/cpu/bugs.c b/arch/x86/kernel/cpu/bugs.c
index c39576cb3018..525514cf33c3 100644
--- a/arch/x86/kernel/cpu/bugs.c
+++ b/arch/x86/kernel/cpu/bugs.c
@@ -19,6 +19,7 @@
 
 static int __init no_halt(char *s)
 {
+        WARN_ONCE(1, "\"no-hlt\" is deprecated, please use \"idle=poll\"\n");
         boot_cpu_data.hlt_works_ok = 0;
         return 1;
 }
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
index 53f02f5d8cce..22a073d7fbff 100644
--- a/arch/x86/kernel/cpu/common.c
+++ b/arch/x86/kernel/cpu/common.c
@@ -902,7 +902,7 @@ static void vgetcpu_set_mode(void)
 void __init identify_boot_cpu(void)
 {
         identify_cpu(&boot_cpu_data);
-        init_c1e_mask();
+        init_amd_e400_c1e_mask();
 #ifdef CONFIG_X86_32
         sysenter_setup();
         enable_sep_cpu();
diff --git a/arch/x86/kernel/process.c b/arch/x86/kernel/process.c
index 88a90a977f8e..426a5b66f7e4 100644
--- a/arch/x86/kernel/process.c
+++ b/arch/x86/kernel/process.c
@@ -337,7 +337,9 @@ EXPORT_SYMBOL(boot_option_idle_override);
  * Powermanagement idle function, if any..
  */
 void (*pm_idle)(void);
+#if defined(CONFIG_APM_MODULE) && defined(CONFIG_APM_CPU_IDLE)
 EXPORT_SYMBOL(pm_idle);
+#endif
 
 #ifdef CONFIG_X86_32
 /*
@@ -397,7 +399,7 @@ void default_idle(void)
                 cpu_relax();
         }
 }
-#ifdef CONFIG_APM_MODULE
+#if defined(CONFIG_APM_MODULE) && defined(CONFIG_APM_CPU_IDLE)
 EXPORT_SYMBOL(default_idle);
 #endif
 
@@ -535,45 +537,45 @@ int mwait_usable(const struct cpuinfo_x86 *c)
         return (edx & MWAIT_EDX_C1);
 }
 
-bool c1e_detected;
-EXPORT_SYMBOL(c1e_detected);
+bool amd_e400_c1e_detected;
+EXPORT_SYMBOL(amd_e400_c1e_detected);
 
-static cpumask_var_t c1e_mask;
+static cpumask_var_t amd_e400_c1e_mask;
 
-void c1e_remove_cpu(int cpu)
+void amd_e400_remove_cpu(int cpu)
 {
-        if (c1e_mask != NULL)
-                cpumask_clear_cpu(cpu, c1e_mask);
+        if (amd_e400_c1e_mask != NULL)
+                cpumask_clear_cpu(cpu, amd_e400_c1e_mask);
 }
 
 /*
- * C1E aware idle routine. We check for C1E active in the interrupt
+ * AMD Erratum 400 aware idle routine. We check for C1E active in the interrupt
  * pending message MSR. If we detect C1E, then we handle it the same
  * way as C3 power states (local apic timer and TSC stop)
  */
-static void c1e_idle(void)
+static void amd_e400_idle(void)
 {
         if (need_resched())
                 return;
 
-        if (!c1e_detected) {
+        if (!amd_e400_c1e_detected) {
                 u32 lo, hi;
 
                 rdmsr(MSR_K8_INT_PENDING_MSG, lo, hi);
 
                 if (lo & K8_INTP_C1E_ACTIVE_MASK) {
-                        c1e_detected = true;
+                        amd_e400_c1e_detected = true;
                         if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
                                 mark_tsc_unstable("TSC halt in AMD C1E");
                         printk(KERN_INFO "System has AMD C1E enabled\n");
                 }
         }
 
-        if (c1e_detected) {
+        if (amd_e400_c1e_detected) {
                 int cpu = smp_processor_id();
 
-                if (!cpumask_test_cpu(cpu, c1e_mask)) {
-                        cpumask_set_cpu(cpu, c1e_mask);
+                if (!cpumask_test_cpu(cpu, amd_e400_c1e_mask)) {
+                        cpumask_set_cpu(cpu, amd_e400_c1e_mask);
                         /*
                          * Force broadcast so ACPI can not interfere.
                          */
@@ -616,17 +618,17 @@ void __cpuinit select_idle_routine(const struct cpuinfo_x86 *c)
                 pm_idle = mwait_idle;
         } else if (cpu_has_amd_erratum(amd_erratum_400)) {
                 /* E400: APIC timer interrupt does not wake up CPU from C1e */
-                printk(KERN_INFO "using C1E aware idle routine\n");
-                pm_idle = c1e_idle;
+                printk(KERN_INFO "using AMD E400 aware idle routine\n");
+                pm_idle = amd_e400_idle;
         } else
                 pm_idle = default_idle;
 }
 
-void __init init_c1e_mask(void)
+void __init init_amd_e400_c1e_mask(void)
 {
-        /* If we're using c1e_idle, we need to allocate c1e_mask. */
-        if (pm_idle == c1e_idle)
-                zalloc_cpumask_var(&c1e_mask, GFP_KERNEL);
+        /* If we're using amd_e400_idle, we need to allocate amd_e400_c1e_mask. */
+        if (pm_idle == amd_e400_idle)
+                zalloc_cpumask_var(&amd_e400_c1e_mask, GFP_KERNEL);
 }
 
 static int __init idle_setup(char *str)
@@ -640,6 +642,7 @@ static int __init idle_setup(char *str)
                 boot_option_idle_override = IDLE_POLL;
         } else if (!strcmp(str, "mwait")) {
                 boot_option_idle_override = IDLE_FORCE_MWAIT;
+                WARN_ONCE(1, "\idle=mwait\" will be removed in 2012\"\n");
         } else if (!strcmp(str, "halt")) {
                 /*
                  * When the boot option of idle=halt is added, halt is
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index a3c430bdfb60..eefd96765e79 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -1307,7 +1307,7 @@ void play_dead_common(void)
 {
         idle_task_exit();
         reset_lazy_tlbstate();
-        c1e_remove_cpu(raw_smp_processor_id());
+        amd_e400_remove_cpu(raw_smp_processor_id());
 
         mb();
         /* Ack it */
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index bc2218db5ba9..de0e3df76776 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -369,6 +369,21 @@ config ACPI_HED
           which is used to report some hardware errors notified via
           SCI, mainly the corrected errors.
 
+config ACPI_CUSTOM_METHOD
+        tristate "Allow ACPI methods to be inserted/replaced at run time"
+        depends on DEBUG_FS
+        default n
+        help
+          This debug facility allows ACPI AML methods to me inserted and/or
+          replaced without rebooting the system. For details refer to:
+          Documentation/acpi/method-customizing.txt.
+
+          NOTE: This option is security sensitive, because it allows arbitrary
+          kernel memory to be written to by root (uid=0) users, allowing them
+          to bypass certain security measures (e.g. if root is not allowed to
+          load additional kernel modules after boot, this feature may be used
+          to override that restriction).
+
 source "drivers/acpi/apei/Kconfig"
 
 endif   # ACPI
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index b66fbb2fc85f..ecb26b4f29a0 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -61,6 +61,7 @@ obj-$(CONFIG_ACPI_SBS)		+= sbshc.o
 obj-$(CONFIG_ACPI_SBS)          += sbs.o
 obj-$(CONFIG_ACPI_HED)          += hed.o
 obj-$(CONFIG_ACPI_EC_DEBUGFS)   += ec_sys.o
+obj-$(CONFIG_ACPI_CUSTOM_METHOD)+= custom_method.o
 
 # processor has its own "processor." module_param namespace
 processor-y                     := processor_driver.o processor_throttling.o
diff --git a/drivers/acpi/acpica/Makefile b/drivers/acpi/acpica/Makefile
index a1224712fd0c..301bd2d388ad 100644
--- a/drivers/acpi/acpica/Makefile
+++ b/drivers/acpi/acpica/Makefile
@@ -14,7 +14,7 @@ acpi-y := dsfield.o   dsmthdat.o  dsopcode.o  dswexec.o  dswscope.o \
 
 acpi-y += evevent.o  evregion.o  evsci.o    evxfevnt.o \
          evmisc.o   evrgnini.o  evxface.o  evxfregn.o \
-         evgpe.o    evgpeblk.o evgpeinit.o  evgpeutil.o evxfgpe.o
+         evgpe.o    evgpeblk.o evgpeinit.o  evgpeutil.o evxfgpe.o evglock.o
 
 acpi-y += exconfig.o  exfield.o  exnames.o   exoparg6.o  exresolv.o  exstorob.o\
          exconvrt.o  exfldio.o  exoparg1.o  exprep.o    exresop.o   exsystem.o\
diff --git a/drivers/acpi/acpica/acconfig.h b/drivers/acpi/acpica/acconfig.h
index ab87396c2c07..bc533dde16c4 100644
--- a/drivers/acpi/acpica/acconfig.h
+++ b/drivers/acpi/acpica/acconfig.h
@@ -187,7 +187,6 @@
 
 /* Operation regions */
 
-#define ACPI_NUM_PREDEFINED_REGIONS     9
 #define ACPI_USER_REGION_BEGIN          0x80
 
 /* Maximum space_ids for Operation Regions */
diff --git a/drivers/acpi/acpica/acevents.h b/drivers/acpi/acpica/acevents.h
index 41d247daf461..bea3b4899183 100644
--- a/drivers/acpi/acpica/acevents.h
+++ b/drivers/acpi/acpica/acevents.h
@@ -58,12 +58,6 @@ u32 acpi_ev_fixed_event_detect(void);
  */
 u8 acpi_ev_is_notify_object(struct acpi_namespace_node *node);
 
-acpi_status acpi_ev_acquire_global_lock(u16 timeout);
-
-acpi_status acpi_ev_release_global_lock(void);
-
-acpi_status acpi_ev_init_global_lock_handler(void);
-
 u32 acpi_ev_get_gpe_number_index(u32 gpe_number);
 
 acpi_status
@@ -71,6 +65,17 @@ acpi_ev_queue_notify_request(struct acpi_namespace_node *node,
                              u32 notify_value);
 
 /*
+ * evglock - Global Lock support
+ */
+acpi_status acpi_ev_init_global_lock_handler(void);
+
+acpi_status acpi_ev_acquire_global_lock(u16 timeout);
+
+acpi_status acpi_ev_release_global_lock(void);
+
+acpi_status acpi_ev_remove_global_lock_handler(void);
+
+/*
  * evgpe - Low-level GPE support
  */
 u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info *gpe_xrupt_list);
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index d69750b83b36..73863d86f022 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -214,24 +214,23 @@ ACPI_EXTERN struct acpi_mutex_info acpi_gbl_mutex_info[ACPI_NUM_MUTEX];
 
 /*
  * Global lock mutex is an actual AML mutex object
- * Global lock semaphore works in conjunction with the HW global lock
+ * Global lock semaphore works in conjunction with the actual global lock
+ * Global lock spinlock is used for "pending" handshake
  */
 ACPI_EXTERN union acpi_operand_object *acpi_gbl_global_lock_mutex;
 ACPI_EXTERN acpi_semaphore acpi_gbl_global_lock_semaphore;
+ACPI_EXTERN acpi_spinlock acpi_gbl_global_lock_pending_lock;
 ACPI_EXTERN u16 acpi_gbl_global_lock_handle;
 ACPI_EXTERN u8 acpi_gbl_global_lock_acquired;
 ACPI_EXTERN u8 acpi_gbl_global_lock_present;
+ACPI_EXTERN u8 acpi_gbl_global_lock_pending;
 
 /*
  * Spinlocks are used for interfaces that can be possibly called at
  * interrupt level
  */
-ACPI_EXTERN spinlock_t _acpi_gbl_gpe_lock;      /* For GPE data structs and registers */
-ACPI_EXTERN spinlock_t _acpi_gbl_hardware_lock; /* For ACPI H/W except GPE registers */
-ACPI_EXTERN spinlock_t _acpi_ev_global_lock_pending_lock; /* For global lock */
-#define acpi_gbl_gpe_lock       &_acpi_gbl_gpe_lock
-#define acpi_gbl_hardware_lock  &_acpi_gbl_hardware_lock
-#define acpi_ev_global_lock_pending_lock &_acpi_ev_global_lock_pending_lock
+ACPI_EXTERN acpi_spinlock acpi_gbl_gpe_lock;    /* For GPE data structs and registers */
+ACPI_EXTERN acpi_spinlock acpi_gbl_hardware_lock;       /* For ACPI H/W except GPE registers */
 
 /*****************************************************************************
  *
diff --git a/drivers/acpi/acpica/amlcode.h b/drivers/acpi/acpica/amlcode.h
index f4f0998d3967..1077f17859ed 100644
--- a/drivers/acpi/acpica/amlcode.h
+++ b/drivers/acpi/acpica/amlcode.h
@@ -394,21 +394,6 @@
 #define AML_CLASS_METHOD_CALL       0x09
 #define AML_CLASS_UNKNOWN           0x0A
 
-/* Predefined Operation Region space_iDs */
-
-typedef enum {
-        REGION_MEMORY = 0,
-        REGION_IO,
-        REGION_PCI_CONFIG,
-        REGION_EC,
-        REGION_SMBUS,
-        REGION_CMOS,
-        REGION_PCI_BAR,
-        REGION_IPMI,
-        REGION_DATA_TABLE,      /* Internal use only */
-        REGION_FIXED_HW = 0x7F
-} AML_REGION_TYPES;
-
 /* Comparison operation codes for match_op operator */
 
 typedef enum {
diff --git a/drivers/acpi/acpica/dswload.c b/drivers/acpi/acpica/dswload.c
index 23a3b1ab20c1..324acec1179a 100644
--- a/drivers/acpi/acpica/dswload.c
+++ b/drivers/acpi/acpica/dswload.c
@@ -450,7 +450,7 @@ acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
                         status =
                             acpi_ex_create_region(op->named.data,
                                                   op->named.length,
-                                                  REGION_DATA_TABLE,
+                                                  ACPI_ADR_SPACE_DATA_TABLE,
                                                   walk_state);
                         if (ACPI_FAILURE(status)) {
                                 return_ACPI_STATUS(status);
diff --git a/drivers/acpi/acpica/dswload2.c b/drivers/acpi/acpica/dswload2.c
index 4be4e921dfe1..976318138c56 100644
--- a/drivers/acpi/acpica/dswload2.c
+++ b/drivers/acpi/acpica/dswload2.c
@@ -562,7 +562,7 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
                                     ((op->common.value.arg)->common.value.
                                      integer);
                         } else {
-                                region_space = REGION_DATA_TABLE;
+                                region_space = ACPI_ADR_SPACE_DATA_TABLE;
                         }
 
                         /*
diff --git a/drivers/acpi/acpica/evglock.c b/drivers/acpi/acpica/evglock.c
new file mode 100644
index 000000000000..56a562a1e5d7
--- /dev/null
+++ b/drivers/acpi/acpica/evglock.c
@@ -0,0 +1,335 @@
+/******************************************************************************
+ *
+ * Module Name: evglock - Global Lock support
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2011, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <acpi/acpi.h>
+#include "accommon.h"
+#include "acevents.h"
+#include "acinterp.h"
+
+#define _COMPONENT          ACPI_EVENTS
+ACPI_MODULE_NAME("evglock")
+
+/* Local prototypes */
+static u32 acpi_ev_global_lock_handler(void *context);
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_init_global_lock_handler
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Install a handler for the global lock release event
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ev_init_global_lock_handler(void)
+{
+        acpi_status status;
+
+        ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
+
+        /* Attempt installation of the global lock handler */
+
+        status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
+                                                  acpi_ev_global_lock_handler,
+                                                  NULL);
+
+        /*
+         * If the global lock does not exist on this platform, the attempt to
+         * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick).
+         * Map to AE_OK, but mark global lock as not present. Any attempt to
+         * actually use the global lock will be flagged with an error.
+         */
+        acpi_gbl_global_lock_present = FALSE;
+        if (status == AE_NO_HARDWARE_RESPONSE) {
+                ACPI_ERROR((AE_INFO,
+                            "No response from Global Lock hardware, disabling lock"));
+
+                return_ACPI_STATUS(AE_OK);
+        }
+
+        status = acpi_os_create_lock(&acpi_gbl_global_lock_pending_lock);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        acpi_gbl_global_lock_pending = FALSE;
+        acpi_gbl_global_lock_present = TRUE;
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_remove_global_lock_handler
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Remove the handler for the Global Lock
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ev_remove_global_lock_handler(void)
+{
+        acpi_status status;
+
+        ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler);
+
+        acpi_gbl_global_lock_present = FALSE;
+        status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL,
+                                                 acpi_ev_global_lock_handler);
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_global_lock_handler
+ *
+ * PARAMETERS:  Context         - From thread interface, not used
+ *
+ * RETURN:      ACPI_INTERRUPT_HANDLED
+ *
+ * DESCRIPTION: Invoked directly from the SCI handler when a global lock
+ *              release interrupt occurs. If there is actually a pending
+ *              request for the lock, signal the waiting thread.
+ *
+ ******************************************************************************/
+
+static u32 acpi_ev_global_lock_handler(void *context)
+{
+        acpi_status status;
+        acpi_cpu_flags flags;
+
+        flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
+
+        /*
+         * If a request for the global lock is not actually pending,
+         * we are done. This handles "spurious" global lock interrupts
+         * which are possible (and have been seen) with bad BIOSs.
+         */
+        if (!acpi_gbl_global_lock_pending) {
+                goto cleanup_and_exit;
+        }
+
+        /*
+         * Send a unit to the global lock semaphore. The actual acquisition
+         * of the global lock will be performed by the waiting thread.
+         */
+        status = acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore, 1);
+        if (ACPI_FAILURE(status)) {
+                ACPI_ERROR((AE_INFO, "Could not signal Global Lock semaphore"));
+        }
+
+        acpi_gbl_global_lock_pending = FALSE;
+
+      cleanup_and_exit:
+
+        acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
+        return (ACPI_INTERRUPT_HANDLED);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_acquire_global_lock
+ *
+ * PARAMETERS:  Timeout         - Max time to wait for the lock, in millisec.
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Attempt to gain ownership of the Global Lock.
+ *
+ * MUTEX:       Interpreter must be locked
+ *
+ * Note: The original implementation allowed multiple threads to "acquire" the
+ * Global Lock, and the OS would hold the lock until the last thread had
+ * released it. However, this could potentially starve the BIOS out of the
+ * lock, especially in the case where there is a tight handshake between the
+ * Embedded Controller driver and the BIOS. Therefore, this implementation
+ * allows only one thread to acquire the HW Global Lock at a time, and makes
+ * the global lock appear as a standard mutex on the OS side.
+ *
+ *****************************************************************************/
+
+acpi_status acpi_ev_acquire_global_lock(u16 timeout)
+{
+        acpi_cpu_flags flags;
+        acpi_status status;
+        u8 acquired = FALSE;
+
+        ACPI_FUNCTION_TRACE(ev_acquire_global_lock);
+
+        /*
+         * Only one thread can acquire the GL at a time, the global_lock_mutex
+         * enforces this. This interface releases the interpreter if we must wait.
+         */
+        status =
+            acpi_ex_system_wait_mutex(acpi_gbl_global_lock_mutex->mutex.
+                                      os_mutex, timeout);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        /*
+         * Update the global lock handle and check for wraparound. The handle is
+         * only used for the external global lock interfaces, but it is updated
+         * here to properly handle the case where a single thread may acquire the
+         * lock via both the AML and the acpi_acquire_global_lock interfaces. The
+         * handle is therefore updated on the first acquire from a given thread
+         * regardless of where the acquisition request originated.
+         */
+        acpi_gbl_global_lock_handle++;
+        if (acpi_gbl_global_lock_handle == 0) {
+                acpi_gbl_global_lock_handle = 1;
+        }
+
+        /*
+         * Make sure that a global lock actually exists. If not, just
+         * treat the lock as a standard mutex.
+         */
+        if (!acpi_gbl_global_lock_present) {
+                acpi_gbl_global_lock_acquired = TRUE;
+                return_ACPI_STATUS(AE_OK);
+        }
+
+        flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
+
+        do {
+
+                /* Attempt to acquire the actual hardware lock */
+
+                ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
+                if (acquired) {
+                        acpi_gbl_global_lock_acquired = TRUE;
+                        ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                          "Acquired hardware Global Lock\n"));
+                        break;
+                }
+
+                /*
+                 * Did not get the lock. The pending bit was set above, and
+                 * we must now wait until we receive the global lock
+                 * released interrupt.
+                 */
+                acpi_gbl_global_lock_pending = TRUE;
+                acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
+
+                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                  "Waiting for hardware Global Lock\n"));
+
+                /*
+                 * Wait for handshake with the global lock interrupt handler.
+                 * This interface releases the interpreter if we must wait.
+                 */
+                status =
+                    acpi_ex_system_wait_semaphore
+                    (acpi_gbl_global_lock_semaphore, ACPI_WAIT_FOREVER);
+
+                flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
+
+        } while (ACPI_SUCCESS(status));
+
+        acpi_gbl_global_lock_pending = FALSE;
+        acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_release_global_lock
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Releases ownership of the Global Lock.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ev_release_global_lock(void)
+{
+        u8 pending = FALSE;
+        acpi_status status = AE_OK;
+
+        ACPI_FUNCTION_TRACE(ev_release_global_lock);
+
+        /* Lock must be already acquired */
+
+        if (!acpi_gbl_global_lock_acquired) {
+                ACPI_WARNING((AE_INFO,
+                              "Cannot release the ACPI Global Lock, it has not been acquired"));
+                return_ACPI_STATUS(AE_NOT_ACQUIRED);
+        }
+
+        if (acpi_gbl_global_lock_present) {
+
+                /* Allow any thread to release the lock */
+
+                ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending);
+
+                /*
+                 * If the pending bit was set, we must write GBL_RLS to the control
+                 * register
+                 */
+                if (pending) {
+                        status =
+                            acpi_write_bit_register
+                            (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
+                             ACPI_ENABLE_EVENT);
+                }
+
+                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                  "Released hardware Global Lock\n"));
+        }
+
+        acpi_gbl_global_lock_acquired = FALSE;
+
+        /* Release the local GL mutex */
+
+        acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex);
+        return_ACPI_STATUS(status);
+}
diff --git a/drivers/acpi/acpica/evmisc.c b/drivers/acpi/acpica/evmisc.c
index 7dc80946f7bd..d0b331844427 100644
--- a/drivers/acpi/acpica/evmisc.c
+++ b/drivers/acpi/acpica/evmisc.c
@@ -45,7 +45,6 @@
 #include "accommon.h"
 #include "acevents.h"
 #include "acnamesp.h"
-#include "acinterp.h"
 
 #define _COMPONENT          ACPI_EVENTS
 ACPI_MODULE_NAME("evmisc")
@@ -53,10 +52,6 @@ ACPI_MODULE_NAME("evmisc")
 /* Local prototypes */
 static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context);
 
-static u32 acpi_ev_global_lock_handler(void *context);
-
-static acpi_status acpi_ev_remove_global_lock_handler(void);
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_is_notify_object
@@ -275,304 +270,6 @@ static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context)
         acpi_ut_delete_generic_state(notify_info);
 }
 
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ev_global_lock_handler
- *
- * PARAMETERS:  Context         - From thread interface, not used
- *
- * RETURN:      ACPI_INTERRUPT_HANDLED
- *
- * DESCRIPTION: Invoked directly from the SCI handler when a global lock
- *              release interrupt occurs.  If there's a thread waiting for
- *              the global lock, signal it.
- *
- * NOTE: Assumes that the semaphore can be signaled from interrupt level. If
- * this is not possible for some reason, a separate thread will have to be
- * scheduled to do this.
- *
- ******************************************************************************/
-static u8 acpi_ev_global_lock_pending;
-
-static u32 acpi_ev_global_lock_handler(void *context)
-{
-        acpi_status status;
-        acpi_cpu_flags flags;
-
-        flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);
-
-        if (!acpi_ev_global_lock_pending) {
-                goto out;
-        }
-
-        /* Send a unit to the semaphore */
-
-        status = acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore, 1);
-        if (ACPI_FAILURE(status)) {
-                ACPI_ERROR((AE_INFO, "Could not signal Global Lock semaphore"));
-        }
-
-        acpi_ev_global_lock_pending = FALSE;
-
- out:
-        acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);
-
-        return (ACPI_INTERRUPT_HANDLED);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ev_init_global_lock_handler
- *
- * PARAMETERS:  None
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Install a handler for the global lock release event
- *
- ******************************************************************************/
-
-acpi_status acpi_ev_init_global_lock_handler(void)
-{
-        acpi_status status;
-
-        ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
-
-        /* Attempt installation of the global lock handler */
-
-        status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
-                                                  acpi_ev_global_lock_handler,
-                                                  NULL);
-
-        /*
-         * If the global lock does not exist on this platform, the attempt to
-         * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick).
-         * Map to AE_OK, but mark global lock as not present. Any attempt to
-         * actually use the global lock will be flagged with an error.
-         */
-        if (status == AE_NO_HARDWARE_RESPONSE) {
-                ACPI_ERROR((AE_INFO,
-                            "No response from Global Lock hardware, disabling lock"));
-
-                acpi_gbl_global_lock_present = FALSE;
-                return_ACPI_STATUS(AE_OK);
-        }
-
-        acpi_gbl_global_lock_present = TRUE;
-        return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ev_remove_global_lock_handler
- *
- * PARAMETERS:  None
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Remove the handler for the Global Lock
- *
- ******************************************************************************/
-
-static acpi_status acpi_ev_remove_global_lock_handler(void)
-{
-        acpi_status status;
-
-        ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler);
-
-        acpi_gbl_global_lock_present = FALSE;
-        status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL,
-                                                 acpi_ev_global_lock_handler);
-
-        return_ACPI_STATUS(status);
-}
-
-/******************************************************************************
- *
- * FUNCTION:    acpi_ev_acquire_global_lock
- *
- * PARAMETERS:  Timeout         - Max time to wait for the lock, in millisec.
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Attempt to gain ownership of the Global Lock.
- *
- * MUTEX:       Interpreter must be locked
- *
- * Note: The original implementation allowed multiple threads to "acquire" the
- * Global Lock, and the OS would hold the lock until the last thread had
- * released it. However, this could potentially starve the BIOS out of the
- * lock, especially in the case where there is a tight handshake between the
- * Embedded Controller driver and the BIOS. Therefore, this implementation
- * allows only one thread to acquire the HW Global Lock at a time, and makes
- * the global lock appear as a standard mutex on the OS side.
- *
- *****************************************************************************/
-static acpi_thread_id acpi_ev_global_lock_thread_id;
-static int acpi_ev_global_lock_acquired;
-
-acpi_status acpi_ev_acquire_global_lock(u16 timeout)
-{
-        acpi_cpu_flags flags;
-        acpi_status status = AE_OK;
-        u8 acquired = FALSE;
-
-        ACPI_FUNCTION_TRACE(ev_acquire_global_lock);
-
-        /*
-         * Only one thread can acquire the GL at a time, the global_lock_mutex
-         * enforces this. This interface releases the interpreter if we must wait.
-         */
-        status = acpi_ex_system_wait_mutex(
-                        acpi_gbl_global_lock_mutex->mutex.os_mutex, 0);
-        if (status == AE_TIME) {
-                if (acpi_ev_global_lock_thread_id == acpi_os_get_thread_id()) {
-                        acpi_ev_global_lock_acquired++;
-                        return AE_OK;
-                }
-        }
-
-        if (ACPI_FAILURE(status)) {
-                status = acpi_ex_system_wait_mutex(
-                                acpi_gbl_global_lock_mutex->mutex.os_mutex,
-                                timeout);
-        }
-        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
-        }
-
-        acpi_ev_global_lock_thread_id = acpi_os_get_thread_id();
-        acpi_ev_global_lock_acquired++;
-
-        /*
-         * Update the global lock handle and check for wraparound. The handle is
-         * only used for the external global lock interfaces, but it is updated
-         * here to properly handle the case where a single thread may acquire the
-         * lock via both the AML and the acpi_acquire_global_lock interfaces. The
-         * handle is therefore updated on the first acquire from a given thread
-         * regardless of where the acquisition request originated.
-         */
-        acpi_gbl_global_lock_handle++;
-        if (acpi_gbl_global_lock_handle == 0) {
-                acpi_gbl_global_lock_handle = 1;
-        }
-
-        /*
-         * Make sure that a global lock actually exists. If not, just treat the
-         * lock as a standard mutex.
-         */
-        if (!acpi_gbl_global_lock_present) {
-                acpi_gbl_global_lock_acquired = TRUE;
-                return_ACPI_STATUS(AE_OK);
-        }
-
-        flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);
-
-        do {
-
-                /* Attempt to acquire the actual hardware lock */
-
-                ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
-                if (acquired) {
-                        acpi_gbl_global_lock_acquired = TRUE;
-
-                        ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                          "Acquired hardware Global Lock\n"));
-                        break;
-                }
-
-                acpi_ev_global_lock_pending = TRUE;
-
-                acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);
-
-                /*
-                 * Did not get the lock. The pending bit was set above, and we
-                 * must wait until we get the global lock released interrupt.
-                 */
-                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                  "Waiting for hardware Global Lock\n"));
-
-                /*
-                 * Wait for handshake with the global lock interrupt handler.
-                 * This interface releases the interpreter if we must wait.
-                 */
-                status = acpi_ex_system_wait_semaphore(
-                                                acpi_gbl_global_lock_semaphore,
-                                                ACPI_WAIT_FOREVER);
-
-                flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);
-
-        } while (ACPI_SUCCESS(status));
-
-        acpi_ev_global_lock_pending = FALSE;
-
-        acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);
-
-        return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ev_release_global_lock
- *
- * PARAMETERS:  None
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Releases ownership of the Global Lock.
- *
- ******************************************************************************/
-
-acpi_status acpi_ev_release_global_lock(void)
-{
-        u8 pending = FALSE;
-        acpi_status status = AE_OK;
-
-        ACPI_FUNCTION_TRACE(ev_release_global_lock);
-
-        /* Lock must be already acquired */
-
-        if (!acpi_gbl_global_lock_acquired) {
-                ACPI_WARNING((AE_INFO,
-                              "Cannot release the ACPI Global Lock, it has not been acquired"));
-                return_ACPI_STATUS(AE_NOT_ACQUIRED);
-        }
-
-        acpi_ev_global_lock_acquired--;
-        if (acpi_ev_global_lock_acquired > 0) {
-                return AE_OK;
-        }
-
-        if (acpi_gbl_global_lock_present) {
-
-                /* Allow any thread to release the lock */
-
-                ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending);
-
-                /*
-                 * If the pending bit was set, we must write GBL_RLS to the control
-                 * register
-                 */
-                if (pending) {
-                        status =
-                            acpi_write_bit_register
-                            (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
-                             ACPI_ENABLE_EVENT);
-                }
-
-                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                  "Released hardware Global Lock\n"));
-        }
-
-        acpi_gbl_global_lock_acquired = FALSE;
-
-        /* Release the local GL mutex */
-        acpi_ev_global_lock_thread_id = 0;
-        acpi_ev_global_lock_acquired = 0;
-        acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex);
-        return_ACPI_STATUS(status);
-}
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_ev_terminate
diff --git a/drivers/acpi/acpica/evregion.c b/drivers/acpi/acpica/evregion.c
index bea7223d7a71..f0edf5c43c03 100644
--- a/drivers/acpi/acpica/evregion.c
+++ b/drivers/acpi/acpica/evregion.c
@@ -55,6 +55,8 @@ static u8
 acpi_ev_has_default_handler(struct acpi_namespace_node *node,
                             acpi_adr_space_type space_id);
 
+static void acpi_ev_orphan_ec_reg_method(void);
+
 static acpi_status
 acpi_ev_reg_run(acpi_handle obj_handle,
                 u32 level, void *context, void **return_value);
@@ -561,7 +563,9 @@ acpi_ev_detach_region(union acpi_operand_object *region_obj,
 
                         /* Now stop region accesses by executing the _REG method */
 
-                        status = acpi_ev_execute_reg_method(region_obj, 0);
+                        status =
+                            acpi_ev_execute_reg_method(region_obj,
+                                                       ACPI_REG_DISCONNECT);
                         if (ACPI_FAILURE(status)) {
                                 ACPI_EXCEPTION((AE_INFO, status,
                                                 "from region _REG, [%s]",
@@ -1062,6 +1066,12 @@ acpi_ev_execute_reg_methods(struct acpi_namespace_node *node,
                                         ACPI_NS_WALK_UNLOCK, acpi_ev_reg_run,
                                         NULL, &space_id, NULL);
 
+        /* Special case for EC: handle "orphan" _REG methods with no region */
+
+        if (space_id == ACPI_ADR_SPACE_EC) {
+                acpi_ev_orphan_ec_reg_method();
+        }
+
         return_ACPI_STATUS(status);
 }
 
@@ -1120,6 +1130,113 @@ acpi_ev_reg_run(acpi_handle obj_handle,
                 return (AE_OK);
         }
 
-        status = acpi_ev_execute_reg_method(obj_desc, 1);
+        status = acpi_ev_execute_reg_method(obj_desc, ACPI_REG_CONNECT);
         return (status);
 }
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_orphan_ec_reg_method
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Execute an "orphan" _REG method that appears under the EC
+ *              device. This is a _REG method that has no corresponding region
+ *              within the EC device scope. The orphan _REG method appears to
+ *              have been enabled by the description of the ECDT in the ACPI
+ *              specification: "The availability of the region space can be
+ *              detected by providing a _REG method object underneath the
+ *              Embedded Controller device."
+ *
+ *              To quickly access the EC device, we use the EC_ID that appears
+ *              within the ECDT. Otherwise, we would need to perform a time-
+ *              consuming namespace walk, executing _HID methods to find the
+ *              EC device.
+ *
+ ******************************************************************************/
+
+static void acpi_ev_orphan_ec_reg_method(void)
+{
+        struct acpi_table_ecdt *table;
+        acpi_status status;
+        struct acpi_object_list args;
+        union acpi_object objects[2];
+        struct acpi_namespace_node *ec_device_node;
+        struct acpi_namespace_node *reg_method;
+        struct acpi_namespace_node *next_node;
+
+        ACPI_FUNCTION_TRACE(ev_orphan_ec_reg_method);
+
+        /* Get the ECDT (if present in system) */
+
+        status = acpi_get_table(ACPI_SIG_ECDT, 0,
+                                ACPI_CAST_INDIRECT_PTR(struct acpi_table_header,
+                                                       &table));
+        if (ACPI_FAILURE(status)) {
+                return_VOID;
+        }
+
+        /* We need a valid EC_ID string */
+
+        if (!(*table->id)) {
+                return_VOID;
+        }
+
+        /* Namespace is currently locked, must release */
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+
+        /* Get a handle to the EC device referenced in the ECDT */
+
+        status = acpi_get_handle(NULL,
+                                 ACPI_CAST_PTR(char, table->id),
+                                 ACPI_CAST_PTR(acpi_handle, &ec_device_node));
+        if (ACPI_FAILURE(status)) {
+                goto exit;
+        }
+
+        /* Get a handle to a _REG method immediately under the EC device */
+
+        status = acpi_get_handle(ec_device_node,
+                                 METHOD_NAME__REG, ACPI_CAST_PTR(acpi_handle,
+                                                                 &reg_method));
+        if (ACPI_FAILURE(status)) {
+                goto exit;
+        }
+
+        /*
+         * Execute the _REG method only if there is no Operation Region in
+         * this scope with the Embedded Controller space ID. Otherwise, it
+         * will already have been executed. Note, this allows for Regions
+         * with other space IDs to be present; but the code below will then
+         * execute the _REG method with the EC space ID argument.
+         */
+        next_node = acpi_ns_get_next_node(ec_device_node, NULL);
+        while (next_node) {
+                if ((next_node->type == ACPI_TYPE_REGION) &&
+                    (next_node->object) &&
+                    (next_node->object->region.space_id == ACPI_ADR_SPACE_EC)) {
+                        goto exit;      /* Do not execute _REG */
+                }
+                next_node = acpi_ns_get_next_node(ec_device_node, next_node);
+        }
+
+        /* Evaluate the _REG(EC,Connect) method */
+
+        args.count = 2;
+        args.pointer = objects;
+        objects[0].type = ACPI_TYPE_INTEGER;
+        objects[0].integer.value = ACPI_ADR_SPACE_EC;
+        objects[1].type = ACPI_TYPE_INTEGER;
+        objects[1].integer.value = ACPI_REG_CONNECT;
+
+        status = acpi_evaluate_object(reg_method, NULL, &args, NULL);
+
+      exit:
+        /* We ignore all errors from above, don't care */
+
+        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+        return_VOID;
+}
diff --git a/drivers/acpi/acpica/evrgnini.c b/drivers/acpi/acpica/evrgnini.c
index 9659cee6093e..55a5d35ef34a 100644
--- a/drivers/acpi/acpica/evrgnini.c
+++ b/drivers/acpi/acpica/evrgnini.c
@@ -637,7 +637,7 @@ acpi_ev_initialize_region(union acpi_operand_object *region_obj,
 
                                         status =
                                             acpi_ev_execute_reg_method
-                                            (region_obj, 1);
+                                            (region_obj, ACPI_REG_CONNECT);
 
                                         if (acpi_ns_locked) {
                                                 status =
diff --git a/drivers/acpi/acpica/evxfregn.c b/drivers/acpi/acpica/evxfregn.c
index c85c8c45599d..00cd95692a91 100644
--- a/drivers/acpi/acpica/evxfregn.c
+++ b/drivers/acpi/acpica/evxfregn.c
@@ -130,20 +130,21 @@ acpi_install_address_space_handler(acpi_handle device,
         case ACPI_ADR_SPACE_PCI_CONFIG:
         case ACPI_ADR_SPACE_DATA_TABLE:
 
-                if (acpi_gbl_reg_methods_executed) {
+                if (!acpi_gbl_reg_methods_executed) {
 
-                        /* Run all _REG methods for this address space */
-
-                        status = acpi_ev_execute_reg_methods(node, space_id);
+                        /* We will defer execution of the _REG methods for this space */
+                        goto unlock_and_exit;
                 }
                 break;
 
         default:
-
-                status = acpi_ev_execute_reg_methods(node, space_id);
                 break;
         }
 
+        /* Run all _REG methods for this address space */
+
+        status = acpi_ev_execute_reg_methods(node, space_id);
+
       unlock_and_exit:
         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
         return_ACPI_STATUS(status);
diff --git a/drivers/acpi/acpica/excreate.c b/drivers/acpi/acpica/excreate.c
index e7b372d17667..110711afada8 100644
--- a/drivers/acpi/acpica/excreate.c
+++ b/drivers/acpi/acpica/excreate.c
@@ -305,7 +305,8 @@ acpi_ex_create_region(u8 * aml_start,
          * range
          */
         if ((region_space >= ACPI_NUM_PREDEFINED_REGIONS) &&
-            (region_space < ACPI_USER_REGION_BEGIN)) {
+            (region_space < ACPI_USER_REGION_BEGIN) &&
+            (region_space != ACPI_ADR_SPACE_DATA_TABLE)) {
                 ACPI_ERROR((AE_INFO, "Invalid AddressSpace type 0x%X",
                             region_space));
                 return_ACPI_STATUS(AE_AML_INVALID_SPACE_ID);
diff --git a/drivers/acpi/acpica/nsrepair.c b/drivers/acpi/acpica/nsrepair.c
index 1d76ac85b5e7..ac7b854b0bd7 100644
--- a/drivers/acpi/acpica/nsrepair.c
+++ b/drivers/acpi/acpica/nsrepair.c
@@ -74,7 +74,6 @@ ACPI_MODULE_NAME("nsrepair")
  *
  * Additional possible repairs:
  *
- * Optional/unnecessary NULL package elements removed
  * Required package elements that are NULL replaced by Integer/String/Buffer
  * Incorrect standalone package wrapped with required outer package
  *
@@ -623,16 +622,12 @@ acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
         ACPI_FUNCTION_NAME(ns_remove_null_elements);
 
         /*
-         * PTYPE1 packages contain no subpackages.
-         * PTYPE2 packages contain a variable number of sub-packages. We can
-         * safely remove all NULL elements from the PTYPE2 packages.
+         * We can safely remove all NULL elements from these package types:
+         * PTYPE1_VAR packages contain a variable number of simple data types.
+         * PTYPE2 packages contain a variable number of sub-packages.
          */
         switch (package_type) {
-        case ACPI_PTYPE1_FIXED:
         case ACPI_PTYPE1_VAR:
-        case ACPI_PTYPE1_OPTION:
-                return;
-
         case ACPI_PTYPE2:
         case ACPI_PTYPE2_COUNT:
         case ACPI_PTYPE2_PKG_COUNT:
@@ -642,6 +637,8 @@ acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
                 break;
 
         default:
+        case ACPI_PTYPE1_FIXED:
+        case ACPI_PTYPE1_OPTION:
                 return;
         }
 
diff --git a/drivers/acpi/acpica/utdecode.c b/drivers/acpi/acpica/utdecode.c
index 136a814cec69..97cb36f85ce9 100644
--- a/drivers/acpi/acpica/utdecode.c
+++ b/drivers/acpi/acpica/utdecode.c
@@ -170,8 +170,7 @@ const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
         "SMBus",
         "SystemCMOS",
         "PCIBARTarget",
-        "IPMI",
-        "DataTable"
+        "IPMI"
 };
 
 char *acpi_ut_get_region_name(u8 space_id)
@@ -179,6 +178,8 @@ char *acpi_ut_get_region_name(u8 space_id)
 
         if (space_id >= ACPI_USER_REGION_BEGIN) {
                 return ("UserDefinedRegion");
+        } else if (space_id == ACPI_ADR_SPACE_DATA_TABLE) {
+                return ("DataTable");
         } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
                 return ("FunctionalFixedHW");
         } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
diff --git a/drivers/acpi/acpica/utmutex.c b/drivers/acpi/acpica/utmutex.c
index a946c689f03b..7d797e2baecd 100644
--- a/drivers/acpi/acpica/utmutex.c
+++ b/drivers/acpi/acpica/utmutex.c
@@ -83,9 +83,15 @@ acpi_status acpi_ut_mutex_initialize(void)
 
         /* Create the spinlocks for use at interrupt level */
 
-        spin_lock_init(acpi_gbl_gpe_lock);
-        spin_lock_init(acpi_gbl_hardware_lock);
-        spin_lock_init(acpi_ev_global_lock_pending_lock);
+        status = acpi_os_create_lock (&acpi_gbl_gpe_lock);
+        if (ACPI_FAILURE (status)) {
+                return_ACPI_STATUS (status);
+        }
+
+        status = acpi_os_create_lock (&acpi_gbl_hardware_lock);
+        if (ACPI_FAILURE (status)) {
+                return_ACPI_STATUS (status);
+        }
 
         /* Mutex for _OSI support */
         status = acpi_os_create_mutex(&acpi_gbl_osi_mutex);
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index 9749980ca6ca..d1e06c182cdb 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -227,7 +227,7 @@ static int __acpi_bus_set_power(struct acpi_device *device, int state)
         acpi_status status = AE_OK;
         char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
 
-        if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
+        if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
                 return -EINVAL;
 
         /* Make sure this is a valid target state */
diff --git a/drivers/acpi/custom_method.c b/drivers/acpi/custom_method.c
new file mode 100644
index 000000000000..5d42c2414ae5
--- /dev/null
+++ b/drivers/acpi/custom_method.c
@@ -0,0 +1,100 @@
+/*
+ * debugfs.c - ACPI debugfs interface to userspace.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <acpi/acpi_drivers.h>
+
+#include "internal.h"
+
+#define _COMPONENT              ACPI_SYSTEM_COMPONENT
+ACPI_MODULE_NAME("custom_method");
+MODULE_LICENSE("GPL");
+
+static struct dentry *cm_dentry;
+
+/* /sys/kernel/debug/acpi/custom_method */
+
+static ssize_t cm_write(struct file *file, const char __user * user_buf,
+                        size_t count, loff_t *ppos)
+{
+        static char *buf;
+        static u32 max_size;
+        static u32 uncopied_bytes;
+
+        struct acpi_table_header table;
+        acpi_status status;
+
+        if (!(*ppos)) {
+                /* parse the table header to get the table length */
+                if (count <= sizeof(struct acpi_table_header))
+                        return -EINVAL;
+                if (copy_from_user(&table, user_buf,
+                                   sizeof(struct acpi_table_header)))
+                        return -EFAULT;
+                uncopied_bytes = max_size = table.length;
+                buf = kzalloc(max_size, GFP_KERNEL);
+                if (!buf)
+                        return -ENOMEM;
+        }
+
+        if (buf == NULL)
+                return -EINVAL;
+
+        if ((*ppos > max_size) ||
+            (*ppos + count > max_size) ||
+            (*ppos + count < count) ||
+            (count > uncopied_bytes))
+                return -EINVAL;
+
+        if (copy_from_user(buf + (*ppos), user_buf, count)) {
+                kfree(buf);
+                buf = NULL;
+                return -EFAULT;
+        }
+
+        uncopied_bytes -= count;
+        *ppos += count;
+
+        if (!uncopied_bytes) {
+                status = acpi_install_method(buf);
+                kfree(buf);
+                buf = NULL;
+                if (ACPI_FAILURE(status))
+                        return -EINVAL;
+                add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
+        }
+
+        return count;
+}
+
+static const struct file_operations cm_fops = {
+        .write = cm_write,
+        .llseek = default_llseek,
+};
+
+static int __init acpi_custom_method_init(void)
+{
+        if (acpi_debugfs_dir == NULL)
+                return -ENOENT;
+
+        cm_dentry = debugfs_create_file("custom_method", S_IWUSR,
+                                        acpi_debugfs_dir, NULL, &cm_fops);
+        if (cm_dentry == NULL)
+                return -ENODEV;
+
+        return 0;
+}
+
+static void __exit acpi_custom_method_exit(void)
+{
+        if (cm_dentry)
+                debugfs_remove(cm_dentry);
+ }
+
+module_init(acpi_custom_method_init);
+module_exit(acpi_custom_method_exit);
diff --git a/drivers/acpi/debugfs.c b/drivers/acpi/debugfs.c
index 384f7abcff77..182a9fc36355 100644
--- a/drivers/acpi/debugfs.c
+++ b/drivers/acpi/debugfs.c
@@ -3,100 +3,16 @@
  */
 
 #include <linux/init.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/uaccess.h>
 #include <linux/debugfs.h>
 #include <acpi/acpi_drivers.h>
 
 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
 ACPI_MODULE_NAME("debugfs");
 
+struct dentry *acpi_debugfs_dir;
+EXPORT_SYMBOL_GPL(acpi_debugfs_dir);
 
-/* /sys/modules/acpi/parameters/aml_debug_output */
-
-module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object,
-                   bool, 0644);
-MODULE_PARM_DESC(aml_debug_output,
-                 "To enable/disable the ACPI Debug Object output.");
-
-/* /sys/kernel/debug/acpi/custom_method */
-
-static ssize_t cm_write(struct file *file, const char __user * user_buf,
-                        size_t count, loff_t *ppos)
+void __init acpi_debugfs_init(void)
 {
-        static char *buf;
-        static u32 max_size;
-        static u32 uncopied_bytes;
-
-        struct acpi_table_header table;
-        acpi_status status;
-
-        if (!(*ppos)) {
-                /* parse the table header to get the table length */
-                if (count <= sizeof(struct acpi_table_header))
-                        return -EINVAL;
-                if (copy_from_user(&table, user_buf,
-                                   sizeof(struct acpi_table_header)))
-                        return -EFAULT;
-                uncopied_bytes = max_size = table.length;
-                buf = kzalloc(max_size, GFP_KERNEL);
-                if (!buf)
-                        return -ENOMEM;
-        }
-
-        if (buf == NULL)
-                return -EINVAL;
-
-        if ((*ppos > max_size) ||
-            (*ppos + count > max_size) ||
-            (*ppos + count < count) ||
-            (count > uncopied_bytes))
-                return -EINVAL;
-
-        if (copy_from_user(buf + (*ppos), user_buf, count)) {
-                kfree(buf);
-                buf = NULL;
-                return -EFAULT;
-        }
-
-        uncopied_bytes -= count;
-        *ppos += count;
-
-        if (!uncopied_bytes) {
-                status = acpi_install_method(buf);
-                kfree(buf);
-                buf = NULL;
-                if (ACPI_FAILURE(status))
-                        return -EINVAL;
-                add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
-        }
-
-        return count;
-}
-
-static const struct file_operations cm_fops = {
-        .write = cm_write,
-        .llseek = default_llseek,
-};
-
-int __init acpi_debugfs_init(void)
-{
-        struct dentry *acpi_dir, *cm_dentry;
-
-        acpi_dir = debugfs_create_dir("acpi", NULL);
-        if (!acpi_dir)
-                goto err;
-
-        cm_dentry = debugfs_create_file("custom_method", S_IWUSR,
-                                        acpi_dir, NULL, &cm_fops);
-        if (!cm_dentry)
-                goto err;
-
-        return 0;
-
-err:
-        if (acpi_dir)
-                debugfs_remove(acpi_dir);
-        return -EINVAL;
+        acpi_debugfs_dir = debugfs_create_dir("acpi", NULL);
 }
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index fa848c4116a8..b19a18dd994f 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -69,7 +69,6 @@ enum ec_command {
 
 #define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
-#define ACPI_EC_CDELAY          10      /* Wait 10us before polling EC */
 #define ACPI_EC_MSI_UDELAY      550     /* Wait 550us for MSI EC */
 
 #define ACPI_EC_STORM_THRESHOLD 8       /* number of false interrupts
@@ -433,8 +432,7 @@ EXPORT_SYMBOL(ec_write);
 
 int ec_transaction(u8 command,
                    const u8 * wdata, unsigned wdata_len,
-                   u8 * rdata, unsigned rdata_len,
-                   int force_poll)
+                   u8 * rdata, unsigned rdata_len)
 {
         struct transaction t = {.command = command,
                                 .wdata = wdata, .rdata = rdata,
@@ -592,8 +590,6 @@ static void acpi_ec_gpe_query(void *ec_cxt)
         mutex_unlock(&ec->lock);
 }
 
-static void acpi_ec_gpe_query(void *ec_cxt);
-
 static int ec_check_sci(struct acpi_ec *ec, u8 state)
 {
         if (state & ACPI_EC_FLAG_SCI) {
@@ -808,8 +804,6 @@ static int acpi_ec_add(struct acpi_device *device)
                         return -EINVAL;
         }
 
-        ec->handle = device->handle;
-
         /* Find and register all query methods */
         acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
                             acpi_ec_register_query_methods, NULL, ec, NULL);
@@ -938,8 +932,19 @@ static struct dmi_system_id __initdata ec_dmi_table[] = {
         ec_flag_msi, "MSI hardware", {
         DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL},
         {
+        ec_flag_msi, "Quanta hardware", {
+        DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
+        DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL},
+        {
+        ec_flag_msi, "Quanta hardware", {
+        DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
+        DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL},
+        {
         ec_validate_ecdt, "ASUS hardware", {
         DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
+        {
+        ec_validate_ecdt, "ASUS hardware", {
+        DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
         {},
 };
 
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 4bfb759deb10..ca75b9ce0489 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -28,9 +28,10 @@ int acpi_scan_init(void);
 int acpi_sysfs_init(void);
 
 #ifdef CONFIG_DEBUG_FS
+extern struct dentry *acpi_debugfs_dir;
 int acpi_debugfs_init(void);
 #else
-static inline int acpi_debugfs_init(void) { return 0; }
+static inline void acpi_debugfs_init(void) { return; }
 #endif
 
 /* --------------------------------------------------------------------------
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 45ad4ffef533..52ca9649d769 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -902,14 +902,6 @@ void acpi_os_wait_events_complete(void *context)
 
 EXPORT_SYMBOL(acpi_os_wait_events_complete);
 
-/*
- * Deallocate the memory for a spinlock.
- */
-void acpi_os_delete_lock(acpi_spinlock handle)
-{
-        return;
-}
-
 acpi_status
 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
 {
@@ -1341,6 +1333,31 @@ int acpi_resources_are_enforced(void)
 EXPORT_SYMBOL(acpi_resources_are_enforced);
 
 /*
+ * Create and initialize a spinlock.
+ */
+acpi_status
+acpi_os_create_lock(acpi_spinlock *out_handle)
+{
+        spinlock_t *lock;
+
+        lock = ACPI_ALLOCATE(sizeof(spinlock_t));
+        if (!lock)
+                return AE_NO_MEMORY;
+        spin_lock_init(lock);
+        *out_handle = lock;
+
+        return AE_OK;
+}
+
+/*
+ * Deallocate the memory for a spinlock.
+ */
+void acpi_os_delete_lock(acpi_spinlock handle)
+{
+        ACPI_FREE(handle);
+}
+
+/*
  * Acquire a spinlock.
  *
  * handle is a pointer to the spinlock_t.
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index 25bf17da69fd..02d2a4c9084d 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -37,7 +37,6 @@ static struct dmi_system_id __initdata processor_idle_dmi_table[] = {
         {},
 };
 
-#ifdef CONFIG_SMP
 static int map_lapic_id(struct acpi_subtable_header *entry,
                  u32 acpi_id, int *apic_id)
 {
@@ -165,7 +164,9 @@ exit:
 
 int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
 {
+#ifdef CONFIG_SMP
         int i;
+#endif
         int apic_id = -1;
 
         apic_id = map_mat_entry(handle, type, acpi_id);
@@ -174,14 +175,19 @@ int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
         if (apic_id == -1)
                 return apic_id;
 
+#ifdef CONFIG_SMP
         for_each_possible_cpu(i) {
                 if (cpu_physical_id(i) == apic_id)
                         return i;
         }
+#else
+        /* In UP kernel, only processor 0 is valid */
+        if (apic_id == 0)
+                return apic_id;
+#endif
         return -1;
 }
 EXPORT_SYMBOL_GPL(acpi_get_cpuid);
-#endif
 
 static bool __init processor_physically_present(acpi_handle handle)
 {
@@ -217,7 +223,7 @@ static bool __init processor_physically_present(acpi_handle handle)
         type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0;
         cpuid = acpi_get_cpuid(handle, type, acpi_id);
 
-        if ((cpuid == -1) && (num_possible_cpus() > 1))
+        if (cpuid == -1)
                 return false;
 
         return true;
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index d615b7d69bca..431ab11c8c1b 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -161,7 +161,7 @@ static void lapic_timer_check_state(int state, struct acpi_processor *pr,
         if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT))
                 return;
 
-        if (c1e_detected)
+        if (amd_e400_c1e_detected)
                 type = ACPI_STATE_C1;
 
         /*
diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
index 61891e75583d..77255f250dbb 100644
--- a/drivers/acpi/sysfs.c
+++ b/drivers/acpi/sysfs.c
@@ -220,6 +220,14 @@ module_param_call(trace_state, param_set_trace_state, param_get_trace_state,
                   NULL, 0644);
 #endif /* CONFIG_ACPI_DEBUG */
 
+
+/* /sys/modules/acpi/parameters/aml_debug_output */
+
+module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object,
+                   bool, 0644);
+MODULE_PARM_DESC(aml_debug_output,
+                 "To enable/disable the ACPI Debug Object output.");
+
 /* /sys/module/acpi/parameters/acpica_version */
 static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
 {
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index db8f88586c8d..98de8f418676 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -1038,6 +1038,7 @@ static void floppy_disable_hlt(void)
 {
         unsigned long flags;
 
+        WARN_ONCE(1, "floppy_disable_hlt() scheduled for removal in 2012");
         spin_lock_irqsave(&floppy_hlt_lock, flags);
         if (!hlt_disabled) {
                 hlt_disabled = 1;
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index f508690eb958..c47f3d09c1ee 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -237,6 +237,7 @@ static int menu_select(struct cpuidle_device *dev)
         unsigned int power_usage = -1;
         int i;
         int multiplier;
+        struct timespec t;
 
         if (data->needs_update) {
                 menu_update(dev);
@@ -251,8 +252,9 @@ static int menu_select(struct cpuidle_device *dev)
                 return 0;
 
         /* determine the expected residency time, round up */
+        t = ktime_to_timespec(tick_nohz_get_sleep_length());
         data->expected_us =
-            DIV_ROUND_UP((u32)ktime_to_ns(tick_nohz_get_sleep_length()), 1000);
+                t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC;
 
 
         data->bucket = which_bucket(data->expected_us);
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 592397629ddc..4a7f63143455 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -89,24 +89,28 @@ config GPIO_IT8761E
 config GPIO_EXYNOS4
         bool "Samsung Exynos4 GPIO library support"
         default y if CPU_EXYNOS4210
+        depends on ARM
         help
           Say yes here to support Samsung Exynos4 series SoCs GPIO library
 
 config GPIO_PLAT_SAMSUNG
         bool "Samsung SoCs GPIO library support"
         default y if SAMSUNG_GPIOLIB_4BIT
+        depends on ARM
         help
           Say yes here to support Samsung SoCs GPIO library
 
 config GPIO_S5PC100
         bool "Samsung S5PC100 GPIO library support"
         default y if CPU_S5PC100
+        depends on ARM
         help
           Say yes here to support Samsung S5PC100 SoCs GPIO library
 
 config GPIO_S5PV210
         bool "Samsung S5PV210/S5PC110 GPIO library support"
         default y if CPU_S5PV210
+        depends on ARM
         help
           Say yes here to support Samsung S5PV210/S5PC110 SoCs GPIO library
 
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index 76a5af00a26b..2067288f61f9 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -19,6 +19,8 @@
 #define DM_MSG_PREFIX "io"
 
 #define DM_IO_MAX_REGIONS       BITS_PER_LONG
+#define MIN_IOS         16
+#define MIN_BIOS        16
 
 struct dm_io_client {
         mempool_t *pool;
@@ -41,33 +43,21 @@ struct io {
 static struct kmem_cache *_dm_io_cache;
 
 /*
- * io contexts are only dynamically allocated for asynchronous
- * io.  Since async io is likely to be the majority of io we'll
- * have the same number of io contexts as bios! (FIXME: must reduce this).
- */
-
-static unsigned int pages_to_ios(unsigned int pages)
-{
-        return 4 * pages;       /* too many ? */
-}
-
-/*
  * Create a client with mempool and bioset.
  */
-struct dm_io_client *dm_io_client_create(unsigned num_pages)
+struct dm_io_client *dm_io_client_create(void)
 {
-        unsigned ios = pages_to_ios(num_pages);
         struct dm_io_client *client;
 
         client = kmalloc(sizeof(*client), GFP_KERNEL);
         if (!client)
                 return ERR_PTR(-ENOMEM);
 
-        client->pool = mempool_create_slab_pool(ios, _dm_io_cache);
+        client->pool = mempool_create_slab_pool(MIN_IOS, _dm_io_cache);
         if (!client->pool)
                 goto bad;
 
-        client->bios = bioset_create(16, 0);
+        client->bios = bioset_create(MIN_BIOS, 0);
         if (!client->bios)
                 goto bad;
 
@@ -81,13 +71,6 @@ struct dm_io_client *dm_io_client_create(unsigned num_pages)
 }
 EXPORT_SYMBOL(dm_io_client_create);
 
-int dm_io_client_resize(unsigned num_pages, struct dm_io_client *client)
-{
-        return mempool_resize(client->pool, pages_to_ios(num_pages),
-                              GFP_KERNEL);
-}
-EXPORT_SYMBOL(dm_io_client_resize);
-
 void dm_io_client_destroy(struct dm_io_client *client)
 {
         mempool_destroy(client->pool);
diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index 1bb73a13ca40..819e37eaaeba 100644
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -27,15 +27,19 @@
 
 #include "dm.h"
 
+#define SUB_JOB_SIZE    128
+#define SPLIT_COUNT     8
+#define MIN_JOBS        8
+#define RESERVE_PAGES   (DIV_ROUND_UP(SUB_JOB_SIZE << SECTOR_SHIFT, PAGE_SIZE))
+
 /*-----------------------------------------------------------------
  * Each kcopyd client has its own little pool of preallocated
  * pages for kcopyd io.
  *---------------------------------------------------------------*/
 struct dm_kcopyd_client {
-        spinlock_t lock;
         struct page_list *pages;
-        unsigned int nr_pages;
-        unsigned int nr_free_pages;
+        unsigned nr_reserved_pages;
+        unsigned nr_free_pages;
 
         struct dm_io_client *io_client;
 
@@ -67,15 +71,18 @@ static void wake(struct dm_kcopyd_client *kc)
         queue_work(kc->kcopyd_wq, &kc->kcopyd_work);
 }
 
-static struct page_list *alloc_pl(void)
+/*
+ * Obtain one page for the use of kcopyd.
+ */
+static struct page_list *alloc_pl(gfp_t gfp)
 {
         struct page_list *pl;
 
-        pl = kmalloc(sizeof(*pl), GFP_KERNEL);
+        pl = kmalloc(sizeof(*pl), gfp);
         if (!pl)
                 return NULL;
 
-        pl->page = alloc_page(GFP_KERNEL);
+        pl->page = alloc_page(gfp);
         if (!pl->page) {
                 kfree(pl);
                 return NULL;
@@ -90,41 +97,56 @@ static void free_pl(struct page_list *pl)
         kfree(pl);
 }
 
-static int kcopyd_get_pages(struct dm_kcopyd_client *kc,
-                            unsigned int nr, struct page_list **pages)
+/*
+ * Add the provided pages to a client's free page list, releasing
+ * back to the system any beyond the reserved_pages limit.
+ */
+static void kcopyd_put_pages(struct dm_kcopyd_client *kc, struct page_list *pl)
 {
-        struct page_list *pl;
-
-        spin_lock(&kc->lock);
-        if (kc->nr_free_pages < nr) {
-                spin_unlock(&kc->lock);
-                return -ENOMEM;
-        }
-
-        kc->nr_free_pages -= nr;
-        for (*pages = pl = kc->pages; --nr; pl = pl->next)
-                ;
+        struct page_list *next;
 
-        kc->pages = pl->next;
-        pl->next = NULL;
+        do {
+                next = pl->next;
 
-        spin_unlock(&kc->lock);
+                if (kc->nr_free_pages >= kc->nr_reserved_pages)
+                        free_pl(pl);
+                else {
+                        pl->next = kc->pages;
+                        kc->pages = pl;
+                        kc->nr_free_pages++;
+                }
 
-        return 0;
+                pl = next;
+        } while (pl);
 }
 
-static void kcopyd_put_pages(struct dm_kcopyd_client *kc, struct page_list *pl)
+static int kcopyd_get_pages(struct dm_kcopyd_client *kc,
+                            unsigned int nr, struct page_list **pages)
 {
-        struct page_list *cursor;
+        struct page_list *pl;
+
+        *pages = NULL;
+
+        do {
+                pl = alloc_pl(__GFP_NOWARN | __GFP_NORETRY);
+                if (unlikely(!pl)) {
+                        /* Use reserved pages */
+                        pl = kc->pages;
+                        if (unlikely(!pl))
+                                goto out_of_memory;
+                        kc->pages = pl->next;
+                        kc->nr_free_pages--;
+                }
+                pl->next = *pages;
+                *pages = pl;
+        } while (--nr);
 
-        spin_lock(&kc->lock);
-        for (cursor = pl; cursor->next; cursor = cursor->next)
-                kc->nr_free_pages++;
+        return 0;
 
-        kc->nr_free_pages++;
-        cursor->next = kc->pages;
-        kc->pages = pl;
-        spin_unlock(&kc->lock);
+out_of_memory:
+        if (*pages)
+                kcopyd_put_pages(kc, *pages);
+        return -ENOMEM;
 }
 
 /*
@@ -141,13 +163,16 @@ static void drop_pages(struct page_list *pl)
         }
 }
 
-static int client_alloc_pages(struct dm_kcopyd_client *kc, unsigned int nr)
+/*
+ * Allocate and reserve nr_pages for the use of a specific client.
+ */
+static int client_reserve_pages(struct dm_kcopyd_client *kc, unsigned nr_pages)
 {
-        unsigned int i;
+        unsigned i;
         struct page_list *pl = NULL, *next;
 
-        for (i = 0; i < nr; i++) {
-                next = alloc_pl();
+        for (i = 0; i < nr_pages; i++) {
+                next = alloc_pl(GFP_KERNEL);
                 if (!next) {
                         if (pl)
                                 drop_pages(pl);
@@ -157,17 +182,18 @@ static int client_alloc_pages(struct dm_kcopyd_client *kc, unsigned int nr)
                 pl = next;
         }
 
+        kc->nr_reserved_pages += nr_pages;
         kcopyd_put_pages(kc, pl);
-        kc->nr_pages += nr;
+
         return 0;
 }
 
 static void client_free_pages(struct dm_kcopyd_client *kc)
 {
-        BUG_ON(kc->nr_free_pages != kc->nr_pages);
+        BUG_ON(kc->nr_free_pages != kc->nr_reserved_pages);
         drop_pages(kc->pages);
         kc->pages = NULL;
-        kc->nr_free_pages = kc->nr_pages = 0;
+        kc->nr_free_pages = kc->nr_reserved_pages = 0;
 }
 
 /*-----------------------------------------------------------------
@@ -216,16 +242,17 @@ struct kcopyd_job {
         struct mutex lock;
         atomic_t sub_jobs;
         sector_t progress;
-};
 
-/* FIXME: this should scale with the number of pages */
-#define MIN_JOBS 512
+        struct kcopyd_job *master_job;
+};
 
 static struct kmem_cache *_job_cache;
 
 int __init dm_kcopyd_init(void)
 {
-        _job_cache = KMEM_CACHE(kcopyd_job, 0);
+        _job_cache = kmem_cache_create("kcopyd_job",
+                                sizeof(struct kcopyd_job) * (SPLIT_COUNT + 1),
+                                __alignof__(struct kcopyd_job), 0, NULL);
         if (!_job_cache)
                 return -ENOMEM;
 
@@ -299,7 +326,12 @@ static int run_complete_job(struct kcopyd_job *job)
 
         if (job->pages)
                 kcopyd_put_pages(kc, job->pages);
-        mempool_free(job, kc->job_pool);
+        /*
+         * If this is the master job, the sub jobs have already
+         * completed so we can free everything.
+         */
+        if (job->master_job == job)
+                mempool_free(job, kc->job_pool);
         fn(read_err, write_err, context);
 
         if (atomic_dec_and_test(&kc->nr_jobs))
@@ -460,14 +492,14 @@ static void dispatch_job(struct kcopyd_job *job)
         wake(kc);
 }
 
-#define SUB_JOB_SIZE 128
 static void segment_complete(int read_err, unsigned long write_err,
                              void *context)
 {
         /* FIXME: tidy this function */
         sector_t progress = 0;
         sector_t count = 0;
-        struct kcopyd_job *job = (struct kcopyd_job *) context;
+        struct kcopyd_job *sub_job = (struct kcopyd_job *) context;
+        struct kcopyd_job *job = sub_job->master_job;
         struct dm_kcopyd_client *kc = job->kc;
 
         mutex_lock(&job->lock);
@@ -498,8 +530,6 @@ static void segment_complete(int read_err, unsigned long write_err,
 
         if (count) {
                 int i;
-                struct kcopyd_job *sub_job = mempool_alloc(kc->job_pool,
-                                                           GFP_NOIO);
 
                 *sub_job = *job;
                 sub_job->source.sector += progress;
@@ -511,7 +541,7 @@ static void segment_complete(int read_err, unsigned long write_err,
                 }
 
                 sub_job->fn = segment_complete;
-                sub_job->context = job;
+                sub_job->context = sub_job;
                 dispatch_job(sub_job);
 
         } else if (atomic_dec_and_test(&job->sub_jobs)) {
@@ -531,19 +561,19 @@ static void segment_complete(int read_err, unsigned long write_err,
 }
 
 /*
- * Create some little jobs that will do the move between
- * them.
+ * Create some sub jobs to share the work between them.
  */
-#define SPLIT_COUNT 8
-static void split_job(struct kcopyd_job *job)
+static void split_job(struct kcopyd_job *master_job)
 {
         int i;
 
-        atomic_inc(&job->kc->nr_jobs);
+        atomic_inc(&master_job->kc->nr_jobs);
 
-        atomic_set(&job->sub_jobs, SPLIT_COUNT);
-        for (i = 0; i < SPLIT_COUNT; i++)
-                segment_complete(0, 0u, job);
+        atomic_set(&master_job->sub_jobs, SPLIT_COUNT);
+        for (i = 0; i < SPLIT_COUNT; i++) {
+                master_job[i + 1].master_job = master_job;
+                segment_complete(0, 0u, &master_job[i + 1]);
+        }
 }
 
 int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
@@ -553,7 +583,8 @@ int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
         struct kcopyd_job *job;
 
         /*
-         * Allocate a new job.
+         * Allocate an array of jobs consisting of one master job
+         * followed by SPLIT_COUNT sub jobs.
          */
         job = mempool_alloc(kc->job_pool, GFP_NOIO);
 
@@ -577,10 +608,10 @@ int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
 
         job->fn = fn;
         job->context = context;
+        job->master_job = job;
 
-        if (job->source.count < SUB_JOB_SIZE)
+        if (job->source.count <= SUB_JOB_SIZE)
                 dispatch_job(job);
-
         else {
                 mutex_init(&job->lock);
                 job->progress = 0;
@@ -606,17 +637,15 @@ int kcopyd_cancel(struct kcopyd_job *job, int block)
 /*-----------------------------------------------------------------
  * Client setup
  *---------------------------------------------------------------*/
-int dm_kcopyd_client_create(unsigned int nr_pages,
-                            struct dm_kcopyd_client **result)
+struct dm_kcopyd_client *dm_kcopyd_client_create(void)
 {
         int r = -ENOMEM;
         struct dm_kcopyd_client *kc;
 
         kc = kmalloc(sizeof(*kc), GFP_KERNEL);
         if (!kc)
-                return -ENOMEM;
+                return ERR_PTR(-ENOMEM);
 
-        spin_lock_init(&kc->lock);
         spin_lock_init(&kc->job_lock);
         INIT_LIST_HEAD(&kc->complete_jobs);
         INIT_LIST_HEAD(&kc->io_jobs);
@@ -633,12 +662,12 @@ int dm_kcopyd_client_create(unsigned int nr_pages,
                 goto bad_workqueue;
 
         kc->pages = NULL;
-        kc->nr_pages = kc->nr_free_pages = 0;
-        r = client_alloc_pages(kc, nr_pages);
+        kc->nr_reserved_pages = kc->nr_free_pages = 0;
+        r = client_reserve_pages(kc, RESERVE_PAGES);
         if (r)
                 goto bad_client_pages;
 
-        kc->io_client = dm_io_client_create(nr_pages);
+        kc->io_client = dm_io_client_create();
         if (IS_ERR(kc->io_client)) {
                 r = PTR_ERR(kc->io_client);
                 goto bad_io_client;
@@ -647,8 +676,7 @@ int dm_kcopyd_client_create(unsigned int nr_pages,
         init_waitqueue_head(&kc->destroyq);
         atomic_set(&kc->nr_jobs, 0);
 
-        *result = kc;
-        return 0;
+        return kc;
 
 bad_io_client:
         client_free_pages(kc);
@@ -659,7 +687,7 @@ bad_workqueue:
 bad_slab:
         kfree(kc);
 
-        return r;
+        return ERR_PTR(r);
 }
 EXPORT_SYMBOL(dm_kcopyd_client_create);
 
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index a1f321889676..948e3f4925bf 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -449,8 +449,7 @@ static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
 
                 lc->io_req.mem.type = DM_IO_VMA;
                 lc->io_req.notify.fn = NULL;
-                lc->io_req.client = dm_io_client_create(dm_div_up(buf_size,
-                                                                   PAGE_SIZE));
+                lc->io_req.client = dm_io_client_create();
                 if (IS_ERR(lc->io_req.client)) {
                         r = PTR_ERR(lc->io_req.client);
                         DMWARN("couldn't allocate disk io client");
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index a550a057d991..aa4e570c2cb5 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -1290,7 +1290,7 @@ static int do_end_io(struct multipath *m, struct request *clone,
         if (!error && !clone->errors)
                 return 0;       /* I/O complete */
 
-        if (error == -EOPNOTSUPP || error == -EREMOTEIO)
+        if (error == -EOPNOTSUPP || error == -EREMOTEIO || error == -EILSEQ)
                 return error;
 
         if (mpio->pgpath)
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 976ad4688afc..9bfd057be686 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -22,8 +22,6 @@
 #define DM_MSG_PREFIX "raid1"
 
 #define MAX_RECOVERY 1  /* Maximum number of regions recovered in parallel. */
-#define DM_IO_PAGES 64
-#define DM_KCOPYD_PAGES 64
 
 #define DM_RAID1_HANDLE_ERRORS 0x01
 #define errors_handled(p)       ((p)->features & DM_RAID1_HANDLE_ERRORS)
@@ -887,7 +885,7 @@ static struct mirror_set *alloc_context(unsigned int nr_mirrors,
                 return NULL;
         }
 
-        ms->io_client = dm_io_client_create(DM_IO_PAGES);
+        ms->io_client = dm_io_client_create();
         if (IS_ERR(ms->io_client)) {
                 ti->error = "Error creating dm_io client";
                 mempool_destroy(ms->read_record_pool);
@@ -1117,9 +1115,11 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto err_destroy_wq;
         }
 
-        r = dm_kcopyd_client_create(DM_KCOPYD_PAGES, &ms->kcopyd_client);
-        if (r)
+        ms->kcopyd_client = dm_kcopyd_client_create();
+        if (IS_ERR(ms->kcopyd_client)) {
+                r = PTR_ERR(ms->kcopyd_client);
                 goto err_destroy_wq;
+        }
 
         wakeup_mirrord(ms);
         return 0;
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index 95891dfcbca0..135c2f1fdbfc 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -154,11 +154,6 @@ struct pstore {
         struct workqueue_struct *metadata_wq;
 };
 
-static unsigned sectors_to_pages(unsigned sectors)
-{
-        return DIV_ROUND_UP(sectors, PAGE_SIZE >> 9);
-}
-
 static int alloc_area(struct pstore *ps)
 {
         int r = -ENOMEM;
@@ -318,8 +313,7 @@ static int read_header(struct pstore *ps, int *new_snapshot)
                 chunk_size_supplied = 0;
         }
 
-        ps->io_client = dm_io_client_create(sectors_to_pages(ps->store->
-                                                             chunk_size));
+        ps->io_client = dm_io_client_create();
         if (IS_ERR(ps->io_client))
                 return PTR_ERR(ps->io_client);
 
@@ -368,11 +362,6 @@ static int read_header(struct pstore *ps, int *new_snapshot)
                 return r;
         }
 
-        r = dm_io_client_resize(sectors_to_pages(ps->store->chunk_size),
-                                ps->io_client);
-        if (r)
-                return r;
-
         r = alloc_area(ps);
         return r;
 
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index a2d330942cb2..9ecff5f3023a 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -40,11 +40,6 @@ static const char dm_snapshot_merge_target_name[] = "snapshot-merge";
 #define SNAPSHOT_COPY_PRIORITY 2
 
 /*
- * Reserve 1MB for each snapshot initially (with minimum of 1 page).
- */
-#define SNAPSHOT_PAGES (((1UL << 20) >> PAGE_SHIFT) ? : 1)
-
-/*
  * The size of the mempool used to track chunks in use.
  */
 #define MIN_IOS 256
@@ -1116,8 +1111,9 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad_hash_tables;
         }
 
-        r = dm_kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client);
-        if (r) {
+        s->kcopyd_client = dm_kcopyd_client_create();
+        if (IS_ERR(s->kcopyd_client)) {
+                r = PTR_ERR(s->kcopyd_client);
                 ti->error = "Could not create kcopyd client";
                 goto bad_kcopyd;
         }
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index cb8380c9767f..451c3bb176d2 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -362,6 +362,7 @@ static void close_dev(struct dm_dev_internal *d, struct mapped_device *md)
 static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
                                   sector_t start, sector_t len, void *data)
 {
+        struct request_queue *q;
         struct queue_limits *limits = data;
         struct block_device *bdev = dev->bdev;
         sector_t dev_size =
@@ -370,6 +371,22 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
                 limits->logical_block_size >> SECTOR_SHIFT;
         char b[BDEVNAME_SIZE];
 
+        /*
+         * Some devices exist without request functions,
+         * such as loop devices not yet bound to backing files.
+         * Forbid the use of such devices.
+         */
+        q = bdev_get_queue(bdev);
+        if (!q || !q->make_request_fn) {
+                DMWARN("%s: %s is not yet initialised: "
+                       "start=%llu, len=%llu, dev_size=%llu",
+                       dm_device_name(ti->table->md), bdevname(bdev, b),
+                       (unsigned long long)start,
+                       (unsigned long long)len,
+                       (unsigned long long)dev_size);
+                return 1;
+        }
+
         if (!dev_size)
                 return 0;
 
@@ -1346,7 +1363,8 @@ bool dm_table_supports_discards(struct dm_table *t)
                 return 0;
 
         /*
-         * Ensure that at least one underlying device supports discards.
+         * Unless any target used by the table set discards_supported,
+         * require at least one underlying device to support discards.
          * t->devices includes internal dm devices such as mirror logs
          * so we need to use iterate_devices here, which targets
          * supporting discard must provide.
@@ -1354,6 +1372,9 @@ bool dm_table_supports_discards(struct dm_table *t)
         while (i < dm_table_get_num_targets(t)) {
                 ti = dm_table_get_target(t, i++);
 
+                if (ti->discards_supported)
+                        return 1;
+
                 if (ti->type->iterate_devices &&
                     ti->type->iterate_devices(ti, device_discard_capable, NULL))
                         return 1;
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 7c3b18e78cee..d36f41ea8cbf 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -195,6 +195,8 @@ static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
                 return PCI_D2;
         case ACPI_STATE_D3:
                 return PCI_D3hot;
+        case ACPI_STATE_D3_COLD:
+                return PCI_D3cold;
         }
         return PCI_POWER_ERROR;
 }
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 5cb999b50f95..45e0191c35dd 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -39,7 +39,7 @@ config ACER_WMI
 
 config ACERHDF
         tristate "Acer Aspire One temperature and fan driver"
-        depends on THERMAL && THERMAL_HWMON && ACPI
+        depends on THERMAL && ACPI
         ---help---
           This is a driver for Acer Aspire One netbooks. It allows to access
           the temperature sensor and to control the fan.
@@ -760,4 +760,13 @@ config MXM_WMI
           MXM is a standard for laptop graphics cards, the WMI interface
           is required for switchable nvidia graphics machines
 
+config INTEL_OAKTRAIL
+        tristate "Intel Oaktrail Platform Extras"
+        depends on ACPI
+        depends on RFKILL && BACKLIGHT_CLASS_DEVICE && ACPI
+        ---help---
+          Intel Oaktrail platform need this driver to provide interfaces to
+          enable/disable the Camera, WiFi, BT etc. devices. If in doubt, say Y
+          here; it will only load on supported platforms.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index a7ab3bc7b3a1..afc1f832aa67 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -41,5 +41,6 @@ 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
 obj-$(CONFIG_MXM_WMI)           += mxm-wmi.o
+obj-$(CONFIG_INTEL_MID_POWER_BUTTON)    += intel_mid_powerbtn.o
+obj-$(CONFIG_INTEL_OAKTRAIL)    += intel_oaktrail.o
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index ac4e7f83ce6c..005417bd429e 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -98,13 +98,26 @@ enum acer_wmi_event_ids {
 
 static const struct key_entry acer_wmi_keymap[] = {
         {KE_KEY, 0x01, {KEY_WLAN} },     /* WiFi */
+        {KE_KEY, 0x03, {KEY_WLAN} },     /* WiFi */
         {KE_KEY, 0x12, {KEY_BLUETOOTH} },       /* BT */
         {KE_KEY, 0x21, {KEY_PROG1} },    /* Backup */
         {KE_KEY, 0x22, {KEY_PROG2} },    /* Arcade */
         {KE_KEY, 0x23, {KEY_PROG3} },    /* P_Key */
         {KE_KEY, 0x24, {KEY_PROG4} },    /* Social networking_Key */
+        {KE_IGNORE, 0x41, {KEY_MUTE} },
+        {KE_IGNORE, 0x42, {KEY_PREVIOUSSONG} },
+        {KE_IGNORE, 0x43, {KEY_NEXTSONG} },
+        {KE_IGNORE, 0x44, {KEY_PLAYPAUSE} },
+        {KE_IGNORE, 0x45, {KEY_STOP} },
+        {KE_IGNORE, 0x48, {KEY_VOLUMEUP} },
+        {KE_IGNORE, 0x49, {KEY_VOLUMEDOWN} },
+        {KE_IGNORE, 0x61, {KEY_SWITCHVIDEOMODE} },
+        {KE_IGNORE, 0x62, {KEY_BRIGHTNESSUP} },
+        {KE_IGNORE, 0x63, {KEY_BRIGHTNESSDOWN} },
         {KE_KEY, 0x64, {KEY_SWITCHVIDEOMODE} }, /* Display Switch */
+        {KE_IGNORE, 0x81, {KEY_SLEEP} },
         {KE_KEY, 0x82, {KEY_TOUCHPAD_TOGGLE} }, /* Touch Pad On/Off */
+        {KE_IGNORE, 0x83, {KEY_TOUCHPAD_TOGGLE} },
         {KE_END, 0}
 };
 
@@ -122,6 +135,7 @@ struct event_return_value {
  */
 #define ACER_WMID3_GDS_WIRELESS         (1<<0)  /* WiFi */
 #define ACER_WMID3_GDS_THREEG           (1<<6)  /* 3G */
+#define ACER_WMID3_GDS_WIMAX            (1<<7)  /* WiMAX */
 #define ACER_WMID3_GDS_BLUETOOTH        (1<<11) /* BT */
 
 struct lm_input_params {
@@ -737,8 +751,11 @@ WMI_execute_u32(u32 method_id, u32 in, u32 *out)
 
         obj = (union acpi_object *) result.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 tmp = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                tmp = (u32) obj->integer.value;
         } else {
                 tmp = 0;
         }
@@ -866,8 +883,11 @@ static acpi_status WMID_set_capabilities(void)
 
         obj = (union acpi_object *) out.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 devices = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                devices = (u32) obj->integer.value;
         } else {
                 kfree(out.pointer);
                 return AE_ERROR;
@@ -876,7 +896,8 @@ static acpi_status WMID_set_capabilities(void)
         dmi_walk(type_aa_dmi_decode, NULL);
         if (!has_type_aa) {
                 interface->capability |= ACER_CAP_WIRELESS;
-                interface->capability |= ACER_CAP_THREEG;
+                if (devices & 0x40)
+                        interface->capability |= ACER_CAP_THREEG;
                 if (devices & 0x10)
                         interface->capability |= ACER_CAP_BLUETOOTH;
         }
@@ -961,10 +982,12 @@ static void __init acer_commandline_init(void)
          * These will all fail silently if the value given is invalid, or the
          * capability isn't available on the given interface
          */
-        set_u32(mailled, ACER_CAP_MAILLED);
-        if (!has_type_aa)
+        if (mailled >= 0)
+                set_u32(mailled, ACER_CAP_MAILLED);
+        if (!has_type_aa && threeg >= 0)
                 set_u32(threeg, ACER_CAP_THREEG);
-        set_u32(brightness, ACER_CAP_BRIGHTNESS);
+        if (brightness >= 0)
+                set_u32(brightness, ACER_CAP_BRIGHTNESS);
 }
 
 /*
@@ -1081,7 +1104,7 @@ static acpi_status wmid3_get_device_status(u32 *value, u16 device)
                 return AE_ERROR;
         }
         if (obj->buffer.length != 8) {
-                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return AE_ERROR;
         }
@@ -1090,8 +1113,8 @@ static acpi_status wmid3_get_device_status(u32 *value, u16 device)
         kfree(obj);
 
         if (return_value.error_code || return_value.ec_return_value)
-                pr_warning("Get Device Status failed: "
-                        "0x%x - 0x%x\n", return_value.error_code,
+                pr_warn("Get Device Status failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
                         return_value.ec_return_value);
         else
                 *value = !!(return_value.devices & device);
@@ -1124,6 +1147,114 @@ static acpi_status get_device_status(u32 *value, u32 cap)
         }
 }
 
+static acpi_status wmid3_set_device_status(u32 value, u16 device)
+{
+        struct wmid3_gds_return_value return_value;
+        acpi_status status;
+        union acpi_object *obj;
+        u16 devices;
+        struct wmid3_gds_input_param params = {
+                .function_num = 0x1,
+                .hotkey_number = 0x01,
+                .devices = ACER_WMID3_GDS_WIRELESS &
+                                ACER_WMID3_GDS_THREEG &
+                                ACER_WMID3_GDS_WIMAX &
+                                ACER_WMID3_GDS_BLUETOOTH,
+        };
+        struct acpi_buffer input = {
+                sizeof(struct wmid3_gds_input_param),
+                &params
+        };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer output2 = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &input, &output);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = output.pointer;
+
+        if (!obj)
+                return AE_ERROR;
+        else if (obj->type != ACPI_TYPE_BUFFER) {
+                kfree(obj);
+                return AE_ERROR;
+        }
+        if (obj->buffer.length != 8) {
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return AE_ERROR;
+        }
+
+        return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        if (return_value.error_code || return_value.ec_return_value) {
+                pr_warning("Get Current Device Status failed: "
+                        "0x%x - 0x%x\n", return_value.error_code,
+                        return_value.ec_return_value);
+                return status;
+        }
+
+        devices = return_value.devices;
+        params.function_num = 0x2;
+        params.hotkey_number = 0x01;
+        params.devices = (value) ? (devices | device) : (devices & ~device);
+
+        status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &input, &output2);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = output2.pointer;
+
+        if (!obj)
+                return AE_ERROR;
+        else if (obj->type != ACPI_TYPE_BUFFER) {
+                kfree(obj);
+                return AE_ERROR;
+        }
+        if (obj->buffer.length != 4) {
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return AE_ERROR;
+        }
+
+        return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        if (return_value.error_code || return_value.ec_return_value)
+                pr_warning("Set Device Status failed: "
+                        "0x%x - 0x%x\n", return_value.error_code,
+                        return_value.ec_return_value);
+
+        return status;
+}
+
+static acpi_status set_device_status(u32 value, u32 cap)
+{
+        if (wmi_has_guid(WMID_GUID3)) {
+                u16 device;
+
+                switch (cap) {
+                case ACER_CAP_WIRELESS:
+                        device = ACER_WMID3_GDS_WIRELESS;
+                        break;
+                case ACER_CAP_BLUETOOTH:
+                        device = ACER_WMID3_GDS_BLUETOOTH;
+                        break;
+                case ACER_CAP_THREEG:
+                        device = ACER_WMID3_GDS_THREEG;
+                        break;
+                default:
+                        return AE_ERROR;
+                }
+                return wmid3_set_device_status(value, device);
+
+        } else {
+                return set_u32(value, cap);
+        }
+}
+
 /*
  * Rfkill devices
  */
@@ -1160,7 +1291,7 @@ static int acer_rfkill_set(void *data, bool blocked)
         u32 cap = (unsigned long)data;
 
         if (rfkill_inited) {
-                status = set_u32(!blocked, cap);
+                status = set_device_status(!blocked, cap);
                 if (ACPI_FAILURE(status))
                         return -ENODEV;
         }
@@ -1317,7 +1448,7 @@ static void acer_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                pr_warning("bad event status 0x%x\n", status);
+                pr_warn("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -1326,12 +1457,12 @@ static void acer_wmi_notify(u32 value, void *context)
         if (!obj)
                 return;
         if (obj->type != ACPI_TYPE_BUFFER) {
-                pr_warning("Unknown response received %d\n", obj->type);
+                pr_warn("Unknown response received %d\n", obj->type);
                 kfree(obj);
                 return;
         }
         if (obj->buffer.length != 8) {
-                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return;
         }
@@ -1343,7 +1474,7 @@ static void acer_wmi_notify(u32 value, void *context)
         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);
+                        pr_debug("device state: 0x%x\n", device_state);
                         if (has_cap(ACER_CAP_WIRELESS))
                                 rfkill_set_sw_state(wireless_rfkill,
                                 !(device_state & ACER_WMID3_GDS_WIRELESS));
@@ -1356,11 +1487,11 @@ static void acer_wmi_notify(u32 value, void *context)
                 }
                 if (!sparse_keymap_report_event(acer_wmi_input_dev,
                                 return_value.key_num, 1, true))
-                        pr_warning("Unknown key number - 0x%x\n",
+                        pr_warn("Unknown key number - 0x%x\n",
                                 return_value.key_num);
                 break;
         default:
-                pr_warning("Unknown function number - %d - %d\n",
+                pr_warn("Unknown function number - %d - %d\n",
                         return_value.function, return_value.key_num);
                 break;
         }
@@ -1389,7 +1520,7 @@ wmid3_set_lm_mode(struct lm_input_params *params,
                 return AE_ERROR;
         }
         if (obj->buffer.length != 4) {
-                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return AE_ERROR;
         }
@@ -1414,11 +1545,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)
-                pr_warning("Enabling EC raw mode failed: "
-                       "0x%x - 0x%x\n", return_value.error_code,
-                       return_value.ec_return_value);
+                pr_warn("Enabling EC raw mode failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
+                        return_value.ec_return_value);
         else
-                pr_info("Enabled EC raw mode");
+                pr_info("Enabled EC raw mode\n");
 
         return status;
 }
@@ -1437,9 +1568,9 @@ 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)
-                pr_warning("Enabling Launch Manager failed: "
-                       "0x%x - 0x%x\n", return_value.error_code,
-                       return_value.ec_return_value);
+                pr_warn("Enabling Launch Manager failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
+                        return_value.ec_return_value);
 
         return status;
 }
@@ -1506,8 +1637,11 @@ static u32 get_wmid_devices(void)
 
         obj = (union acpi_object *) out.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 devices = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                devices = (u32) obj->integer.value;
         }
 
         kfree(out.pointer);
diff --git a/drivers/platform/x86/acerhdf.c b/drivers/platform/x86/acerhdf.c
index 60f9cfcac93f..fca3489218b7 100644
--- a/drivers/platform/x86/acerhdf.c
+++ b/drivers/platform/x86/acerhdf.c
@@ -35,10 +35,8 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/fs.h>
 #include <linux/dmi.h>
-#include <acpi/acpi_drivers.h>
-#include <linux/sched.h>
+#include <linux/acpi.h>
 #include <linux/thermal.h>
 #include <linux/platform_device.h>
 
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index c53b3ff7978a..d65df92e2acc 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -318,7 +318,7 @@ static int acpi_check_handle(acpi_handle handle, const char *method,
 
         if (status != AE_OK) {
                 if (ret)
-                        pr_warning("Error finding %s\n", method);
+                        pr_warn("Error finding %s\n", method);
                 return -ENODEV;
         }
         return 0;
@@ -383,7 +383,7 @@ static int asus_kled_lvl(struct asus_laptop *asus)
         rv = acpi_evaluate_integer(asus->handle, METHOD_KBD_LIGHT_GET,
                                    &params, &kblv);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading kled level\n");
+                pr_warn("Error reading kled level\n");
                 return -ENODEV;
         }
         return kblv;
@@ -397,7 +397,7 @@ static int asus_kled_set(struct asus_laptop *asus, int kblv)
                 kblv = 0;
 
         if (write_acpi_int(asus->handle, METHOD_KBD_LIGHT_SET, kblv)) {
-                pr_warning("Keyboard LED display write failed\n");
+                pr_warn("Keyboard LED display write failed\n");
                 return -EINVAL;
         }
         return 0;
@@ -531,7 +531,7 @@ static int asus_read_brightness(struct backlight_device *bd)
         rv = acpi_evaluate_integer(asus->handle, METHOD_BRIGHTNESS_GET,
                                    NULL, &value);
         if (ACPI_FAILURE(rv))
-                pr_warning("Error reading brightness\n");
+                pr_warn("Error reading brightness\n");
 
         return value;
 }
@@ -541,7 +541,7 @@ static int asus_set_brightness(struct backlight_device *bd, int value)
         struct asus_laptop *asus = bl_get_data(bd);
 
         if (write_acpi_int(asus->handle, METHOD_BRIGHTNESS_SET, value)) {
-                pr_warning("Error changing brightness\n");
+                pr_warn("Error changing brightness\n");
                 return -EIO;
         }
         return 0;
@@ -730,7 +730,7 @@ static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
         rv = parse_arg(buf, count, &value);
         if (rv > 0) {
                 if (write_acpi_int(asus->handle, METHOD_LEDD, value)) {
-                        pr_warning("LED display write failed\n");
+                        pr_warn("LED display write failed\n");
                         return -ENODEV;
                 }
                 asus->ledd_status = (u32) value;
@@ -752,7 +752,7 @@ static int asus_wireless_status(struct asus_laptop *asus, int mask)
         rv = acpi_evaluate_integer(asus->handle, METHOD_WL_STATUS,
                                    NULL, &status);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading Wireless status\n");
+                pr_warn("Error reading Wireless status\n");
                 return -EINVAL;
         }
         return !!(status & mask);
@@ -764,7 +764,7 @@ static int asus_wireless_status(struct asus_laptop *asus, int mask)
 static int asus_wlan_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_WLAN, !!status)) {
-                pr_warning("Error setting wlan status to %d", status);
+                pr_warn("Error setting wlan status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -792,7 +792,7 @@ static ssize_t store_wlan(struct device *dev, struct device_attribute *attr,
 static int asus_bluetooth_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_BLUETOOTH, !!status)) {
-                pr_warning("Error setting bluetooth status to %d", status);
+                pr_warn("Error setting bluetooth status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -821,7 +821,7 @@ static ssize_t store_bluetooth(struct device *dev,
 static int asus_wimax_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_WIMAX, !!status)) {
-                pr_warning("Error setting wimax status to %d", status);
+                pr_warn("Error setting wimax status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -850,7 +850,7 @@ static ssize_t store_wimax(struct device *dev,
 static int asus_wwan_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_WWAN, !!status)) {
-                pr_warning("Error setting wwan status to %d", status);
+                pr_warn("Error setting wwan status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -880,7 +880,7 @@ static void asus_set_display(struct asus_laptop *asus, int value)
 {
         /* no sanity check needed for now */
         if (write_acpi_int(asus->handle, METHOD_SWITCH_DISPLAY, value))
-                pr_warning("Error setting display\n");
+                pr_warn("Error setting display\n");
         return;
 }
 
@@ -909,7 +909,7 @@ static ssize_t store_disp(struct device *dev, struct device_attribute *attr,
 static void asus_als_switch(struct asus_laptop *asus, int value)
 {
         if (write_acpi_int(asus->handle, METHOD_ALS_CONTROL, value))
-                pr_warning("Error setting light sensor switch\n");
+                pr_warn("Error setting light sensor switch\n");
         asus->light_switch = value;
 }
 
@@ -937,7 +937,7 @@ static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
 static void asus_als_level(struct asus_laptop *asus, int value)
 {
         if (write_acpi_int(asus->handle, METHOD_ALS_LEVEL, value))
-                pr_warning("Error setting light sensor level\n");
+                pr_warn("Error setting light sensor level\n");
         asus->light_level = value;
 }
 
@@ -976,7 +976,7 @@ static int asus_gps_status(struct asus_laptop *asus)
         rv = acpi_evaluate_integer(asus->handle, METHOD_GPS_STATUS,
                                    NULL, &status);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading GPS status\n");
+                pr_warn("Error reading GPS status\n");
                 return -ENODEV;
         }
         return !!status;
@@ -1284,7 +1284,7 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
          */
         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus->dsdt_info);
         if (ACPI_FAILURE(status))
-                pr_warning("Couldn't get the DSDT table header\n");
+                pr_warn("Couldn't get the DSDT table header\n");
 
         /* We have to write 0 on init this far for all ASUS models */
         if (write_acpi_int_ret(asus->handle, "INIT", 0, &buffer)) {
@@ -1296,7 +1296,7 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
         status =
             acpi_evaluate_integer(asus->handle, "BSTS", NULL, &bsts_result);
         if (ACPI_FAILURE(status))
-                pr_warning("Error calling BSTS\n");
+                pr_warn("Error calling BSTS\n");
         else if (bsts_result)
                 pr_notice("BSTS called, 0x%02x returned\n",
                        (uint) bsts_result);
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 832a3fd7c1c8..00460cb9587b 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -425,7 +425,7 @@ static void asus_rfkill_hotplug(struct asus_wmi *asus)
         if (asus->hotplug_slot) {
                 bus = pci_find_bus(0, 1);
                 if (!bus) {
-                        pr_warning("Unable to find PCI bus 1?\n");
+                        pr_warn("Unable to find PCI bus 1?\n");
                         goto out_unlock;
                 }
 
@@ -436,12 +436,12 @@ static void asus_rfkill_hotplug(struct asus_wmi *asus)
                 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");
+                        pr_warn("BIOS says wireless lan is %s, "
+                                "but the pci device is %s\n",
+                                blocked ? "blocked" : "unblocked",
+                                absent ? "absent" : "present");
+                        pr_warn("skipped wireless hotplug as probably "
+                                "inappropriate for this model\n");
                         goto out_unlock;
                 }
 
@@ -500,7 +500,7 @@ static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
                                                      ACPI_SYSTEM_NOTIFY,
                                                      asus_rfkill_notify, asus);
                 if (ACPI_FAILURE(status))
-                        pr_warning("Failed to register notify on %s\n", node);
+                        pr_warn("Failed to register notify on %s\n", node);
         } else
                 return -ENODEV;
 
@@ -1223,7 +1223,7 @@ static int asus_wmi_sysfs_init(struct platform_device *device)
 /*
  * Platform device
  */
-static int __init asus_wmi_platform_init(struct asus_wmi *asus)
+static int asus_wmi_platform_init(struct asus_wmi *asus)
 {
         int rv;
 
@@ -1583,12 +1583,12 @@ static int asus_wmi_probe(struct platform_device *pdev)
         int ret;
 
         if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
-                pr_warning("Management GUID not found\n");
+                pr_warn("Management GUID not found\n");
                 return -ENODEV;
         }
 
         if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
-                pr_warning("Event GUID not found\n");
+                pr_warn("Event GUID not found\n");
                 return -ENODEV;
         }
 
diff --git a/drivers/platform/x86/asus_acpi.c b/drivers/platform/x86/asus_acpi.c
index f503607c0645..d9312b3073e5 100644
--- a/drivers/platform/x86/asus_acpi.c
+++ b/drivers/platform/x86/asus_acpi.c
@@ -30,6 +30,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -581,8 +583,7 @@ static int read_led(const char *ledname, int ledmask)
                 if (read_acpi_int(NULL, ledname, &led_status))
                         return led_status;
                 else
-                        printk(KERN_WARNING "Asus ACPI: Error reading LED "
-                               "status\n");
+                        pr_warn("Error reading LED status\n");
         }
         return (hotk->status & ledmask) ? 1 : 0;
 }
@@ -621,8 +622,7 @@ write_led(const char __user *buffer, unsigned long count,
                 led_out = !led_out;
 
         if (!write_acpi_int(hotk->handle, ledname, led_out, NULL))
-                printk(KERN_WARNING "Asus ACPI: LED (%s) write failed\n",
-                       ledname);
+                pr_warn("LED (%s) write failed\n", ledname);
 
         return rv;
 }
@@ -679,8 +679,7 @@ static ssize_t ledd_proc_write(struct file *file, const char __user *buffer,
         if (rv > 0) {
                 if (!write_acpi_int
                     (hotk->handle, hotk->methods->mt_ledd, value, NULL))
-                        printk(KERN_WARNING
-                               "Asus ACPI: LED display write failed\n");
+                        pr_warn("LED display write failed\n");
                 else
                         hotk->ledd_status = (u32) value;
         }
@@ -838,8 +837,7 @@ static int get_lcd_state(void)
         } else {
                 /* We don't have to check anything if we are here */
                 if (!read_acpi_int(NULL, hotk->methods->lcd_status, &lcd))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading LCD status\n");
+                        pr_warn("Error reading LCD status\n");
 
                 if (hotk->model == L2D)
                         lcd = ~lcd;
@@ -871,7 +869,7 @@ static int set_lcd_state(int value)
                            the exact behaviour is simulated here */
                 }
                 if (ACPI_FAILURE(status))
-                        printk(KERN_WARNING "Asus ACPI: Error switching LCD\n");
+                        pr_warn("Error switching LCD\n");
         }
         return 0;
 
@@ -915,13 +913,11 @@ static int read_brightness(struct backlight_device *bd)
         if (hotk->methods->brightness_get) {    /* SPLV/GPLV laptop */
                 if (!read_acpi_int(hotk->handle, hotk->methods->brightness_get,
                                    &value))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading brightness\n");
+                        pr_warn("Error reading brightness\n");
         } else if (hotk->methods->brightness_status) {  /* For D1 for example */
                 if (!read_acpi_int(NULL, hotk->methods->brightness_status,
                                    &value))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading brightness\n");
+                        pr_warn("Error reading brightness\n");
         } else                  /* No GPLV method */
                 value = hotk->brightness;
         return value;
@@ -939,8 +935,7 @@ static int set_brightness(int value)
         if (hotk->methods->brightness_set) {
                 if (!write_acpi_int(hotk->handle, hotk->methods->brightness_set,
                                     value, NULL)) {
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error changing brightness\n");
+                        pr_warn("Error changing brightness\n");
                         ret = -EIO;
                 }
                 goto out;
@@ -955,8 +950,7 @@ static int set_brightness(int value)
                                               NULL, NULL);
                 (value > 0) ? value-- : value++;
                 if (ACPI_FAILURE(status)) {
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error changing brightness\n");
+                        pr_warn("Error changing brightness\n");
                         ret = -EIO;
                 }
         }
@@ -1008,7 +1002,7 @@ static void set_display(int value)
         /* no sanity check needed for now */
         if (!write_acpi_int(hotk->handle, hotk->methods->display_set,
                             value, NULL))
-                printk(KERN_WARNING "Asus ACPI: Error setting display\n");
+                pr_warn("Error setting display\n");
         return;
 }
 
@@ -1021,8 +1015,7 @@ static int disp_proc_show(struct seq_file *m, void *v)
         int value = 0;
 
         if (!read_acpi_int(hotk->handle, hotk->methods->display_get, &value))
-                printk(KERN_WARNING
-                       "Asus ACPI: Error reading display status\n");
+                pr_warn("Error reading display status\n");
         value &= 0x07;  /* needed for some models, shouldn't hurt others */
         seq_printf(m, "%d\n", value);
         return 0;
@@ -1068,7 +1061,7 @@ asus_proc_add(char *name, const struct file_operations *proc_fops, mode_t mode,
         proc = proc_create_data(name, mode, acpi_device_dir(device),
                                 proc_fops, acpi_driver_data(device));
         if (!proc) {
-                printk(KERN_WARNING "  Unable to create %s fs entry\n", name);
+                pr_warn("  Unable to create %s fs entry\n", name);
                 return -1;
         }
         proc->uid = asus_uid;
@@ -1085,8 +1078,8 @@ static int asus_hotk_add_fs(struct acpi_device *device)
                 mode = S_IFREG | S_IRUGO | S_IWUSR | S_IWGRP;
         } else {
                 mode = S_IFREG | S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP;
-                printk(KERN_WARNING "  asus_uid and asus_gid parameters are "
-                       "deprecated, use chown and chmod instead!\n");
+                pr_warn("  asus_uid and asus_gid parameters are "
+                        "deprecated, use chown and chmod instead!\n");
         }
 
         acpi_device_dir(device) = asus_proc_dir;
@@ -1099,8 +1092,7 @@ static int asus_hotk_add_fs(struct acpi_device *device)
                 proc->uid = asus_uid;
                 proc->gid = asus_gid;
         } else {
-                printk(KERN_WARNING "  Unable to create " PROC_INFO
-                       " fs entry\n");
+                pr_warn("  Unable to create " PROC_INFO " fs entry\n");
         }
 
         if (hotk->methods->mt_wled) {
@@ -1283,20 +1275,19 @@ static int asus_hotk_get_info(void)
          */
         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus_info);
         if (ACPI_FAILURE(status))
-                printk(KERN_WARNING "  Couldn't get the DSDT table header\n");
+                pr_warn("  Couldn't get the DSDT table header\n");
 
         /* We have to write 0 on init this far for all ASUS models */
         if (!write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
-                printk(KERN_ERR "  Hotkey initialization failed\n");
+                pr_err("  Hotkey initialization failed\n");
                 return -ENODEV;
         }
 
         /* This needs to be called for some laptops to init properly */
         if (!read_acpi_int(hotk->handle, "BSTS", &bsts_result))
-                printk(KERN_WARNING "  Error calling BSTS\n");
+                pr_warn("  Error calling BSTS\n");
         else if (bsts_result)
-                printk(KERN_NOTICE "  BSTS called, 0x%02x returned\n",
-                       bsts_result);
+                pr_notice("  BSTS called, 0x%02x returned\n", bsts_result);
 
         /*
          * Try to match the object returned by INIT to the specific model.
@@ -1324,23 +1315,21 @@ static int asus_hotk_get_info(void)
                 if (asus_info &&
                     strncmp(asus_info->oem_table_id, "ODEM", 4) == 0) {
                         hotk->model = P30;
-                        printk(KERN_NOTICE
-                               "  Samsung P30 detected, supported\n");
+                        pr_notice("  Samsung P30 detected, supported\n");
                         hotk->methods = &model_conf[hotk->model];
                         kfree(model);
                         return 0;
                 } else {
                         hotk->model = M2E;
-                        printk(KERN_NOTICE "  unsupported model %s, trying "
-                               "default values\n", string);
-                        printk(KERN_NOTICE
-                               "  send /proc/acpi/dsdt to the developers\n");
+                        pr_notice("  unsupported model %s, trying default values\n",
+                                  string);
+                        pr_notice("  send /proc/acpi/dsdt to the developers\n");
                         kfree(model);
                         return -ENODEV;
                 }
         }
         hotk->methods = &model_conf[hotk->model];
-        printk(KERN_NOTICE "  %s model detected, supported\n", string);
+        pr_notice("  %s model detected, supported\n", string);
 
         /* Sort of per-model blacklist */
         if (strncmp(string, "L2B", 3) == 0)
@@ -1385,7 +1374,7 @@ static int asus_hotk_check(void)
         if (hotk->device->status.present) {
                 result = asus_hotk_get_info();
         } else {
-                printk(KERN_ERR "  Hotkey device not present, aborting\n");
+                pr_err("  Hotkey device not present, aborting\n");
                 return -EINVAL;
         }
 
@@ -1399,8 +1388,7 @@ static int asus_hotk_add(struct acpi_device *device)
         acpi_status status = AE_OK;
         int result;
 
-        printk(KERN_NOTICE "Asus Laptop ACPI Extras version %s\n",
-               ASUS_ACPI_VERSION);
+        pr_notice("Asus Laptop ACPI Extras version %s\n", ASUS_ACPI_VERSION);
 
         hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
         if (!hotk)
@@ -1428,15 +1416,14 @@ static int asus_hotk_add(struct acpi_device *device)
                     acpi_evaluate_object(NULL, hotk->methods->brightness_down,
                                          NULL, NULL);
                 if (ACPI_FAILURE(status))
-                        printk(KERN_WARNING "  Error changing brightness\n");
+                        pr_warn("  Error changing brightness\n");
                 else {
                         status =
                             acpi_evaluate_object(NULL,
                                                  hotk->methods->brightness_up,
                                                  NULL, NULL);
                         if (ACPI_FAILURE(status))
-                                printk(KERN_WARNING "  Strange, error changing"
-                                       " brightness\n");
+                                pr_warn("  Strange, error changing brightness\n");
                 }
         }
 
@@ -1488,7 +1475,7 @@ static int __init asus_acpi_init(void)
 
         asus_proc_dir = proc_mkdir(PROC_ASUS, acpi_root_dir);
         if (!asus_proc_dir) {
-                printk(KERN_ERR "Asus ACPI: Unable to create /proc entry\n");
+                pr_err("Unable to create /proc entry\n");
                 acpi_bus_unregister_driver(&asus_hotk_driver);
                 return -ENODEV;
         }
@@ -1513,7 +1500,7 @@ static int __init asus_acpi_init(void)
                                                           &asus_backlight_data,
                                                           &props);
         if (IS_ERR(asus_backlight_device)) {
-                printk(KERN_ERR "Could not register asus backlight device\n");
+                pr_err("Could not register asus backlight device\n");
                 asus_backlight_device = NULL;
                 asus_acpi_exit();
                 return -ENODEV;
diff --git a/drivers/platform/x86/compal-laptop.c b/drivers/platform/x86/compal-laptop.c
index c16a27641ced..3f204fde1b02 100644
--- a/drivers/platform/x86/compal-laptop.c
+++ b/drivers/platform/x86/compal-laptop.c
@@ -68,6 +68,8 @@
  * only enabled on a JHL90 board until it is verified that they work on the
  * other boards too.  See the extra_features variable. */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -200,8 +202,8 @@ static bool extra_features;
  * watching the output of address 0x4F (do an ec_transaction writing 0x33
  * 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 labelled "fan1 table information" in the service manual.
+ *      ec_transaction(0x4F, &writeData, 1, buffer, 32);
+ * That address is labeled "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
@@ -286,7 +288,7 @@ static int get_backlight_level(void)
 static void set_backlight_state(bool on)
 {
         u8 data = on ? BACKLIGHT_STATE_ON_DATA : BACKLIGHT_STATE_OFF_DATA;
-        ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0, 0);
+        ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0);
 }
 
 
@@ -294,24 +296,24 @@ static void set_backlight_state(bool on)
 static void pwm_enable_control(void)
 {
         unsigned char writeData = PWM_ENABLE_DATA;
-        ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0, 0);
+        ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0);
 }
 
 static void pwm_disable_control(void)
 {
         unsigned char writeData = PWM_DISABLE_DATA;
-        ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0, 0);
+        ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0);
 }
 
 static void set_pwm(int pwm)
 {
-        ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0, 0);
+        ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0);
 }
 
 static int get_fan_rpm(void)
 {
         u8 value, data = FAN_DATA;
-        ec_transaction(FAN_ADDRESS, &data, 1, &value, 1, 0);
+        ec_transaction(FAN_ADDRESS, &data, 1, &value, 1);
         return 100 * (int)value;
 }
 
@@ -760,16 +762,14 @@ static struct rfkill *bt_rfkill;
 
 static int dmi_check_cb(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO DRIVER_NAME": Identified laptop model '%s'\n",
-                id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         extra_features = false;
         return 1;
 }
 
 static int dmi_check_cb_extra(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO DRIVER_NAME": Identified laptop model '%s', "
-                "enabling extra features\n",
+        pr_info("Identified laptop model '%s', enabling extra features\n",
                 id->ident);
         extra_features = true;
         return 1;
@@ -956,14 +956,12 @@ static int __init compal_init(void)
         int ret;
 
         if (acpi_disabled) {
-                printk(KERN_ERR DRIVER_NAME": ACPI needs to be enabled for "
-                                                "this driver to work!\n");
+                pr_err("ACPI needs to be enabled for this driver to work!\n");
                 return -ENODEV;
         }
 
         if (!force && !dmi_check_system(compal_dmi_table)) {
-                printk(KERN_ERR DRIVER_NAME": Motherboard not recognized (You "
-                                "could try the module's force-parameter)");
+                pr_err("Motherboard not recognized (You could try the module's force-parameter)\n");
                 return -ENODEV;
         }
 
@@ -998,8 +996,7 @@ static int __init compal_init(void)
         if (ret)
                 goto err_rfkill;
 
-        printk(KERN_INFO DRIVER_NAME": Driver "DRIVER_VERSION
-                                                " successfully loaded\n");
+        pr_info("Driver " DRIVER_VERSION " successfully loaded\n");
         return 0;
 
 err_rfkill:
@@ -1064,7 +1061,7 @@ static void __exit compal_cleanup(void)
         rfkill_destroy(wifi_rfkill);
         rfkill_destroy(bt_rfkill);
 
-        printk(KERN_INFO DRIVER_NAME": Driver unloaded\n");
+        pr_info("Driver unloaded\n");
 }
 
 static int __devexit compal_remove(struct platform_device *pdev)
@@ -1074,8 +1071,7 @@ static int __devexit compal_remove(struct platform_device *pdev)
         if (!extra_features)
                 return 0;
 
-        printk(KERN_INFO DRIVER_NAME": Unloading: resetting fan control "
-                                                        "to motherboard\n");
+        pr_info("Unloading: resetting fan control to motherboard\n");
         pwm_disable_control();
 
         data = platform_get_drvdata(pdev);
diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index de301aa8e5c3..d3841de6a8cf 100644
--- a/drivers/platform/x86/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -11,6 +11,8 @@
  *  published by the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -434,8 +436,7 @@ static int __init dell_setup_rfkill(void)
         int ret;
 
         if (dmi_check_system(dell_blacklist)) {
-                printk(KERN_INFO "dell-laptop: Blacklisted hardware detected - "
-                                "not enabling rfkill\n");
+                pr_info("Blacklisted hardware detected - not enabling rfkill\n");
                 return 0;
         }
 
@@ -606,7 +607,7 @@ static int __init dell_init(void)
         dmi_walk(find_tokens, NULL);
 
         if (!da_tokens)  {
-                printk(KERN_INFO "dell-laptop: Unable to find dmi tokens\n");
+                pr_info("Unable to find dmi tokens\n");
                 return -ENODEV;
         }
 
@@ -636,14 +637,13 @@ static int __init dell_init(void)
         ret = dell_setup_rfkill();
 
         if (ret) {
-                printk(KERN_WARNING "dell-laptop: Unable to setup rfkill\n");
+                pr_warn("Unable to setup rfkill\n");
                 goto fail_rfkill;
         }
 
         ret = i8042_install_filter(dell_laptop_i8042_filter);
         if (ret) {
-                printk(KERN_WARNING
-                       "dell-laptop: Unable to install key filter\n");
+                pr_warn("Unable to install key filter\n");
                 goto fail_filter;
         }
 
diff --git a/drivers/platform/x86/dell-wmi-aio.c b/drivers/platform/x86/dell-wmi-aio.c
index 0ed84573ae1f..3f945457f71c 100644
--- a/drivers/platform/x86/dell-wmi-aio.c
+++ b/drivers/platform/x86/dell-wmi-aio.c
@@ -15,6 +15,7 @@
  *  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>
@@ -138,7 +139,7 @@ static int __init dell_wmi_aio_init(void)
 
         guid = dell_wmi_aio_find();
         if (!guid) {
-                pr_warning("No known WMI GUID found\n");
+                pr_warn("No known WMI GUID found\n");
                 return -ENXIO;
         }
 
diff --git a/drivers/platform/x86/dell-wmi.c b/drivers/platform/x86/dell-wmi.c
index 77f1d55414c6..ce790827e199 100644
--- a/drivers/platform/x86/dell-wmi.c
+++ b/drivers/platform/x86/dell-wmi.c
@@ -23,6 +23,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>
@@ -141,7 +143,7 @@ static void dell_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO "dell-wmi: bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -153,8 +155,8 @@ static void dell_wmi_notify(u32 value, void *context)
                 u16 *buffer_entry = (u16 *)obj->buffer.pointer;
 
                 if (dell_new_hk_type && (buffer_entry[1] != 0x10)) {
-                        printk(KERN_INFO "dell-wmi: Received unknown WMI event"
-                                         " (0x%x)\n", buffer_entry[1]);
+                        pr_info("Received unknown WMI event (0x%x)\n",
+                                buffer_entry[1]);
                         kfree(obj);
                         return;
                 }
@@ -167,8 +169,7 @@ static void dell_wmi_notify(u32 value, void *context)
                 key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
                                                         reported_key);
                 if (!key) {
-                        printk(KERN_INFO "dell-wmi: Unknown key %x pressed\n",
-                                reported_key);
+                        pr_info("Unknown key %x pressed\n", reported_key);
                 } else if ((key->keycode == KEY_BRIGHTNESSUP ||
                             key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
                         /* Don't report brightness notifications that will also
@@ -275,7 +276,7 @@ static int __init dell_wmi_init(void)
         acpi_status status;
 
         if (!wmi_has_guid(DELL_EVENT_GUID)) {
-                printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
+                pr_warn("No known WMI GUID found\n");
                 return -ENODEV;
         }
 
@@ -290,9 +291,7 @@ static int __init dell_wmi_init(void)
                                          dell_wmi_notify, NULL);
         if (ACPI_FAILURE(status)) {
                 dell_wmi_input_destroy();
-                printk(KERN_ERR
-                        "dell-wmi: Unable to register notify handler - %d\n",
-                        status);
+                pr_err("Unable to register notify handler - %d\n", status);
                 return -ENODEV;
         }
 
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 2c1abf63957f..1c45d92e2163 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -228,7 +228,7 @@ static int set_acpi(struct eeepc_laptop *eeepc, int cm, int value)
                 return -ENODEV;
 
         if (write_acpi_int(eeepc->handle, method, value))
-                pr_warning("Error writing %s\n", method);
+                pr_warn("Error writing %s\n", method);
         return 0;
 }
 
@@ -243,7 +243,7 @@ static int get_acpi(struct eeepc_laptop *eeepc, int cm)
                 return -ENODEV;
 
         if (read_acpi_int(eeepc->handle, method, &value))
-                pr_warning("Error reading %s\n", method);
+                pr_warn("Error reading %s\n", method);
         return value;
 }
 
@@ -261,7 +261,7 @@ static int acpi_setter_handle(struct eeepc_laptop *eeepc, int cm,
         status = acpi_get_handle(eeepc->handle, (char *)method,
                                  handle);
         if (status != AE_OK) {
-                pr_warning("Error finding %s\n", method);
+                pr_warn("Error finding %s\n", method);
                 return -ENODEV;
         }
         return 0;
@@ -417,7 +417,7 @@ static ssize_t store_cpufv_disabled(struct device *dev,
         switch (value) {
         case 0:
                 if (eeepc->cpufv_disabled)
-                        pr_warning("cpufv enabled (not officially supported "
+                        pr_warn("cpufv enabled (not officially supported "
                                 "on this model)\n");
                 eeepc->cpufv_disabled = false;
                 return rv;
@@ -609,7 +609,7 @@ static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc, acpi_handle handle)
                 bus = port->subordinate;
 
                 if (!bus) {
-                        pr_warning("Unable to find PCI bus?\n");
+                        pr_warn("Unable to find PCI bus 1?\n");
                         goto out_unlock;
                 }
 
@@ -621,12 +621,12 @@ static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc, acpi_handle handle)
                 absent = (l == 0xffffffff);
 
                 if (blocked != absent) {
-                        pr_warning("BIOS says wireless lan is %s, "
-                                        "but the pci device is %s\n",
+                        pr_warn("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");
+                        pr_warn("skipped wireless hotplug as probably "
+                                "inappropriate for this model\n");
                         goto out_unlock;
                 }
 
@@ -691,7 +691,8 @@ static int eeepc_register_rfkill_notifier(struct eeepc_laptop *eeepc,
                                                      eeepc_rfkill_notify,
                                                      eeepc);
                 if (ACPI_FAILURE(status))
-                        pr_warning("Failed to register notify on %s\n", node);
+                        pr_warn("Failed to register notify on %s\n", node);
+
                 /*
                  * Refresh pci hotplug in case the rfkill state was
                  * changed during setup.
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
index 649dcadd8ea3..4aa867a9b88b 100644
--- a/drivers/platform/x86/eeepc-wmi.c
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -84,7 +84,7 @@ static const struct key_entry eeepc_wmi_keymap[] = {
 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);
+        pr_warn("Found legacy ATKD device (%s)\n", EEEPC_ACPI_HID);
         *(bool *)context = true;
         return AE_CTRL_TERMINATE;
 }
@@ -105,12 +105,12 @@ static int eeepc_wmi_check_atkd(void)
 static int eeepc_wmi_probe(struct platform_device *pdev)
 {
         if (eeepc_wmi_check_atkd()) {
-                pr_warning("WMI device present, but legacy ATKD device is also "
-                           "present and enabled.");
-                pr_warning("You probably booted with acpi_osi=\"Linux\" or "
-                           "acpi_osi=\"!Windows 2009\"");
-                pr_warning("Can't load eeepc-wmi, use default acpi_osi "
-                           "(preferred) or eeepc-laptop");
+                pr_warn("WMI device present, but legacy ATKD device is also "
+                        "present and enabled\n");
+                pr_warn("You probably booted with acpi_osi=\"Linux\" or "
+                        "acpi_osi=\"!Windows 2009\"\n");
+                pr_warn("Can't load eeepc-wmi, use default acpi_osi "
+                        "(preferred) or eeepc-laptop\n");
                 return -EBUSY;
         }
         return 0;
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index 493054c2dbe1..6b26666b37f2 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -56,6 +56,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -585,8 +587,7 @@ static struct platform_driver fujitsupf_driver = {
 static void dmi_check_cb_common(const struct dmi_system_id *id)
 {
         acpi_handle handle;
-        printk(KERN_INFO "fujitsu-laptop: Identified laptop model '%s'.\n",
-               id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         if (use_alt_lcd_levels == -1) {
                 if (ACPI_SUCCESS(acpi_get_handle(NULL,
                                 "\\_SB.PCI0.LPCB.FJEX.SBL2", &handle)))
@@ -691,11 +692,11 @@ static int acpi_fujitsu_add(struct acpi_device *device)
 
         result = acpi_bus_update_power(fujitsu->acpi_handle, &state);
         if (result) {
-                printk(KERN_ERR "Error reading power state\n");
+                pr_err("Error reading power state\n");
                 goto err_unregister_input_dev;
         }
 
-        printk(KERN_INFO "ACPI: %s [%s] (%s)\n",
+        pr_info("ACPI: %s [%s] (%s)\n",
                acpi_device_name(device), acpi_device_bid(device),
                !device->power.state ? "on" : "off");
 
@@ -707,7 +708,7 @@ static int acpi_fujitsu_add(struct acpi_device *device)
                 if (ACPI_FAILURE
                     (acpi_evaluate_object
                      (device->handle, METHOD_NAME__INI, NULL, NULL)))
-                        printk(KERN_ERR "_INI Method failed\n");
+                        pr_err("_INI Method failed\n");
         }
 
         /* do config (detect defaults) */
@@ -827,7 +828,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
         error = kfifo_alloc(&fujitsu_hotkey->fifo, RINGBUFFERSIZE * sizeof(int),
                         GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 goto err_stop;
         }
 
@@ -859,13 +860,13 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
 
         result = acpi_bus_update_power(fujitsu_hotkey->acpi_handle, &state);
         if (result) {
-                printk(KERN_ERR "Error reading power state\n");
+                pr_err("Error reading power state\n");
                 goto err_unregister_input_dev;
         }
 
-        printk(KERN_INFO "ACPI: %s [%s] (%s)\n",
-               acpi_device_name(device), acpi_device_bid(device),
-               !device->power.state ? "on" : "off");
+        pr_info("ACPI: %s [%s] (%s)\n",
+                acpi_device_name(device), acpi_device_bid(device),
+                !device->power.state ? "on" : "off");
 
         fujitsu_hotkey->dev = device;
 
@@ -875,7 +876,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (ACPI_FAILURE
                     (acpi_evaluate_object
                      (device->handle, METHOD_NAME__INI, NULL, NULL)))
-                        printk(KERN_ERR "_INI Method failed\n");
+                        pr_err("_INI Method failed\n");
         }
 
         i = 0;
@@ -897,8 +898,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                         call_fext_func(FUNC_RFKILL, 0x4, 0x0, 0x0);
 
         /* Suspect this is a keymap of the application panel, print it */
-        printk(KERN_INFO "fujitsu-laptop: BTNI: [0x%x]\n",
-                call_fext_func(FUNC_BUTTONS, 0x0, 0x0, 0x0));
+        pr_info("BTNI: [0x%x]\n", call_fext_func(FUNC_BUTTONS, 0x0, 0x0, 0x0));
 
 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
         if (call_fext_func(FUNC_LEDS, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON) {
@@ -907,8 +907,8 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (result == 0) {
                         fujitsu_hotkey->logolamp_registered = 1;
                 } else {
-                        printk(KERN_ERR "fujitsu-laptop: Could not register "
-                        "LED handler for logo lamp, error %i\n", result);
+                        pr_err("Could not register LED handler for logo lamp, error %i\n",
+                               result);
                 }
         }
 
@@ -919,8 +919,8 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (result == 0) {
                         fujitsu_hotkey->kblamps_registered = 1;
                 } else {
-                        printk(KERN_ERR "fujitsu-laptop: Could not register "
-                        "LED handler for keyboard lamps, error %i\n", result);
+                        pr_err("Could not register LED handler for keyboard lamps, error %i\n",
+                               result);
                 }
         }
 #endif
@@ -1169,8 +1169,7 @@ static int __init fujitsu_init(void)
                         fujitsu->bl_device->props.power = 0;
         }
 
-        printk(KERN_INFO "fujitsu-laptop: driver " FUJITSU_DRIVER_VERSION
-               " successfully loaded.\n");
+        pr_info("driver " FUJITSU_DRIVER_VERSION " successfully loaded\n");
 
         return 0;
 
@@ -1216,7 +1215,7 @@ static void __exit fujitsu_cleanup(void)
 
         kfree(fujitsu);
 
-        printk(KERN_INFO "fujitsu-laptop: driver unloaded.\n");
+        pr_info("driver unloaded\n");
 }
 
 module_init(fujitsu_init);
diff --git a/drivers/platform/x86/hdaps.c b/drivers/platform/x86/hdaps.c
index 067bf36d32f3..5a34973dc164 100644
--- a/drivers/platform/x86/hdaps.c
+++ b/drivers/platform/x86/hdaps.c
@@ -26,6 +26,8 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/input-polldev.h>
@@ -238,7 +240,7 @@ static int hdaps_device_init(void)
                      __check_latch(0x1611, 0x01))
                 goto out;
 
-        printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x).\n",
+        printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x)\n",
                __get_latch(0x1611));
 
         outb(0x17, 0x1610);
@@ -299,7 +301,7 @@ static int hdaps_probe(struct platform_device *dev)
         if (ret)
                 return ret;
 
-        printk(KERN_INFO "hdaps: device successfully initialized.\n");
+        pr_info("device successfully initialized\n");
         return 0;
 }
 
@@ -480,7 +482,7 @@ static struct attribute_group hdaps_attribute_group = {
 /* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
 static int __init hdaps_dmi_match(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
+        pr_info("%s detected\n", id->ident);
         return 1;
 }
 
@@ -488,8 +490,7 @@ static int __init hdaps_dmi_match(const struct dmi_system_id *id)
 static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
 {
         hdaps_invert = (unsigned long)id->driver_data;
-        printk(KERN_INFO "hdaps: inverting axis (%u) readings.\n",
-               hdaps_invert);
+        pr_info("inverting axis (%u) readings\n", hdaps_invert);
         return hdaps_dmi_match(id);
 }
 
@@ -543,7 +544,7 @@ static int __init hdaps_init(void)
         int ret;
 
         if (!dmi_check_system(hdaps_whitelist)) {
-                printk(KERN_WARNING "hdaps: supported laptop not found!\n");
+                pr_warn("supported laptop not found!\n");
                 ret = -ENODEV;
                 goto out;
         }
@@ -595,7 +596,7 @@ static int __init hdaps_init(void)
         if (ret)
                 goto out_idev;
 
-        printk(KERN_INFO "hdaps: driver successfully loaded.\n");
+        pr_info("driver successfully loaded\n");
         return 0;
 
 out_idev:
@@ -609,7 +610,7 @@ out_driver:
 out_region:
         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 out:
-        printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
+        pr_warn("driver init failed (ret=%d)!\n", ret);
         return ret;
 }
 
@@ -622,7 +623,7 @@ static void __exit hdaps_exit(void)
         platform_driver_unregister(&hdaps_driver);
         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 
-        printk(KERN_INFO "hdaps: driver unloaded.\n");
+        pr_info("driver unloaded\n");
 }
 
 module_init(hdaps_init);
diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c
index 1bc4a7539ba9..f94017bcdd6e 100644
--- a/drivers/platform/x86/hp-wmi.c
+++ b/drivers/platform/x86/hp-wmi.c
@@ -24,6 +24,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>
@@ -54,9 +56,6 @@ MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
 #define HPWMI_HOTKEY_QUERY 0xc
 #define HPWMI_WIRELESS2_QUERY 0x1b
 
-#define PREFIX "HP WMI: "
-#define UNIMP "Unimplemented "
-
 enum hp_wmi_radio {
         HPWMI_WIFI = 0,
         HPWMI_BLUETOOTH = 1,
@@ -228,9 +227,8 @@ static int hp_wmi_perform_query(int query, int write, void *buffer,
 
         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);
+                        pr_warn("query 0x%x returned error 0x%x\n",
+                                query, bios_return->return_code);
                 kfree(obj);
                 return bios_return->return_code;
         }
@@ -384,8 +382,7 @@ static int hp_wmi_rfkill2_refresh(void)
 
                 if (num >= state.count ||
                     devstate->rfkill_id != rfkill2[i].id) {
-                        printk(KERN_WARNING PREFIX "power configuration of "
-                               "the wireless devices unexpectedly changed\n");
+                        pr_warn("power configuration of the wireless devices unexpectedly changed\n");
                         continue;
                 }
 
@@ -471,7 +468,7 @@ static void hp_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO PREFIX "bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -480,8 +477,7 @@ static void hp_wmi_notify(u32 value, void *context)
         if (!obj)
                 return;
         if (obj->type != ACPI_TYPE_BUFFER) {
-                printk(KERN_INFO "hp-wmi: Unknown response received %d\n",
-                       obj->type);
+                pr_info("Unknown response received %d\n", obj->type);
                 kfree(obj);
                 return;
         }
@@ -498,8 +494,7 @@ static void hp_wmi_notify(u32 value, void *context)
                 event_id = *location;
                 event_data = *(location + 2);
         } else {
-                printk(KERN_INFO "hp-wmi: Unknown buffer length %d\n",
-                       obj->buffer.length);
+                pr_info("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return;
         }
@@ -527,8 +522,7 @@ static void hp_wmi_notify(u32 value, void *context)
 
                 if (!sparse_keymap_report_event(hp_wmi_input_dev,
                                                 key_code, 1, true))
-                        printk(KERN_INFO PREFIX "Unknown key code - 0x%x\n",
-                               key_code);
+                        pr_info("Unknown key code - 0x%x\n", key_code);
                 break;
         case HPWMI_WIRELESS:
                 if (rfkill2_count) {
@@ -550,14 +544,12 @@ static void hp_wmi_notify(u32 value, void *context)
                                           hp_wmi_get_hw_state(HPWMI_WWAN));
                 break;
         case HPWMI_CPU_BATTERY_THROTTLE:
-                printk(KERN_INFO PREFIX UNIMP "CPU throttle because of 3 Cell"
-                       " battery event detected\n");
+                pr_info("Unimplemented CPU throttle because of 3 Cell battery event detected\n");
                 break;
         case HPWMI_LOCK_SWITCH:
                 break;
         default:
-                printk(KERN_INFO PREFIX "Unknown event_id - %d - 0x%x\n",
-                       event_id, event_data);
+                pr_info("Unknown event_id - %d - 0x%x\n", event_id, event_data);
                 break;
         }
 }
@@ -705,7 +697,7 @@ static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
                 return err;
 
         if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {
-                printk(KERN_WARNING PREFIX "unable to parse 0x1b query output\n");
+                pr_warn("unable to parse 0x1b query output\n");
                 return -EINVAL;
         }
 
@@ -727,14 +719,14 @@ static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
                         name = "hp-wwan";
                         break;
                 default:
-                        printk(KERN_WARNING PREFIX "unknown device type 0x%x\n",
-                                 state.device[i].radio_type);
+                        pr_warn("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);
+                        pr_warn("zero device %d while %d reported\n",
+                                i, state.count);
                         continue;
                 }
 
@@ -755,8 +747,7 @@ static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
                                     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);
+                        pr_info("device %s blocked by BIOS\n", name);
 
                 err = rfkill_register(rfkill);
                 if (err) {
diff --git a/drivers/platform/x86/ibm_rtl.c b/drivers/platform/x86/ibm_rtl.c
index b1396e5b2953..811d436cd677 100644
--- a/drivers/platform/x86/ibm_rtl.c
+++ b/drivers/platform/x86/ibm_rtl.c
@@ -22,6 +22,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/module.h>
@@ -69,9 +71,10 @@ struct ibm_rtl_table {
 #define RTL_SIGNATURE 0x0000005f4c54525fULL
 #define RTL_MASK      0x000000ffffffffffULL
 
-#define RTL_DEBUG(A, ...) do { \
-        if (debug) \
-                pr_info("ibm-rtl: " A, ##__VA_ARGS__ ); \
+#define RTL_DEBUG(fmt, ...)                             \
+do {                                                    \
+        if (debug)                                      \
+                pr_info(fmt, ##__VA_ARGS__);            \
 } while (0)
 
 static DEFINE_MUTEX(rtl_lock);
@@ -114,7 +117,7 @@ static int ibm_rtl_write(u8 value)
         int ret = 0, count = 0;
         static u32 cmd_port_val;
 
-        RTL_DEBUG("%s(%d)\n", __FUNCTION__, value);
+        RTL_DEBUG("%s(%d)\n", __func__, value);
 
         value = value == 1 ? RTL_CMD_ENTER_PRTM : RTL_CMD_EXIT_PRTM;
 
@@ -144,8 +147,8 @@ static int ibm_rtl_write(u8 value)
                 while (ioread8(&rtl_table->command)) {
                         msleep(10);
                         if (count++ > 500) {
-                                pr_err("ibm-rtl: Hardware not responding to "
-                                        "mode switch request\n");
+                                pr_err("Hardware not responding to "
+                                       "mode switch request\n");
                                 ret = -EIO;
                                 break;
                         }
@@ -250,7 +253,7 @@ static int __init ibm_rtl_init(void) {
         int ret = -ENODEV, i;
 
         if (force)
-                pr_warning("ibm-rtl: module loaded by force\n");
+                pr_warn("module loaded by force\n");
         /* first ensure that we are running on IBM HW */
         else if (efi_enabled || !dmi_check_system(ibm_rtl_dmi_table))
                 return -ENODEV;
@@ -288,19 +291,19 @@ static int __init ibm_rtl_init(void) {
                 if ((readq(&tmp->signature) & RTL_MASK) == RTL_SIGNATURE) {
                         phys_addr_t addr;
                         unsigned int plen;
-                        RTL_DEBUG("found RTL_SIGNATURE at %#llx\n", (u64)tmp);
+                        RTL_DEBUG("found RTL_SIGNATURE at %p\n", tmp);
                         rtl_table = tmp;
                         /* The address, value, width and offset are platform
                          * dependent and found in the ibm_rtl_table */
                         rtl_cmd_width = ioread8(&rtl_table->cmd_granularity);
                         rtl_cmd_type = ioread8(&rtl_table->cmd_address_type);
                         RTL_DEBUG("rtl_cmd_width = %u, rtl_cmd_type = %u\n",
-                              rtl_cmd_width, rtl_cmd_type);
+                                  rtl_cmd_width, rtl_cmd_type);
                         addr = ioread32(&rtl_table->cmd_port_address);
                         RTL_DEBUG("addr = %#llx\n", (unsigned long long)addr);
                         plen = rtl_cmd_width/sizeof(char);
                         rtl_cmd_addr = rtl_port_map(addr, plen);
-                        RTL_DEBUG("rtl_cmd_addr = %#llx\n", (u64)rtl_cmd_addr);
+                        RTL_DEBUG("rtl_cmd_addr = %p\n", rtl_cmd_addr);
                         if (!rtl_cmd_addr) {
                                 ret = -ENOMEM;
                                 break;
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 21b101899bae..bfdda33feb26 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -20,6 +20,8 @@
  *  02110-1301, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
diff --git a/drivers/platform/x86/intel_menlow.c b/drivers/platform/x86/intel_menlow.c
index eacd5da7dd24..809adea4965f 100644
--- a/drivers/platform/x86/intel_menlow.c
+++ b/drivers/platform/x86/intel_menlow.c
@@ -27,6 +27,8 @@
  *  to get/set bandwidth.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -135,8 +137,7 @@ static int memory_set_cur_bandwidth(struct thermal_cooling_device *cdev,
             acpi_evaluate_integer(handle, MEMORY_SET_BANDWIDTH, &arg_list,
                                   &temp);
 
-        printk(KERN_INFO
-               "Bandwidth value was %ld: status is %d\n", state, status);
+        pr_info("Bandwidth value was %ld: status is %d\n", state, status);
         if (ACPI_FAILURE(status))
                 return -EFAULT;
 
diff --git a/drivers/platform/x86/intel_mid_powerbtn.c b/drivers/platform/x86/intel_mid_powerbtn.c
index 213e79ba68d5..f1ae5078b7ec 100644
--- a/drivers/platform/x86/intel_mid_powerbtn.c
+++ b/drivers/platform/x86/intel_mid_powerbtn.c
@@ -23,58 +23,48 @@
 #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;
-};
+#define MSIC_PB_LEVEL   (1 << 3) /* 1 - release, 0 - press */
 
 static irqreturn_t mfld_pb_isr(int irq, void *dev_id)
 {
-        struct mfld_pb_priv *priv = dev_id;
+        struct input_dev *input = 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);
+        if (ret < 0) {
+                dev_err(input->dev.parent, "Read error %d while reading"
+                               " MSIC_PB_STATUS\n", ret);
+        } else {
+                input_event(input, EV_KEY, KEY_POWER,
+                               !(pbstat & MSIC_PB_LEVEL));
+                input_sync(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 irq = platform_get_irq(pdev, 0);
         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;
+        if (!input) {
+                dev_err(&pdev->dev, "Input device allocation error\n");
+                return -ENOMEM;
         }
 
-        priv->input = input;
-        priv->irq = irq;
-
         input->name = pdev->name;
         input->phys = "power-button/input0";
         input->id.bustype = BUS_HOST;
@@ -82,42 +72,40 @@ static int __devinit mfld_pb_probe(struct platform_device *pdev)
 
         input_set_capability(input, EV_KEY, KEY_POWER);
 
-        error = request_threaded_irq(priv->irq, NULL, mfld_pb_isr,
-                                     0, DRIVER_NAME, priv);
+        error = request_threaded_irq(irq, NULL, mfld_pb_isr, 0,
+                        DRIVER_NAME, input);
         if (error) {
-                dev_err(&pdev->dev,
-                        "unable to request irq %d for mfld power button\n",
-                        irq);
-                goto err_free_mem;
+                dev_err(&pdev->dev, "Unable to request irq %d for mfld power"
+                                "button\n", irq);
+                goto err_free_input;
         }
 
         error = input_register_device(input);
         if (error) {
-                dev_err(&pdev->dev,
-                        "unable to register input dev, error %d\n", error);
+                dev_err(&pdev->dev, "Unable to register input dev, error "
+                                "%d\n", error);
                 goto err_free_irq;
         }
 
-        platform_set_drvdata(pdev, priv);
+        platform_set_drvdata(pdev, input);
         return 0;
 
 err_free_irq:
-        free_irq(priv->irq, priv);
-err_free_mem:
+        free_irq(irq, input);
+err_free_input:
         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);
+        struct input_dev *input = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
 
+        free_irq(irq, input);
+        input_unregister_device(input);
         platform_set_drvdata(pdev, NULL);
+
         return 0;
 }
 
diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
index c2f4bd8013b5..3a578323122b 100644
--- a/drivers/platform/x86/intel_mid_thermal.c
+++ b/drivers/platform/x86/intel_mid_thermal.c
@@ -37,49 +37,50 @@
 #include <asm/intel_scu_ipc.h>
 
 /* Number of thermal sensors */
-#define MSIC_THERMAL_SENSORS   4
+#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_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_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)
+#define MSIC_STOPBIT_MASK       16
+#define MSIC_ADCTHERM_MASK      4
+/* Number of ADC channels */
+#define ADC_CHANLS_MAX          15
+#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_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
+#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
+#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 */
+#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
+#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
@@ -87,15 +88,15 @@
 static int channel_index;
 
 struct platform_info {
-       struct platform_device *pdev;
-       struct thermal_zone_device *tzd[MSIC_THERMAL_SENSORS];
+        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;
+        unsigned int chnl_addr;
+        int direct;
+        /* This holds the current temperature in millidegree celsius */
+        long curr_temp;
 };
 
 /**
@@ -106,7 +107,7 @@ struct thermal_device_info {
  */
 static int to_msic_die_temp(uint16_t adc_val)
 {
-       return (368 * (adc_val) / 1000) - 220;
+        return (368 * (adc_val) / 1000) - 220;
 }
 
 /**
@@ -118,7 +119,7 @@ static int to_msic_die_temp(uint16_t adc_val)
  */
 static int is_valid_adc(uint16_t adc_val, uint16_t min, uint16_t max)
 {
-       return (adc_val >= min) && (adc_val <= max);
+        return (adc_val >= min) && (adc_val <= max);
 }
 
 /**
@@ -136,35 +137,35 @@ static int is_valid_adc(uint16_t adc_val, uint16_t min, uint16_t max)
  */
 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;
+        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;
 }
 
 /**
@@ -178,47 +179,47 @@ static int adc_to_temp(int direct, uint16_t adc_val, unsigned long *tp)
  */
 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 accommodate 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;
+        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 accommodate 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;
 }
 
 /**
@@ -231,22 +232,21 @@ static int mid_read_temp(struct thermal_zone_device *tzd, unsigned long *temp)
  */
 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);
+        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);
 }
 
 /**
@@ -259,30 +259,30 @@ static int configure_adc(int val)
  */
 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);
+        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);
 }
 
 /**
@@ -293,13 +293,13 @@ static int set_up_therm_channel(u16 base_addr)
  */
 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));
+        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));
 }
 
 /**
@@ -317,30 +317,30 @@ static int reset_stopbit(uint16_t addr)
  */
 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;
+        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;
 }
 
 /**
@@ -351,48 +351,48 @@ static int find_free_channel(void)
  */
 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;
+        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;
 }
 
 /**
@@ -403,18 +403,18 @@ static int mid_initialize_adc(struct device *dev)
  */
 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;
+        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;
 }
 
 /**
@@ -425,7 +425,7 @@ static struct thermal_device_info *initialize_sensor(int index)
  */
 static int mid_thermal_resume(struct platform_device *pdev)
 {
-       return mid_initialize_adc(&pdev->dev);
+        return mid_initialize_adc(&pdev->dev);
 }
 
 /**
@@ -437,12 +437,12 @@ static int mid_thermal_resume(struct platform_device *pdev)
  */
 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);
+        /*
+         * 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);
 }
 
 /**
@@ -453,16 +453,15 @@ static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
  */
 static int read_curr_temp(struct thermal_zone_device *tzd, unsigned long *temp)
 {
-       WARN_ON(tzd == NULL);
-       return mid_read_temp(tzd, 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,
+        .get_temp = read_curr_temp,
 };
 
-
 /**
  * mid_thermal_probe - mfld thermal initialize
  * @pdev: platform device structure
@@ -472,46 +471,45 @@ static struct thermal_zone_device_ops tzd_ops = {
  */
 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;
+        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;
+        ret = PTR_ERR(pinfo->tzd[i]);
+        while (--i >= 0)
+                thermal_zone_device_unregister(pinfo->tzd[i]);
+        configure_adc(0);
+        kfree(pinfo);
+        return ret;
 }
 
 /**
@@ -523,49 +521,46 @@ reg_fail:
  */
 static int mid_thermal_remove(struct platform_device *pdev)
 {
-       int i;
-       struct platform_info *pinfo = platform_get_drvdata(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]);
+        for (i = 0; i < MSIC_THERMAL_SENSORS; i++)
+                thermal_zone_device_unregister(pinfo->tzd[i]);
 
-       platform_set_drvdata(pdev, NULL);
+        kfree(pinfo);
+        platform_set_drvdata(pdev, NULL);
 
-       /* Stop the ADC */
-       return configure_adc(0);
+        /* 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 },
-       { }
+        { 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,
+        .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);
+        return platform_driver_register(&mid_thermal_driver);
 }
 
 static void __exit mid_thermal_module_exit(void)
 {
-       platform_driver_unregister(&mid_thermal_driver);
+        platform_driver_unregister(&mid_thermal_driver);
 }
 
 module_init(mid_thermal_module_init);
diff --git a/drivers/platform/x86/intel_oaktrail.c b/drivers/platform/x86/intel_oaktrail.c
new file mode 100644
index 000000000000..e936364a609d
--- /dev/null
+++ b/drivers/platform/x86/intel_oaktrail.c
@@ -0,0 +1,396 @@
+/*
+ * intel_oaktrail.c - Intel OakTrail Platform support.
+ *
+ * Copyright (C) 2010-2011 Intel Corporation
+ * Author: Yin Kangkai (kangkai.yin@intel.com)
+ *
+ * based on Compal driver, Copyright (C) 2008 Cezary Jackiewicz
+ * <cezary.jackiewicz (at) gmail.com>, based on MSI driver
+ * Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de>
+ *
+ *  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., 51 Franklin Street, Fifth Floor, Boston, MA
+ *  02110-1301, USA.
+ *
+ * This driver does below things:
+ * 1. registers itself in the Linux backlight control in
+ *    /sys/class/backlight/intel_oaktrail/
+ *
+ * 2. registers in the rfkill subsystem here: /sys/class/rfkill/rfkillX/
+ *    for these components: wifi, bluetooth, wwan (3g), gps
+ *
+ * This driver might work on other products based on Oaktrail. If you
+ * want to try it you can pass force=1 as argument to the module which
+ * will force it to load even when the DMI data doesn't identify the
+ * product as compatible.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/fb.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/backlight.h>
+#include <linux/platform_device.h>
+#include <linux/dmi.h>
+#include <linux/rfkill.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+
+#define DRIVER_NAME     "intel_oaktrail"
+#define DRIVER_VERSION  "0.4ac1"
+
+/*
+ * This is the devices status address in EC space, and the control bits
+ * definition:
+ *
+ * (1 << 0):    Camera enable/disable, RW.
+ * (1 << 1):    Bluetooth enable/disable, RW.
+ * (1 << 2):    GPS enable/disable, RW.
+ * (1 << 3):    WiFi enable/disable, RW.
+ * (1 << 4):    WWAN (3G) enable/disalbe, RW.
+ * (1 << 5):    Touchscreen enable/disable, Read Only.
+ */
+#define OT_EC_DEVICE_STATE_ADDRESS      0xD6
+
+#define OT_EC_CAMERA_MASK       (1 << 0)
+#define OT_EC_BT_MASK           (1 << 1)
+#define OT_EC_GPS_MASK          (1 << 2)
+#define OT_EC_WIFI_MASK         (1 << 3)
+#define OT_EC_WWAN_MASK         (1 << 4)
+#define OT_EC_TS_MASK           (1 << 5)
+
+/*
+ * This is the address in EC space and commands used to control LCD backlight:
+ *
+ * Two steps needed to change the LCD backlight:
+ *   1. write the backlight percentage into OT_EC_BL_BRIGHTNESS_ADDRESS;
+ *   2. write OT_EC_BL_CONTROL_ON_DATA into OT_EC_BL_CONTROL_ADDRESS.
+ *
+ * To read the LCD back light, just read out the value from
+ * OT_EC_BL_BRIGHTNESS_ADDRESS.
+ *
+ * LCD backlight brightness range: 0 - 100 (OT_EC_BL_BRIGHTNESS_MAX)
+ */
+#define OT_EC_BL_BRIGHTNESS_ADDRESS     0x44
+#define OT_EC_BL_BRIGHTNESS_MAX         100
+#define OT_EC_BL_CONTROL_ADDRESS        0x3A
+#define OT_EC_BL_CONTROL_ON_DATA        0x1A
+
+
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
+
+static struct platform_device *oaktrail_device;
+static struct backlight_device *oaktrail_bl_device;
+static struct rfkill *bt_rfkill;
+static struct rfkill *gps_rfkill;
+static struct rfkill *wifi_rfkill;
+static struct rfkill *wwan_rfkill;
+
+
+/* rfkill */
+static int oaktrail_rfkill_set(void *data, bool blocked)
+{
+        u8 value;
+        u8 result;
+        unsigned long radio = (unsigned long) data;
+
+        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &result);
+
+        if (!blocked)
+                value = (u8) (result | radio);
+        else
+                value = (u8) (result & ~radio);
+
+        ec_write(OT_EC_DEVICE_STATE_ADDRESS, value);
+
+        return 0;
+}
+
+static const struct rfkill_ops oaktrail_rfkill_ops = {
+        .set_block = oaktrail_rfkill_set,
+};
+
+static struct rfkill *oaktrail_rfkill_new(char *name, enum rfkill_type type,
+                                          unsigned long mask)
+{
+        struct rfkill *rfkill_dev;
+        u8 value;
+        int err;
+
+        rfkill_dev = rfkill_alloc(name, &oaktrail_device->dev, type,
+                                  &oaktrail_rfkill_ops, (void *)mask);
+        if (!rfkill_dev)
+                return ERR_PTR(-ENOMEM);
+
+        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &value);
+        rfkill_init_sw_state(rfkill_dev, (value & mask) != 1);
+
+        err = rfkill_register(rfkill_dev);
+        if (err) {
+                rfkill_destroy(rfkill_dev);
+                return ERR_PTR(err);
+        }
+
+        return rfkill_dev;
+}
+
+static inline void __oaktrail_rfkill_cleanup(struct rfkill *rf)
+{
+        if (rf) {
+                rfkill_unregister(rf);
+                rfkill_destroy(rf);
+        }
+}
+
+static void oaktrail_rfkill_cleanup(void)
+{
+        __oaktrail_rfkill_cleanup(wifi_rfkill);
+        __oaktrail_rfkill_cleanup(bt_rfkill);
+        __oaktrail_rfkill_cleanup(gps_rfkill);
+        __oaktrail_rfkill_cleanup(wwan_rfkill);
+}
+
+static int oaktrail_rfkill_init(void)
+{
+        int ret;
+
+        wifi_rfkill = oaktrail_rfkill_new("oaktrail-wifi",
+                                          RFKILL_TYPE_WLAN,
+                                          OT_EC_WIFI_MASK);
+        if (IS_ERR(wifi_rfkill)) {
+                ret = PTR_ERR(wifi_rfkill);
+                wifi_rfkill = NULL;
+                goto cleanup;
+        }
+
+        bt_rfkill = oaktrail_rfkill_new("oaktrail-bluetooth",
+                                        RFKILL_TYPE_BLUETOOTH,
+                                        OT_EC_BT_MASK);
+        if (IS_ERR(bt_rfkill)) {
+                ret = PTR_ERR(bt_rfkill);
+                bt_rfkill = NULL;
+                goto cleanup;
+        }
+
+        gps_rfkill = oaktrail_rfkill_new("oaktrail-gps",
+                                         RFKILL_TYPE_GPS,
+                                         OT_EC_GPS_MASK);
+        if (IS_ERR(gps_rfkill)) {
+                ret = PTR_ERR(gps_rfkill);
+                gps_rfkill = NULL;
+                goto cleanup;
+        }
+
+        wwan_rfkill = oaktrail_rfkill_new("oaktrail-wwan",
+                                          RFKILL_TYPE_WWAN,
+                                          OT_EC_WWAN_MASK);
+        if (IS_ERR(wwan_rfkill)) {
+                ret = PTR_ERR(wwan_rfkill);
+                wwan_rfkill = NULL;
+                goto cleanup;
+        }
+
+        return 0;
+
+cleanup:
+        oaktrail_rfkill_cleanup();
+        return ret;
+}
+
+
+/* backlight */
+static int get_backlight_brightness(struct backlight_device *b)
+{
+        u8 value;
+        ec_read(OT_EC_BL_BRIGHTNESS_ADDRESS, &value);
+
+        return value;
+}
+
+static int set_backlight_brightness(struct backlight_device *b)
+{
+        u8 percent = (u8) b->props.brightness;
+        if (percent < 0 || percent > OT_EC_BL_BRIGHTNESS_MAX)
+                return -EINVAL;
+
+        ec_write(OT_EC_BL_BRIGHTNESS_ADDRESS, percent);
+        ec_write(OT_EC_BL_CONTROL_ADDRESS, OT_EC_BL_CONTROL_ON_DATA);
+
+        return 0;
+}
+
+static const struct backlight_ops oaktrail_bl_ops = {
+        .get_brightness = get_backlight_brightness,
+        .update_status  = set_backlight_brightness,
+};
+
+static int oaktrail_backlight_init(void)
+{
+        struct backlight_device *bd;
+        struct backlight_properties props;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = OT_EC_BL_BRIGHTNESS_MAX;
+        bd = backlight_device_register(DRIVER_NAME,
+                                       &oaktrail_device->dev, NULL,
+                                       &oaktrail_bl_ops,
+                                       &props);
+
+        if (IS_ERR(bd)) {
+                oaktrail_bl_device = NULL;
+                pr_warning("Unable to register backlight device\n");
+                return PTR_ERR(bd);
+        }
+
+        oaktrail_bl_device = bd;
+
+        bd->props.brightness = get_backlight_brightness(bd);
+        bd->props.power = FB_BLANK_UNBLANK;
+        backlight_update_status(bd);
+
+        return 0;
+}
+
+static void oaktrail_backlight_exit(void)
+{
+        if (oaktrail_bl_device)
+                backlight_device_unregister(oaktrail_bl_device);
+}
+
+static int __devinit oaktrail_probe(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static int __devexit oaktrail_remove(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static struct platform_driver oaktrail_driver = {
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe  = oaktrail_probe,
+        .remove = __devexit_p(oaktrail_remove)
+};
+
+static int dmi_check_cb(const struct dmi_system_id *id)
+{
+        pr_info("Identified model '%s'\n", id->ident);
+        return 0;
+}
+
+static struct dmi_system_id __initdata oaktrail_dmi_table[] = {
+        {
+                .ident = "OakTrail platform",
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OakTrail platform"),
+                },
+                .callback = dmi_check_cb
+        },
+        { }
+};
+
+static int __init oaktrail_init(void)
+{
+        int ret;
+
+        if (acpi_disabled) {
+                pr_err("ACPI needs to be enabled for this driver to work!\n");
+                return -ENODEV;
+        }
+
+        if (!force && !dmi_check_system(oaktrail_dmi_table)) {
+                pr_err("Platform not recognized (You could try the module's force-parameter)");
+                return -ENODEV;
+        }
+
+        ret = platform_driver_register(&oaktrail_driver);
+        if (ret) {
+                pr_warning("Unable to register platform driver\n");
+                goto err_driver_reg;
+        }
+
+        oaktrail_device = platform_device_alloc(DRIVER_NAME, -1);
+        if (!oaktrail_device) {
+                pr_warning("Unable to allocate platform device\n");
+                ret = -ENOMEM;
+                goto err_device_alloc;
+        }
+
+        ret = platform_device_add(oaktrail_device);
+        if (ret) {
+                pr_warning("Unable to add platform device\n");
+                goto err_device_add;
+        }
+
+        if (!acpi_video_backlight_support()) {
+                ret = oaktrail_backlight_init();
+                if (ret)
+                        goto err_backlight;
+
+        } else
+                pr_info("Backlight controlled by ACPI video driver\n");
+
+        ret = oaktrail_rfkill_init();
+        if (ret) {
+                pr_warning("Setup rfkill failed\n");
+                goto err_rfkill;
+        }
+
+        pr_info("Driver "DRIVER_VERSION" successfully loaded\n");
+        return 0;
+
+err_rfkill:
+        oaktrail_backlight_exit();
+err_backlight:
+        platform_device_del(oaktrail_device);
+err_device_add:
+        platform_device_put(oaktrail_device);
+err_device_alloc:
+        platform_driver_unregister(&oaktrail_driver);
+err_driver_reg:
+
+        return ret;
+}
+
+static void __exit oaktrail_cleanup(void)
+{
+        oaktrail_backlight_exit();
+        oaktrail_rfkill_cleanup();
+        platform_device_unregister(oaktrail_device);
+        platform_driver_unregister(&oaktrail_driver);
+
+        pr_info("Driver unloaded\n");
+}
+
+module_init(oaktrail_init);
+module_exit(oaktrail_cleanup);
+
+MODULE_AUTHOR("Yin Kangkai (kangkai.yin@intel.com)");
+MODULE_DESCRIPTION("Intel Oaktrail Platform ACPI Extras");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("dmi:*:svnIntelCorporation:pnOakTrailplatform:*");
diff --git a/drivers/platform/x86/intel_pmic_gpio.c b/drivers/platform/x86/intel_pmic_gpio.c
index 464bb3fc4d88..1686c1e07d5d 100644
--- a/drivers/platform/x86/intel_pmic_gpio.c
+++ b/drivers/platform/x86/intel_pmic_gpio.c
@@ -19,6 +19,8 @@
  * Moorestown platform PMIC chip
  */
 
+#define pr_fmt(fmt) "%s: " fmt, __func__
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
@@ -90,8 +92,7 @@ static void pmic_program_irqtype(int gpio, int type)
 static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
         if (offset > 8) {
-                printk(KERN_ERR
-                        "%s: only pin 0-7 support input\n", __func__);
+                pr_err("only pin 0-7 support input\n");
                 return -1;/* we only have 8 GPIO can use as input */
         }
         return intel_scu_ipc_update_register(GPIO0 + offset,
@@ -116,8 +117,7 @@ static int pmic_gpio_direction_output(struct gpio_chip *chip,
                                 value ? 1 << (offset - 16) : 0,
                                 1 << (offset - 16));
         else {
-                printk(KERN_ERR
-                        "%s: invalid PMIC GPIO pin %d!\n", __func__, offset);
+                pr_err("invalid PMIC GPIO pin %d!\n", offset);
                 WARN_ON(1);
         }
 
@@ -260,7 +260,7 @@ static int __devinit platform_pmic_gpio_probe(struct platform_device *pdev)
         /* setting up SRAM mapping for GPIOINT register */
         pg->gpiointr = ioremap_nocache(pdata->gpiointr, 8);
         if (!pg->gpiointr) {
-                printk(KERN_ERR "%s: Can not map GPIOINT.\n", __func__);
+                pr_err("Can not map GPIOINT\n");
                 retval = -EINVAL;
                 goto err2;
         }
@@ -281,13 +281,13 @@ static int __devinit platform_pmic_gpio_probe(struct platform_device *pdev)
         pg->chip.dev = dev;
         retval = gpiochip_add(&pg->chip);
         if (retval) {
-                printk(KERN_ERR "%s: Can not add pmic gpio chip.\n", __func__);
+                pr_err("Can not add pmic gpio chip\n");
                 goto err;
         }
 
         retval = request_irq(pg->irq, pmic_irq_handler, 0, "pmic", pg);
         if (retval) {
-                printk(KERN_WARNING "pmic: Interrupt request failed\n");
+                pr_warn("Interrupt request failed\n");
                 goto err;
         }
 
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index 23fb2afda00b..3ff629df9f01 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -135,7 +135,7 @@ static int set_lcd_level(int level)
         buf[1] = (u8) (level*31);
 
         return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, buf, sizeof(buf),
-                              NULL, 0, 1);
+                              NULL, 0);
 }
 
 static int get_lcd_level(void)
@@ -144,7 +144,7 @@ static int get_lcd_level(void)
         int result;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -157,7 +157,7 @@ static int get_auto_brightness(void)
         int result;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -172,7 +172,7 @@ static int set_auto_brightness(int enable)
         wdata[0] = 4;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -180,7 +180,7 @@ static int set_auto_brightness(int enable)
         wdata[1] = (rdata & 0xF7) | (enable ? 8 : 0);
 
         return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 2,
-                              NULL, 0, 1);
+                              NULL, 0);
 }
 
 static ssize_t set_device_state(const char *buf, size_t count, u8 mask)
@@ -217,7 +217,7 @@ static int get_wireless_state(int *wlan, int *bluetooth)
         u8 wdata = 0, rdata;
         int result;
 
-        result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1, 1);
+        result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1);
         if (result < 0)
                 return -1;
 
@@ -447,7 +447,7 @@ static struct platform_device *msipf_device;
 
 static int dmi_check_cb(const struct dmi_system_id *id)
 {
-        pr_info("Identified laptop model '%s'.\n", id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         return 1;
 }
 
@@ -800,7 +800,7 @@ static void msi_laptop_input_destroy(void)
         input_unregister_device(msi_laptop_input_dev);
 }
 
-static int load_scm_model_init(struct platform_device *sdev)
+static int __init load_scm_model_init(struct platform_device *sdev)
 {
         u8 data;
         int result;
@@ -875,8 +875,7 @@ static int __init msi_init(void)
         /* Register backlight stuff */
 
         if (acpi_video_backlight_support()) {
-                pr_info("Brightness ignored, must be controlled "
-                       "by ACPI video driver\n");
+                pr_info("Brightness ignored, must be controlled by ACPI video driver\n");
         } else {
                 struct backlight_properties props;
                 memset(&props, 0, sizeof(struct backlight_properties));
@@ -930,7 +929,7 @@ static int __init msi_init(void)
         if (auto_brightness != 2)
                 set_auto_brightness(auto_brightness);
 
-        pr_info("driver "MSI_DRIVER_VERSION" successfully loaded.\n");
+        pr_info("driver " MSI_DRIVER_VERSION " successfully loaded\n");
 
         return 0;
 
@@ -978,7 +977,7 @@ static void __exit msi_cleanup(void)
         if (auto_brightness != 2)
                 set_auto_brightness(1);
 
-        pr_info("driver unloaded.\n");
+        pr_info("driver unloaded\n");
 }
 
 module_init(msi_init);
diff --git a/drivers/platform/x86/msi-wmi.c b/drivers/platform/x86/msi-wmi.c
index d5419c9ec07a..c832e3356cd6 100644
--- a/drivers/platform/x86/msi-wmi.c
+++ b/drivers/platform/x86/msi-wmi.c
@@ -20,6 +20,7 @@
  *  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/input.h>
@@ -36,13 +37,10 @@ MODULE_ALIAS("wmi:551A1F84-FBDD-4125-91DB-3EA8F44F1D45");
 MODULE_ALIAS("wmi:B6F3EEF2-3D2F-49DC-9DE3-85BCE18C62F2");
 
 #define DRV_NAME "msi-wmi"
-#define DRV_PFX DRV_NAME ": "
 
 #define MSIWMI_BIOS_GUID "551A1F84-FBDD-4125-91DB-3EA8F44F1D45"
 #define MSIWMI_EVENT_GUID "B6F3EEF2-3D2F-49DC-9DE3-85BCE18C62F2"
 
-#define dprintk(msg...) pr_debug(DRV_PFX msg)
-
 #define SCANCODE_BASE 0xD0
 #define MSI_WMI_BRIGHTNESSUP   SCANCODE_BASE
 #define MSI_WMI_BRIGHTNESSDOWN (SCANCODE_BASE + 1)
@@ -78,7 +76,7 @@ static int msi_wmi_query_block(int instance, int *ret)
 
         if (!obj || obj->type != ACPI_TYPE_INTEGER) {
                 if (obj) {
-                        printk(KERN_ERR DRV_PFX "query block returned object "
+                        pr_err("query block returned object "
                                "type: %d - buffer length:%d\n", obj->type,
                                obj->type == ACPI_TYPE_BUFFER ?
                                obj->buffer.length : 0);
@@ -97,8 +95,8 @@ static int msi_wmi_set_block(int instance, int value)
 
         struct acpi_buffer input = { sizeof(int), &value };
 
-        dprintk("Going to set block of instance: %d - value: %d\n",
-                instance, value);
+        pr_debug("Going to set block of instance: %d - value: %d\n",
+                 instance, value);
 
         status = wmi_set_block(MSIWMI_BIOS_GUID, instance, &input);
 
@@ -112,20 +110,19 @@ static int bl_get(struct backlight_device *bd)
         /* Instance 1 is "get backlight", cmp with DSDT */
         err = msi_wmi_query_block(1, &ret);
         if (err) {
-                printk(KERN_ERR DRV_PFX "Could not query backlight: %d\n", err);
+                pr_err("Could not query backlight: %d\n", err);
                 return -EINVAL;
         }
-        dprintk("Get: Query block returned: %d\n", ret);
+        pr_debug("Get: Query block returned: %d\n", ret);
         for (level = 0; level < ARRAY_SIZE(backlight_map); level++) {
                 if (backlight_map[level] == ret) {
-                        dprintk("Current backlight level: 0x%X - index: %d\n",
-                                backlight_map[level], level);
+                        pr_debug("Current backlight level: 0x%X - index: %d\n",
+                                 backlight_map[level], level);
                         break;
                 }
         }
         if (level == ARRAY_SIZE(backlight_map)) {
-                printk(KERN_ERR DRV_PFX "get: Invalid brightness value: 0x%X\n",
-                       ret);
+                pr_err("get: Invalid brightness value: 0x%X\n", ret);
                 return -EINVAL;
         }
         return level;
@@ -156,7 +153,7 @@ static void msi_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO DRV_PFX "bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -164,7 +161,7 @@ static void msi_wmi_notify(u32 value, void *context)
 
         if (obj && obj->type == ACPI_TYPE_INTEGER) {
                 int eventcode = obj->integer.value;
-                dprintk("Eventcode: 0x%x\n", eventcode);
+                pr_debug("Eventcode: 0x%x\n", eventcode);
                 key = sparse_keymap_entry_from_scancode(msi_wmi_input_dev,
                                 eventcode);
                 if (key) {
@@ -175,8 +172,8 @@ static void msi_wmi_notify(u32 value, void *context)
                         /* Ignore event if the same event happened in a 50 ms
                            timeframe -> Key press may result in 10-20 GPEs */
                         if (ktime_to_us(diff) < 1000 * 50) {
-                                dprintk("Suppressed key event 0x%X - "
-                                        "Last press was %lld us ago\n",
+                                pr_debug("Suppressed key event 0x%X - "
+                                         "Last press was %lld us ago\n",
                                          key->code, ktime_to_us(diff));
                                 return;
                         }
@@ -187,17 +184,16 @@ static void msi_wmi_notify(u32 value, void *context)
                         (!acpi_video_backlight_support() ||
                         (key->code != MSI_WMI_BRIGHTNESSUP &&
                         key->code != MSI_WMI_BRIGHTNESSDOWN))) {
-                                dprintk("Send key: 0x%X - "
-                                        "Input layer keycode: %d\n", key->code,
-                                         key->keycode);
+                                pr_debug("Send key: 0x%X - "
+                                         "Input layer keycode: %d\n",
+                                         key->code, key->keycode);
                                 sparse_keymap_report_entry(msi_wmi_input_dev,
                                                 key, 1, true);
                         }
                 } else
-                        printk(KERN_INFO "Unknown key pressed - %x\n",
-                               eventcode);
+                        pr_info("Unknown key pressed - %x\n", eventcode);
         } else
-                printk(KERN_INFO DRV_PFX "Unknown event received\n");
+                pr_info("Unknown event received\n");
         kfree(response.pointer);
 }
 
@@ -238,8 +234,7 @@ static int __init msi_wmi_init(void)
         int err;
 
         if (!wmi_has_guid(MSIWMI_EVENT_GUID)) {
-                printk(KERN_ERR
-                       "This machine doesn't have MSI-hotkeys through WMI\n");
+                pr_err("This machine doesn't have MSI-hotkeys through WMI\n");
                 return -ENODEV;
         }
         err = wmi_install_notify_handler(MSIWMI_EVENT_GUID,
@@ -270,7 +265,7 @@ static int __init msi_wmi_init(void)
 
                 backlight->props.brightness = err;
         }
-        dprintk("Event handler installed\n");
+        pr_debug("Event handler installed\n");
 
         return 0;
 
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 6fe8cd6e23b5..bbd182e178cb 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -42,6 +42,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
@@ -70,10 +72,10 @@
 #include <linux/miscdevice.h>
 #endif
 
-#define DRV_PFX                 "sony-laptop: "
-#define dprintk(msg...)         do {    \
-        if (debug)                      \
-                pr_warn(DRV_PFX msg);   \
+#define dprintk(fmt, ...)                       \
+do {                                            \
+        if (debug)                              \
+                pr_warn(fmt, ##__VA_ARGS__);    \
 } while (0)
 
 #define SONY_LAPTOP_DRIVER_VERSION      "0.6"
@@ -418,7 +420,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) {
-                pr_err(DRV_PFX "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 goto err_dec_users;
         }
 
@@ -702,7 +704,7 @@ static int acpi_callgetfunc(acpi_handle handle, char *name, int *result)
                 return 0;
         }
 
-        pr_warn(DRV_PFX "acpi_callreadfunc failed\n");
+        pr_warn("acpi_callreadfunc failed\n");
 
         return -1;
 }
@@ -728,8 +730,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) {
-                                pr_warn(DRV_PFX "acpi_evaluate_object bad "
-                                       "return type\n");
+                                pr_warn("acpi_evaluate_object bad return type\n");
                                 return -1;
                         }
                         *result = out_obj.integer.value;
@@ -737,7 +738,7 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
                 return 0;
         }
 
-        pr_warn(DRV_PFX "acpi_evaluate_object failed\n");
+        pr_warn("acpi_evaluate_object failed\n");
 
         return -1;
 }
@@ -961,7 +962,6 @@ static int sony_backlight_get_brightness(struct backlight_device *bd)
 static int sony_nc_get_brightness_ng(struct backlight_device *bd)
 {
         int result;
-        int *handle = (int *)bl_get_data(bd);
         struct sony_backlight_props *sdev =
                 (struct sony_backlight_props *)bl_get_data(bd);
 
@@ -973,7 +973,6 @@ static int sony_nc_get_brightness_ng(struct backlight_device *bd)
 static int sony_nc_update_status_ng(struct backlight_device *bd)
 {
         int value, result;
-        int *handle = (int *)bl_get_data(bd);
         struct sony_backlight_props *sdev =
                 (struct sony_backlight_props *)bl_get_data(bd);
 
@@ -1104,10 +1103,8 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                                 }
 
                                 if (!key_event->data)
-                                        pr_info(DRV_PFX
-                                                        "Unknown event: 0x%x 0x%x\n",
-                                                        key_handle,
-                                                        ev);
+                                        pr_info("Unknown event: 0x%x 0x%x\n",
+                                                key_handle, ev);
                                 else
                                         sony_laptop_report_input_event(ev);
                         }
@@ -1128,7 +1125,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))) {
-                pr_warn(DRV_PFX "method: name: %4.4s, args %X\n",
+                pr_warn("method: name: %4.4s, args %X\n",
                         (char *)&info->name, info->param_count);
 
                 kfree(info);
@@ -1169,7 +1166,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) {
-                        pr_err(DRV_PFX "%s: %d\n", __func__, ret);
+                        pr_err("%s: %d\n", __func__, ret);
                         break;
                 }
         }
@@ -1336,12 +1333,12 @@ static void sony_nc_rfkill_setup(struct acpi_device *device)
 
         device_enum = (union acpi_object *) buffer.pointer;
         if (!device_enum) {
-                pr_err(DRV_PFX "No SN06 return object.");
+                pr_err("No SN06 return object\n");
                 goto out_no_enum;
         }
         if (device_enum->type != ACPI_TYPE_BUFFER) {
-                pr_err(DRV_PFX "Invalid SN06 return object 0x%.2x\n",
-                                device_enum->type);
+                pr_err("Invalid SN06 return object 0x%.2x\n",
+                       device_enum->type);
                 goto out_no_enum;
         }
 
@@ -1662,7 +1659,7 @@ static void sony_nc_backlight_setup(void)
                                                       ops, &props);
 
         if (IS_ERR(sony_bl_props.dev)) {
-                pr_warn(DRV_PFX "unable to register backlight device\n");
+                pr_warn("unable to register backlight device\n");
                 sony_bl_props.dev = NULL;
         } else
                 sony_bl_props.dev->props.brightness =
@@ -1682,8 +1679,7 @@ static int sony_nc_add(struct acpi_device *device)
         acpi_handle handle;
         struct sony_nc_value *item;
 
-        pr_info(DRV_PFX "%s v%s.\n", SONY_NC_DRIVER_NAME,
-                        SONY_LAPTOP_DRIVER_VERSION);
+        pr_info("%s v%s\n", SONY_NC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
 
         sony_nc_acpi_device = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -1708,7 +1704,7 @@ static int sony_nc_add(struct acpi_device *device)
                                 sony_nc_acpi_handle, 1, sony_walk_callback,
                                 NULL, NULL, NULL);
                 if (ACPI_FAILURE(status)) {
-                        pr_warn(DRV_PFX "unable to walk acpi resources\n");
+                        pr_warn("unable to walk acpi resources\n");
                         result = -ENODEV;
                         goto outpresent;
                 }
@@ -1736,13 +1732,12 @@ static int sony_nc_add(struct acpi_device *device)
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                pr_err(DRV_PFX "Unable to create input devices.\n");
+                pr_err("Unable to create input devices\n");
                 goto outkbdbacklight;
         }
 
         if (acpi_video_backlight_support()) {
-                pr_info(DRV_PFX "brightness ignored, must be "
-                       "controlled by ACPI video driver\n");
+                pr_info("brightness ignored, must be controlled by ACPI video driver\n");
         } else {
                 sony_nc_backlight_setup();
         }
@@ -2265,9 +2260,9 @@ out:
         if (pcidev)
                 pci_dev_put(pcidev);
 
-        pr_info(DRV_PFX "detected Type%d model\n",
-                        dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
-                        dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
+        pr_info("detected Type%d model\n",
+                dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
+                dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
 }
 
 /* camera tests and poweron/poweroff */
@@ -2313,7 +2308,7 @@ static int __sony_pic_camera_ready(void)
 static int __sony_pic_camera_off(void)
 {
         if (!camera) {
-                pr_warn(DRV_PFX "camera control not enabled\n");
+                pr_warn("camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -2333,7 +2328,7 @@ static int __sony_pic_camera_on(void)
         int i, j, x;
 
         if (!camera) {
-                pr_warn(DRV_PFX "camera control not enabled\n");
+                pr_warn("camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -2356,7 +2351,7 @@ static int __sony_pic_camera_on(void)
         }
 
         if (j == 0) {
-                pr_warn(DRV_PFX "failed to power on camera\n");
+                pr_warn("failed to power on camera\n");
                 return -ENODEV;
         }
 
@@ -2412,8 +2407,7 @@ int sony_pic_camera_command(int command, u8 value)
                                 ITERATIONS_SHORT);
                 break;
         default:
-                pr_err(DRV_PFX "sony_pic_camera_command invalid: %d\n",
-                       command);
+                pr_err("sony_pic_camera_command invalid: %d\n", command);
                 break;
         }
         mutex_unlock(&spic_dev.lock);
@@ -2819,7 +2813,7 @@ static int sonypi_compat_init(void)
         error =
          kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                pr_err(DRV_PFX "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 return error;
         }
 
@@ -2829,12 +2823,12 @@ static int sonypi_compat_init(void)
                 sonypi_misc_device.minor = minor;
         error = misc_register(&sonypi_misc_device);
         if (error) {
-                pr_err(DRV_PFX "misc_register failed\n");
+                pr_err("misc_register failed\n");
                 goto err_free_kfifo;
         }
         if (minor == -1)
-                pr_info(DRV_PFX "device allocated minor is %d\n",
-                       sonypi_misc_device.minor);
+                pr_info("device allocated minor is %d\n",
+                        sonypi_misc_device.minor);
 
         return 0;
 
@@ -2893,8 +2887,8 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                         }
                         for (i = 0; i < p->interrupt_count; i++) {
                                 if (!p->interrupts[i]) {
-                                        pr_warn(DRV_PFX "Invalid IRQ %d\n",
-                                                        p->interrupts[i]);
+                                        pr_warn("Invalid IRQ %d\n",
+                                                p->interrupts[i]);
                                         continue;
                                 }
                                 interrupt = kzalloc(sizeof(*interrupt),
@@ -2932,14 +2926,14 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                                                 ioport->io2.address_length);
                         }
                         else {
-                                pr_err(DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n");
+                                pr_err("Unknown SPIC Type, more than 2 IO Ports\n");
                                 return AE_ERROR;
                         }
                         return AE_OK;
                 }
         default:
                 dprintk("Resource %d isn't an IRQ nor an IO port\n",
-                                resource->type);
+                        resource->type);
 
         case ACPI_RESOURCE_TYPE_END_TAG:
                 return AE_OK;
@@ -2960,7 +2954,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         dprintk("Evaluating _STA\n");
         result = acpi_bus_get_status(device);
         if (result) {
-                pr_warn(DRV_PFX "Unable to read status\n");
+                pr_warn("Unable to read status\n");
                 goto end;
         }
 
@@ -2976,8 +2970,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)) {
-                pr_warn(DRV_PFX "Failure evaluating %s\n",
-                                METHOD_NAME__PRS);
+                pr_warn("Failure evaluating %s\n", METHOD_NAME__PRS);
                 result = -ENODEV;
         }
 end:
@@ -3090,7 +3083,7 @@ static int sony_pic_enable(struct acpi_device *device,
 
         /* check for total failure */
         if (ACPI_FAILURE(status)) {
-                pr_err(DRV_PFX "Error evaluating _SRS\n");
+                pr_err("Error evaluating _SRS\n");
                 result = -ENODEV;
                 goto end;
         }
@@ -3182,7 +3175,7 @@ static int sony_pic_remove(struct acpi_device *device, int type)
         struct sony_pic_irq *irq, *tmp_irq;
 
         if (sony_pic_disable(device)) {
-                pr_err(DRV_PFX "Couldn't disable device.\n");
+                pr_err("Couldn't disable device\n");
                 return -ENXIO;
         }
 
@@ -3222,8 +3215,7 @@ static int sony_pic_add(struct acpi_device *device)
         struct sony_pic_ioport *io, *tmp_io;
         struct sony_pic_irq *irq, *tmp_irq;
 
-        pr_info(DRV_PFX "%s v%s.\n", SONY_PIC_DRIVER_NAME,
-                        SONY_LAPTOP_DRIVER_VERSION);
+        pr_info("%s v%s\n", SONY_PIC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
 
         spic_dev.acpi_dev = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -3233,14 +3225,14 @@ static int sony_pic_add(struct acpi_device *device)
         /* read _PRS resources */
         result = sony_pic_possible_resources(device);
         if (result) {
-                pr_err(DRV_PFX "Unable to read possible resources.\n");
+                pr_err("Unable to read possible resources\n");
                 goto err_free_resources;
         }
 
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                pr_err(DRV_PFX "Unable to create input devices.\n");
+                pr_err("Unable to create input devices\n");
                 goto err_free_resources;
         }
 
@@ -3281,7 +3273,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_ioport) {
-                pr_err(DRV_PFX "Failed to request_region.\n");
+                pr_err("Failed to request_region\n");
                 result = -ENODEV;
                 goto err_remove_compat;
         }
@@ -3301,7 +3293,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_irq) {
-                pr_err(DRV_PFX "Failed to request_irq.\n");
+                pr_err("Failed to request_irq\n");
                 result = -ENODEV;
                 goto err_release_region;
         }
@@ -3309,7 +3301,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) {
-                pr_err(DRV_PFX "Couldn't enable device.\n");
+                pr_err("Couldn't enable device\n");
                 goto err_free_irq;
         }
 
@@ -3418,7 +3410,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) {
-                        pr_err(DRV_PFX "Unable to register SPIC driver.");
+                        pr_err("Unable to register SPIC driver\n");
                         goto out;
                 }
                 spic_drv_registered = 1;
@@ -3426,7 +3418,7 @@ static int __init sony_laptop_init(void)
 
         result = acpi_bus_register_driver(&sony_nc_driver);
         if (result) {
-                pr_err(DRV_PFX "Unable to register SNC driver.");
+                pr_err("Unable to register SNC driver\n");
                 goto out_unregister_pic;
         }
 
diff --git a/drivers/platform/x86/tc1100-wmi.c b/drivers/platform/x86/tc1100-wmi.c
index 865ef78d6f1a..e24f5ae475af 100644
--- a/drivers/platform/x86/tc1100-wmi.c
+++ b/drivers/platform/x86/tc1100-wmi.c
@@ -25,6 +25,8 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -40,9 +42,6 @@
 #define TC1100_INSTANCE_WIRELESS                1
 #define TC1100_INSTANCE_JOGDIAL         2
 
-#define TC1100_LOGPREFIX "tc1100-wmi: "
-#define TC1100_INFO KERN_INFO TC1100_LOGPREFIX
-
 MODULE_AUTHOR("Jamey Hicks, Carlos Corbacho");
 MODULE_DESCRIPTION("HP Compaq TC1100 Tablet WMI Extras");
 MODULE_LICENSE("GPL");
@@ -264,7 +263,7 @@ static int __init tc1100_init(void)
         if (error)
                 goto err_device_del;
 
-        printk(TC1100_INFO "HP Compaq TC1100 Tablet WMI Extras loaded\n");
+        pr_info("HP Compaq TC1100 Tablet WMI Extras loaded\n");
         return 0;
 
  err_device_del:
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 562fcf0dd2b5..77f6e707a2a9 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -21,6 +21,8 @@
  *  02110-1301, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define TPACPI_VERSION "0.24"
 #define TPACPI_SYSFS_VERSION 0x020700
 
@@ -224,17 +226,6 @@ enum tpacpi_hkey_event_t {
 
 #define TPACPI_MAX_ACPI_ARGS 3
 
-/* printk headers */
-#define TPACPI_LOG TPACPI_FILE ": "
-#define TPACPI_EMERG    KERN_EMERG      TPACPI_LOG
-#define TPACPI_ALERT    KERN_ALERT      TPACPI_LOG
-#define TPACPI_CRIT     KERN_CRIT       TPACPI_LOG
-#define TPACPI_ERR      KERN_ERR        TPACPI_LOG
-#define TPACPI_WARN     KERN_WARNING    TPACPI_LOG
-#define TPACPI_NOTICE   KERN_NOTICE     TPACPI_LOG
-#define TPACPI_INFO     KERN_INFO       TPACPI_LOG
-#define TPACPI_DEBUG    KERN_DEBUG      TPACPI_LOG
-
 /* Debugging printk groups */
 #define TPACPI_DBG_ALL          0xffff
 #define TPACPI_DBG_DISCLOSETASK 0x8000
@@ -389,34 +380,36 @@ static int tpacpi_uwb_emulstate;
  *  Debugging helpers
  */
 
-#define dbg_printk(a_dbg_level, format, arg...) \
-        do { if (dbg_level & (a_dbg_level)) \
-                printk(TPACPI_DEBUG "%s: " format, __func__ , ## arg); \
-        } while (0)
+#define dbg_printk(a_dbg_level, format, arg...)                         \
+do {                                                                    \
+        if (dbg_level & (a_dbg_level))                                  \
+                printk(KERN_DEBUG pr_fmt("%s: " format),                \
+                       __func__, ##arg);                                \
+} while (0)
 
 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
 #define vdbg_printk dbg_printk
 static const char *str_supported(int is_supported);
 #else
-#define vdbg_printk(a_dbg_level, format, arg...) \
-        do { } while (0)
+static inline const char *str_supported(int is_supported) { return ""; }
+#define vdbg_printk(a_dbg_level, format, arg...)        \
+        no_printk(format, ##arg)
 #endif
 
 static void tpacpi_log_usertask(const char * const what)
 {
-        printk(TPACPI_DEBUG "%s: access by process with PID %d\n",
-                what, task_tgid_vnr(current));
+        printk(KERN_DEBUG pr_fmt("%s: access by process with PID %d\n"),
+               what, task_tgid_vnr(current));
 }
 
-#define tpacpi_disclose_usertask(what, format, arg...) \
-        do { \
-                if (unlikely( \
-                    (dbg_level & TPACPI_DBG_DISCLOSETASK) && \
-                    (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) { \
-                        printk(TPACPI_DEBUG "%s: PID %d: " format, \
-                                what, task_tgid_vnr(current), ## arg); \
-                } \
-        } while (0)
+#define tpacpi_disclose_usertask(what, format, arg...)                  \
+do {                                                                    \
+        if (unlikely((dbg_level & TPACPI_DBG_DISCLOSETASK) &&           \
+                     (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) {      \
+                printk(KERN_DEBUG pr_fmt("%s: PID %d: " format),        \
+                       what, task_tgid_vnr(current), ## arg);           \
+        }                                                               \
+} while (0)
 
 /*
  * Quirk handling helpers
@@ -535,15 +528,6 @@ TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY",	/* 600e/x, 770e, 770x */
            "HKEY",              /* all others */
            );                   /* 570 */
 
-TPACPI_HANDLE(vid, root, "\\_SB.PCI.AGP.VGA",   /* 570 */
-           "\\_SB.PCI0.AGP0.VID0",      /* 600e/x, 770x */
-           "\\_SB.PCI0.VID0",   /* 770e */
-           "\\_SB.PCI0.VID",    /* A21e, G4x, R50e, X30, X40 */
-           "\\_SB.PCI0.AGP.VGA",        /* X100e and a few others */
-           "\\_SB.PCI0.AGP.VID",        /* all others */
-           );                           /* R30, R31 */
-
-
 /*************************************************************************
  * ACPI helpers
  */
@@ -563,7 +547,7 @@ static int acpi_evalf(acpi_handle handle,
         int quiet;
 
         if (!*fmt) {
-                printk(TPACPI_ERR "acpi_evalf() called with empty format\n");
+                pr_err("acpi_evalf() called with empty format\n");
                 return 0;
         }
 
@@ -588,7 +572,7 @@ static int acpi_evalf(acpi_handle handle,
                         break;
                         /* add more types as needed */
                 default:
-                        printk(TPACPI_ERR "acpi_evalf() called "
+                        pr_err("acpi_evalf() called "
                                "with invalid format character '%c'\n", c);
                         va_end(ap);
                         return 0;
@@ -617,13 +601,13 @@ static int acpi_evalf(acpi_handle handle,
                 break;
                 /* add more types as needed */
         default:
-                printk(TPACPI_ERR "acpi_evalf() called "
+                pr_err("acpi_evalf() called "
                        "with invalid format character '%c'\n", res_type);
                 return 0;
         }
 
         if (!success && !quiet)
-                printk(TPACPI_ERR "acpi_evalf(%s, %s, ...) failed: %s\n",
+                pr_err("acpi_evalf(%s, %s, ...) failed: %s\n",
                        method, fmt0, acpi_format_exception(status));
 
         return success;
@@ -767,8 +751,7 @@ static int __init setup_acpi_notify(struct ibm_struct *ibm)
 
         rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
         if (rc < 0) {
-                printk(TPACPI_ERR "acpi_bus_get_device(%s) failed: %d\n",
-                        ibm->name, rc);
+                pr_err("acpi_bus_get_device(%s) failed: %d\n", ibm->name, rc);
                 return -ENODEV;
         }
 
@@ -781,12 +764,10 @@ static int __init setup_acpi_notify(struct ibm_struct *ibm)
                         ibm->acpi->type, dispatch_acpi_notify, ibm);
         if (ACPI_FAILURE(status)) {
                 if (status == AE_ALREADY_EXISTS) {
-                        printk(TPACPI_NOTICE
-                               "another device driver is already "
-                               "handling %s events\n", ibm->name);
+                        pr_notice("another device driver is already "
+                                  "handling %s events\n", ibm->name);
                 } else {
-                        printk(TPACPI_ERR
-                               "acpi_install_notify_handler(%s) failed: %s\n",
+                        pr_err("acpi_install_notify_handler(%s) failed: %s\n",
                                ibm->name, acpi_format_exception(status));
                 }
                 return -ENODEV;
@@ -811,8 +792,7 @@ static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
 
         ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
         if (!ibm->acpi->driver) {
-                printk(TPACPI_ERR
-                       "failed to allocate memory for ibm->acpi->driver\n");
+                pr_err("failed to allocate memory for ibm->acpi->driver\n");
                 return -ENOMEM;
         }
 
@@ -823,7 +803,7 @@ static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
 
         rc = acpi_bus_register_driver(ibm->acpi->driver);
         if (rc < 0) {
-                printk(TPACPI_ERR "acpi_bus_register_driver(%s) failed: %d\n",
+                pr_err("acpi_bus_register_driver(%s) failed: %d\n",
                        ibm->name, rc);
                 kfree(ibm->acpi->driver);
                 ibm->acpi->driver = NULL;
@@ -1081,15 +1061,14 @@ static int parse_strtoul(const char *buf,
 static void tpacpi_disable_brightness_delay(void)
 {
         if (acpi_evalf(hkey_handle, NULL, "PWMS", "qvd", 0))
-                printk(TPACPI_NOTICE
-                        "ACPI backlight control delay disabled\n");
+                pr_notice("ACPI backlight control delay disabled\n");
 }
 
 static void printk_deprecated_attribute(const char * const what,
                                         const char * const details)
 {
         tpacpi_log_usertask("deprecated sysfs attribute");
-        printk(TPACPI_WARN "WARNING: sysfs attribute %s is deprecated and "
+        pr_warn("WARNING: sysfs attribute %s is deprecated and "
                 "will be removed. %s\n",
                 what, details);
 }
@@ -1264,8 +1243,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
                                                 &tpacpi_rfk_rfkill_ops,
                                                 atp_rfk);
         if (!atp_rfk || !atp_rfk->rfkill) {
-                printk(TPACPI_ERR
-                        "failed to allocate memory for rfkill class\n");
+                pr_err("failed to allocate memory for rfkill class\n");
                 kfree(atp_rfk);
                 return -ENOMEM;
         }
@@ -1275,9 +1253,8 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         sw_status = (tp_rfkops->get_status)();
         if (sw_status < 0) {
-                printk(TPACPI_ERR
-                        "failed to read initial state for %s, error %d\n",
-                        name, sw_status);
+                pr_err("failed to read initial state for %s, error %d\n",
+                       name, sw_status);
         } else {
                 sw_state = (sw_status == TPACPI_RFK_RADIO_OFF);
                 if (set_default) {
@@ -1291,9 +1268,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         res = rfkill_register(atp_rfk->rfkill);
         if (res < 0) {
-                printk(TPACPI_ERR
-                        "failed to register %s rfkill switch: %d\n",
-                        name, res);
+                pr_err("failed to register %s rfkill switch: %d\n", name, res);
                 rfkill_destroy(atp_rfk->rfkill);
                 kfree(atp_rfk);
                 return res;
@@ -1301,7 +1276,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         tpacpi_rfkill_switches[id] = atp_rfk;
 
-        printk(TPACPI_INFO "rfkill switch %s: radio is %sblocked\n",
+        pr_info("rfkill switch %s: radio is %sblocked\n",
                 name, (sw_state || hw_state) ? "" : "un");
         return 0;
 }
@@ -1825,10 +1800,8 @@ static void __init tpacpi_check_outdated_fw(void)
                  * broken, or really stable to begin with, so it is
                  * best if the user upgrades the firmware anyway.
                  */
-                printk(TPACPI_WARN
-                        "WARNING: Outdated ThinkPad BIOS/EC firmware\n");
-                printk(TPACPI_WARN
-                        "WARNING: This firmware may be missing critical bug "
+                pr_warn("WARNING: Outdated ThinkPad BIOS/EC firmware\n");
+                pr_warn("WARNING: This firmware may be missing critical bug "
                         "fixes and/or important features\n");
         }
 }
@@ -2117,9 +2090,7 @@ void static hotkey_mask_warn_incomplete_mask(void)
                 (hotkey_all_mask | TPACPI_HKEY_NVRAM_KNOWN_MASK);
 
         if (wantedmask)
-                printk(TPACPI_NOTICE
-                        "required events 0x%08x not enabled!\n",
-                        wantedmask);
+                pr_notice("required events 0x%08x not enabled!\n", wantedmask);
 }
 
 /*
@@ -2157,10 +2128,9 @@ static int hotkey_mask_set(u32 mask)
          * a given event.
          */
         if (!hotkey_mask_get() && !rc && (fwmask & ~hotkey_acpi_mask)) {
-                printk(TPACPI_NOTICE
-                       "asked for hotkey mask 0x%08x, but "
-                       "firmware forced it to 0x%08x\n",
-                       fwmask, hotkey_acpi_mask);
+                pr_notice("asked for hotkey mask 0x%08x, but "
+                          "firmware forced it to 0x%08x\n",
+                          fwmask, hotkey_acpi_mask);
         }
 
         if (tpacpi_lifecycle != TPACPI_LIFE_EXITING)
@@ -2184,13 +2154,11 @@ static int hotkey_user_mask_set(const u32 mask)
             (mask == 0xffff || mask == 0xffffff ||
              mask == 0xffffffff)) {
                 tp_warned.hotkey_mask_ff = 1;
-                printk(TPACPI_NOTICE
-                       "setting the hotkey mask to 0x%08x is likely "
-                       "not the best way to go about it\n", mask);
-                printk(TPACPI_NOTICE
-                       "please consider using the driver defaults, "
-                       "and refer to up-to-date thinkpad-acpi "
-                       "documentation\n");
+                pr_notice("setting the hotkey mask to 0x%08x is likely "
+                          "not the best way to go about it\n", mask);
+                pr_notice("please consider using the driver defaults, "
+                          "and refer to up-to-date thinkpad-acpi "
+                          "documentation\n");
         }
 
         /* Try to enable what the user asked for, plus whatever we need.
@@ -2574,8 +2542,7 @@ static void hotkey_poll_setup(const bool may_warn)
                                         NULL, TPACPI_NVRAM_KTHREAD_NAME);
                         if (IS_ERR(tpacpi_hotkey_task)) {
                                 tpacpi_hotkey_task = NULL;
-                                printk(TPACPI_ERR
-                                       "could not create kernel thread "
+                                pr_err("could not create kernel thread "
                                        "for hotkey polling\n");
                         }
                 }
@@ -2583,11 +2550,10 @@ static void hotkey_poll_setup(const bool may_warn)
                 hotkey_poll_stop_sync();
                 if (may_warn && (poll_driver_mask || poll_user_mask) &&
                     hotkey_poll_freq == 0) {
-                        printk(TPACPI_NOTICE
-                                "hot keys 0x%08x and/or events 0x%08x "
-                                "require polling, which is currently "
-                                "disabled\n",
-                                poll_user_mask, poll_driver_mask);
+                        pr_notice("hot keys 0x%08x and/or events 0x%08x "
+                                  "require polling, which is currently "
+                                  "disabled\n",
+                                  poll_user_mask, poll_driver_mask);
                 }
         }
 }
@@ -2811,13 +2777,13 @@ static ssize_t hotkey_source_mask_store(struct device *dev,
         mutex_unlock(&hotkey_mutex);
 
         if (rc < 0)
-                printk(TPACPI_ERR "hotkey_source_mask: failed to update the"
-                        "firmware event mask!\n");
+                pr_err("hotkey_source_mask: "
+                       "failed to update the firmware event mask!\n");
 
         if (r_ev)
-                printk(TPACPI_NOTICE "hotkey_source_mask: "
-                        "some important events were disabled: "
-                        "0x%04x\n", r_ev);
+                pr_notice("hotkey_source_mask: "
+                          "some important events were disabled: 0x%04x\n",
+                          r_ev);
 
         tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t);
 
@@ -3048,8 +3014,7 @@ static void hotkey_exit(void)
         if (((tp_features.hotkey_mask &&
               hotkey_mask_set(hotkey_orig_mask)) |
              hotkey_status_set(false)) != 0)
-                printk(TPACPI_ERR
-                       "failed to restore hot key mask "
+                pr_err("failed to restore hot key mask "
                        "to BIOS defaults\n");
 }
 
@@ -3288,10 +3253,9 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
            for HKEY interface version 0x100 */
         if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
                 if ((hkeyv >> 8) != 1) {
-                        printk(TPACPI_ERR "unknown version of the "
-                               "HKEY interface: 0x%x\n", hkeyv);
-                        printk(TPACPI_ERR "please report this to %s\n",
-                               TPACPI_MAIL);
+                        pr_err("unknown version of the HKEY interface: 0x%x\n",
+                               hkeyv);
+                        pr_err("please report this to %s\n", TPACPI_MAIL);
                 } else {
                         /*
                          * MHKV 0x100 in A31, R40, R40e,
@@ -3304,8 +3268,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                         /* Paranoia check AND init hotkey_all_mask */
                         if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
                                         "MHKA", "qd")) {
-                                printk(TPACPI_ERR
-                                       "missing MHKA handler, "
+                                pr_err("missing MHKA handler, "
                                        "please report this to %s\n",
                                        TPACPI_MAIL);
                                 /* Fallback: pre-init for FN+F3,F4,F12 */
@@ -3343,16 +3306,14 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         if (dbg_wlswemul) {
                 tp_features.hotkey_wlsw = 1;
                 radiosw_state = !!tpacpi_wlsw_emulstate;
-                printk(TPACPI_INFO
-                        "radio switch emulation enabled\n");
+                pr_info("radio switch emulation enabled\n");
         } else
 #endif
         /* Not all thinkpads have a hardware radio switch */
         if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
                 tp_features.hotkey_wlsw = 1;
                 radiosw_state = !!status;
-                printk(TPACPI_INFO
-                        "radio switch found; radios are %s\n",
+                pr_info("radio switch found; radios are %s\n",
                         enabled(status, 0));
         }
         if (tp_features.hotkey_wlsw)
@@ -3363,8 +3324,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         if (!res && acpi_evalf(hkey_handle, &status, "MHKG", "qd")) {
                 tp_features.hotkey_tablet = 1;
                 tabletsw_state = !!(status & TP_HOTKEY_TABLET_MASK);
-                printk(TPACPI_INFO
-                        "possible tablet mode switch found; "
+                pr_info("possible tablet mode switch found; "
                         "ThinkPad in %s mode\n",
                         (tabletsw_state) ? "tablet" : "laptop");
                 res = add_to_attr_set(hotkey_dev_attributes,
@@ -3382,8 +3342,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         hotkey_keycode_map = kmalloc(TPACPI_HOTKEY_MAP_SIZE,
                                         GFP_KERNEL);
         if (!hotkey_keycode_map) {
-                printk(TPACPI_ERR
-                        "failed to allocate memory for key map\n");
+                pr_err("failed to allocate memory for key map\n");
                 res = -ENOMEM;
                 goto err_exit;
         }
@@ -3426,13 +3385,11 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
          * userspace. tpacpi_detect_brightness_capabilities() must have
          * been called before this point  */
         if (tp_features.bright_acpimode && acpi_video_backlight_support()) {
-                printk(TPACPI_INFO
-                       "This ThinkPad has standard ACPI backlight "
-                       "brightness control, supported by the ACPI "
-                       "video driver\n");
-                printk(TPACPI_NOTICE
-                       "Disabling thinkpad-acpi brightness events "
-                       "by default...\n");
+                pr_info("This ThinkPad has standard ACPI backlight "
+                        "brightness control, supported by the ACPI "
+                        "video driver\n");
+                pr_notice("Disabling thinkpad-acpi brightness events "
+                          "by default...\n");
 
                 /* Disable brightness up/down on Lenovo thinkpads when
                  * ACPI is handling them, otherwise it is plain impossible
@@ -3539,8 +3496,7 @@ static bool hotkey_notify_wakeup(const u32 hkey,
 
         case TP_HKEY_EV_WKUP_S3_BATLOW: /* Battery on critical low level/S3 */
         case TP_HKEY_EV_WKUP_S4_BATLOW: /* Battery on critical low level/S4 */
-                printk(TPACPI_ALERT
-                        "EMERGENCY WAKEUP: battery almost empty\n");
+                pr_alert("EMERGENCY WAKEUP: battery almost empty\n");
                 /* how to auto-heal: */
                 /* 2313: woke up from S3, go to S4/S5 */
                 /* 2413: woke up from S4, go to S5 */
@@ -3551,9 +3507,7 @@ static bool hotkey_notify_wakeup(const u32 hkey,
         }
 
         if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
-                printk(TPACPI_INFO
-                       "woke up due to a hot-unplug "
-                       "request...\n");
+                pr_info("woke up due to a hot-unplug request...\n");
                 hotkey_wakeup_reason_notify_change();
         }
         return true;
@@ -3605,37 +3559,31 @@ static bool hotkey_notify_thermal(const u32 hkey,
 
         switch (hkey) {
         case TP_HKEY_EV_THM_TABLE_CHANGED:
-                printk(TPACPI_INFO
-                        "EC reports that Thermal Table has changed\n");
+                pr_info("EC reports that Thermal Table has changed\n");
                 /* recommended action: do nothing, we don't have
                  * Lenovo ATM information */
                 return true;
         case TP_HKEY_EV_ALARM_BAT_HOT:
-                printk(TPACPI_CRIT
-                        "THERMAL ALARM: battery is too hot!\n");
+                pr_crit("THERMAL ALARM: battery is too hot!\n");
                 /* recommended action: warn user through gui */
                 break;
         case TP_HKEY_EV_ALARM_BAT_XHOT:
-                printk(TPACPI_ALERT
-                        "THERMAL EMERGENCY: battery is extremely hot!\n");
+                pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n");
                 /* recommended action: immediate sleep/hibernate */
                 break;
         case TP_HKEY_EV_ALARM_SENSOR_HOT:
-                printk(TPACPI_CRIT
-                        "THERMAL ALARM: "
+                pr_crit("THERMAL ALARM: "
                         "a sensor reports something is too hot!\n");
                 /* recommended action: warn user through gui, that */
                 /* some internal component is too hot */
                 break;
         case TP_HKEY_EV_ALARM_SENSOR_XHOT:
-                printk(TPACPI_ALERT
-                        "THERMAL EMERGENCY: "
-                        "a sensor reports something is extremely hot!\n");
+                pr_alert("THERMAL EMERGENCY: "
+                         "a sensor reports something is extremely hot!\n");
                 /* recommended action: immediate sleep/hibernate */
                 break;
         default:
-                printk(TPACPI_ALERT
-                         "THERMAL ALERT: unknown thermal alarm received\n");
+                pr_alert("THERMAL ALERT: unknown thermal alarm received\n");
                 known = false;
         }
 
@@ -3652,8 +3600,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
         bool known_ev;
 
         if (event != 0x80) {
-                printk(TPACPI_ERR
-                       "unknown HKEY notification event %d\n", event);
+                pr_err("unknown HKEY notification event %d\n", event);
                 /* forward it to userspace, maybe it knows how to handle it */
                 acpi_bus_generate_netlink_event(
                                         ibm->acpi->device->pnp.device_class,
@@ -3664,7 +3611,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
 
         while (1) {
                 if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
-                        printk(TPACPI_ERR "failed to retrieve HKEY event\n");
+                        pr_err("failed to retrieve HKEY event\n");
                         return;
                 }
 
@@ -3692,8 +3639,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         switch (hkey) {
                         case TP_HKEY_EV_BAYEJ_ACK:
                                 hotkey_autosleep_ack = 1;
-                                printk(TPACPI_INFO
-                                       "bay ejected\n");
+                                pr_info("bay ejected\n");
                                 hotkey_wakeup_hotunplug_complete_notify_change();
                                 known_ev = true;
                                 break;
@@ -3709,8 +3655,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         /* 0x4000-0x4FFF: dock-related wakeups */
                         if (hkey == TP_HKEY_EV_UNDOCK_ACK) {
                                 hotkey_autosleep_ack = 1;
-                                printk(TPACPI_INFO
-                                       "undocked\n");
+                                pr_info("undocked\n");
                                 hotkey_wakeup_hotunplug_complete_notify_change();
                                 known_ev = true;
                         } else {
@@ -3741,11 +3686,9 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         known_ev = false;
                 }
                 if (!known_ev) {
-                        printk(TPACPI_NOTICE
-                               "unhandled HKEY event 0x%04x\n", hkey);
-                        printk(TPACPI_NOTICE
-                               "please report the conditions when this "
-                               "event happened to %s\n", TPACPI_MAIL);
+                        pr_notice("unhandled HKEY event 0x%04x\n", hkey);
+                        pr_notice("please report the conditions when this "
+                                  "event happened to %s\n", TPACPI_MAIL);
                 }
 
                 /* Legacy events */
@@ -3778,8 +3721,7 @@ static void hotkey_resume(void)
 
         if (hotkey_status_set(true) < 0 ||
             hotkey_mask_set(hotkey_acpi_mask) < 0)
-                printk(TPACPI_ERR
-                       "error while attempting to reset the event "
+                pr_err("error while attempting to reset the event "
                        "firmware interface\n");
 
         tpacpi_send_radiosw_update();
@@ -3824,14 +3766,12 @@ static void hotkey_enabledisable_warn(bool enable)
 {
         tpacpi_log_usertask("procfs hotkey enable/disable");
         if (!WARN((tpacpi_lifecycle == TPACPI_LIFE_RUNNING || !enable),
-                        TPACPI_WARN
-                        "hotkey enable/disable functionality has been "
-                        "removed from the driver.  Hotkeys are always "
-                        "enabled\n"))
-                printk(TPACPI_ERR
-                        "Please remove the hotkey=enable module "
-                        "parameter, it is deprecated.  Hotkeys are always "
-                        "enabled\n");
+                  pr_fmt("hotkey enable/disable functionality has been "
+                         "removed from the driver.  "
+                         "Hotkeys are always enabled.\n")))
+                pr_err("Please remove the hotkey=enable module "
+                       "parameter, it is deprecated.  "
+                       "Hotkeys are always enabled.\n");
 }
 
 static int hotkey_write(char *buf)
@@ -4011,8 +3951,7 @@ static void bluetooth_shutdown(void)
         /* Order firmware to save current state to NVRAM */
         if (!acpi_evalf(NULL, NULL, "\\BLTH", "vd",
                         TP_ACPI_BLTH_SAVE_STATE))
-                printk(TPACPI_NOTICE
-                        "failed to save bluetooth state to NVRAM\n");
+                pr_notice("failed to save bluetooth state to NVRAM\n");
         else
                 vdbg_printk(TPACPI_DBG_RFKILL,
                         "bluestooth state saved to NVRAM\n");
@@ -4051,8 +3990,7 @@ static int __init bluetooth_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_bluetoothemul) {
                 tp_features.bluetooth = 1;
-                printk(TPACPI_INFO
-                        "bluetooth switch emulation enabled\n");
+                pr_info("bluetooth switch emulation enabled\n");
         } else
 #endif
         if (tp_features.bluetooth &&
@@ -4203,8 +4141,7 @@ static void wan_shutdown(void)
         /* Order firmware to save current state to NVRAM */
         if (!acpi_evalf(NULL, NULL, "\\WGSV", "vd",
                         TP_ACPI_WGSV_SAVE_STATE))
-                printk(TPACPI_NOTICE
-                        "failed to save WWAN state to NVRAM\n");
+                pr_notice("failed to save WWAN state to NVRAM\n");
         else
                 vdbg_printk(TPACPI_DBG_RFKILL,
                         "WWAN state saved to NVRAM\n");
@@ -4241,8 +4178,7 @@ static int __init wan_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_wwanemul) {
                 tp_features.wan = 1;
-                printk(TPACPI_INFO
-                        "wwan switch emulation enabled\n");
+                pr_info("wwan switch emulation enabled\n");
         } else
 #endif
         if (tp_features.wan &&
@@ -4382,8 +4318,7 @@ static int __init uwb_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_uwbemul) {
                 tp_features.uwb = 1;
-                printk(TPACPI_INFO
-                        "uwb switch emulation enabled\n");
+                pr_info("uwb switch emulation enabled\n");
         } else
 #endif
         if (tp_features.uwb &&
@@ -4444,6 +4379,15 @@ static int video_orig_autosw;
 static int video_autosw_get(void);
 static int video_autosw_set(int enable);
 
+TPACPI_HANDLE(vid, root,
+              "\\_SB.PCI.AGP.VGA",      /* 570 */
+              "\\_SB.PCI0.AGP0.VID0",   /* 600e/x, 770x */
+              "\\_SB.PCI0.VID0",        /* 770e */
+              "\\_SB.PCI0.VID",         /* A21e, G4x, R50e, X30, X40 */
+              "\\_SB.PCI0.AGP.VGA",     /* X100e and a few others */
+              "\\_SB.PCI0.AGP.VID",     /* all others */
+        );                              /* R30, R31 */
+
 TPACPI_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID");       /* G41 */
 
 static int __init video_init(struct ibm_init_struct *iibm)
@@ -4487,7 +4431,7 @@ static void video_exit(void)
         dbg_printk(TPACPI_DBG_EXIT,
                    "restoring original video autoswitch mode\n");
         if (video_autosw_set(video_orig_autosw))
-                printk(TPACPI_ERR "error while trying to restore original "
+                pr_err("error while trying to restore original "
                         "video autoswitch mode\n");
 }
 
@@ -4560,8 +4504,7 @@ static int video_outputsw_set(int status)
                 res = acpi_evalf(vid_handle, NULL,
                                  "ASWT", "vdd", status * 0x100, 0);
                 if (!autosw && video_autosw_set(autosw)) {
-                        printk(TPACPI_ERR
-                               "video auto-switch left enabled due to error\n");
+                        pr_err("video auto-switch left enabled due to error\n");
                         return -EIO;
                 }
                 break;
@@ -4630,8 +4573,7 @@ static int video_outputsw_cycle(void)
                 return -ENOSYS;
         }
         if (!autosw && video_autosw_set(autosw)) {
-                printk(TPACPI_ERR
-                       "video auto-switch left enabled due to error\n");
+                pr_err("video auto-switch left enabled due to error\n");
                 return -EIO;
         }
 
@@ -5348,7 +5290,7 @@ static int __init led_init(struct ibm_init_struct *iibm)
         tpacpi_leds = kzalloc(sizeof(*tpacpi_leds) * TPACPI_LED_NUMLEDS,
                               GFP_KERNEL);
         if (!tpacpi_leds) {
-                printk(TPACPI_ERR "Out of memory for LED data\n");
+                pr_err("Out of memory for LED data\n");
                 return -ENOMEM;
         }
 
@@ -5367,9 +5309,8 @@ static int __init led_init(struct ibm_init_struct *iibm)
         }
 
 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
-        printk(TPACPI_NOTICE
-                "warning: userspace override of important "
-                "firmware LEDs is enabled\n");
+        pr_notice("warning: userspace override of important "
+                  "firmware LEDs is enabled\n");
 #endif
         return 0;
 }
@@ -5639,17 +5580,16 @@ static void thermal_dump_all_sensors(void)
         if (n <= 0)
                 return;
 
-        printk(TPACPI_NOTICE
-                "temperatures (Celsius):");
+        pr_notice("temperatures (Celsius):");
 
         for (i = 0; i < n; i++) {
                 if (t.temp[i] != TPACPI_THERMAL_SENSOR_NA)
-                        printk(KERN_CONT " %d", (int)(t.temp[i] / 1000));
+                        pr_cont(" %d", (int)(t.temp[i] / 1000));
                 else
-                        printk(KERN_CONT " N/A");
+                        pr_cont(" N/A");
         }
 
-        printk(KERN_CONT "\n");
+        pr_cont("\n");
 }
 
 /* sysfs temp##_input -------------------------------------------------- */
@@ -5769,14 +5709,12 @@ static int __init thermal_init(struct ibm_init_struct *iibm)
                 if (ta1 == 0) {
                         /* This is sheer paranoia, but we handle it anyway */
                         if (acpi_tmp7) {
-                                printk(TPACPI_ERR
-                                       "ThinkPad ACPI EC access misbehaving, "
+                                pr_err("ThinkPad ACPI EC access misbehaving, "
                                        "falling back to ACPI TMPx access "
                                        "mode\n");
                                 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
                         } else {
-                                printk(TPACPI_ERR
-                                       "ThinkPad ACPI EC access misbehaving, "
+                                pr_err("ThinkPad ACPI EC access misbehaving, "
                                        "disabling thermal sensors access\n");
                                 thermal_read_mode = TPACPI_THERMAL_NONE;
                         }
@@ -6129,8 +6067,8 @@ static int __init tpacpi_query_bcl_levels(acpi_handle handle)
         if (ACPI_SUCCESS(acpi_evaluate_object(handle, "_BCL", NULL, &buffer))) {
                 obj = (union acpi_object *)buffer.pointer;
                 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
-                        printk(TPACPI_ERR "Unknown _BCL data, "
-                               "please report this to %s\n", TPACPI_MAIL);
+                        pr_err("Unknown _BCL data, please report this to %s\n",
+                               TPACPI_MAIL);
                         rc = 0;
                 } else {
                         rc = obj->package.count;
@@ -6214,18 +6152,15 @@ static void __init tpacpi_detect_brightness_capabilities(void)
         switch (b) {
         case 16:
                 bright_maxlvl = 15;
-                printk(TPACPI_INFO
-                       "detected a 16-level brightness capable ThinkPad\n");
+                pr_info("detected a 16-level brightness capable ThinkPad\n");
                 break;
         case 8:
         case 0:
                 bright_maxlvl = 7;
-                printk(TPACPI_INFO
-                       "detected a 8-level brightness capable ThinkPad\n");
+                pr_info("detected a 8-level brightness capable ThinkPad\n");
                 break;
         default:
-                printk(TPACPI_ERR
-                       "Unsupported brightness interface, "
+                pr_err("Unsupported brightness interface, "
                        "please contact %s\n", TPACPI_MAIL);
                 tp_features.bright_unkfw = 1;
                 bright_maxlvl = b - 1;
@@ -6260,22 +6195,19 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
 
         if (acpi_video_backlight_support()) {
                 if (brightness_enable > 1) {
-                        printk(TPACPI_INFO
-                               "Standard ACPI backlight interface "
-                               "available, not loading native one.\n");
+                        pr_info("Standard ACPI backlight interface "
+                                "available, not loading native one\n");
                         return 1;
                 } else if (brightness_enable == 1) {
-                        printk(TPACPI_WARN
-                                "Cannot enable backlight brightness support, "
+                        pr_warn("Cannot enable backlight brightness support, "
                                 "ACPI is already handling it.  Refer to the "
-                                "acpi_backlight kernel parameter\n");
+                                "acpi_backlight kernel parameter.\n");
                         return 1;
                 }
         } else if (tp_features.bright_acpimode && brightness_enable > 1) {
-                printk(TPACPI_NOTICE
-                        "Standard ACPI backlight interface not "
-                        "available, thinkpad_acpi native "
-                        "brightness control enabled\n");
+                pr_notice("Standard ACPI backlight interface not "
+                          "available, thinkpad_acpi native "
+                          "brightness control enabled\n");
         }
 
         /*
@@ -6319,19 +6251,17 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
         if (IS_ERR(ibm_backlight_device)) {
                 int rc = PTR_ERR(ibm_backlight_device);
                 ibm_backlight_device = NULL;
-                printk(TPACPI_ERR "Could not register backlight device\n");
+                pr_err("Could not register backlight device\n");
                 return rc;
         }
         vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
                         "brightness is supported\n");
 
         if (quirks & TPACPI_BRGHT_Q_ASK) {
-                printk(TPACPI_NOTICE
-                        "brightness: will use unverified default: "
-                        "brightness_mode=%d\n", brightness_mode);
-                printk(TPACPI_NOTICE
-                        "brightness: please report to %s whether it works well "
-                        "or not on your ThinkPad\n", TPACPI_MAIL);
+                pr_notice("brightness: will use unverified default: "
+                          "brightness_mode=%d\n", brightness_mode);
+                pr_notice("brightness: please report to %s whether it works well "
+                          "or not on your ThinkPad\n", TPACPI_MAIL);
         }
 
         /* Added by mistake in early 2007.  Probably useless, but it could
@@ -6804,8 +6734,7 @@ static int __init volume_create_alsa_mixer(void)
         rc = snd_card_create(alsa_index, alsa_id, THIS_MODULE,
                             sizeof(struct tpacpi_alsa_data), &card);
         if (rc < 0 || !card) {
-                printk(TPACPI_ERR
-                        "Failed to create ALSA card structures: %d\n", rc);
+                pr_err("Failed to create ALSA card structures: %d\n", rc);
                 return 1;
         }
 
@@ -6839,9 +6768,8 @@ static int __init volume_create_alsa_mixer(void)
                 ctl_vol = snd_ctl_new1(&volume_alsa_control_vol, NULL);
                 rc = snd_ctl_add(card, ctl_vol);
                 if (rc < 0) {
-                        printk(TPACPI_ERR
-                                "Failed to create ALSA volume control: %d\n",
-                                rc);
+                        pr_err("Failed to create ALSA volume control: %d\n",
+                               rc);
                         goto err_exit;
                 }
                 data->ctl_vol_id = &ctl_vol->id;
@@ -6850,8 +6778,7 @@ static int __init volume_create_alsa_mixer(void)
         ctl_mute = snd_ctl_new1(&volume_alsa_control_mute, NULL);
         rc = snd_ctl_add(card, ctl_mute);
         if (rc < 0) {
-                printk(TPACPI_ERR "Failed to create ALSA mute control: %d\n",
-                        rc);
+                pr_err("Failed to create ALSA mute control: %d\n", rc);
                 goto err_exit;
         }
         data->ctl_mute_id = &ctl_mute->id;
@@ -6859,7 +6786,7 @@ static int __init volume_create_alsa_mixer(void)
         snd_card_set_dev(card, &tpacpi_pdev->dev);
         rc = snd_card_register(card);
         if (rc < 0) {
-                printk(TPACPI_ERR "Failed to register ALSA card: %d\n", rc);
+                pr_err("Failed to register ALSA card: %d\n", rc);
                 goto err_exit;
         }
 
@@ -6915,9 +6842,8 @@ static int __init volume_init(struct ibm_init_struct *iibm)
                 return -EINVAL;
 
         if (volume_mode == TPACPI_VOL_MODE_UCMS_STEP) {
-                printk(TPACPI_ERR
-                        "UCMS step volume mode not implemented, "
-                        "please contact %s\n", TPACPI_MAIL);
+                pr_err("UCMS step volume mode not implemented, "
+                       "please contact %s\n", TPACPI_MAIL);
                 return 1;
         }
 
@@ -6981,13 +6907,11 @@ static int __init volume_init(struct ibm_init_struct *iibm)
 
         rc = volume_create_alsa_mixer();
         if (rc) {
-                printk(TPACPI_ERR
-                        "Could not create the ALSA mixer interface\n");
+                pr_err("Could not create the ALSA mixer interface\n");
                 return rc;
         }
 
-        printk(TPACPI_INFO
-                "Console audio control enabled, mode: %s\n",
+        pr_info("Console audio control enabled, mode: %s\n",
                 (volume_control_allowed) ?
                         "override (read/write)" :
                         "monitor (read only)");
@@ -7049,12 +6973,10 @@ static int volume_write(char *buf)
         if (!volume_control_allowed && tpacpi_lifecycle != TPACPI_LIFE_INIT) {
                 if (unlikely(!tp_warned.volume_ctrl_forbidden)) {
                         tp_warned.volume_ctrl_forbidden = 1;
-                        printk(TPACPI_NOTICE
-                                "Console audio control in monitor mode, "
-                                "changes are not allowed.\n");
-                        printk(TPACPI_NOTICE
-                                "Use the volume_control=1 module parameter "
-                                "to enable volume control\n");
+                        pr_notice("Console audio control in monitor mode, "
+                                  "changes are not allowed\n");
+                        pr_notice("Use the volume_control=1 module parameter "
+                                  "to enable volume control\n");
                 }
                 return -EPERM;
         }
@@ -7129,8 +7051,7 @@ static void inline volume_alsa_notify_change(void)
 
 static int __init volume_init(struct ibm_init_struct *iibm)
 {
-        printk(TPACPI_INFO
-                "volume: disabled as there is no ALSA support in this kernel\n");
+        pr_info("volume: disabled as there is no ALSA support in this kernel\n");
 
         return 1;
 }
@@ -7337,9 +7258,8 @@ TPACPI_HANDLE(sfan, ec, "SFAN",	/* 570 */
 static void fan_quirk1_setup(void)
 {
         if (fan_control_initial_status == 0x07) {
-                printk(TPACPI_NOTICE
-                       "fan_init: initial fan status is unknown, "
-                       "assuming it is in auto mode\n");
+                pr_notice("fan_init: initial fan status is unknown, "
+                          "assuming it is in auto mode\n");
                 tp_features.fan_ctrl_status_undef = 1;
         }
 }
@@ -7726,8 +7646,7 @@ static void fan_watchdog_reset(void)
                 if (!queue_delayed_work(tpacpi_wq, &fan_watchdog_task,
                                 msecs_to_jiffies(fan_watchdog_maxinterval
                                                  * 1000))) {
-                        printk(TPACPI_ERR
-                               "failed to queue the fan watchdog, "
+                        pr_err("failed to queue the fan watchdog, "
                                "watchdog will not trigger\n");
                 }
         } else
@@ -7741,11 +7660,11 @@ static void fan_watchdog_fire(struct work_struct *ignored)
         if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
                 return;
 
-        printk(TPACPI_NOTICE "fan watchdog: enabling fan\n");
+        pr_notice("fan watchdog: enabling fan\n");
         rc = fan_set_enable();
         if (rc < 0) {
-                printk(TPACPI_ERR "fan watchdog: error %d while enabling fan, "
-                        "will try again later...\n", -rc);
+                pr_err("fan watchdog: error %d while enabling fan, "
+                       "will try again later...\n", -rc);
                 /* reschedule for later */
                 fan_watchdog_reset();
         }
@@ -8049,8 +7968,7 @@ static int __init fan_init(struct ibm_init_struct *iibm)
                                         "secondary fan support enabled\n");
                         }
                 } else {
-                        printk(TPACPI_ERR
-                               "ThinkPad ACPI EC access misbehaving, "
+                        pr_err("ThinkPad ACPI EC access misbehaving, "
                                "fan status and control unavailable\n");
                         return 1;
                 }
@@ -8150,9 +8068,8 @@ static void fan_suspend(pm_message_t state)
         fan_control_resume_level = 0;
         rc = fan_get_status_safe(&fan_control_resume_level);
         if (rc < 0)
-                printk(TPACPI_NOTICE
-                        "failed to read fan level for later "
-                        "restore during resume: %d\n", rc);
+                pr_notice("failed to read fan level for later "
+                          "restore during resume: %d\n", rc);
 
         /* if it is undefined, don't attempt to restore it.
          * KEEP THIS LAST */
@@ -8207,13 +8124,11 @@ static void fan_resume(void)
                 return;
         }
         if (do_set) {
-                printk(TPACPI_NOTICE
-                        "restoring fan level to 0x%02x\n",
-                        fan_control_resume_level);
+                pr_notice("restoring fan level to 0x%02x\n",
+                          fan_control_resume_level);
                 rc = fan_set_level_safe(fan_control_resume_level);
                 if (rc < 0)
-                        printk(TPACPI_NOTICE
-                                "failed to restore fan level: %d\n", rc);
+                        pr_notice("failed to restore fan level: %d\n", rc);
         }
 }
 
@@ -8305,8 +8220,8 @@ static int fan_write_cmd_level(const char *cmd, int *rc)
 
         *rc = fan_set_level_safe(level);
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "level command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("level command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan",
                         "set level to %d\n", level);
@@ -8321,8 +8236,8 @@ static int fan_write_cmd_enable(const char *cmd, int *rc)
 
         *rc = fan_set_enable();
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "enable command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("enable command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan", "enable\n");
 
@@ -8336,8 +8251,8 @@ static int fan_write_cmd_disable(const char *cmd, int *rc)
 
         *rc = fan_set_disable();
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "disable command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("disable command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan", "disable\n");
 
@@ -8356,8 +8271,8 @@ static int fan_write_cmd_speed(const char *cmd, int *rc)
 
         *rc = fan_set_speed(speed);
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "speed command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("speed command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan",
                         "set speed to %d\n", speed);
@@ -8560,8 +8475,8 @@ static int __init ibm_init(struct ibm_init_struct *iibm)
                 if (ibm->acpi->notify) {
                         ret = setup_acpi_notify(ibm);
                         if (ret == -ENODEV) {
-                                printk(TPACPI_NOTICE "disabling subdriver %s\n",
-                                        ibm->name);
+                                pr_notice("disabling subdriver %s\n",
+                                          ibm->name);
                                 ret = 0;
                                 goto err_out;
                         }
@@ -8583,8 +8498,7 @@ static int __init ibm_init(struct ibm_init_struct *iibm)
                 entry = proc_create_data(ibm->name, mode, proc_dir,
                                          &dispatch_proc_fops, ibm);
                 if (!entry) {
-                        printk(TPACPI_ERR "unable to create proc entry %s\n",
-                               ibm->name);
+                        pr_err("unable to create proc entry %s\n", ibm->name);
                         ret = -ENODEV;
                         goto err_out;
                 }
@@ -8683,13 +8597,11 @@ static int __must_check __init get_thinkpad_model_data(
                                 tp->ec_release = (ec_fw_string[4] << 8)
                                                 | ec_fw_string[5];
                         } else {
-                                printk(TPACPI_NOTICE
-                                        "ThinkPad firmware release %s "
-                                        "doesn't match the known patterns\n",
-                                        ec_fw_string);
-                                printk(TPACPI_NOTICE
-                                        "please report this to %s\n",
-                                        TPACPI_MAIL);
+                                pr_notice("ThinkPad firmware release %s "
+                                          "doesn't match the known patterns\n",
+                                          ec_fw_string);
+                                pr_notice("please report this to %s\n",
+                                          TPACPI_MAIL);
                         }
                         break;
                 }
@@ -8733,8 +8645,7 @@ static int __init probe_for_thinkpad(void)
         tpacpi_acpi_handle_locate("ec", TPACPI_ACPI_EC_HID, &ec_handle);
         if (!ec_handle) {
                 if (is_thinkpad)
-                        printk(TPACPI_ERR
-                                "Not yet supported ThinkPad detected!\n");
+                        pr_err("Not yet supported ThinkPad detected!\n");
                 return -ENODEV;
         }
 
@@ -8746,10 +8657,10 @@ static int __init probe_for_thinkpad(void)
 
 static void __init thinkpad_acpi_init_banner(void)
 {
-        printk(TPACPI_INFO "%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
-        printk(TPACPI_INFO "%s\n", TPACPI_URL);
+        pr_info("%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
+        pr_info("%s\n", TPACPI_URL);
 
-        printk(TPACPI_INFO "ThinkPad BIOS %s, EC %s\n",
+        pr_info("ThinkPad BIOS %s, EC %s\n",
                 (thinkpad_id.bios_version_str) ?
                         thinkpad_id.bios_version_str : "unknown",
                 (thinkpad_id.ec_version_str) ?
@@ -8758,7 +8669,7 @@ static void __init thinkpad_acpi_init_banner(void)
         BUG_ON(!thinkpad_id.vendor);
 
         if (thinkpad_id.model_str)
-                printk(TPACPI_INFO "%s %s, model %s\n",
+                pr_info("%s %s, model %s\n",
                         (thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
                                 "IBM" : ((thinkpad_id.vendor ==
                                                 PCI_VENDOR_ID_LENOVO) ?
@@ -9024,8 +8935,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = get_thinkpad_model_data(&thinkpad_id);
         if (ret) {
-                printk(TPACPI_ERR
-                        "unable to get DMI data: %d\n", ret);
+                pr_err("unable to get DMI data: %d\n", ret);
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9051,16 +8961,14 @@ static int __init thinkpad_acpi_module_init(void)
 
         proc_dir = proc_mkdir(TPACPI_PROC_DIR, acpi_root_dir);
         if (!proc_dir) {
-                printk(TPACPI_ERR
-                       "unable to create proc dir " TPACPI_PROC_DIR);
+                pr_err("unable to create proc dir " TPACPI_PROC_DIR "\n");
                 thinkpad_acpi_module_exit();
                 return -ENODEV;
         }
 
         ret = platform_driver_register(&tpacpi_pdriver);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to register main platform driver\n");
+                pr_err("unable to register main platform driver\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9068,8 +8976,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = platform_driver_register(&tpacpi_hwmon_pdriver);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to register hwmon platform driver\n");
+                pr_err("unable to register hwmon platform driver\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9082,8 +8989,7 @@ static int __init thinkpad_acpi_module_init(void)
                                         &tpacpi_hwmon_pdriver.driver);
         }
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to create sysfs driver attributes\n");
+                pr_err("unable to create sysfs driver attributes\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9096,7 +9002,7 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_pdev)) {
                 ret = PTR_ERR(tpacpi_pdev);
                 tpacpi_pdev = NULL;
-                printk(TPACPI_ERR "unable to register platform device\n");
+                pr_err("unable to register platform device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9106,16 +9012,14 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_sensors_pdev)) {
                 ret = PTR_ERR(tpacpi_sensors_pdev);
                 tpacpi_sensors_pdev = NULL;
-                printk(TPACPI_ERR
-                       "unable to register hwmon platform device\n");
+                pr_err("unable to register hwmon platform device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
         ret = device_create_file(&tpacpi_sensors_pdev->dev,
                                  &dev_attr_thinkpad_acpi_pdev_name);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to create sysfs hwmon device attributes\n");
+                pr_err("unable to create sysfs hwmon device attributes\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9124,14 +9028,14 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_hwmon)) {
                 ret = PTR_ERR(tpacpi_hwmon);
                 tpacpi_hwmon = NULL;
-                printk(TPACPI_ERR "unable to register hwmon device\n");
+                pr_err("unable to register hwmon device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
         mutex_init(&tpacpi_inputdev_send_mutex);
         tpacpi_inputdev = input_allocate_device();
         if (!tpacpi_inputdev) {
-                printk(TPACPI_ERR "unable to allocate input device\n");
+                pr_err("unable to allocate input device\n");
                 thinkpad_acpi_module_exit();
                 return -ENOMEM;
         } else {
@@ -9163,7 +9067,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = input_register_device(tpacpi_inputdev);
         if (ret < 0) {
-                printk(TPACPI_ERR "unable to register input device\n");
+                pr_err("unable to register input device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         } else {
diff --git a/drivers/platform/x86/topstar-laptop.c b/drivers/platform/x86/topstar-laptop.c
index 1d07d6d09f27..4c20447ddbb7 100644
--- a/drivers/platform/x86/topstar-laptop.c
+++ b/drivers/platform/x86/topstar-laptop.c
@@ -194,7 +194,7 @@ static int __init topstar_laptop_init(void)
         if (ret < 0)
                 return ret;
 
-        printk(KERN_INFO "Topstar Laptop ACPI extras driver loaded\n");
+        pr_info("ACPI extras driver loaded\n");
 
         return 0;
 }
diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index 63f42a22e102..cb009b2629ee 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -35,6 +35,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define TOSHIBA_ACPI_VERSION    "0.19"
 #define PROC_INTERFACE_VERSION  1
 
@@ -60,11 +62,6 @@ MODULE_AUTHOR("John Belmonte");
 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
 MODULE_LICENSE("GPL");
 
-#define MY_LOGPREFIX "toshiba_acpi: "
-#define MY_ERR KERN_ERR MY_LOGPREFIX
-#define MY_NOTICE KERN_NOTICE MY_LOGPREFIX
-#define MY_INFO KERN_INFO MY_LOGPREFIX
-
 /* Toshiba ACPI method paths */
 #define METHOD_LCD_BRIGHTNESS   "\\_SB_.PCI0.VGA_.LCD_._BCM"
 #define TOSH_INTERFACE_1        "\\_SB_.VALD"
@@ -301,7 +298,7 @@ static int toshiba_illumination_available(void)
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return 0;
         }
         in[0] = 0xf400;
@@ -320,7 +317,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return;
         }
 
@@ -331,7 +328,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
                 in[2] = 1;
                 status = hci_raw(in, out);
                 if (ACPI_FAILURE(status)) {
-                        printk(MY_INFO "ACPI call for illumination failed.\n");
+                        pr_info("ACPI call for illumination failed\n");
                         return;
                 }
         } else {
@@ -341,7 +338,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
                 in[2] = 0;
                 status = hci_raw(in, out);
                 if (ACPI_FAILURE(status)) {
-                        printk(MY_INFO "ACPI call for illumination failed.\n");
+                        pr_info("ACPI call for illumination failed.\n");
                         return;
                 }
         }
@@ -364,7 +361,7 @@ static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return LED_OFF;
         }
 
@@ -373,7 +370,7 @@ static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
         in[1] = 0x14e;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "ACPI call for illumination failed.\n");
+                pr_info("ACPI call for illumination failed.\n");
                 return LED_OFF;
         }
 
@@ -517,7 +514,7 @@ static int lcd_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "brightness_levels:       %d\n",
                              HCI_LCD_BRIGHTNESS_LEVELS);
         } else {
-                printk(MY_ERR "Error reading LCD brightness\n");
+                pr_err("Error reading LCD brightness\n");
         }
 
         return 0;
@@ -592,7 +589,7 @@ static int video_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "crt_out:                 %d\n", is_crt);
                 seq_printf(m, "tv_out:                  %d\n", is_tv);
         } else {
-                printk(MY_ERR "Error reading video out status\n");
+                pr_err("Error reading video out status\n");
         }
 
         return 0;
@@ -686,7 +683,7 @@ static int fan_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "running:                 %d\n", (value > 0));
                 seq_printf(m, "force_on:                %d\n", force_fan);
         } else {
-                printk(MY_ERR "Error reading fan status\n");
+                pr_err("Error reading fan status\n");
         }
 
         return 0;
@@ -750,9 +747,9 @@ static int keys_proc_show(struct seq_file *m, void *v)
                          * some machines where system events sporadically
                          * become disabled. */
                         hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
-                        printk(MY_NOTICE "Re-enabled hotkeys\n");
+                        pr_notice("Re-enabled hotkeys\n");
                 } else {
-                        printk(MY_ERR "Error reading hotkey status\n");
+                        pr_err("Error reading hotkey status\n");
                         goto end;
                 }
         }
@@ -863,7 +860,7 @@ static void toshiba_acpi_notify(acpi_handle handle, u32 event, void *context)
 
                         if (!sparse_keymap_report_event(toshiba_acpi.hotkey_dev,
                                                         value, 1, true)) {
-                                printk(MY_INFO "Unknown key %x\n",
+                                pr_info("Unknown key %x\n",
                                        value);
                         }
                 } else if (hci_result == HCI_NOT_SUPPORTED) {
@@ -871,7 +868,7 @@ static void toshiba_acpi_notify(acpi_handle handle, u32 event, void *context)
                          * some machines where system events sporadically
                          * become disabled. */
                         hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
-                        printk(MY_NOTICE "Re-enabled hotkeys\n");
+                        pr_notice("Re-enabled hotkeys\n");
                 }
         } while (hci_result != HCI_EMPTY);
 }
@@ -883,13 +880,13 @@ static int __init toshiba_acpi_setup_keyboard(char *device)
 
         status = acpi_get_handle(NULL, device, &toshiba_acpi.handle);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to get notification device\n");
+                pr_info("Unable to get notification device\n");
                 return -ENODEV;
         }
 
         toshiba_acpi.hotkey_dev = input_allocate_device();
         if (!toshiba_acpi.hotkey_dev) {
-                printk(MY_INFO "Unable to register input device\n");
+                pr_info("Unable to register input device\n");
                 return -ENOMEM;
         }
 
@@ -905,21 +902,21 @@ static int __init toshiba_acpi_setup_keyboard(char *device)
         status = acpi_install_notify_handler(toshiba_acpi.handle,
                                 ACPI_DEVICE_NOTIFY, toshiba_acpi_notify, NULL);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to install hotkey notification\n");
+                pr_info("Unable to install hotkey notification\n");
                 error = -ENODEV;
                 goto err_free_keymap;
         }
 
         status = acpi_evaluate_object(toshiba_acpi.handle, "ENAB", NULL, NULL);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to enable hotkeys\n");
+                pr_info("Unable to enable hotkeys\n");
                 error = -ENODEV;
                 goto err_remove_notify;
         }
 
         error = input_register_device(toshiba_acpi.hotkey_dev);
         if (error) {
-                printk(MY_INFO "Unable to register input device\n");
+                pr_info("Unable to register input device\n");
                 goto err_remove_notify;
         }
 
@@ -980,17 +977,17 @@ static int __init toshiba_acpi_init(void)
         if (is_valid_acpi_path(TOSH_INTERFACE_1 GHCI_METHOD)) {
                 method_hci = TOSH_INTERFACE_1 GHCI_METHOD;
                 if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_1))
-                        printk(MY_INFO "Unable to activate hotkeys\n");
+                        pr_info("Unable to activate hotkeys\n");
         } else if (is_valid_acpi_path(TOSH_INTERFACE_2 GHCI_METHOD)) {
                 method_hci = TOSH_INTERFACE_2 GHCI_METHOD;
                 if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_2))
-                        printk(MY_INFO "Unable to activate hotkeys\n");
+                        pr_info("Unable to activate hotkeys\n");
         } else
                 return -ENODEV;
 
-        printk(MY_INFO "Toshiba Laptop ACPI Extras version %s\n",
+        pr_info("Toshiba Laptop ACPI Extras version %s\n",
                TOSHIBA_ACPI_VERSION);
-        printk(MY_INFO "    HCI method: %s\n", method_hci);
+        pr_info("    HCI method: %s\n", method_hci);
 
         mutex_init(&toshiba_acpi.mutex);
 
@@ -998,7 +995,7 @@ static int __init toshiba_acpi_init(void)
                                                               -1, NULL, 0);
         if (IS_ERR(toshiba_acpi.p_dev)) {
                 ret = PTR_ERR(toshiba_acpi.p_dev);
-                printk(MY_ERR "unable to register platform device\n");
+                pr_err("unable to register platform device\n");
                 toshiba_acpi.p_dev = NULL;
                 toshiba_acpi_exit();
                 return ret;
@@ -1028,7 +1025,7 @@ static int __init toshiba_acpi_init(void)
         if (IS_ERR(toshiba_backlight_device)) {
                 ret = PTR_ERR(toshiba_backlight_device);
 
-                printk(KERN_ERR "Could not register toshiba backlight device\n");
+                pr_err("Could not register toshiba backlight device\n");
                 toshiba_backlight_device = NULL;
                 toshiba_acpi_exit();
                 return ret;
@@ -1042,14 +1039,14 @@ static int __init toshiba_acpi_init(void)
                                                    &toshiba_rfk_ops,
                                                    &toshiba_acpi);
                 if (!toshiba_acpi.bt_rfk) {
-                        printk(MY_ERR "unable to allocate rfkill device\n");
+                        pr_err("unable to allocate rfkill device\n");
                         toshiba_acpi_exit();
                         return -ENOMEM;
                 }
 
                 ret = rfkill_register(toshiba_acpi.bt_rfk);
                 if (ret) {
-                        printk(MY_ERR "unable to register rfkill device\n");
+                        pr_err("unable to register rfkill device\n");
                         rfkill_destroy(toshiba_acpi.bt_rfk);
                         toshiba_acpi_exit();
                         return ret;
diff --git a/drivers/platform/x86/toshiba_bluetooth.c b/drivers/platform/x86/toshiba_bluetooth.c
index 944068611919..5fb7186694df 100644
--- a/drivers/platform/x86/toshiba_bluetooth.c
+++ b/drivers/platform/x86/toshiba_bluetooth.c
@@ -17,6 +17,8 @@
  * delivered.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -70,14 +72,13 @@ static int toshiba_bluetooth_enable(acpi_handle handle)
         if (!(result & 0x01))
                 return 0;
 
-        printk(KERN_INFO "toshiba_bluetooth: Re-enabling Toshiba Bluetooth\n");
+        pr_info("Re-enabling Toshiba Bluetooth\n");
         res1 = acpi_evaluate_object(handle, "AUSB", NULL, NULL);
         res2 = acpi_evaluate_object(handle, "BTPO", NULL, NULL);
         if (!ACPI_FAILURE(res1) || !ACPI_FAILURE(res2))
                 return 0;
 
-        printk(KERN_WARNING "toshiba_bluetooth: Failed to re-enable "
-               "Toshiba Bluetooth\n");
+        pr_warn("Failed to re-enable Toshiba Bluetooth\n");
 
         return -ENODEV;
 }
@@ -107,8 +108,8 @@ static int toshiba_bt_rfkill_add(struct acpi_device *device)
                                        &bt_present);
 
         if (!ACPI_FAILURE(status) && bt_present) {
-                printk(KERN_INFO "Detected Toshiba ACPI Bluetooth device - "
-                      "installing RFKill handler\n");
+                pr_info("Detected Toshiba ACPI Bluetooth device - "
+                        "installing RFKill handler\n");
                 result = toshiba_bluetooth_enable(device->handle);
         }
 
diff --git a/drivers/platform/x86/wmi.c b/drivers/platform/x86/wmi.c
index 05cc79672a8b..f23d5a84e7b1 100644
--- a/drivers/platform/x86/wmi.c
+++ b/drivers/platform/x86/wmi.c
@@ -486,16 +486,16 @@ static void wmi_dump_wdg(const struct guid_block *g)
         pr_info("\tnotify_id: %02X\n", g->notify_id);
         pr_info("\treserved: %02X\n", g->reserved);
         pr_info("\tinstance_count: %d\n", g->instance_count);
-        pr_info("\tflags: %#x ", g->flags);
+        pr_info("\tflags: %#x", g->flags);
         if (g->flags) {
                 if (g->flags & ACPI_WMI_EXPENSIVE)
-                        pr_cont("ACPI_WMI_EXPENSIVE ");
+                        pr_cont(" ACPI_WMI_EXPENSIVE");
                 if (g->flags & ACPI_WMI_METHOD)
-                        pr_cont("ACPI_WMI_METHOD ");
+                        pr_cont(" ACPI_WMI_METHOD");
                 if (g->flags & ACPI_WMI_STRING)
-                        pr_cont("ACPI_WMI_STRING ");
+                        pr_cont(" ACPI_WMI_STRING");
                 if (g->flags & ACPI_WMI_EVENT)
-                        pr_cont("ACPI_WMI_EVENT ");
+                        pr_cont(" ACPI_WMI_EVENT");
         }
         pr_cont("\n");
 
diff --git a/drivers/platform/x86/xo15-ebook.c b/drivers/platform/x86/xo15-ebook.c
index c1372ed9d2e9..fad153dc0355 100644
--- a/drivers/platform/x86/xo15-ebook.c
+++ b/drivers/platform/x86/xo15-ebook.c
@@ -11,6 +11,8 @@
  *  your option) any later version.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -20,7 +22,6 @@
 #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
@@ -105,7 +106,7 @@ static int ebook_switch_add(struct acpi_device *device)
         class = acpi_device_class(device);
 
         if (strcmp(hid, XO15_EBOOK_HID)) {
-                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
+                pr_err("Unsupported hid [%s]\n", hid);
                 error = -ENODEV;
                 goto err_free_input;
         }
diff --git a/drivers/thermal/thermal_sys.c b/drivers/thermal/thermal_sys.c
index fc6f2a5bde01..0b1c82ad6805 100644
--- a/drivers/thermal/thermal_sys.c
+++ b/drivers/thermal/thermal_sys.c
@@ -499,7 +499,7 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
         dev_set_drvdata(hwmon->device, hwmon);
         result = device_create_file(hwmon->device, &dev_attr_name);
         if (result)
-                goto unregister_hwmon_device;
+                goto free_mem;
 
  register_sys_interface:
         tz->hwmon = hwmon;
@@ -513,7 +513,7 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
         sysfs_attr_init(&tz->temp_input.attr.attr);
         result = device_create_file(hwmon->device, &tz->temp_input.attr);
         if (result)
-                goto unregister_hwmon_device;
+                goto unregister_name;
 
         if (tz->ops->get_crit_temp) {
                 unsigned long temperature;
@@ -527,7 +527,7 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
                         result = device_create_file(hwmon->device,
                                                     &tz->temp_crit.attr);
                         if (result)
-                                goto unregister_hwmon_device;
+                                goto unregister_input;
                 }
         }
 
@@ -539,9 +539,9 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
 
         return 0;
 
- unregister_hwmon_device:
-        device_remove_file(hwmon->device, &tz->temp_crit.attr);
+ unregister_input:
         device_remove_file(hwmon->device, &tz->temp_input.attr);
+ unregister_name:
         if (new_hwmon_device) {
                 device_remove_file(hwmon->device, &dev_attr_name);
                 hwmon_device_unregister(hwmon->device);
diff --git a/fs/cifs/cifsacl.c b/fs/cifs/cifsacl.c
index 8f1700623b41..21de1d6d5849 100644
--- a/fs/cifs/cifsacl.c
+++ b/fs/cifs/cifsacl.c
@@ -74,8 +74,9 @@ shrink_idmap_tree(struct rb_root *root, int nr_to_scan, int *nr_rem,
  * Run idmap cache shrinker.
  */
 static int
-cifs_idmap_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask)
+cifs_idmap_shrinker(struct shrinker *shrink, struct shrink_control *sc)
 {
+        int nr_to_scan = sc->nr_to_scan;
         int nr_del = 0;
         int nr_rem = 0;
         struct rb_root *root;
diff --git a/fs/nfs/Kconfig b/fs/nfs/Kconfig
index ba306658a6db..81515545ba75 100644
--- a/fs/nfs/Kconfig
+++ b/fs/nfs/Kconfig
@@ -87,6 +87,16 @@ config NFS_V4_1
 config PNFS_FILE_LAYOUT
         tristate
 
+config PNFS_OBJLAYOUT
+        tristate "Provide support for the pNFS Objects Layout Driver for NFSv4.1 pNFS (EXPERIMENTAL)"
+        depends on NFS_FS && NFS_V4_1 && SCSI_OSD_ULD
+        help
+          Say M here if you want your pNFS client to support the Objects Layout Driver.
+          Requires the SCSI osd initiator library (SCSI_OSD_INITIATOR) and
+          upper level driver (SCSI_OSD_ULD).
+
+          If unsure, say N.
+
 config ROOT_NFS
         bool "Root file system on NFS"
         depends on NFS_FS=y && IP_PNP
diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index 4776ff9e3814..6a34f7dd0e6f 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -15,9 +15,11 @@ nfs-$(CONFIG_NFS_V4)	+= nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o \
                            delegation.o idmap.o \
                            callback.o callback_xdr.o callback_proc.o \
                            nfs4namespace.o
-nfs-$(CONFIG_NFS_V4_1)  += pnfs.o
+nfs-$(CONFIG_NFS_V4_1)  += pnfs.o pnfs_dev.o
 nfs-$(CONFIG_SYSCTL) += sysctl.o
 nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o
 
 obj-$(CONFIG_PNFS_FILE_LAYOUT) += nfs_layout_nfsv41_files.o
 nfs_layout_nfsv41_files-y := nfs4filelayout.o nfs4filelayoutdev.o
+
+obj-$(CONFIG_PNFS_OBJLAYOUT) += objlayout/
diff --git a/fs/nfs/callback.h b/fs/nfs/callback.h
index 46d93ce7311b..b257383bb565 100644
--- a/fs/nfs/callback.h
+++ b/fs/nfs/callback.h
@@ -167,6 +167,23 @@ extern unsigned nfs4_callback_layoutrecall(
 
 extern void nfs4_check_drain_bc_complete(struct nfs4_session *ses);
 extern void nfs4_cb_take_slot(struct nfs_client *clp);
+
+struct cb_devicenotifyitem {
+        uint32_t                cbd_notify_type;
+        uint32_t                cbd_layout_type;
+        struct nfs4_deviceid    cbd_dev_id;
+        uint32_t                cbd_immediate;
+};
+
+struct cb_devicenotifyargs {
+        int                              ndevs;
+        struct cb_devicenotifyitem       *devs;
+};
+
+extern __be32 nfs4_callback_devicenotify(
+        struct cb_devicenotifyargs *args,
+        void *dummy, struct cb_process_state *cps);
+
 #endif /* CONFIG_NFS_V4_1 */
 extern int check_gss_callback_principal(struct nfs_client *, struct svc_rqst *);
 extern __be32 nfs4_callback_getattr(struct cb_getattrargs *args,
diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c
index 2f41dccea18e..d4d1954e9bb9 100644
--- a/fs/nfs/callback_proc.c
+++ b/fs/nfs/callback_proc.c
@@ -139,7 +139,7 @@ static u32 initiate_file_draining(struct nfs_client *clp,
         spin_lock(&ino->i_lock);
         if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags) ||
             mark_matching_lsegs_invalid(lo, &free_me_list,
-                                        args->cbl_range.iomode))
+                                        &args->cbl_range))
                 rv = NFS4ERR_DELAY;
         else
                 rv = NFS4ERR_NOMATCHING_LAYOUT;
@@ -184,7 +184,7 @@ static u32 initiate_bulk_draining(struct nfs_client *clp,
                 ino = lo->plh_inode;
                 spin_lock(&ino->i_lock);
                 set_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags);
-                if (mark_matching_lsegs_invalid(lo, &free_me_list, range.iomode))
+                if (mark_matching_lsegs_invalid(lo, &free_me_list, &range))
                         rv = NFS4ERR_DELAY;
                 list_del_init(&lo->plh_bulk_recall);
                 spin_unlock(&ino->i_lock);
@@ -241,6 +241,53 @@ static void pnfs_recall_all_layouts(struct nfs_client *clp)
         do_callback_layoutrecall(clp, &args);
 }
 
+__be32 nfs4_callback_devicenotify(struct cb_devicenotifyargs *args,
+                                  void *dummy, struct cb_process_state *cps)
+{
+        int i;
+        __be32 res = 0;
+        struct nfs_client *clp = cps->clp;
+        struct nfs_server *server = NULL;
+
+        dprintk("%s: -->\n", __func__);
+
+        if (!clp) {
+                res = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
+                goto out;
+        }
+
+        for (i = 0; i < args->ndevs; i++) {
+                struct cb_devicenotifyitem *dev = &args->devs[i];
+
+                if (!server ||
+                    server->pnfs_curr_ld->id != dev->cbd_layout_type) {
+                        rcu_read_lock();
+                        list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
+                                if (server->pnfs_curr_ld &&
+                                    server->pnfs_curr_ld->id == dev->cbd_layout_type) {
+                                        rcu_read_unlock();
+                                        goto found;
+                                }
+                        rcu_read_unlock();
+                        dprintk("%s: layout type %u not found\n",
+                                __func__, dev->cbd_layout_type);
+                        continue;
+                }
+
+        found:
+                if (dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE)
+                        dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
+                                "deleting instead\n", __func__);
+                nfs4_delete_deviceid(server->pnfs_curr_ld, clp, &dev->cbd_dev_id);
+        }
+
+out:
+        kfree(args->devs);
+        dprintk("%s: exit with status = %u\n",
+                __func__, be32_to_cpu(res));
+        return res;
+}
+
 int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
 {
         if (delegation == NULL)
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index 00ecf62ce7c1..c6c86a77e043 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -25,6 +25,7 @@
 
 #if defined(CONFIG_NFS_V4_1)
 #define CB_OP_LAYOUTRECALL_RES_MAXSZ    (CB_OP_HDR_RES_MAXSZ)
+#define CB_OP_DEVICENOTIFY_RES_MAXSZ    (CB_OP_HDR_RES_MAXSZ)
 #define CB_OP_SEQUENCE_RES_MAXSZ        (CB_OP_HDR_RES_MAXSZ + \
                                         4 + 1 + 3)
 #define CB_OP_RECALLANY_RES_MAXSZ       (CB_OP_HDR_RES_MAXSZ)
@@ -284,6 +285,93 @@ out:
         return status;
 }
 
+static
+__be32 decode_devicenotify_args(struct svc_rqst *rqstp,
+                                struct xdr_stream *xdr,
+                                struct cb_devicenotifyargs *args)
+{
+        __be32 *p;
+        __be32 status = 0;
+        u32 tmp;
+        int n, i;
+        args->ndevs = 0;
+
+        /* Num of device notifications */
+        p = read_buf(xdr, sizeof(uint32_t));
+        if (unlikely(p == NULL)) {
+                status = htonl(NFS4ERR_BADXDR);
+                goto out;
+        }
+        n = ntohl(*p++);
+        if (n <= 0)
+                goto out;
+
+        args->devs = kmalloc(n * sizeof(*args->devs), GFP_KERNEL);
+        if (!args->devs) {
+                status = htonl(NFS4ERR_DELAY);
+                goto out;
+        }
+
+        /* Decode each dev notification */
+        for (i = 0; i < n; i++) {
+                struct cb_devicenotifyitem *dev = &args->devs[i];
+
+                p = read_buf(xdr, (4 * sizeof(uint32_t)) + NFS4_DEVICEID4_SIZE);
+                if (unlikely(p == NULL)) {
+                        status = htonl(NFS4ERR_BADXDR);
+                        goto err;
+                }
+
+                tmp = ntohl(*p++);      /* bitmap size */
+                if (tmp != 1) {
+                        status = htonl(NFS4ERR_INVAL);
+                        goto err;
+                }
+                dev->cbd_notify_type = ntohl(*p++);
+                if (dev->cbd_notify_type != NOTIFY_DEVICEID4_CHANGE &&
+                    dev->cbd_notify_type != NOTIFY_DEVICEID4_DELETE) {
+                        status = htonl(NFS4ERR_INVAL);
+                        goto err;
+                }
+
+                tmp = ntohl(*p++);      /* opaque size */
+                if (((dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE) &&
+                     (tmp != NFS4_DEVICEID4_SIZE + 8)) ||
+                    ((dev->cbd_notify_type == NOTIFY_DEVICEID4_DELETE) &&
+                     (tmp != NFS4_DEVICEID4_SIZE + 4))) {
+                        status = htonl(NFS4ERR_INVAL);
+                        goto err;
+                }
+                dev->cbd_layout_type = ntohl(*p++);
+                memcpy(dev->cbd_dev_id.data, p, NFS4_DEVICEID4_SIZE);
+                p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
+
+                if (dev->cbd_layout_type == NOTIFY_DEVICEID4_CHANGE) {
+                        p = read_buf(xdr, sizeof(uint32_t));
+                        if (unlikely(p == NULL)) {
+                                status = htonl(NFS4ERR_BADXDR);
+                                goto err;
+                        }
+                        dev->cbd_immediate = ntohl(*p++);
+                } else {
+                        dev->cbd_immediate = 0;
+                }
+
+                args->ndevs++;
+
+                dprintk("%s: type %d layout 0x%x immediate %d\n",
+                        __func__, dev->cbd_notify_type, dev->cbd_layout_type,
+                        dev->cbd_immediate);
+        }
+out:
+        dprintk("%s: status %d ndevs %d\n",
+                __func__, ntohl(status), args->ndevs);
+        return status;
+err:
+        kfree(args->devs);
+        goto out;
+}
+
 static __be32 decode_sessionid(struct xdr_stream *xdr,
                                  struct nfs4_sessionid *sid)
 {
@@ -639,10 +727,10 @@ preprocess_nfs41_op(int nop, unsigned int op_nr, struct callback_op **op)
         case OP_CB_RECALL_ANY:
         case OP_CB_RECALL_SLOT:
         case OP_CB_LAYOUTRECALL:
+        case OP_CB_NOTIFY_DEVICEID:
                 *op = &callback_ops[op_nr];
                 break;
 
-        case OP_CB_NOTIFY_DEVICEID:
         case OP_CB_NOTIFY:
         case OP_CB_PUSH_DELEG:
         case OP_CB_RECALLABLE_OBJ_AVAIL:
@@ -849,6 +937,12 @@ static struct callback_op callback_ops[] = {
                         (callback_decode_arg_t)decode_layoutrecall_args,
                 .res_maxsize = CB_OP_LAYOUTRECALL_RES_MAXSZ,
         },
+        [OP_CB_NOTIFY_DEVICEID] = {
+                .process_op = (callback_process_op_t)nfs4_callback_devicenotify,
+                .decode_args =
+                        (callback_decode_arg_t)decode_devicenotify_args,
+                .res_maxsize = CB_OP_DEVICENOTIFY_RES_MAXSZ,
+        },
         [OP_CB_SEQUENCE] = {
                 .process_op = (callback_process_op_t)nfs4_callback_sequence,
                 .decode_args = (callback_decode_arg_t)decode_cb_sequence_args,
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 139be9647d80..b3dc2b88b65b 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -290,6 +290,8 @@ static void nfs_free_client(struct nfs_client *clp)
         if (clp->cl_machine_cred != NULL)
                 put_rpccred(clp->cl_machine_cred);
 
+        nfs4_deviceid_purge_client(clp);
+
         kfree(clp->cl_hostname);
         kfree(clp);
 
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index bbbc6bf5cb2e..dd25c2aec375 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -21,25 +21,13 @@
 #include "delegation.h"
 #include "internal.h"
 
-static void nfs_do_free_delegation(struct nfs_delegation *delegation)
-{
-        kfree(delegation);
-}
-
-static void nfs_free_delegation_callback(struct rcu_head *head)
-{
-        struct nfs_delegation *delegation = container_of(head, struct nfs_delegation, rcu);
-
-        nfs_do_free_delegation(delegation);
-}
-
 static void nfs_free_delegation(struct nfs_delegation *delegation)
 {
         if (delegation->cred) {
                 put_rpccred(delegation->cred);
                 delegation->cred = NULL;
         }
-        call_rcu(&delegation->rcu, nfs_free_delegation_callback);
+        kfree_rcu(delegation, rcu);
 }
 
 /**
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index 424e47773a84..ededdbd0db38 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -512,12 +512,7 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *en
                                 struct page **xdr_pages, struct page *page, unsigned int buflen)
 {
         struct xdr_stream stream;
-        struct xdr_buf buf = {
-                .pages = xdr_pages,
-                .page_len = buflen,
-                .buflen = buflen,
-                .len = buflen,
-        };
+        struct xdr_buf buf;
         struct page *scratch;
         struct nfs_cache_array *array;
         unsigned int count = 0;
@@ -527,7 +522,7 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *en
         if (scratch == NULL)
                 return -ENOMEM;
 
-        xdr_init_decode(&stream, &buf, NULL);
+        xdr_init_decode_pages(&stream, &buf, xdr_pages, buflen);
         xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
 
         do {
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 57bb31ad7a5e..144f2a3c7185 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1298,8 +1298,12 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                                 i_size_write(inode, new_isize);
                                 invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
                         }
-                        dprintk("NFS: isize change on server for file %s/%ld\n",
-                                        inode->i_sb->s_id, inode->i_ino);
+                        dprintk("NFS: isize change on server for file %s/%ld "
+                                        "(%Ld to %Ld)\n",
+                                        inode->i_sb->s_id,
+                                        inode->i_ino,
+                                        (long long)cur_isize,
+                                        (long long)new_isize);
                 }
         } else
                 invalid |= save_cache_validity & (NFS_INO_INVALID_ATTR
@@ -1424,9 +1428,10 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  */
 void nfs4_evict_inode(struct inode *inode)
 {
-        pnfs_destroy_layout(NFS_I(inode));
         truncate_inode_pages(&inode->i_data, 0);
         end_writeback(inode);
+        pnfs_return_layout(inode);
+        pnfs_destroy_layout(NFS_I(inode));
         /* If we are holding a delegation, return it! */
         nfs_inode_return_delegation_noreclaim(inode);
         /* First call standard NFS clear_inode() code */
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 2df6ca7b5898..b9056cbe68d6 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -310,6 +310,7 @@ extern int nfs_migrate_page(struct address_space *,
 #endif
 
 /* nfs4proc.c */
+extern void __nfs4_read_done_cb(struct nfs_read_data *);
 extern void nfs4_reset_read(struct rpc_task *task, struct nfs_read_data *data);
 extern int nfs4_init_client(struct nfs_client *clp,
                             const struct rpc_timeout *timeparms,
diff --git a/fs/nfs/nfs4filelayout.c b/fs/nfs/nfs4filelayout.c
index be79dc9f386d..426908809c97 100644
--- a/fs/nfs/nfs4filelayout.c
+++ b/fs/nfs/nfs4filelayout.c
@@ -421,6 +421,7 @@ filelayout_check_layout(struct pnfs_layout_hdr *lo,
                         struct nfs4_deviceid *id,
                         gfp_t gfp_flags)
 {
+        struct nfs4_deviceid_node *d;
         struct nfs4_file_layout_dsaddr *dsaddr;
         int status = -EINVAL;
         struct nfs_server *nfss = NFS_SERVER(lo->plh_inode);
@@ -428,7 +429,7 @@ filelayout_check_layout(struct pnfs_layout_hdr *lo,
         dprintk("--> %s\n", __func__);
 
         if (fl->pattern_offset > lgr->range.offset) {
-                dprintk("%s pattern_offset %lld to large\n",
+                dprintk("%s pattern_offset %lld too large\n",
                                 __func__, fl->pattern_offset);
                 goto out;
         }
@@ -440,12 +441,14 @@ filelayout_check_layout(struct pnfs_layout_hdr *lo,
         }
 
         /* find and reference the deviceid */
-        dsaddr = nfs4_fl_find_get_deviceid(id);
-        if (dsaddr == NULL) {
+        d = nfs4_find_get_deviceid(NFS_SERVER(lo->plh_inode)->pnfs_curr_ld,
+                                   NFS_SERVER(lo->plh_inode)->nfs_client, id);
+        if (d == NULL) {
                 dsaddr = get_device_info(lo->plh_inode, id, gfp_flags);
                 if (dsaddr == NULL)
                         goto out;
-        }
+        } else
+                dsaddr = container_of(d, struct nfs4_file_layout_dsaddr, id_node);
         fl->dsaddr = dsaddr;
 
         if (fl->first_stripe_index < 0 ||
@@ -507,12 +510,7 @@ filelayout_decode_layout(struct pnfs_layout_hdr *flo,
                          gfp_t gfp_flags)
 {
         struct xdr_stream stream;
-        struct xdr_buf buf = {
-                .pages =  lgr->layoutp->pages,
-                .page_len =  lgr->layoutp->len,
-                .buflen =  lgr->layoutp->len,
-                .len = lgr->layoutp->len,
-        };
+        struct xdr_buf buf;
         struct page *scratch;
         __be32 *p;
         uint32_t nfl_util;
@@ -524,7 +522,7 @@ filelayout_decode_layout(struct pnfs_layout_hdr *flo,
         if (!scratch)
                 return -ENOMEM;
 
-        xdr_init_decode(&stream, &buf, NULL);
+        xdr_init_decode_pages(&stream, &buf, lgr->layoutp->pages, lgr->layoutp->len);
         xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
 
         /* 20 = ufl_util (4), first_stripe_index (4), pattern_offset (8),
@@ -535,7 +533,7 @@ filelayout_decode_layout(struct pnfs_layout_hdr *flo,
 
         memcpy(id, p, sizeof(*id));
         p += XDR_QUADLEN(NFS4_DEVICEID4_SIZE);
-        print_deviceid(id);
+        nfs4_print_deviceid(id);
 
         nfl_util = be32_to_cpup(p++);
         if (nfl_util & NFL4_UFLG_COMMIT_THRU_MDS)
@@ -653,16 +651,19 @@ filelayout_alloc_lseg(struct pnfs_layout_hdr *layoutid,
 /*
  * filelayout_pg_test(). Called by nfs_can_coalesce_requests()
  *
- * return 1 :  coalesce page
- * return 0 :  don't coalesce page
+ * return true  : coalesce page
+ * return false : don't coalesce page
  */
-int
+bool
 filelayout_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
                    struct nfs_page *req)
 {
         u64 p_stripe, r_stripe;
         u32 stripe_unit;
 
+        if (!pnfs_generic_pg_test(pgio, prev, req))
+                return 0;
+
         if (!pgio->pg_lseg)
                 return 1;
         p_stripe = (u64)prev->wb_index << PAGE_CACHE_SHIFT;
@@ -860,6 +861,12 @@ filelayout_commit_pagelist(struct inode *inode, struct list_head *mds_pages,
         return -ENOMEM;
 }
 
+static void
+filelayout_free_deveiceid_node(struct nfs4_deviceid_node *d)
+{
+        nfs4_fl_free_deviceid(container_of(d, struct nfs4_file_layout_dsaddr, id_node));
+}
+
 static struct pnfs_layoutdriver_type filelayout_type = {
         .id                     = LAYOUT_NFSV4_1_FILES,
         .name                   = "LAYOUT_NFSV4_1_FILES",
@@ -872,6 +879,7 @@ static struct pnfs_layoutdriver_type filelayout_type = {
         .commit_pagelist        = filelayout_commit_pagelist,
         .read_pagelist          = filelayout_read_pagelist,
         .write_pagelist         = filelayout_write_pagelist,
+        .free_deviceid_node     = filelayout_free_deveiceid_node,
 };
 
 static int __init nfs4filelayout_init(void)
diff --git a/fs/nfs/nfs4filelayout.h b/fs/nfs/nfs4filelayout.h
index 2b461d77b43a..cebe01e3795e 100644
--- a/fs/nfs/nfs4filelayout.h
+++ b/fs/nfs/nfs4filelayout.h
@@ -59,9 +59,7 @@ struct nfs4_pnfs_ds {
 #define NFS4_DEVICE_ID_NEG_ENTRY        0x00000001
 
 struct nfs4_file_layout_dsaddr {
-        struct hlist_node               node;
-        struct nfs4_deviceid            deviceid;
-        atomic_t                        ref;
+        struct nfs4_deviceid_node       id_node;
         unsigned long                   flags;
         u32                             stripe_count;
         u8                              *stripe_indices;
@@ -95,14 +93,12 @@ extern struct nfs_fh *
 nfs4_fl_select_ds_fh(struct pnfs_layout_segment *lseg, u32 j);
 
 extern void print_ds(struct nfs4_pnfs_ds *ds);
-extern void print_deviceid(struct nfs4_deviceid *dev_id);
 u32 nfs4_fl_calc_j_index(struct pnfs_layout_segment *lseg, loff_t offset);
 u32 nfs4_fl_calc_ds_index(struct pnfs_layout_segment *lseg, u32 j);
 struct nfs4_pnfs_ds *nfs4_fl_prepare_ds(struct pnfs_layout_segment *lseg,
                                         u32 ds_idx);
-extern struct nfs4_file_layout_dsaddr *
-nfs4_fl_find_get_deviceid(struct nfs4_deviceid *dev_id);
 extern void nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);
+extern void nfs4_fl_free_deviceid(struct nfs4_file_layout_dsaddr *dsaddr);
 struct nfs4_file_layout_dsaddr *
 get_device_info(struct inode *inode, struct nfs4_deviceid *dev_id, gfp_t gfp_flags);
 
diff --git a/fs/nfs/nfs4filelayoutdev.c b/fs/nfs/nfs4filelayoutdev.c
index db07c7af1395..3b7bf1377264 100644
--- a/fs/nfs/nfs4filelayoutdev.c
+++ b/fs/nfs/nfs4filelayoutdev.c
@@ -37,30 +37,6 @@
 #define NFSDBG_FACILITY         NFSDBG_PNFS_LD
 
 /*
- * Device ID RCU cache. A device ID is unique per client ID and layout type.
- */
-#define NFS4_FL_DEVICE_ID_HASH_BITS     5
-#define NFS4_FL_DEVICE_ID_HASH_SIZE     (1 << NFS4_FL_DEVICE_ID_HASH_BITS)
-#define NFS4_FL_DEVICE_ID_HASH_MASK     (NFS4_FL_DEVICE_ID_HASH_SIZE - 1)
-
-static inline u32
-nfs4_fl_deviceid_hash(struct nfs4_deviceid *id)
-{
-        unsigned char *cptr = (unsigned char *)id->data;
-        unsigned int nbytes = NFS4_DEVICEID4_SIZE;
-        u32 x = 0;
-
-        while (nbytes--) {
-                x *= 37;
-                x += *cptr++;
-        }
-        return x & NFS4_FL_DEVICE_ID_HASH_MASK;
-}
-
-static struct hlist_head filelayout_deviceid_cache[NFS4_FL_DEVICE_ID_HASH_SIZE];
-static DEFINE_SPINLOCK(filelayout_deviceid_lock);
-
-/*
  * Data server cache
  *
  * Data servers can be mapped to different device ids.
@@ -89,27 +65,6 @@ print_ds(struct nfs4_pnfs_ds *ds)
                 ds->ds_clp ? ds->ds_clp->cl_exchange_flags : 0);
 }
 
-void
-print_ds_list(struct nfs4_file_layout_dsaddr *dsaddr)
-{
-        int i;
-
-        ifdebug(FACILITY) {
-                printk("%s dsaddr->ds_num %d\n", __func__,
-                       dsaddr->ds_num);
-                for (i = 0; i < dsaddr->ds_num; i++)
-                        print_ds(dsaddr->ds_list[i]);
-        }
-}
-
-void print_deviceid(struct nfs4_deviceid *id)
-{
-        u32 *p = (u32 *)id;
-
-        dprintk("%s: device id= [%x%x%x%x]\n", __func__,
-                p[0], p[1], p[2], p[3]);
-}
-
 /* nfs4_ds_cache_lock is held */
 static struct nfs4_pnfs_ds *
 _data_server_lookup_locked(u32 ip_addr, u32 port)
@@ -201,13 +156,13 @@ destroy_ds(struct nfs4_pnfs_ds *ds)
         kfree(ds);
 }
 
-static void
+void
 nfs4_fl_free_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
 {
         struct nfs4_pnfs_ds *ds;
         int i;
 
-        print_deviceid(&dsaddr->deviceid);
+        nfs4_print_deviceid(&dsaddr->id_node.deviceid);
 
         for (i = 0; i < dsaddr->ds_num; i++) {
                 ds = dsaddr->ds_list[i];
@@ -353,12 +308,7 @@ decode_device(struct inode *ino, struct pnfs_device *pdev, gfp_t gfp_flags)
         u8 max_stripe_index;
         struct nfs4_file_layout_dsaddr *dsaddr = NULL;
         struct xdr_stream stream;
-        struct xdr_buf buf = {
-                .pages = pdev->pages,
-                .page_len = pdev->pglen,
-                .buflen = pdev->pglen,
-                .len = pdev->pglen,
-        };
+        struct xdr_buf buf;
         struct page *scratch;
 
         /* set up xdr stream */
@@ -366,7 +316,7 @@ decode_device(struct inode *ino, struct pnfs_device *pdev, gfp_t gfp_flags)
         if (!scratch)
                 goto out_err;
 
-        xdr_init_decode(&stream, &buf, NULL);
+        xdr_init_decode_pages(&stream, &buf, pdev->pages, pdev->pglen);
         xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
 
         /* Get the stripe count (number of stripe index) */
@@ -431,8 +381,10 @@ decode_device(struct inode *ino, struct pnfs_device *pdev, gfp_t gfp_flags)
         dsaddr->stripe_indices = stripe_indices;
         stripe_indices = NULL;
         dsaddr->ds_num = num;
-
-        memcpy(&dsaddr->deviceid, &pdev->dev_id, sizeof(pdev->dev_id));
+        nfs4_init_deviceid_node(&dsaddr->id_node,
+                                NFS_SERVER(ino)->pnfs_curr_ld,
+                                NFS_SERVER(ino)->nfs_client,
+                                &pdev->dev_id);
 
         for (i = 0; i < dsaddr->ds_num; i++) {
                 int j;
@@ -505,8 +457,8 @@ out_err:
 static struct nfs4_file_layout_dsaddr *
 decode_and_add_device(struct inode *inode, struct pnfs_device *dev, gfp_t gfp_flags)
 {
-        struct nfs4_file_layout_dsaddr *d, *new;
-        long hash;
+        struct nfs4_deviceid_node *d;
+        struct nfs4_file_layout_dsaddr *n, *new;
 
         new = decode_device(inode, dev, gfp_flags);
         if (!new) {
@@ -515,20 +467,13 @@ decode_and_add_device(struct inode *inode, struct pnfs_device *dev, gfp_t gfp_fl
                 return NULL;
         }
 
-        spin_lock(&filelayout_deviceid_lock);
-        d = nfs4_fl_find_get_deviceid(&new->deviceid);
-        if (d) {
-                spin_unlock(&filelayout_deviceid_lock);
+        d = nfs4_insert_deviceid_node(&new->id_node);
+        n = container_of(d, struct nfs4_file_layout_dsaddr, id_node);
+        if (n != new) {
                 nfs4_fl_free_deviceid(new);
-                return d;
+                return n;
         }
 
-        INIT_HLIST_NODE(&new->node);
-        atomic_set(&new->ref, 1);
-        hash = nfs4_fl_deviceid_hash(&new->deviceid);
-        hlist_add_head_rcu(&new->node, &filelayout_deviceid_cache[hash]);
-        spin_unlock(&filelayout_deviceid_lock);
-
         return new;
 }
 
@@ -600,35 +545,7 @@ out_free:
 void
 nfs4_fl_put_deviceid(struct nfs4_file_layout_dsaddr *dsaddr)
 {
-        if (atomic_dec_and_lock(&dsaddr->ref, &filelayout_deviceid_lock)) {
-                hlist_del_rcu(&dsaddr->node);
-                spin_unlock(&filelayout_deviceid_lock);
-
-                synchronize_rcu();
-                nfs4_fl_free_deviceid(dsaddr);
-        }
-}
-
-struct nfs4_file_layout_dsaddr *
-nfs4_fl_find_get_deviceid(struct nfs4_deviceid *id)
-{
-        struct nfs4_file_layout_dsaddr *d;
-        struct hlist_node *n;
-        long hash = nfs4_fl_deviceid_hash(id);
-
-
-        rcu_read_lock();
-        hlist_for_each_entry_rcu(d, n, &filelayout_deviceid_cache[hash], node) {
-                if (!memcmp(&d->deviceid, id, sizeof(*id))) {
-                        if (!atomic_inc_not_zero(&d->ref))
-                                goto fail;
-                        rcu_read_unlock();
-                        return d;
-                }
-        }
-fail:
-        rcu_read_unlock();
-        return NULL;
+        nfs4_put_deviceid_node(&dsaddr->id_node);
 }
 
 /*
@@ -676,15 +593,15 @@ static void
 filelayout_mark_devid_negative(struct nfs4_file_layout_dsaddr *dsaddr,
                                int err, u32 ds_addr)
 {
-        u32 *p = (u32 *)&dsaddr->deviceid;
+        u32 *p = (u32 *)&dsaddr->id_node.deviceid;
 
         printk(KERN_ERR "NFS: data server %x connection error %d."
                 " Deviceid [%x%x%x%x] marked out of use.\n",
                 ds_addr, err, p[0], p[1], p[2], p[3]);
 
-        spin_lock(&filelayout_deviceid_lock);
+        spin_lock(&nfs4_ds_cache_lock);
         dsaddr->flags |= NFS4_DEVICE_ID_NEG_ENTRY;
-        spin_unlock(&filelayout_deviceid_lock);
+        spin_unlock(&nfs4_ds_cache_lock);
 }
 
 struct nfs4_pnfs_ds *
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index cf1b339c3937..d2c4b59c896d 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -267,9 +267,11 @@ static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struc
                                 break;
                         nfs4_schedule_stateid_recovery(server, state);
                         goto wait_on_recovery;
+                case -NFS4ERR_EXPIRED:
+                        if (state != NULL)
+                                nfs4_schedule_stateid_recovery(server, state);
                 case -NFS4ERR_STALE_STATEID:
                 case -NFS4ERR_STALE_CLIENTID:
-                case -NFS4ERR_EXPIRED:
                         nfs4_schedule_lease_recovery(clp);
                         goto wait_on_recovery;
 #if defined(CONFIG_NFS_V4_1)
@@ -2361,6 +2363,9 @@ nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
         struct nfs4_state *state = NULL;
         int status;
 
+        if (pnfs_ld_layoutret_on_setattr(inode))
+                pnfs_return_layout(inode);
+
         nfs_fattr_init(fattr);
         
         /* Search for an existing open(O_WRITE) file */
@@ -3175,6 +3180,11 @@ static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
         return err;
 }
 
+void __nfs4_read_done_cb(struct nfs_read_data *data)
+{
+        nfs_invalidate_atime(data->inode);
+}
+
 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
 {
         struct nfs_server *server = NFS_SERVER(data->inode);
@@ -3184,7 +3194,7 @@ static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
                 return -EAGAIN;
         }
 
-        nfs_invalidate_atime(data->inode);
+        __nfs4_read_done_cb(data);
         if (task->tk_status > 0)
                 renew_lease(server, data->timestamp);
         return 0;
@@ -3198,7 +3208,8 @@ static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
         if (!nfs4_sequence_done(task, &data->res.seq_res))
                 return -EAGAIN;
 
-        return data->read_done_cb(task, data);
+        return data->read_done_cb ? data->read_done_cb(task, data) :
+                                    nfs4_read_done_cb(task, data);
 }
 
 static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
@@ -3243,7 +3254,8 @@ static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
 {
         if (!nfs4_sequence_done(task, &data->res.seq_res))
                 return -EAGAIN;
-        return data->write_done_cb(task, data);
+        return data->write_done_cb ? data->write_done_cb(task, data) :
+                nfs4_write_done_cb(task, data);
 }
 
 /* Reset the the nfs_write_data to send the write to the MDS. */
@@ -3670,9 +3682,11 @@ nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server,
                                 break;
                         nfs4_schedule_stateid_recovery(server, state);
                         goto wait_on_recovery;
+                case -NFS4ERR_EXPIRED:
+                        if (state != NULL)
+                                nfs4_schedule_stateid_recovery(server, state);
                 case -NFS4ERR_STALE_STATEID:
                 case -NFS4ERR_STALE_CLIENTID:
-                case -NFS4ERR_EXPIRED:
                         nfs4_schedule_lease_recovery(clp);
                         goto wait_on_recovery;
 #if defined(CONFIG_NFS_V4_1)
@@ -4543,6 +4557,7 @@ int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl)
                         case -ESTALE:
                                 goto out;
                         case -NFS4ERR_EXPIRED:
+                                nfs4_schedule_stateid_recovery(server, state);
                         case -NFS4ERR_STALE_CLIENTID:
                         case -NFS4ERR_STALE_STATEID:
                                 nfs4_schedule_lease_recovery(server->nfs_client);
@@ -5666,6 +5681,88 @@ int nfs4_proc_layoutget(struct nfs4_layoutget *lgp)
         return status;
 }
 
+static void
+nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
+{
+        struct nfs4_layoutreturn *lrp = calldata;
+
+        dprintk("--> %s\n", __func__);
+        if (nfs41_setup_sequence(lrp->clp->cl_session, &lrp->args.seq_args,
+                                &lrp->res.seq_res, 0, task))
+                return;
+        rpc_call_start(task);
+}
+
+static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
+{
+        struct nfs4_layoutreturn *lrp = calldata;
+        struct nfs_server *server;
+
+        dprintk("--> %s\n", __func__);
+
+        if (!nfs4_sequence_done(task, &lrp->res.seq_res))
+                return;
+
+        server = NFS_SERVER(lrp->args.inode);
+        if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
+                nfs_restart_rpc(task, lrp->clp);
+                return;
+        }
+        if (task->tk_status == 0) {
+                struct pnfs_layout_hdr *lo = NFS_I(lrp->args.inode)->layout;
+
+                if (lrp->res.lrs_present) {
+                        spin_lock(&lo->plh_inode->i_lock);
+                        pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
+                        spin_unlock(&lo->plh_inode->i_lock);
+                } else
+                        BUG_ON(!list_empty(&lo->plh_segs));
+        }
+        dprintk("<-- %s\n", __func__);
+}
+
+static void nfs4_layoutreturn_release(void *calldata)
+{
+        struct nfs4_layoutreturn *lrp = calldata;
+
+        dprintk("--> %s\n", __func__);
+        put_layout_hdr(NFS_I(lrp->args.inode)->layout);
+        kfree(calldata);
+        dprintk("<-- %s\n", __func__);
+}
+
+static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
+        .rpc_call_prepare = nfs4_layoutreturn_prepare,
+        .rpc_call_done = nfs4_layoutreturn_done,
+        .rpc_release = nfs4_layoutreturn_release,
+};
+
+int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
+{
+        struct rpc_task *task;
+        struct rpc_message msg = {
+                .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
+                .rpc_argp = &lrp->args,
+                .rpc_resp = &lrp->res,
+        };
+        struct rpc_task_setup task_setup_data = {
+                .rpc_client = lrp->clp->cl_rpcclient,
+                .rpc_message = &msg,
+                .callback_ops = &nfs4_layoutreturn_call_ops,
+                .callback_data = lrp,
+        };
+        int status;
+
+        dprintk("--> %s\n", __func__);
+        task = rpc_run_task(&task_setup_data);
+        if (IS_ERR(task))
+                return PTR_ERR(task);
+        status = task->tk_status;
+        dprintk("<-- %s status=%d\n", __func__, status);
+        rpc_put_task(task);
+        return status;
+}
+
 static int
 _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
 {
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 036f5adc9e1f..e97dd219f84f 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -1466,7 +1466,10 @@ static int nfs4_reclaim_lease(struct nfs_client *clp)
 #ifdef CONFIG_NFS_V4_1
 void nfs4_schedule_session_recovery(struct nfs4_session *session)
 {
-        nfs4_schedule_lease_recovery(session->clp);
+        struct nfs_client *clp = session->clp;
+
+        set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
+        nfs4_schedule_lease_recovery(clp);
 }
 EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
 
@@ -1549,6 +1552,7 @@ static int nfs4_reset_session(struct nfs_client *clp)
                 status = nfs4_recovery_handle_error(clp, status);
                 goto out;
         }
+        clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
         /* create_session negotiated new slot table */
         clear_bit(NFS4CLNT_RECALL_SLOT, &clp->cl_state);
 
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index c3ccd2c46834..d869a5e5464b 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -338,7 +338,11 @@ static int nfs4_stat_to_errno(int);
                                 1 /* layoutupdate4 layout type */ + \
                                 1 /* NULL filelayout layoutupdate4 payload */)
 #define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)
-
+#define encode_layoutreturn_maxsz (8 + op_encode_hdr_maxsz + \
+                                encode_stateid_maxsz + \
+                                1 /* FIXME: opaque lrf_body always empty at the moment */)
+#define decode_layoutreturn_maxsz (op_decode_hdr_maxsz + \
+                                1 + decode_stateid_maxsz)
 #else /* CONFIG_NFS_V4_1 */
 #define encode_sequence_maxsz   0
 #define decode_sequence_maxsz   0
@@ -760,7 +764,14 @@ static int nfs4_stat_to_errno(int);
                                 decode_putfh_maxsz + \
                                 decode_layoutcommit_maxsz + \
                                 decode_getattr_maxsz)
-
+#define NFS4_enc_layoutreturn_sz (compound_encode_hdr_maxsz + \
+                                encode_sequence_maxsz + \
+                                encode_putfh_maxsz + \
+                                encode_layoutreturn_maxsz)
+#define NFS4_dec_layoutreturn_sz (compound_decode_hdr_maxsz + \
+                                decode_sequence_maxsz + \
+                                decode_putfh_maxsz + \
+                                decode_layoutreturn_maxsz)
 
 const u32 nfs41_maxwrite_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
                                       compound_encode_hdr_maxsz +
@@ -1864,6 +1875,7 @@ encode_layoutget(struct xdr_stream *xdr,
 
 static int
 encode_layoutcommit(struct xdr_stream *xdr,
+                    struct inode *inode,
                     const struct nfs4_layoutcommit_args *args,
                     struct compound_hdr *hdr)
 {
@@ -1872,7 +1884,7 @@ encode_layoutcommit(struct xdr_stream *xdr,
         dprintk("%s: lbw: %llu type: %d\n", __func__, args->lastbytewritten,
                 NFS_SERVER(args->inode)->pnfs_curr_ld->id);
 
-        p = reserve_space(xdr, 48 + NFS4_STATEID_SIZE);
+        p = reserve_space(xdr, 44 + NFS4_STATEID_SIZE);
         *p++ = cpu_to_be32(OP_LAYOUTCOMMIT);
         /* Only whole file layouts */
         p = xdr_encode_hyper(p, 0); /* offset */
@@ -1883,12 +1895,49 @@ encode_layoutcommit(struct xdr_stream *xdr,
         p = xdr_encode_hyper(p, args->lastbytewritten);
         *p++ = cpu_to_be32(0); /* Never send time_modify_changed */
         *p++ = cpu_to_be32(NFS_SERVER(args->inode)->pnfs_curr_ld->id);/* type */
-        *p++ = cpu_to_be32(0); /* no file layout payload */
+
+        if (NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit)
+                NFS_SERVER(inode)->pnfs_curr_ld->encode_layoutcommit(
+                        NFS_I(inode)->layout, xdr, args);
+        else {
+                p = reserve_space(xdr, 4);
+                *p = cpu_to_be32(0); /* no layout-type payload */
+        }
 
         hdr->nops++;
         hdr->replen += decode_layoutcommit_maxsz;
         return 0;
 }
+
+static void
+encode_layoutreturn(struct xdr_stream *xdr,
+                    const struct nfs4_layoutreturn_args *args,
+                    struct compound_hdr *hdr)
+{
+        __be32 *p;
+
+        p = reserve_space(xdr, 20);
+        *p++ = cpu_to_be32(OP_LAYOUTRETURN);
+        *p++ = cpu_to_be32(0);          /* reclaim. always 0 for now */
+        *p++ = cpu_to_be32(args->layout_type);
+        *p++ = cpu_to_be32(IOMODE_ANY);
+        *p = cpu_to_be32(RETURN_FILE);
+        p = reserve_space(xdr, 16 + NFS4_STATEID_SIZE);
+        p = xdr_encode_hyper(p, 0);
+        p = xdr_encode_hyper(p, NFS4_MAX_UINT64);
+        spin_lock(&args->inode->i_lock);
+        xdr_encode_opaque_fixed(p, &args->stateid.data, NFS4_STATEID_SIZE);
+        spin_unlock(&args->inode->i_lock);
+        if (NFS_SERVER(args->inode)->pnfs_curr_ld->encode_layoutreturn) {
+                NFS_SERVER(args->inode)->pnfs_curr_ld->encode_layoutreturn(
+                        NFS_I(args->inode)->layout, xdr, args);
+        } else {
+                p = reserve_space(xdr, 4);
+                *p = cpu_to_be32(0);
+        }
+        hdr->nops++;
+        hdr->replen += decode_layoutreturn_maxsz;
+}
 #endif /* CONFIG_NFS_V4_1 */
 
 /*
@@ -2706,10 +2755,12 @@ static void nfs4_xdr_enc_layoutget(struct rpc_rqst *req,
 /*
  *  Encode LAYOUTCOMMIT request
  */
-static int nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
-                                     struct xdr_stream *xdr,
-                                     struct nfs4_layoutcommit_args *args)
+static void nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
+                                      struct xdr_stream *xdr,
+                                      struct nfs4_layoutcommit_args *args)
 {
+        struct nfs4_layoutcommit_data *data =
+                container_of(args, struct nfs4_layoutcommit_data, args);
         struct compound_hdr hdr = {
                 .minorversion = nfs4_xdr_minorversion(&args->seq_args),
         };
@@ -2717,10 +2768,27 @@ static int nfs4_xdr_enc_layoutcommit(struct rpc_rqst *req,
         encode_compound_hdr(xdr, req, &hdr);
         encode_sequence(xdr, &args->seq_args, &hdr);
         encode_putfh(xdr, NFS_FH(args->inode), &hdr);
-        encode_layoutcommit(xdr, args, &hdr);
+        encode_layoutcommit(xdr, data->args.inode, args, &hdr);
         encode_getfattr(xdr, args->bitmask, &hdr);
         encode_nops(&hdr);
-        return 0;
+}
+
+/*
+ * Encode LAYOUTRETURN request
+ */
+static void nfs4_xdr_enc_layoutreturn(struct rpc_rqst *req,
+                                      struct xdr_stream *xdr,
+                                      struct nfs4_layoutreturn_args *args)
+{
+        struct compound_hdr hdr = {
+                .minorversion = nfs4_xdr_minorversion(&args->seq_args),
+        };
+
+        encode_compound_hdr(xdr, req, &hdr);
+        encode_sequence(xdr, &args->seq_args, &hdr);
+        encode_putfh(xdr, NFS_FH(args->inode), &hdr);
+        encode_layoutreturn(xdr, args, &hdr);
+        encode_nops(&hdr);
 }
 #endif /* CONFIG_NFS_V4_1 */
 
@@ -5203,6 +5271,27 @@ out_overflow:
         return -EIO;
 }
 
+static int decode_layoutreturn(struct xdr_stream *xdr,
+                               struct nfs4_layoutreturn_res *res)
+{
+        __be32 *p;
+        int status;
+
+        status = decode_op_hdr(xdr, OP_LAYOUTRETURN);
+        if (status)
+                return status;
+        p = xdr_inline_decode(xdr, 4);
+        if (unlikely(!p))
+                goto out_overflow;
+        res->lrs_present = be32_to_cpup(p);
+        if (res->lrs_present)
+                status = decode_stateid(xdr, &res->stateid);
+        return status;
+out_overflow:
+        print_overflow_msg(__func__, xdr);
+        return -EIO;
+}
+
 static int decode_layoutcommit(struct xdr_stream *xdr,
                                struct rpc_rqst *req,
                                struct nfs4_layoutcommit_res *res)
@@ -6320,6 +6409,30 @@ out:
 }
 
 /*
+ * Decode LAYOUTRETURN response
+ */
+static int nfs4_xdr_dec_layoutreturn(struct rpc_rqst *rqstp,
+                                     struct xdr_stream *xdr,
+                                     struct nfs4_layoutreturn_res *res)
+{
+        struct compound_hdr hdr;
+        int status;
+
+        status = decode_compound_hdr(xdr, &hdr);
+        if (status)
+                goto out;
+        status = decode_sequence(xdr, &res->seq_res, rqstp);
+        if (status)
+                goto out;
+        status = decode_putfh(xdr);
+        if (status)
+                goto out;
+        status = decode_layoutreturn(xdr, res);
+out:
+        return status;
+}
+
+/*
  * Decode LAYOUTCOMMIT response
  */
 static int nfs4_xdr_dec_layoutcommit(struct rpc_rqst *rqstp,
@@ -6547,6 +6660,7 @@ struct rpc_procinfo	nfs4_procedures[] = {
         PROC(GETDEVICEINFO,     enc_getdeviceinfo,      dec_getdeviceinfo),
         PROC(LAYOUTGET,         enc_layoutget,          dec_layoutget),
         PROC(LAYOUTCOMMIT,      enc_layoutcommit,       dec_layoutcommit),
+        PROC(LAYOUTRETURN,      enc_layoutreturn,       dec_layoutreturn),
 #endif /* CONFIG_NFS_V4_1 */
 };
 
diff --git a/fs/nfs/nfsroot.c b/fs/nfs/nfsroot.c
index c541093a5bf2..c4744e1d513c 100644
--- a/fs/nfs/nfsroot.c
+++ b/fs/nfs/nfsroot.c
@@ -87,7 +87,7 @@
 #define NFS_ROOT                "/tftpboot/%s"
 
 /* Default NFSROOT mount options. */
-#define NFS_DEF_OPTIONS         "udp"
+#define NFS_DEF_OPTIONS         "vers=2,udp,rsize=4096,wsize=4096"
 
 /* Parameters passed from the kernel command line */
 static char nfs_root_parms[256] __initdata = "";
diff --git a/fs/nfs/objlayout/Kbuild b/fs/nfs/objlayout/Kbuild
new file mode 100644
index 000000000000..ed30ea072bb8
--- /dev/null
+++ b/fs/nfs/objlayout/Kbuild
@@ -0,0 +1,5 @@
+#
+# Makefile for the pNFS Objects Layout Driver kernel module
+#
+objlayoutdriver-y := objio_osd.o pnfs_osd_xdr_cli.o objlayout.o
+obj-$(CONFIG_PNFS_OBJLAYOUT) += objlayoutdriver.o
diff --git a/fs/nfs/objlayout/objio_osd.c b/fs/nfs/objlayout/objio_osd.c
new file mode 100644
index 000000000000..9cf208df1f25
--- /dev/null
+++ b/fs/nfs/objlayout/objio_osd.c
@@ -0,0 +1,1057 @@
+/*
+ *  pNFS Objects layout implementation over open-osd initiator library
+ *
+ *  Copyright (C) 2009 Panasas Inc. [year of first publication]
+ *  All rights reserved.
+ *
+ *  Benny Halevy <bhalevy@panasas.com>
+ *  Boaz Harrosh <bharrosh@panasas.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2
+ *  See the file COPYING included with this distribution for more details.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the Panasas company nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <linux/module.h>
+#include <scsi/osd_initiator.h>
+
+#include "objlayout.h"
+
+#define NFSDBG_FACILITY         NFSDBG_PNFS_LD
+
+#define _LLU(x) ((unsigned long long)x)
+
+enum { BIO_MAX_PAGES_KMALLOC =
+                (PAGE_SIZE - sizeof(struct bio)) / sizeof(struct bio_vec),
+};
+
+struct objio_dev_ent {
+        struct nfs4_deviceid_node id_node;
+        struct osd_dev *od;
+};
+
+static void
+objio_free_deviceid_node(struct nfs4_deviceid_node *d)
+{
+        struct objio_dev_ent *de = container_of(d, struct objio_dev_ent, id_node);
+
+        dprintk("%s: free od=%p\n", __func__, de->od);
+        osduld_put_device(de->od);
+        kfree(de);
+}
+
+static struct objio_dev_ent *_dev_list_find(const struct nfs_server *nfss,
+        const struct nfs4_deviceid *d_id)
+{
+        struct nfs4_deviceid_node *d;
+        struct objio_dev_ent *de;
+
+        d = nfs4_find_get_deviceid(nfss->pnfs_curr_ld, nfss->nfs_client, d_id);
+        if (!d)
+                return NULL;
+
+        de = container_of(d, struct objio_dev_ent, id_node);
+        return de;
+}
+
+static struct objio_dev_ent *
+_dev_list_add(const struct nfs_server *nfss,
+        const struct nfs4_deviceid *d_id, struct osd_dev *od,
+        gfp_t gfp_flags)
+{
+        struct nfs4_deviceid_node *d;
+        struct objio_dev_ent *de = kzalloc(sizeof(*de), gfp_flags);
+        struct objio_dev_ent *n;
+
+        if (!de) {
+                dprintk("%s: -ENOMEM od=%p\n", __func__, od);
+                return NULL;
+        }
+
+        dprintk("%s: Adding od=%p\n", __func__, od);
+        nfs4_init_deviceid_node(&de->id_node,
+                                nfss->pnfs_curr_ld,
+                                nfss->nfs_client,
+                                d_id);
+        de->od = od;
+
+        d = nfs4_insert_deviceid_node(&de->id_node);
+        n = container_of(d, struct objio_dev_ent, id_node);
+        if (n != de) {
+                dprintk("%s: Race with other n->od=%p\n", __func__, n->od);
+                objio_free_deviceid_node(&de->id_node);
+                de = n;
+        }
+
+        atomic_inc(&de->id_node.ref);
+        return de;
+}
+
+struct caps_buffers {
+        u8 caps_key[OSD_CRYPTO_KEYID_SIZE];
+        u8 creds[OSD_CAP_LEN];
+};
+
+struct objio_segment {
+        struct pnfs_layout_segment lseg;
+
+        struct pnfs_osd_object_cred *comps;
+
+        unsigned mirrors_p1;
+        unsigned stripe_unit;
+        unsigned group_width;   /* Data stripe_units without integrity comps */
+        u64 group_depth;
+        unsigned group_count;
+
+        unsigned max_io_size;
+
+        unsigned comps_index;
+        unsigned num_comps;
+        /* variable length */
+        struct objio_dev_ent *ods[];
+};
+
+static inline struct objio_segment *
+OBJIO_LSEG(struct pnfs_layout_segment *lseg)
+{
+        return container_of(lseg, struct objio_segment, lseg);
+}
+
+struct objio_state;
+typedef ssize_t (*objio_done_fn)(struct objio_state *ios);
+
+struct objio_state {
+        /* Generic layer */
+        struct objlayout_io_state ol_state;
+
+        struct objio_segment *layout;
+
+        struct kref kref;
+        objio_done_fn done;
+        void *private;
+
+        unsigned long length;
+        unsigned numdevs; /* Actually used devs in this IO */
+        /* A per-device variable array of size numdevs */
+        struct _objio_per_comp {
+                struct bio *bio;
+                struct osd_request *or;
+                unsigned long length;
+                u64 offset;
+                unsigned dev;
+        } per_dev[];
+};
+
+/* Send and wait for a get_device_info of devices in the layout,
+   then look them up with the osd_initiator library */
+static struct objio_dev_ent *_device_lookup(struct pnfs_layout_hdr *pnfslay,
+                                struct objio_segment *objio_seg, unsigned comp,
+                                gfp_t gfp_flags)
+{
+        struct pnfs_osd_deviceaddr *deviceaddr;
+        struct nfs4_deviceid *d_id;
+        struct objio_dev_ent *ode;
+        struct osd_dev *od;
+        struct osd_dev_info odi;
+        int err;
+
+        d_id = &objio_seg->comps[comp].oc_object_id.oid_device_id;
+
+        ode = _dev_list_find(NFS_SERVER(pnfslay->plh_inode), d_id);
+        if (ode)
+                return ode;
+
+        err = objlayout_get_deviceinfo(pnfslay, d_id, &deviceaddr, gfp_flags);
+        if (unlikely(err)) {
+                dprintk("%s: objlayout_get_deviceinfo dev(%llx:%llx) =>%d\n",
+                        __func__, _DEVID_LO(d_id), _DEVID_HI(d_id), err);
+                return ERR_PTR(err);
+        }
+
+        odi.systemid_len = deviceaddr->oda_systemid.len;
+        if (odi.systemid_len > sizeof(odi.systemid)) {
+                err = -EINVAL;
+                goto out;
+        } else if (odi.systemid_len)
+                memcpy(odi.systemid, deviceaddr->oda_systemid.data,
+                       odi.systemid_len);
+        odi.osdname_len  = deviceaddr->oda_osdname.len;
+        odi.osdname      = (u8 *)deviceaddr->oda_osdname.data;
+
+        if (!odi.osdname_len && !odi.systemid_len) {
+                dprintk("%s: !odi.osdname_len && !odi.systemid_len\n",
+                        __func__);
+                err = -ENODEV;
+                goto out;
+        }
+
+        od = osduld_info_lookup(&odi);
+        if (unlikely(IS_ERR(od))) {
+                err = PTR_ERR(od);
+                dprintk("%s: osduld_info_lookup => %d\n", __func__, err);
+                goto out;
+        }
+
+        ode = _dev_list_add(NFS_SERVER(pnfslay->plh_inode), d_id, od,
+                            gfp_flags);
+
+out:
+        dprintk("%s: return=%d\n", __func__, err);
+        objlayout_put_deviceinfo(deviceaddr);
+        return err ? ERR_PTR(err) : ode;
+}
+
+static int objio_devices_lookup(struct pnfs_layout_hdr *pnfslay,
+        struct objio_segment *objio_seg,
+        gfp_t gfp_flags)
+{
+        unsigned i;
+        int err;
+
+        /* lookup all devices */
+        for (i = 0; i < objio_seg->num_comps; i++) {
+                struct objio_dev_ent *ode;
+
+                ode = _device_lookup(pnfslay, objio_seg, i, gfp_flags);
+                if (unlikely(IS_ERR(ode))) {
+                        err = PTR_ERR(ode);
+                        goto out;
+                }
+                objio_seg->ods[i] = ode;
+        }
+        err = 0;
+
+out:
+        dprintk("%s: return=%d\n", __func__, err);
+        return err;
+}
+
+static int _verify_data_map(struct pnfs_osd_layout *layout)
+{
+        struct pnfs_osd_data_map *data_map = &layout->olo_map;
+        u64 stripe_length;
+        u32 group_width;
+
+/* FIXME: Only raid0 for now. if not go through MDS */
+        if (data_map->odm_raid_algorithm != PNFS_OSD_RAID_0) {
+                printk(KERN_ERR "Only RAID_0 for now\n");
+                return -ENOTSUPP;
+        }
+        if (0 != (data_map->odm_num_comps % (data_map->odm_mirror_cnt + 1))) {
+                printk(KERN_ERR "Data Map wrong, num_comps=%u mirrors=%u\n",
+                          data_map->odm_num_comps, data_map->odm_mirror_cnt);
+                return -EINVAL;
+        }
+
+        if (data_map->odm_group_width)
+                group_width = data_map->odm_group_width;
+        else
+                group_width = data_map->odm_num_comps /
+                                                (data_map->odm_mirror_cnt + 1);
+
+        stripe_length = (u64)data_map->odm_stripe_unit * group_width;
+        if (stripe_length >= (1ULL << 32)) {
+                printk(KERN_ERR "Total Stripe length(0x%llx)"
+                          " >= 32bit is not supported\n", _LLU(stripe_length));
+                return -ENOTSUPP;
+        }
+
+        if (0 != (data_map->odm_stripe_unit & ~PAGE_MASK)) {
+                printk(KERN_ERR "Stripe Unit(0x%llx)"
+                          " must be Multples of PAGE_SIZE(0x%lx)\n",
+                          _LLU(data_map->odm_stripe_unit), PAGE_SIZE);
+                return -ENOTSUPP;
+        }
+
+        return 0;
+}
+
+static void copy_single_comp(struct pnfs_osd_object_cred *cur_comp,
+                             struct pnfs_osd_object_cred *src_comp,
+                             struct caps_buffers *caps_p)
+{
+        WARN_ON(src_comp->oc_cap_key.cred_len > sizeof(caps_p->caps_key));
+        WARN_ON(src_comp->oc_cap.cred_len > sizeof(caps_p->creds));
+
+        *cur_comp = *src_comp;
+
+        memcpy(caps_p->caps_key, src_comp->oc_cap_key.cred,
+               sizeof(caps_p->caps_key));
+        cur_comp->oc_cap_key.cred = caps_p->caps_key;
+
+        memcpy(caps_p->creds, src_comp->oc_cap.cred,
+               sizeof(caps_p->creds));
+        cur_comp->oc_cap.cred = caps_p->creds;
+}
+
+int objio_alloc_lseg(struct pnfs_layout_segment **outp,
+        struct pnfs_layout_hdr *pnfslay,
+        struct pnfs_layout_range *range,
+        struct xdr_stream *xdr,
+        gfp_t gfp_flags)
+{
+        struct objio_segment *objio_seg;
+        struct pnfs_osd_xdr_decode_layout_iter iter;
+        struct pnfs_osd_layout layout;
+        struct pnfs_osd_object_cred *cur_comp, src_comp;
+        struct caps_buffers *caps_p;
+        int err;
+
+        err = pnfs_osd_xdr_decode_layout_map(&layout, &iter, xdr);
+        if (unlikely(err))
+                return err;
+
+        err = _verify_data_map(&layout);
+        if (unlikely(err))
+                return err;
+
+        objio_seg = kzalloc(sizeof(*objio_seg) +
+                            sizeof(objio_seg->ods[0]) * layout.olo_num_comps +
+                            sizeof(*objio_seg->comps) * layout.olo_num_comps +
+                            sizeof(struct caps_buffers) * layout.olo_num_comps,
+                            gfp_flags);
+        if (!objio_seg)
+                return -ENOMEM;
+
+        objio_seg->comps = (void *)(objio_seg->ods + layout.olo_num_comps);
+        cur_comp = objio_seg->comps;
+        caps_p = (void *)(cur_comp + layout.olo_num_comps);
+        while (pnfs_osd_xdr_decode_layout_comp(&src_comp, &iter, xdr, &err))
+                copy_single_comp(cur_comp++, &src_comp, caps_p++);
+        if (unlikely(err))
+                goto err;
+
+        objio_seg->num_comps = layout.olo_num_comps;
+        objio_seg->comps_index = layout.olo_comps_index;
+        err = objio_devices_lookup(pnfslay, objio_seg, gfp_flags);
+        if (err)
+                goto err;
+
+        objio_seg->mirrors_p1 = layout.olo_map.odm_mirror_cnt + 1;
+        objio_seg->stripe_unit = layout.olo_map.odm_stripe_unit;
+        if (layout.olo_map.odm_group_width) {
+                objio_seg->group_width = layout.olo_map.odm_group_width;
+                objio_seg->group_depth = layout.olo_map.odm_group_depth;
+                objio_seg->group_count = layout.olo_map.odm_num_comps /
+                                                objio_seg->mirrors_p1 /
+                                                objio_seg->group_width;
+        } else {
+                objio_seg->group_width = layout.olo_map.odm_num_comps /
+                                                objio_seg->mirrors_p1;
+                objio_seg->group_depth = -1;
+                objio_seg->group_count = 1;
+        }
+
+        /* Cache this calculation it will hit for every page */
+        objio_seg->max_io_size = (BIO_MAX_PAGES_KMALLOC * PAGE_SIZE -
+                                  objio_seg->stripe_unit) *
+                                 objio_seg->group_width;
+
+        *outp = &objio_seg->lseg;
+        return 0;
+
+err:
+        kfree(objio_seg);
+        dprintk("%s: Error: return %d\n", __func__, err);
+        *outp = NULL;
+        return err;
+}
+
+void objio_free_lseg(struct pnfs_layout_segment *lseg)
+{
+        int i;
+        struct objio_segment *objio_seg = OBJIO_LSEG(lseg);
+
+        for (i = 0; i < objio_seg->num_comps; i++) {
+                if (!objio_seg->ods[i])
+                        break;
+                nfs4_put_deviceid_node(&objio_seg->ods[i]->id_node);
+        }
+        kfree(objio_seg);
+}
+
+int objio_alloc_io_state(struct pnfs_layout_segment *lseg,
+                         struct objlayout_io_state **outp,
+                         gfp_t gfp_flags)
+{
+        struct objio_segment *objio_seg = OBJIO_LSEG(lseg);
+        struct objio_state *ios;
+        const unsigned first_size = sizeof(*ios) +
+                                objio_seg->num_comps * sizeof(ios->per_dev[0]);
+        const unsigned sec_size = objio_seg->num_comps *
+                                                sizeof(ios->ol_state.ioerrs[0]);
+
+        ios = kzalloc(first_size + sec_size, gfp_flags);
+        if (unlikely(!ios))
+                return -ENOMEM;
+
+        ios->layout = objio_seg;
+        ios->ol_state.ioerrs = ((void *)ios) + first_size;
+        ios->ol_state.num_comps = objio_seg->num_comps;
+
+        *outp = &ios->ol_state;
+        return 0;
+}
+
+void objio_free_io_state(struct objlayout_io_state *ol_state)
+{
+        struct objio_state *ios = container_of(ol_state, struct objio_state,
+                                               ol_state);
+
+        kfree(ios);
+}
+
+enum pnfs_osd_errno osd_pri_2_pnfs_err(enum osd_err_priority oep)
+{
+        switch (oep) {
+        case OSD_ERR_PRI_NO_ERROR:
+                return (enum pnfs_osd_errno)0;
+
+        case OSD_ERR_PRI_CLEAR_PAGES:
+                BUG_ON(1);
+                return 0;
+
+        case OSD_ERR_PRI_RESOURCE:
+                return PNFS_OSD_ERR_RESOURCE;
+        case OSD_ERR_PRI_BAD_CRED:
+                return PNFS_OSD_ERR_BAD_CRED;
+        case OSD_ERR_PRI_NO_ACCESS:
+                return PNFS_OSD_ERR_NO_ACCESS;
+        case OSD_ERR_PRI_UNREACHABLE:
+                return PNFS_OSD_ERR_UNREACHABLE;
+        case OSD_ERR_PRI_NOT_FOUND:
+                return PNFS_OSD_ERR_NOT_FOUND;
+        case OSD_ERR_PRI_NO_SPACE:
+                return PNFS_OSD_ERR_NO_SPACE;
+        default:
+                WARN_ON(1);
+                /* fallthrough */
+        case OSD_ERR_PRI_EIO:
+                return PNFS_OSD_ERR_EIO;
+        }
+}
+
+static void _clear_bio(struct bio *bio)
+{
+        struct bio_vec *bv;
+        unsigned i;
+
+        __bio_for_each_segment(bv, bio, i, 0) {
+                unsigned this_count = bv->bv_len;
+
+                if (likely(PAGE_SIZE == this_count))
+                        clear_highpage(bv->bv_page);
+                else
+                        zero_user(bv->bv_page, bv->bv_offset, this_count);
+        }
+}
+
+static int _io_check(struct objio_state *ios, bool is_write)
+{
+        enum osd_err_priority oep = OSD_ERR_PRI_NO_ERROR;
+        int lin_ret = 0;
+        int i;
+
+        for (i = 0; i <  ios->numdevs; i++) {
+                struct osd_sense_info osi;
+                struct osd_request *or = ios->per_dev[i].or;
+                unsigned dev;
+                int ret;
+
+                if (!or)
+                        continue;
+
+                ret = osd_req_decode_sense(or, &osi);
+                if (likely(!ret))
+                        continue;
+
+                if (OSD_ERR_PRI_CLEAR_PAGES == osi.osd_err_pri) {
+                        /* start read offset passed endof file */
+                        BUG_ON(is_write);
+                        _clear_bio(ios->per_dev[i].bio);
+                        dprintk("%s: start read offset passed end of file "
+                                "offset=0x%llx, length=0x%lx\n", __func__,
+                                _LLU(ios->per_dev[i].offset),
+                                ios->per_dev[i].length);
+
+                        continue; /* we recovered */
+                }
+                dev = ios->per_dev[i].dev;
+                objlayout_io_set_result(&ios->ol_state, dev,
+                                        &ios->layout->comps[dev].oc_object_id,
+                                        osd_pri_2_pnfs_err(osi.osd_err_pri),
+                                        ios->per_dev[i].offset,
+                                        ios->per_dev[i].length,
+                                        is_write);
+
+                if (osi.osd_err_pri >= oep) {
+                        oep = osi.osd_err_pri;
+                        lin_ret = ret;
+                }
+        }
+
+        return lin_ret;
+}
+
+/*
+ * Common IO state helpers.
+ */
+static void _io_free(struct objio_state *ios)
+{
+        unsigned i;
+
+        for (i = 0; i < ios->numdevs; i++) {
+                struct _objio_per_comp *per_dev = &ios->per_dev[i];
+
+                if (per_dev->or) {
+                        osd_end_request(per_dev->or);
+                        per_dev->or = NULL;
+                }
+
+                if (per_dev->bio) {
+                        bio_put(per_dev->bio);
+                        per_dev->bio = NULL;
+                }
+        }
+}
+
+struct osd_dev *_io_od(struct objio_state *ios, unsigned dev)
+{
+        unsigned min_dev = ios->layout->comps_index;
+        unsigned max_dev = min_dev + ios->layout->num_comps;
+
+        BUG_ON(dev < min_dev || max_dev <= dev);
+        return ios->layout->ods[dev - min_dev]->od;
+}
+
+struct _striping_info {
+        u64 obj_offset;
+        u64 group_length;
+        unsigned dev;
+        unsigned unit_off;
+};
+
+static void _calc_stripe_info(struct objio_state *ios, u64 file_offset,
+                              struct _striping_info *si)
+{
+        u32     stripe_unit = ios->layout->stripe_unit;
+        u32     group_width = ios->layout->group_width;
+        u64     group_depth = ios->layout->group_depth;
+        u32     U = stripe_unit * group_width;
+
+        u64     T = U * group_depth;
+        u64     S = T * ios->layout->group_count;
+        u64     M = div64_u64(file_offset, S);
+
+        /*
+        G = (L - (M * S)) / T
+        H = (L - (M * S)) % T
+        */
+        u64     LmodU = file_offset - M * S;
+        u32     G = div64_u64(LmodU, T);
+        u64     H = LmodU - G * T;
+
+        u32     N = div_u64(H, U);
+
+        div_u64_rem(file_offset, stripe_unit, &si->unit_off);
+        si->obj_offset = si->unit_off + (N * stripe_unit) +
+                                  (M * group_depth * stripe_unit);
+
+        /* "H - (N * U)" is just "H % U" so it's bound to u32 */
+        si->dev = (u32)(H - (N * U)) / stripe_unit + G * group_width;
+        si->dev *= ios->layout->mirrors_p1;
+
+        si->group_length = T - H;
+}
+
+static int _add_stripe_unit(struct objio_state *ios,  unsigned *cur_pg,
+                unsigned pgbase, struct _objio_per_comp *per_dev, int cur_len,
+                gfp_t gfp_flags)
+{
+        unsigned pg = *cur_pg;
+        struct request_queue *q =
+                        osd_request_queue(_io_od(ios, per_dev->dev));
+
+        per_dev->length += cur_len;
+
+        if (per_dev->bio == NULL) {
+                unsigned stripes = ios->layout->num_comps /
+                                                     ios->layout->mirrors_p1;
+                unsigned pages_in_stripe = stripes *
+                                      (ios->layout->stripe_unit / PAGE_SIZE);
+                unsigned bio_size = (ios->ol_state.nr_pages + pages_in_stripe) /
+                                    stripes;
+
+                if (BIO_MAX_PAGES_KMALLOC < bio_size)
+                        bio_size = BIO_MAX_PAGES_KMALLOC;
+
+                per_dev->bio = bio_kmalloc(gfp_flags, bio_size);
+                if (unlikely(!per_dev->bio)) {
+                        dprintk("Faild to allocate BIO size=%u\n", bio_size);
+                        return -ENOMEM;
+                }
+        }
+
+        while (cur_len > 0) {
+                unsigned pglen = min_t(unsigned, PAGE_SIZE - pgbase, cur_len);
+                unsigned added_len;
+
+                BUG_ON(ios->ol_state.nr_pages <= pg);
+                cur_len -= pglen;
+
+                added_len = bio_add_pc_page(q, per_dev->bio,
+                                        ios->ol_state.pages[pg], pglen, pgbase);
+                if (unlikely(pglen != added_len))
+                        return -ENOMEM;
+                pgbase = 0;
+                ++pg;
+        }
+        BUG_ON(cur_len);
+
+        *cur_pg = pg;
+        return 0;
+}
+
+static int _prepare_one_group(struct objio_state *ios, u64 length,
+                              struct _striping_info *si, unsigned *last_pg,
+                              gfp_t gfp_flags)
+{
+        unsigned stripe_unit = ios->layout->stripe_unit;
+        unsigned mirrors_p1 = ios->layout->mirrors_p1;
+        unsigned devs_in_group = ios->layout->group_width * mirrors_p1;
+        unsigned dev = si->dev;
+        unsigned first_dev = dev - (dev % devs_in_group);
+        unsigned max_comp = ios->numdevs ? ios->numdevs - mirrors_p1 : 0;
+        unsigned cur_pg = *last_pg;
+        int ret = 0;
+
+        while (length) {
+                struct _objio_per_comp *per_dev = &ios->per_dev[dev];
+                unsigned cur_len, page_off = 0;
+
+                if (!per_dev->length) {
+                        per_dev->dev = dev;
+                        if (dev < si->dev) {
+                                per_dev->offset = si->obj_offset + stripe_unit -
+                                                                   si->unit_off;
+                                cur_len = stripe_unit;
+                        } else if (dev == si->dev) {
+                                per_dev->offset = si->obj_offset;
+                                cur_len = stripe_unit - si->unit_off;
+                                page_off = si->unit_off & ~PAGE_MASK;
+                                BUG_ON(page_off &&
+                                      (page_off != ios->ol_state.pgbase));
+                        } else { /* dev > si->dev */
+                                per_dev->offset = si->obj_offset - si->unit_off;
+                                cur_len = stripe_unit;
+                        }
+
+                        if (max_comp < dev)
+                                max_comp = dev;
+                } else {
+                        cur_len = stripe_unit;
+                }
+                if (cur_len >= length)
+                        cur_len = length;
+
+                ret = _add_stripe_unit(ios, &cur_pg, page_off , per_dev,
+                                       cur_len, gfp_flags);
+                if (unlikely(ret))
+                        goto out;
+
+                dev += mirrors_p1;
+                dev = (dev % devs_in_group) + first_dev;
+
+                length -= cur_len;
+                ios->length += cur_len;
+        }
+out:
+        ios->numdevs = max_comp + mirrors_p1;
+        *last_pg = cur_pg;
+        return ret;
+}
+
+static int _io_rw_pagelist(struct objio_state *ios, gfp_t gfp_flags)
+{
+        u64 length = ios->ol_state.count;
+        u64 offset = ios->ol_state.offset;
+        struct _striping_info si;
+        unsigned last_pg = 0;
+        int ret = 0;
+
+        while (length) {
+                _calc_stripe_info(ios, offset, &si);
+
+                if (length < si.group_length)
+                        si.group_length = length;
+
+                ret = _prepare_one_group(ios, si.group_length, &si, &last_pg, gfp_flags);
+                if (unlikely(ret))
+                        goto out;
+
+                offset += si.group_length;
+                length -= si.group_length;
+        }
+
+out:
+        if (!ios->length)
+                return ret;
+
+        return 0;
+}
+
+static ssize_t _sync_done(struct objio_state *ios)
+{
+        struct completion *waiting = ios->private;
+
+        complete(waiting);
+        return 0;
+}
+
+static void _last_io(struct kref *kref)
+{
+        struct objio_state *ios = container_of(kref, struct objio_state, kref);
+
+        ios->done(ios);
+}
+
+static void _done_io(struct osd_request *or, void *p)
+{
+        struct objio_state *ios = p;
+
+        kref_put(&ios->kref, _last_io);
+}
+
+static ssize_t _io_exec(struct objio_state *ios)
+{
+        DECLARE_COMPLETION_ONSTACK(wait);
+        ssize_t status = 0; /* sync status */
+        unsigned i;
+        objio_done_fn saved_done_fn = ios->done;
+        bool sync = ios->ol_state.sync;
+
+        if (sync) {
+                ios->done = _sync_done;
+                ios->private = &wait;
+        }
+
+        kref_init(&ios->kref);
+
+        for (i = 0; i < ios->numdevs; i++) {
+                struct osd_request *or = ios->per_dev[i].or;
+
+                if (!or)
+                        continue;
+
+                kref_get(&ios->kref);
+                osd_execute_request_async(or, _done_io, ios);
+        }
+
+        kref_put(&ios->kref, _last_io);
+
+        if (sync) {
+                wait_for_completion(&wait);
+                status = saved_done_fn(ios);
+        }
+
+        return status;
+}
+
+/*
+ * read
+ */
+static ssize_t _read_done(struct objio_state *ios)
+{
+        ssize_t status;
+        int ret = _io_check(ios, false);
+
+        _io_free(ios);
+
+        if (likely(!ret))
+                status = ios->length;
+        else
+                status = ret;
+
+        objlayout_read_done(&ios->ol_state, status, ios->ol_state.sync);
+        return status;
+}
+
+static int _read_mirrors(struct objio_state *ios, unsigned cur_comp)
+{
+        struct osd_request *or = NULL;
+        struct _objio_per_comp *per_dev = &ios->per_dev[cur_comp];
+        unsigned dev = per_dev->dev;
+        struct pnfs_osd_object_cred *cred =
+                        &ios->layout->comps[dev];
+        struct osd_obj_id obj = {
+                .partition = cred->oc_object_id.oid_partition_id,
+                .id = cred->oc_object_id.oid_object_id,
+        };
+        int ret;
+
+        or = osd_start_request(_io_od(ios, dev), GFP_KERNEL);
+        if (unlikely(!or)) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        per_dev->or = or;
+
+        osd_req_read(or, &obj, per_dev->offset, per_dev->bio, per_dev->length);
+
+        ret = osd_finalize_request(or, 0, cred->oc_cap.cred, NULL);
+        if (ret) {
+                dprintk("%s: Faild to osd_finalize_request() => %d\n",
+                        __func__, ret);
+                goto err;
+        }
+
+        dprintk("%s:[%d] dev=%d obj=0x%llx start=0x%llx length=0x%lx\n",
+                __func__, cur_comp, dev, obj.id, _LLU(per_dev->offset),
+                per_dev->length);
+
+err:
+        return ret;
+}
+
+static ssize_t _read_exec(struct objio_state *ios)
+{
+        unsigned i;
+        int ret;
+
+        for (i = 0; i < ios->numdevs; i += ios->layout->mirrors_p1) {
+                if (!ios->per_dev[i].length)
+                        continue;
+                ret = _read_mirrors(ios, i);
+                if (unlikely(ret))
+                        goto err;
+        }
+
+        ios->done = _read_done;
+        return _io_exec(ios); /* In sync mode exec returns the io status */
+
+err:
+        _io_free(ios);
+        return ret;
+}
+
+ssize_t objio_read_pagelist(struct objlayout_io_state *ol_state)
+{
+        struct objio_state *ios = container_of(ol_state, struct objio_state,
+                                               ol_state);
+        int ret;
+
+        ret = _io_rw_pagelist(ios, GFP_KERNEL);
+        if (unlikely(ret))
+                return ret;
+
+        return _read_exec(ios);
+}
+
+/*
+ * write
+ */
+static ssize_t _write_done(struct objio_state *ios)
+{
+        ssize_t status;
+        int ret = _io_check(ios, true);
+
+        _io_free(ios);
+
+        if (likely(!ret)) {
+                /* FIXME: should be based on the OSD's persistence model
+                 * See OSD2r05 Section 4.13 Data persistence model */
+                ios->ol_state.committed = NFS_FILE_SYNC;
+                status = ios->length;
+        } else {
+                status = ret;
+        }
+
+        objlayout_write_done(&ios->ol_state, status, ios->ol_state.sync);
+        return status;
+}
+
+static int _write_mirrors(struct objio_state *ios, unsigned cur_comp)
+{
+        struct _objio_per_comp *master_dev = &ios->per_dev[cur_comp];
+        unsigned dev = ios->per_dev[cur_comp].dev;
+        unsigned last_comp = cur_comp + ios->layout->mirrors_p1;
+        int ret;
+
+        for (; cur_comp < last_comp; ++cur_comp, ++dev) {
+                struct osd_request *or = NULL;
+                struct pnfs_osd_object_cred *cred =
+                                        &ios->layout->comps[dev];
+                struct osd_obj_id obj = {
+                        .partition = cred->oc_object_id.oid_partition_id,
+                        .id = cred->oc_object_id.oid_object_id,
+                };
+                struct _objio_per_comp *per_dev = &ios->per_dev[cur_comp];
+                struct bio *bio;
+
+                or = osd_start_request(_io_od(ios, dev), GFP_NOFS);
+                if (unlikely(!or)) {
+                        ret = -ENOMEM;
+                        goto err;
+                }
+                per_dev->or = or;
+
+                if (per_dev != master_dev) {
+                        bio = bio_kmalloc(GFP_NOFS,
+                                          master_dev->bio->bi_max_vecs);
+                        if (unlikely(!bio)) {
+                                dprintk("Faild to allocate BIO size=%u\n",
+                                        master_dev->bio->bi_max_vecs);
+                                ret = -ENOMEM;
+                                goto err;
+                        }
+
+                        __bio_clone(bio, master_dev->bio);
+                        bio->bi_bdev = NULL;
+                        bio->bi_next = NULL;
+                        per_dev->bio = bio;
+                        per_dev->dev = dev;
+                        per_dev->length = master_dev->length;
+                        per_dev->offset =  master_dev->offset;
+                } else {
+                        bio = master_dev->bio;
+                        bio->bi_rw |= REQ_WRITE;
+                }
+
+                osd_req_write(or, &obj, per_dev->offset, bio, per_dev->length);
+
+                ret = osd_finalize_request(or, 0, cred->oc_cap.cred, NULL);
+                if (ret) {
+                        dprintk("%s: Faild to osd_finalize_request() => %d\n",
+                                __func__, ret);
+                        goto err;
+                }
+
+                dprintk("%s:[%d] dev=%d obj=0x%llx start=0x%llx length=0x%lx\n",
+                        __func__, cur_comp, dev, obj.id, _LLU(per_dev->offset),
+                        per_dev->length);
+        }
+
+err:
+        return ret;
+}
+
+static ssize_t _write_exec(struct objio_state *ios)
+{
+        unsigned i;
+        int ret;
+
+        for (i = 0; i < ios->numdevs; i += ios->layout->mirrors_p1) {
+                if (!ios->per_dev[i].length)
+                        continue;
+                ret = _write_mirrors(ios, i);
+                if (unlikely(ret))
+                        goto err;
+        }
+
+        ios->done = _write_done;
+        return _io_exec(ios); /* In sync mode exec returns the io->status */
+
+err:
+        _io_free(ios);
+        return ret;
+}
+
+ssize_t objio_write_pagelist(struct objlayout_io_state *ol_state, bool stable)
+{
+        struct objio_state *ios = container_of(ol_state, struct objio_state,
+                                               ol_state);
+        int ret;
+
+        /* TODO: ios->stable = stable; */
+        ret = _io_rw_pagelist(ios, GFP_NOFS);
+        if (unlikely(ret))
+                return ret;
+
+        return _write_exec(ios);
+}
+
+static bool objio_pg_test(struct nfs_pageio_descriptor *pgio,
+                          struct nfs_page *prev, struct nfs_page *req)
+{
+        if (!pnfs_generic_pg_test(pgio, prev, req))
+                return false;
+
+        return pgio->pg_count + req->wb_bytes <=
+                        OBJIO_LSEG(pgio->pg_lseg)->max_io_size;
+}
+
+static struct pnfs_layoutdriver_type objlayout_type = {
+        .id = LAYOUT_OSD2_OBJECTS,
+        .name = "LAYOUT_OSD2_OBJECTS",
+        .flags                   = PNFS_LAYOUTRET_ON_SETATTR,
+
+        .alloc_layout_hdr        = objlayout_alloc_layout_hdr,
+        .free_layout_hdr         = objlayout_free_layout_hdr,
+
+        .alloc_lseg              = objlayout_alloc_lseg,
+        .free_lseg               = objlayout_free_lseg,
+
+        .read_pagelist           = objlayout_read_pagelist,
+        .write_pagelist          = objlayout_write_pagelist,
+        .pg_test                 = objio_pg_test,
+
+        .free_deviceid_node      = objio_free_deviceid_node,
+
+        .encode_layoutcommit     = objlayout_encode_layoutcommit,
+        .encode_layoutreturn     = objlayout_encode_layoutreturn,
+};
+
+MODULE_DESCRIPTION("pNFS Layout Driver for OSD2 objects");
+MODULE_AUTHOR("Benny Halevy <bhalevy@panasas.com>");
+MODULE_LICENSE("GPL");
+
+static int __init
+objlayout_init(void)
+{
+        int ret = pnfs_register_layoutdriver(&objlayout_type);
+
+        if (ret)
+                printk(KERN_INFO
+                        "%s: Registering OSD pNFS Layout Driver failed: error=%d\n",
+                        __func__, ret);
+        else
+                printk(KERN_INFO "%s: Registered OSD pNFS Layout Driver\n",
+                        __func__);
+        return ret;
+}
+
+static void __exit
+objlayout_exit(void)
+{
+        pnfs_unregister_layoutdriver(&objlayout_type);
+        printk(KERN_INFO "%s: Unregistered OSD pNFS Layout Driver\n",
+               __func__);
+}
+
+module_init(objlayout_init);
+module_exit(objlayout_exit);
diff --git a/fs/nfs/objlayout/objlayout.c b/fs/nfs/objlayout/objlayout.c
new file mode 100644
index 000000000000..dc3956c0de80
--- /dev/null
+++ b/fs/nfs/objlayout/objlayout.c
@@ -0,0 +1,712 @@
+/*
+ *  pNFS Objects layout driver high level definitions
+ *
+ *  Copyright (C) 2007 Panasas Inc. [year of first publication]
+ *  All rights reserved.
+ *
+ *  Benny Halevy <bhalevy@panasas.com>
+ *  Boaz Harrosh <bharrosh@panasas.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2
+ *  See the file COPYING included with this distribution for more details.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the Panasas company nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <scsi/osd_initiator.h>
+#include "objlayout.h"
+
+#define NFSDBG_FACILITY         NFSDBG_PNFS_LD
+/*
+ * Create a objlayout layout structure for the given inode and return it.
+ */
+struct pnfs_layout_hdr *
+objlayout_alloc_layout_hdr(struct inode *inode, gfp_t gfp_flags)
+{
+        struct objlayout *objlay;
+
+        objlay = kzalloc(sizeof(struct objlayout), gfp_flags);
+        if (objlay) {
+                spin_lock_init(&objlay->lock);
+                INIT_LIST_HEAD(&objlay->err_list);
+        }
+        dprintk("%s: Return %p\n", __func__, objlay);
+        return &objlay->pnfs_layout;
+}
+
+/*
+ * Free an objlayout layout structure
+ */
+void
+objlayout_free_layout_hdr(struct pnfs_layout_hdr *lo)
+{
+        struct objlayout *objlay = OBJLAYOUT(lo);
+
+        dprintk("%s: objlay %p\n", __func__, objlay);
+
+        WARN_ON(!list_empty(&objlay->err_list));
+        kfree(objlay);
+}
+
+/*
+ * Unmarshall layout and store it in pnfslay.
+ */
+struct pnfs_layout_segment *
+objlayout_alloc_lseg(struct pnfs_layout_hdr *pnfslay,
+                     struct nfs4_layoutget_res *lgr,
+                     gfp_t gfp_flags)
+{
+        int status = -ENOMEM;
+        struct xdr_stream stream;
+        struct xdr_buf buf = {
+                .pages =  lgr->layoutp->pages,
+                .page_len =  lgr->layoutp->len,
+                .buflen =  lgr->layoutp->len,
+                .len = lgr->layoutp->len,
+        };
+        struct page *scratch;
+        struct pnfs_layout_segment *lseg;
+
+        dprintk("%s: Begin pnfslay %p\n", __func__, pnfslay);
+
+        scratch = alloc_page(gfp_flags);
+        if (!scratch)
+                goto err_nofree;
+
+        xdr_init_decode(&stream, &buf, NULL);
+        xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
+
+        status = objio_alloc_lseg(&lseg, pnfslay, &lgr->range, &stream, gfp_flags);
+        if (unlikely(status)) {
+                dprintk("%s: objio_alloc_lseg Return err %d\n", __func__,
+                        status);
+                goto err;
+        }
+
+        __free_page(scratch);
+
+        dprintk("%s: Return %p\n", __func__, lseg);
+        return lseg;
+
+err:
+        __free_page(scratch);
+err_nofree:
+        dprintk("%s: Err Return=>%d\n", __func__, status);
+        return ERR_PTR(status);
+}
+
+/*
+ * Free a layout segement
+ */
+void
+objlayout_free_lseg(struct pnfs_layout_segment *lseg)
+{
+        dprintk("%s: freeing layout segment %p\n", __func__, lseg);
+
+        if (unlikely(!lseg))
+                return;
+
+        objio_free_lseg(lseg);
+}
+
+/*
+ * I/O Operations
+ */
+static inline u64
+end_offset(u64 start, u64 len)
+{
+        u64 end;
+
+        end = start + len;
+        return end >= start ? end : NFS4_MAX_UINT64;
+}
+
+/* last octet in a range */
+static inline u64
+last_byte_offset(u64 start, u64 len)
+{
+        u64 end;
+
+        BUG_ON(!len);
+        end = start + len;
+        return end > start ? end - 1 : NFS4_MAX_UINT64;
+}
+
+static struct objlayout_io_state *
+objlayout_alloc_io_state(struct pnfs_layout_hdr *pnfs_layout_type,
+                        struct page **pages,
+                        unsigned pgbase,
+                        loff_t offset,
+                        size_t count,
+                        struct pnfs_layout_segment *lseg,
+                        void *rpcdata,
+                        gfp_t gfp_flags)
+{
+        struct objlayout_io_state *state;
+        u64 lseg_end_offset;
+
+        dprintk("%s: allocating io_state\n", __func__);
+        if (objio_alloc_io_state(lseg, &state, gfp_flags))
+                return NULL;
+
+        BUG_ON(offset < lseg->pls_range.offset);
+        lseg_end_offset = end_offset(lseg->pls_range.offset,
+                                     lseg->pls_range.length);
+        BUG_ON(offset >= lseg_end_offset);
+        if (offset + count > lseg_end_offset) {
+                count = lseg->pls_range.length -
+                                (offset - lseg->pls_range.offset);
+                dprintk("%s: truncated count %Zd\n", __func__, count);
+        }
+
+        if (pgbase > PAGE_SIZE) {
+                pages += pgbase >> PAGE_SHIFT;
+                pgbase &= ~PAGE_MASK;
+        }
+
+        INIT_LIST_HEAD(&state->err_list);
+        state->lseg = lseg;
+        state->rpcdata = rpcdata;
+        state->pages = pages;
+        state->pgbase = pgbase;
+        state->nr_pages = (pgbase + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        state->offset = offset;
+        state->count = count;
+        state->sync = 0;
+
+        return state;
+}
+
+static void
+objlayout_free_io_state(struct objlayout_io_state *state)
+{
+        dprintk("%s: freeing io_state\n", __func__);
+        if (unlikely(!state))
+                return;
+
+        objio_free_io_state(state);
+}
+
+/*
+ * I/O done common code
+ */
+static void
+objlayout_iodone(struct objlayout_io_state *state)
+{
+        dprintk("%s: state %p status\n", __func__, state);
+
+        if (likely(state->status >= 0)) {
+                objlayout_free_io_state(state);
+        } else {
+                struct objlayout *objlay = OBJLAYOUT(state->lseg->pls_layout);
+
+                spin_lock(&objlay->lock);
+                objlay->delta_space_valid = OBJ_DSU_INVALID;
+                list_add(&objlay->err_list, &state->err_list);
+                spin_unlock(&objlay->lock);
+        }
+}
+
+/*
+ * objlayout_io_set_result - Set an osd_error code on a specific osd comp.
+ *
+ * The @index component IO failed (error returned from target). Register
+ * the error for later reporting at layout-return.
+ */
+void
+objlayout_io_set_result(struct objlayout_io_state *state, unsigned index,
+                        struct pnfs_osd_objid *pooid, int osd_error,
+                        u64 offset, u64 length, bool is_write)
+{
+        struct pnfs_osd_ioerr *ioerr = &state->ioerrs[index];
+
+        BUG_ON(index >= state->num_comps);
+        if (osd_error) {
+                ioerr->oer_component = *pooid;
+                ioerr->oer_comp_offset = offset;
+                ioerr->oer_comp_length = length;
+                ioerr->oer_iswrite = is_write;
+                ioerr->oer_errno = osd_error;
+
+                dprintk("%s: err[%d]: errno=%d is_write=%d dev(%llx:%llx) "
+                        "par=0x%llx obj=0x%llx offset=0x%llx length=0x%llx\n",
+                        __func__, index, ioerr->oer_errno,
+                        ioerr->oer_iswrite,
+                        _DEVID_LO(&ioerr->oer_component.oid_device_id),
+                        _DEVID_HI(&ioerr->oer_component.oid_device_id),
+                        ioerr->oer_component.oid_partition_id,
+                        ioerr->oer_component.oid_object_id,
+                        ioerr->oer_comp_offset,
+                        ioerr->oer_comp_length);
+        } else {
+                /* User need not call if no error is reported */
+                ioerr->oer_errno = 0;
+        }
+}
+
+/* Function scheduled on rpc workqueue to call ->nfs_readlist_complete().
+ * This is because the osd completion is called with ints-off from
+ * the block layer
+ */
+static void _rpc_read_complete(struct work_struct *work)
+{
+        struct rpc_task *task;
+        struct nfs_read_data *rdata;
+
+        dprintk("%s enter\n", __func__);
+        task = container_of(work, struct rpc_task, u.tk_work);
+        rdata = container_of(task, struct nfs_read_data, task);
+
+        pnfs_ld_read_done(rdata);
+}
+
+void
+objlayout_read_done(struct objlayout_io_state *state, ssize_t status, bool sync)
+{
+        int eof = state->eof;
+        struct nfs_read_data *rdata;
+
+        state->status = status;
+        dprintk("%s: Begin status=%ld eof=%d\n", __func__, status, eof);
+        rdata = state->rpcdata;
+        rdata->task.tk_status = status;
+        if (status >= 0) {
+                rdata->res.count = status;
+                rdata->res.eof = eof;
+        }
+        objlayout_iodone(state);
+        /* must not use state after this point */
+
+        if (sync)
+                pnfs_ld_read_done(rdata);
+        else {
+                INIT_WORK(&rdata->task.u.tk_work, _rpc_read_complete);
+                schedule_work(&rdata->task.u.tk_work);
+        }
+}
+
+/*
+ * Perform sync or async reads.
+ */
+enum pnfs_try_status
+objlayout_read_pagelist(struct nfs_read_data *rdata)
+{
+        loff_t offset = rdata->args.offset;
+        size_t count = rdata->args.count;
+        struct objlayout_io_state *state;
+        ssize_t status = 0;
+        loff_t eof;
+
+        dprintk("%s: Begin inode %p offset %llu count %d\n",
+                __func__, rdata->inode, offset, (int)count);
+
+        eof = i_size_read(rdata->inode);
+        if (unlikely(offset + count > eof)) {
+                if (offset >= eof) {
+                        status = 0;
+                        rdata->res.count = 0;
+                        rdata->res.eof = 1;
+                        goto out;
+                }
+                count = eof - offset;
+        }
+
+        state = objlayout_alloc_io_state(NFS_I(rdata->inode)->layout,
+                                         rdata->args.pages, rdata->args.pgbase,
+                                         offset, count,
+                                         rdata->lseg, rdata,
+                                         GFP_KERNEL);
+        if (unlikely(!state)) {
+                status = -ENOMEM;
+                goto out;
+        }
+
+        state->eof = state->offset + state->count >= eof;
+
+        status = objio_read_pagelist(state);
+ out:
+        dprintk("%s: Return status %Zd\n", __func__, status);
+        rdata->pnfs_error = status;
+        return PNFS_ATTEMPTED;
+}
+
+/* Function scheduled on rpc workqueue to call ->nfs_writelist_complete().
+ * This is because the osd completion is called with ints-off from
+ * the block layer
+ */
+static void _rpc_write_complete(struct work_struct *work)
+{
+        struct rpc_task *task;
+        struct nfs_write_data *wdata;
+
+        dprintk("%s enter\n", __func__);
+        task = container_of(work, struct rpc_task, u.tk_work);
+        wdata = container_of(task, struct nfs_write_data, task);
+
+        pnfs_ld_write_done(wdata);
+}
+
+void
+objlayout_write_done(struct objlayout_io_state *state, ssize_t status,
+                     bool sync)
+{
+        struct nfs_write_data *wdata;
+
+        dprintk("%s: Begin\n", __func__);
+        wdata = state->rpcdata;
+        state->status = status;
+        wdata->task.tk_status = status;
+        if (status >= 0) {
+                wdata->res.count = status;
+                wdata->verf.committed = state->committed;
+                dprintk("%s: Return status %d committed %d\n",
+                        __func__, wdata->task.tk_status,
+                        wdata->verf.committed);
+        } else
+                dprintk("%s: Return status %d\n",
+                        __func__, wdata->task.tk_status);
+        objlayout_iodone(state);
+        /* must not use state after this point */
+
+        if (sync)
+                pnfs_ld_write_done(wdata);
+        else {
+                INIT_WORK(&wdata->task.u.tk_work, _rpc_write_complete);
+                schedule_work(&wdata->task.u.tk_work);
+        }
+}
+
+/*
+ * Perform sync or async writes.
+ */
+enum pnfs_try_status
+objlayout_write_pagelist(struct nfs_write_data *wdata,
+                         int how)
+{
+        struct objlayout_io_state *state;
+        ssize_t status;
+
+        dprintk("%s: Begin inode %p offset %llu count %u\n",
+                __func__, wdata->inode, wdata->args.offset, wdata->args.count);
+
+        state = objlayout_alloc_io_state(NFS_I(wdata->inode)->layout,
+                                         wdata->args.pages,
+                                         wdata->args.pgbase,
+                                         wdata->args.offset,
+                                         wdata->args.count,
+                                         wdata->lseg, wdata,
+                                         GFP_NOFS);
+        if (unlikely(!state)) {
+                status = -ENOMEM;
+                goto out;
+        }
+
+        state->sync = how & FLUSH_SYNC;
+
+        status = objio_write_pagelist(state, how & FLUSH_STABLE);
+ out:
+        dprintk("%s: Return status %Zd\n", __func__, status);
+        wdata->pnfs_error = status;
+        return PNFS_ATTEMPTED;
+}
+
+void
+objlayout_encode_layoutcommit(struct pnfs_layout_hdr *pnfslay,
+                              struct xdr_stream *xdr,
+                              const struct nfs4_layoutcommit_args *args)
+{
+        struct objlayout *objlay = OBJLAYOUT(pnfslay);
+        struct pnfs_osd_layoutupdate lou;
+        __be32 *start;
+
+        dprintk("%s: Begin\n", __func__);
+
+        spin_lock(&objlay->lock);
+        lou.dsu_valid = (objlay->delta_space_valid == OBJ_DSU_VALID);
+        lou.dsu_delta = objlay->delta_space_used;
+        objlay->delta_space_used = 0;
+        objlay->delta_space_valid = OBJ_DSU_INIT;
+        lou.olu_ioerr_flag = !list_empty(&objlay->err_list);
+        spin_unlock(&objlay->lock);
+
+        start = xdr_reserve_space(xdr, 4);
+
+        BUG_ON(pnfs_osd_xdr_encode_layoutupdate(xdr, &lou));
+
+        *start = cpu_to_be32((xdr->p - start - 1) * 4);
+
+        dprintk("%s: Return delta_space_used %lld err %d\n", __func__,
+                lou.dsu_delta, lou.olu_ioerr_flag);
+}
+
+static int
+err_prio(u32 oer_errno)
+{
+        switch (oer_errno) {
+        case 0:
+                return 0;
+
+        case PNFS_OSD_ERR_RESOURCE:
+                return OSD_ERR_PRI_RESOURCE;
+        case PNFS_OSD_ERR_BAD_CRED:
+                return OSD_ERR_PRI_BAD_CRED;
+        case PNFS_OSD_ERR_NO_ACCESS:
+                return OSD_ERR_PRI_NO_ACCESS;
+        case PNFS_OSD_ERR_UNREACHABLE:
+                return OSD_ERR_PRI_UNREACHABLE;
+        case PNFS_OSD_ERR_NOT_FOUND:
+                return OSD_ERR_PRI_NOT_FOUND;
+        case PNFS_OSD_ERR_NO_SPACE:
+                return OSD_ERR_PRI_NO_SPACE;
+        default:
+                WARN_ON(1);
+                /* fallthrough */
+        case PNFS_OSD_ERR_EIO:
+                return OSD_ERR_PRI_EIO;
+        }
+}
+
+static void
+merge_ioerr(struct pnfs_osd_ioerr *dest_err,
+            const struct pnfs_osd_ioerr *src_err)
+{
+        u64 dest_end, src_end;
+
+        if (!dest_err->oer_errno) {
+                *dest_err = *src_err;
+                /* accumulated device must be blank */
+                memset(&dest_err->oer_component.oid_device_id, 0,
+                        sizeof(dest_err->oer_component.oid_device_id));
+
+                return;
+        }
+
+        if (dest_err->oer_component.oid_partition_id !=
+                                src_err->oer_component.oid_partition_id)
+                dest_err->oer_component.oid_partition_id = 0;
+
+        if (dest_err->oer_component.oid_object_id !=
+                                src_err->oer_component.oid_object_id)
+                dest_err->oer_component.oid_object_id = 0;
+
+        if (dest_err->oer_comp_offset > src_err->oer_comp_offset)
+                dest_err->oer_comp_offset = src_err->oer_comp_offset;
+
+        dest_end = end_offset(dest_err->oer_comp_offset,
+                              dest_err->oer_comp_length);
+        src_end =  end_offset(src_err->oer_comp_offset,
+                              src_err->oer_comp_length);
+        if (dest_end < src_end)
+                dest_end = src_end;
+
+        dest_err->oer_comp_length = dest_end - dest_err->oer_comp_offset;
+
+        if ((src_err->oer_iswrite == dest_err->oer_iswrite) &&
+            (err_prio(src_err->oer_errno) > err_prio(dest_err->oer_errno))) {
+                        dest_err->oer_errno = src_err->oer_errno;
+        } else if (src_err->oer_iswrite) {
+                dest_err->oer_iswrite = true;
+                dest_err->oer_errno = src_err->oer_errno;
+        }
+}
+
+static void
+encode_accumulated_error(struct objlayout *objlay, __be32 *p)
+{
+        struct objlayout_io_state *state, *tmp;
+        struct pnfs_osd_ioerr accumulated_err = {.oer_errno = 0};
+
+        list_for_each_entry_safe(state, tmp, &objlay->err_list, err_list) {
+                unsigned i;
+
+                for (i = 0; i < state->num_comps; i++) {
+                        struct pnfs_osd_ioerr *ioerr = &state->ioerrs[i];
+
+                        if (!ioerr->oer_errno)
+                                continue;
+
+                        printk(KERN_ERR "%s: err[%d]: errno=%d is_write=%d "
+                                "dev(%llx:%llx) par=0x%llx obj=0x%llx "
+                                "offset=0x%llx length=0x%llx\n",
+                                __func__, i, ioerr->oer_errno,
+                                ioerr->oer_iswrite,
+                                _DEVID_LO(&ioerr->oer_component.oid_device_id),
+                                _DEVID_HI(&ioerr->oer_component.oid_device_id),
+                                ioerr->oer_component.oid_partition_id,
+                                ioerr->oer_component.oid_object_id,
+                                ioerr->oer_comp_offset,
+                                ioerr->oer_comp_length);
+
+                        merge_ioerr(&accumulated_err, ioerr);
+                }
+                list_del(&state->err_list);
+                objlayout_free_io_state(state);
+        }
+
+        pnfs_osd_xdr_encode_ioerr(p, &accumulated_err);
+}
+
+void
+objlayout_encode_layoutreturn(struct pnfs_layout_hdr *pnfslay,
+                              struct xdr_stream *xdr,
+                              const struct nfs4_layoutreturn_args *args)
+{
+        struct objlayout *objlay = OBJLAYOUT(pnfslay);
+        struct objlayout_io_state *state, *tmp;
+        __be32 *start;
+
+        dprintk("%s: Begin\n", __func__);
+        start = xdr_reserve_space(xdr, 4);
+        BUG_ON(!start);
+
+        spin_lock(&objlay->lock);
+
+        list_for_each_entry_safe(state, tmp, &objlay->err_list, err_list) {
+                __be32 *last_xdr = NULL, *p;
+                unsigned i;
+                int res = 0;
+
+                for (i = 0; i < state->num_comps; i++) {
+                        struct pnfs_osd_ioerr *ioerr = &state->ioerrs[i];
+
+                        if (!ioerr->oer_errno)
+                                continue;
+
+                        dprintk("%s: err[%d]: errno=%d is_write=%d "
+                                "dev(%llx:%llx) par=0x%llx obj=0x%llx "
+                                "offset=0x%llx length=0x%llx\n",
+                                __func__, i, ioerr->oer_errno,
+                                ioerr->oer_iswrite,
+                                _DEVID_LO(&ioerr->oer_component.oid_device_id),
+                                _DEVID_HI(&ioerr->oer_component.oid_device_id),
+                                ioerr->oer_component.oid_partition_id,
+                                ioerr->oer_component.oid_object_id,
+                                ioerr->oer_comp_offset,
+                                ioerr->oer_comp_length);
+
+                        p = pnfs_osd_xdr_ioerr_reserve_space(xdr);
+                        if (unlikely(!p)) {
+                                res = -E2BIG;
+                                break; /* accumulated_error */
+                        }
+
+                        last_xdr = p;
+                        pnfs_osd_xdr_encode_ioerr(p, &state->ioerrs[i]);
+                }
+
+                /* TODO: use xdr_write_pages */
+                if (unlikely(res)) {
+                        /* no space for even one error descriptor */
+                        BUG_ON(!last_xdr);
+
+                        /* we've encountered a situation with lots and lots of
+                         * errors and no space to encode them all. Use the last
+                         * available slot to report the union of all the
+                         * remaining errors.
+                         */
+                        encode_accumulated_error(objlay, last_xdr);
+                        goto loop_done;
+                }
+                list_del(&state->err_list);
+                objlayout_free_io_state(state);
+        }
+loop_done:
+        spin_unlock(&objlay->lock);
+
+        *start = cpu_to_be32((xdr->p - start - 1) * 4);
+        dprintk("%s: Return\n", __func__);
+}
+
+
+/*
+ * Get Device Info API for io engines
+ */
+struct objlayout_deviceinfo {
+        struct page *page;
+        struct pnfs_osd_deviceaddr da; /* This must be last */
+};
+
+/* Initialize and call nfs_getdeviceinfo, then decode and return a
+ * "struct pnfs_osd_deviceaddr *" Eventually objlayout_put_deviceinfo()
+ * should be called.
+ */
+int objlayout_get_deviceinfo(struct pnfs_layout_hdr *pnfslay,
+        struct nfs4_deviceid *d_id, struct pnfs_osd_deviceaddr **deviceaddr,
+        gfp_t gfp_flags)
+{
+        struct objlayout_deviceinfo *odi;
+        struct pnfs_device pd;
+        struct super_block *sb;
+        struct page *page, **pages;
+        u32 *p;
+        int err;
+
+        page = alloc_page(gfp_flags);
+        if (!page)
+                return -ENOMEM;
+
+        pages = &page;
+        pd.pages = pages;
+
+        memcpy(&pd.dev_id, d_id, sizeof(*d_id));
+        pd.layout_type = LAYOUT_OSD2_OBJECTS;
+        pd.pages = &page;
+        pd.pgbase = 0;
+        pd.pglen = PAGE_SIZE;
+        pd.mincount = 0;
+
+        sb = pnfslay->plh_inode->i_sb;
+        err = nfs4_proc_getdeviceinfo(NFS_SERVER(pnfslay->plh_inode), &pd);
+        dprintk("%s nfs_getdeviceinfo returned %d\n", __func__, err);
+        if (err)
+                goto err_out;
+
+        p = page_address(page);
+        odi = kzalloc(sizeof(*odi), gfp_flags);
+        if (!odi) {
+                err = -ENOMEM;
+                goto err_out;
+        }
+        pnfs_osd_xdr_decode_deviceaddr(&odi->da, p);
+        odi->page = page;
+        *deviceaddr = &odi->da;
+        return 0;
+
+err_out:
+        __free_page(page);
+        return err;
+}
+
+void objlayout_put_deviceinfo(struct pnfs_osd_deviceaddr *deviceaddr)
+{
+        struct objlayout_deviceinfo *odi = container_of(deviceaddr,
+                                                struct objlayout_deviceinfo,
+                                                da);
+
+        __free_page(odi->page);
+        kfree(odi);
+}
diff --git a/fs/nfs/objlayout/objlayout.h b/fs/nfs/objlayout/objlayout.h
new file mode 100644
index 000000000000..a8244c8e042d
--- /dev/null
+++ b/fs/nfs/objlayout/objlayout.h
@@ -0,0 +1,187 @@
+/*
+ *  Data types and function declerations for interfacing with the
+ *  pNFS standard object layout driver.
+ *
+ *  Copyright (C) 2007 Panasas Inc. [year of first publication]
+ *  All rights reserved.
+ *
+ *  Benny Halevy <bhalevy@panasas.com>
+ *  Boaz Harrosh <bharrosh@panasas.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2
+ *  See the file COPYING included with this distribution for more details.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the Panasas company nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _OBJLAYOUT_H
+#define _OBJLAYOUT_H
+
+#include <linux/nfs_fs.h>
+#include <linux/pnfs_osd_xdr.h>
+#include "../pnfs.h"
+
+/*
+ * per-inode layout
+ */
+struct objlayout {
+        struct pnfs_layout_hdr pnfs_layout;
+
+         /* for layout_commit */
+        enum osd_delta_space_valid_enum {
+                OBJ_DSU_INIT = 0,
+                OBJ_DSU_VALID,
+                OBJ_DSU_INVALID,
+        } delta_space_valid;
+        s64 delta_space_used;  /* consumed by write ops */
+
+         /* for layout_return */
+        spinlock_t lock;
+        struct list_head err_list;
+};
+
+static inline struct objlayout *
+OBJLAYOUT(struct pnfs_layout_hdr *lo)
+{
+        return container_of(lo, struct objlayout, pnfs_layout);
+}
+
+/*
+ * per-I/O operation state
+ * embedded in objects provider io_state data structure
+ */
+struct objlayout_io_state {
+        struct pnfs_layout_segment *lseg;
+
+        struct page **pages;
+        unsigned pgbase;
+        unsigned nr_pages;
+        unsigned long count;
+        loff_t offset;
+        bool sync;
+
+        void *rpcdata;
+        int status;             /* res */
+        int eof;                /* res */
+        int committed;          /* res */
+
+        /* Error reporting (layout_return) */
+        struct list_head err_list;
+        unsigned num_comps;
+        /* Pointer to array of error descriptors of size num_comps.
+         * It should contain as many entries as devices in the osd_layout
+         * that participate in the I/O. It is up to the io_engine to allocate
+         * needed space and set num_comps.
+         */
+        struct pnfs_osd_ioerr *ioerrs;
+};
+
+/*
+ * Raid engine I/O API
+ */
+extern int objio_alloc_lseg(struct pnfs_layout_segment **outp,
+        struct pnfs_layout_hdr *pnfslay,
+        struct pnfs_layout_range *range,
+        struct xdr_stream *xdr,
+        gfp_t gfp_flags);
+extern void objio_free_lseg(struct pnfs_layout_segment *lseg);
+
+extern int objio_alloc_io_state(
+        struct pnfs_layout_segment *lseg,
+        struct objlayout_io_state **outp,
+        gfp_t gfp_flags);
+extern void objio_free_io_state(struct objlayout_io_state *state);
+
+extern ssize_t objio_read_pagelist(struct objlayout_io_state *ol_state);
+extern ssize_t objio_write_pagelist(struct objlayout_io_state *ol_state,
+                                    bool stable);
+
+/*
+ * callback API
+ */
+extern void objlayout_io_set_result(struct objlayout_io_state *state,
+                        unsigned index, struct pnfs_osd_objid *pooid,
+                        int osd_error, u64 offset, u64 length, bool is_write);
+
+static inline void
+objlayout_add_delta_space_used(struct objlayout_io_state *state, s64 space_used)
+{
+        struct objlayout *objlay = OBJLAYOUT(state->lseg->pls_layout);
+
+        /* If one of the I/Os errored out and the delta_space_used was
+         * invalid we render the complete report as invalid. Protocol mandate
+         * the DSU be accurate or not reported.
+         */
+        spin_lock(&objlay->lock);
+        if (objlay->delta_space_valid != OBJ_DSU_INVALID) {
+                objlay->delta_space_valid = OBJ_DSU_VALID;
+                objlay->delta_space_used += space_used;
+        }
+        spin_unlock(&objlay->lock);
+}
+
+extern void objlayout_read_done(struct objlayout_io_state *state,
+                                ssize_t status, bool sync);
+extern void objlayout_write_done(struct objlayout_io_state *state,
+                                 ssize_t status, bool sync);
+
+extern int objlayout_get_deviceinfo(struct pnfs_layout_hdr *pnfslay,
+        struct nfs4_deviceid *d_id, struct pnfs_osd_deviceaddr **deviceaddr,
+        gfp_t gfp_flags);
+extern void objlayout_put_deviceinfo(struct pnfs_osd_deviceaddr *deviceaddr);
+
+/*
+ * exported generic objects function vectors
+ */
+
+extern struct pnfs_layout_hdr *objlayout_alloc_layout_hdr(struct inode *, gfp_t gfp_flags);
+extern void objlayout_free_layout_hdr(struct pnfs_layout_hdr *);
+
+extern struct pnfs_layout_segment *objlayout_alloc_lseg(
+        struct pnfs_layout_hdr *,
+        struct nfs4_layoutget_res *,
+        gfp_t gfp_flags);
+extern void objlayout_free_lseg(struct pnfs_layout_segment *);
+
+extern enum pnfs_try_status objlayout_read_pagelist(
+        struct nfs_read_data *);
+
+extern enum pnfs_try_status objlayout_write_pagelist(
+        struct nfs_write_data *,
+        int how);
+
+extern void objlayout_encode_layoutcommit(
+        struct pnfs_layout_hdr *,
+        struct xdr_stream *,
+        const struct nfs4_layoutcommit_args *);
+
+extern void objlayout_encode_layoutreturn(
+        struct pnfs_layout_hdr *,
+        struct xdr_stream *,
+        const struct nfs4_layoutreturn_args *);
+
+#endif /* _OBJLAYOUT_H */
diff --git a/fs/nfs/objlayout/pnfs_osd_xdr_cli.c b/fs/nfs/objlayout/pnfs_osd_xdr_cli.c
new file mode 100644
index 000000000000..16fc758e9123
--- /dev/null
+++ b/fs/nfs/objlayout/pnfs_osd_xdr_cli.c
@@ -0,0 +1,412 @@
+/*
+ *  Object-Based pNFS Layout XDR layer
+ *
+ *  Copyright (C) 2007 Panasas Inc. [year of first publication]
+ *  All rights reserved.
+ *
+ *  Benny Halevy <bhalevy@panasas.com>
+ *  Boaz Harrosh <bharrosh@panasas.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2
+ *  See the file COPYING included with this distribution for more details.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the Panasas company nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <linux/pnfs_osd_xdr.h>
+
+#define NFSDBG_FACILITY         NFSDBG_PNFS_LD
+
+/*
+ * The following implementation is based on RFC5664
+ */
+
+/*
+ * struct pnfs_osd_objid {
+ *      struct nfs4_deviceid    oid_device_id;
+ *      u64                     oid_partition_id;
+ *      u64                     oid_object_id;
+ * }; // xdr size 32 bytes
+ */
+static __be32 *
+_osd_xdr_decode_objid(__be32 *p, struct pnfs_osd_objid *objid)
+{
+        p = xdr_decode_opaque_fixed(p, objid->oid_device_id.data,
+                                    sizeof(objid->oid_device_id.data));
+
+        p = xdr_decode_hyper(p, &objid->oid_partition_id);
+        p = xdr_decode_hyper(p, &objid->oid_object_id);
+        return p;
+}
+/*
+ * struct pnfs_osd_opaque_cred {
+ *      u32 cred_len;
+ *      void *cred;
+ * }; // xdr size [variable]
+ * The return pointers are from the xdr buffer
+ */
+static int
+_osd_xdr_decode_opaque_cred(struct pnfs_osd_opaque_cred *opaque_cred,
+                            struct xdr_stream *xdr)
+{
+        __be32 *p = xdr_inline_decode(xdr, 1);
+
+        if (!p)
+                return -EINVAL;
+
+        opaque_cred->cred_len = be32_to_cpu(*p++);
+
+        p = xdr_inline_decode(xdr, opaque_cred->cred_len);
+        if (!p)
+                return -EINVAL;
+
+        opaque_cred->cred = p;
+        return 0;
+}
+
+/*
+ * struct pnfs_osd_object_cred {
+ *      struct pnfs_osd_objid           oc_object_id;
+ *      u32                             oc_osd_version;
+ *      u32                             oc_cap_key_sec;
+ *      struct pnfs_osd_opaque_cred     oc_cap_key
+ *      struct pnfs_osd_opaque_cred     oc_cap;
+ * }; // xdr size 32 + 4 + 4 + [variable] + [variable]
+ */
+static int
+_osd_xdr_decode_object_cred(struct pnfs_osd_object_cred *comp,
+                            struct xdr_stream *xdr)
+{
+        __be32 *p = xdr_inline_decode(xdr, 32 + 4 + 4);
+        int ret;
+
+        if (!p)
+                return -EIO;
+
+        p = _osd_xdr_decode_objid(p, &comp->oc_object_id);
+        comp->oc_osd_version = be32_to_cpup(p++);
+        comp->oc_cap_key_sec = be32_to_cpup(p);
+
+        ret = _osd_xdr_decode_opaque_cred(&comp->oc_cap_key, xdr);
+        if (unlikely(ret))
+                return ret;
+
+        ret = _osd_xdr_decode_opaque_cred(&comp->oc_cap, xdr);
+        return ret;
+}
+
+/*
+ * struct pnfs_osd_data_map {
+ *      u32     odm_num_comps;
+ *      u64     odm_stripe_unit;
+ *      u32     odm_group_width;
+ *      u32     odm_group_depth;
+ *      u32     odm_mirror_cnt;
+ *      u32     odm_raid_algorithm;
+ * }; // xdr size 4 + 8 + 4 + 4 + 4 + 4
+ */
+static inline int
+_osd_data_map_xdr_sz(void)
+{
+        return 4 + 8 + 4 + 4 + 4 + 4;
+}
+
+static __be32 *
+_osd_xdr_decode_data_map(__be32 *p, struct pnfs_osd_data_map *data_map)
+{
+        data_map->odm_num_comps = be32_to_cpup(p++);
+        p = xdr_decode_hyper(p, &data_map->odm_stripe_unit);
+        data_map->odm_group_width = be32_to_cpup(p++);
+        data_map->odm_group_depth = be32_to_cpup(p++);
+        data_map->odm_mirror_cnt = be32_to_cpup(p++);
+        data_map->odm_raid_algorithm = be32_to_cpup(p++);
+        dprintk("%s: odm_num_comps=%u odm_stripe_unit=%llu odm_group_width=%u "
+                "odm_group_depth=%u odm_mirror_cnt=%u odm_raid_algorithm=%u\n",
+                __func__,
+                data_map->odm_num_comps,
+                (unsigned long long)data_map->odm_stripe_unit,
+                data_map->odm_group_width,
+                data_map->odm_group_depth,
+                data_map->odm_mirror_cnt,
+                data_map->odm_raid_algorithm);
+        return p;
+}
+
+int pnfs_osd_xdr_decode_layout_map(struct pnfs_osd_layout *layout,
+        struct pnfs_osd_xdr_decode_layout_iter *iter, struct xdr_stream *xdr)
+{
+        __be32 *p;
+
+        memset(iter, 0, sizeof(*iter));
+
+        p = xdr_inline_decode(xdr, _osd_data_map_xdr_sz() + 4 + 4);
+        if (unlikely(!p))
+                return -EINVAL;
+
+        p = _osd_xdr_decode_data_map(p, &layout->olo_map);
+        layout->olo_comps_index = be32_to_cpup(p++);
+        layout->olo_num_comps = be32_to_cpup(p++);
+        iter->total_comps = layout->olo_num_comps;
+        return 0;
+}
+
+bool pnfs_osd_xdr_decode_layout_comp(struct pnfs_osd_object_cred *comp,
+        struct pnfs_osd_xdr_decode_layout_iter *iter, struct xdr_stream *xdr,
+        int *err)
+{
+        BUG_ON(iter->decoded_comps > iter->total_comps);
+        if (iter->decoded_comps == iter->total_comps)
+                return false;
+
+        *err = _osd_xdr_decode_object_cred(comp, xdr);
+        if (unlikely(*err)) {
+                dprintk("%s: _osd_xdr_decode_object_cred=>%d decoded_comps=%d "
+                        "total_comps=%d\n", __func__, *err,
+                        iter->decoded_comps, iter->total_comps);
+                return false; /* stop the loop */
+        }
+        dprintk("%s: dev(%llx:%llx) par=0x%llx obj=0x%llx "
+                "key_len=%u cap_len=%u\n",
+                __func__,
+                _DEVID_LO(&comp->oc_object_id.oid_device_id),
+                _DEVID_HI(&comp->oc_object_id.oid_device_id),
+                comp->oc_object_id.oid_partition_id,
+                comp->oc_object_id.oid_object_id,
+                comp->oc_cap_key.cred_len, comp->oc_cap.cred_len);
+
+        iter->decoded_comps++;
+        return true;
+}
+
+/*
+ * Get Device Information Decoding
+ *
+ * Note: since Device Information is currently done synchronously, all
+ *       variable strings fields are left inside the rpc buffer and are only
+ *       pointed to by the pnfs_osd_deviceaddr members. So the read buffer
+ *       should not be freed while the returned information is in use.
+ */
+/*
+ *struct nfs4_string {
+ *      unsigned int len;
+ *      char *data;
+ *}; // size [variable]
+ * NOTE: Returned string points to inside the XDR buffer
+ */
+static __be32 *
+__read_u8_opaque(__be32 *p, struct nfs4_string *str)
+{
+        str->len = be32_to_cpup(p++);
+        str->data = (char *)p;
+
+        p += XDR_QUADLEN(str->len);
+        return p;
+}
+
+/*
+ * struct pnfs_osd_targetid {
+ *      u32                     oti_type;
+ *      struct nfs4_string      oti_scsi_device_id;
+ * };// size 4 + [variable]
+ */
+static __be32 *
+__read_targetid(__be32 *p, struct pnfs_osd_targetid* targetid)
+{
+        u32 oti_type;
+
+        oti_type = be32_to_cpup(p++);
+        targetid->oti_type = oti_type;
+
+        switch (oti_type) {
+        case OBJ_TARGET_SCSI_NAME:
+        case OBJ_TARGET_SCSI_DEVICE_ID:
+                p = __read_u8_opaque(p, &targetid->oti_scsi_device_id);
+        }
+
+        return p;
+}
+
+/*
+ * struct pnfs_osd_net_addr {
+ *      struct nfs4_string      r_netid;
+ *      struct nfs4_string      r_addr;
+ * };
+ */
+static __be32 *
+__read_net_addr(__be32 *p, struct pnfs_osd_net_addr* netaddr)
+{
+        p = __read_u8_opaque(p, &netaddr->r_netid);
+        p = __read_u8_opaque(p, &netaddr->r_addr);
+
+        return p;
+}
+
+/*
+ * struct pnfs_osd_targetaddr {
+ *      u32                             ota_available;
+ *      struct pnfs_osd_net_addr        ota_netaddr;
+ * };
+ */
+static __be32 *
+__read_targetaddr(__be32 *p, struct pnfs_osd_targetaddr *targetaddr)
+{
+        u32 ota_available;
+
+        ota_available = be32_to_cpup(p++);
+        targetaddr->ota_available = ota_available;
+
+        if (ota_available)
+                p = __read_net_addr(p, &targetaddr->ota_netaddr);
+
+
+        return p;
+}
+
+/*
+ * struct pnfs_osd_deviceaddr {
+ *      struct pnfs_osd_targetid        oda_targetid;
+ *      struct pnfs_osd_targetaddr      oda_targetaddr;
+ *      u8                              oda_lun[8];
+ *      struct nfs4_string              oda_systemid;
+ *      struct pnfs_osd_object_cred     oda_root_obj_cred;
+ *      struct nfs4_string              oda_osdname;
+ * };
+ */
+
+/* We need this version for the pnfs_osd_xdr_decode_deviceaddr which does
+ * not have an xdr_stream
+ */
+static __be32 *
+__read_opaque_cred(__be32 *p,
+                              struct pnfs_osd_opaque_cred *opaque_cred)
+{
+        opaque_cred->cred_len = be32_to_cpu(*p++);
+        opaque_cred->cred = p;
+        return p + XDR_QUADLEN(opaque_cred->cred_len);
+}
+
+static __be32 *
+__read_object_cred(__be32 *p, struct pnfs_osd_object_cred *comp)
+{
+        p = _osd_xdr_decode_objid(p, &comp->oc_object_id);
+        comp->oc_osd_version = be32_to_cpup(p++);
+        comp->oc_cap_key_sec = be32_to_cpup(p++);
+
+        p = __read_opaque_cred(p, &comp->oc_cap_key);
+        p = __read_opaque_cred(p, &comp->oc_cap);
+        return p;
+}
+
+void pnfs_osd_xdr_decode_deviceaddr(
+        struct pnfs_osd_deviceaddr *deviceaddr, __be32 *p)
+{
+        p = __read_targetid(p, &deviceaddr->oda_targetid);
+
+        p = __read_targetaddr(p, &deviceaddr->oda_targetaddr);
+
+        p = xdr_decode_opaque_fixed(p, deviceaddr->oda_lun,
+                                    sizeof(deviceaddr->oda_lun));
+
+        p = __read_u8_opaque(p, &deviceaddr->oda_systemid);
+
+        p = __read_object_cred(p, &deviceaddr->oda_root_obj_cred);
+
+        p = __read_u8_opaque(p, &deviceaddr->oda_osdname);
+
+        /* libosd likes this terminated in dbg. It's last, so no problems */
+        deviceaddr->oda_osdname.data[deviceaddr->oda_osdname.len] = 0;
+}
+
+/*
+ * struct pnfs_osd_layoutupdate {
+ *      u32     dsu_valid;
+ *      s64     dsu_delta;
+ *      u32     olu_ioerr_flag;
+ * }; xdr size 4 + 8 + 4
+ */
+int
+pnfs_osd_xdr_encode_layoutupdate(struct xdr_stream *xdr,
+                                 struct pnfs_osd_layoutupdate *lou)
+{
+        __be32 *p = xdr_reserve_space(xdr,  4 + 8 + 4);
+
+        if (!p)
+                return -E2BIG;
+
+        *p++ = cpu_to_be32(lou->dsu_valid);
+        if (lou->dsu_valid)
+                p = xdr_encode_hyper(p, lou->dsu_delta);
+        *p++ = cpu_to_be32(lou->olu_ioerr_flag);
+        return 0;
+}
+
+/*
+ * struct pnfs_osd_objid {
+ *      struct nfs4_deviceid    oid_device_id;
+ *      u64                     oid_partition_id;
+ *      u64                     oid_object_id;
+ * }; // xdr size 32 bytes
+ */
+static inline __be32 *
+pnfs_osd_xdr_encode_objid(__be32 *p, struct pnfs_osd_objid *object_id)
+{
+        p = xdr_encode_opaque_fixed(p, &object_id->oid_device_id.data,
+                                    sizeof(object_id->oid_device_id.data));
+        p = xdr_encode_hyper(p, object_id->oid_partition_id);
+        p = xdr_encode_hyper(p, object_id->oid_object_id);
+
+        return p;
+}
+
+/*
+ * struct pnfs_osd_ioerr {
+ *      struct pnfs_osd_objid   oer_component;
+ *      u64                     oer_comp_offset;
+ *      u64                     oer_comp_length;
+ *      u32                     oer_iswrite;
+ *      u32                     oer_errno;
+ * }; // xdr size 32 + 24 bytes
+ */
+void pnfs_osd_xdr_encode_ioerr(__be32 *p, struct pnfs_osd_ioerr *ioerr)
+{
+        p = pnfs_osd_xdr_encode_objid(p, &ioerr->oer_component);
+        p = xdr_encode_hyper(p, ioerr->oer_comp_offset);
+        p = xdr_encode_hyper(p, ioerr->oer_comp_length);
+        *p++ = cpu_to_be32(ioerr->oer_iswrite);
+        *p   = cpu_to_be32(ioerr->oer_errno);
+}
+
+__be32 *pnfs_osd_xdr_ioerr_reserve_space(struct xdr_stream *xdr)
+{
+        __be32 *p;
+
+        p = xdr_reserve_space(xdr, 32 + 24);
+        if (unlikely(!p))
+                dprintk("%s: out of xdr space\n", __func__);
+
+        return p;
+}
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index c80add6e2213..7913961aff22 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -204,6 +204,21 @@ nfs_wait_on_request(struct nfs_page *req)
                         TASK_UNINTERRUPTIBLE);
 }
 
+static bool nfs_generic_pg_test(struct nfs_pageio_descriptor *desc, struct nfs_page *prev, struct nfs_page *req)
+{
+        /*
+         * FIXME: ideally we should be able to coalesce all requests
+         * that are not block boundary aligned, but currently this
+         * is problematic for the case of bsize < PAGE_CACHE_SIZE,
+         * since nfs_flush_multi and nfs_pagein_multi assume you
+         * can have only one struct nfs_page.
+         */
+        if (desc->pg_bsize < PAGE_SIZE)
+                return 0;
+
+        return desc->pg_count + req->wb_bytes <= desc->pg_bsize;
+}
+
 /**
  * nfs_pageio_init - initialise a page io descriptor
  * @desc: pointer to descriptor
@@ -229,6 +244,8 @@ void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
         desc->pg_ioflags = io_flags;
         desc->pg_error = 0;
         desc->pg_lseg = NULL;
+        desc->pg_test = nfs_generic_pg_test;
+        pnfs_pageio_init(desc, inode);
 }
 
 /**
@@ -242,29 +259,23 @@ void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
  *
  * Return 'true' if this is the case, else return 'false'.
  */
-static int nfs_can_coalesce_requests(struct nfs_page *prev,
-                                     struct nfs_page *req,
-                                     struct nfs_pageio_descriptor *pgio)
+static bool nfs_can_coalesce_requests(struct nfs_page *prev,
+                                      struct nfs_page *req,
+                                      struct nfs_pageio_descriptor *pgio)
 {
         if (req->wb_context->cred != prev->wb_context->cred)
-                return 0;
+                return false;
         if (req->wb_lock_context->lockowner != prev->wb_lock_context->lockowner)
-                return 0;
+                return false;
         if (req->wb_context->state != prev->wb_context->state)
-                return 0;
+                return false;
         if (req->wb_index != (prev->wb_index + 1))
-                return 0;
+                return false;
         if (req->wb_pgbase != 0)
-                return 0;
+                return false;
         if (prev->wb_pgbase + prev->wb_bytes != PAGE_CACHE_SIZE)
-                return 0;
-        /*
-         * Non-whole file layouts need to check that req is inside of
-         * pgio->pg_lseg.
-         */
-        if (pgio->pg_test && !pgio->pg_test(pgio, prev, req))
-                return 0;
-        return 1;
+                return false;
+        return pgio->pg_test(pgio, prev, req);
 }
 
 /**
@@ -278,31 +289,18 @@ static int nfs_can_coalesce_requests(struct nfs_page *prev,
 static int nfs_pageio_do_add_request(struct nfs_pageio_descriptor *desc,
                                      struct nfs_page *req)
 {
-        size_t newlen = req->wb_bytes;
-
         if (desc->pg_count != 0) {
                 struct nfs_page *prev;
 
-                /*
-                 * FIXME: ideally we should be able to coalesce all requests
-                 * that are not block boundary aligned, but currently this
-                 * is problematic for the case of bsize < PAGE_CACHE_SIZE,
-                 * since nfs_flush_multi and nfs_pagein_multi assume you
-                 * can have only one struct nfs_page.
-                 */
-                if (desc->pg_bsize < PAGE_SIZE)
-                        return 0;
-                newlen += desc->pg_count;
-                if (newlen > desc->pg_bsize)
-                        return 0;
                 prev = nfs_list_entry(desc->pg_list.prev);
                 if (!nfs_can_coalesce_requests(prev, req, desc))
                         return 0;
-        } else
+        } else {
                 desc->pg_base = req->wb_pgbase;
+        }
         nfs_list_remove_request(req);
         nfs_list_add_request(req, &desc->pg_list);
-        desc->pg_count = newlen;
+        desc->pg_count += req->wb_bytes;
         return 1;
 }
 
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index f57f5281a520..8c1309d852a6 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -177,13 +177,28 @@ get_layout_hdr(struct pnfs_layout_hdr *lo)
         atomic_inc(&lo->plh_refcount);
 }
 
+static struct pnfs_layout_hdr *
+pnfs_alloc_layout_hdr(struct inode *ino, gfp_t gfp_flags)
+{
+        struct pnfs_layoutdriver_type *ld = NFS_SERVER(ino)->pnfs_curr_ld;
+        return ld->alloc_layout_hdr ? ld->alloc_layout_hdr(ino, gfp_flags) :
+                kzalloc(sizeof(struct pnfs_layout_hdr), gfp_flags);
+}
+
+static void
+pnfs_free_layout_hdr(struct pnfs_layout_hdr *lo)
+{
+        struct pnfs_layoutdriver_type *ld = NFS_SERVER(lo->plh_inode)->pnfs_curr_ld;
+        return ld->alloc_layout_hdr ? ld->free_layout_hdr(lo) : kfree(lo);
+}
+
 static void
 destroy_layout_hdr(struct pnfs_layout_hdr *lo)
 {
         dprintk("%s: freeing layout cache %p\n", __func__, lo);
         BUG_ON(!list_empty(&lo->plh_layouts));
         NFS_I(lo->plh_inode)->layout = NULL;
-        kfree(lo);
+        pnfs_free_layout_hdr(lo);
 }
 
 static void
@@ -228,7 +243,7 @@ put_lseg_common(struct pnfs_layout_segment *lseg)
 {
         struct inode *inode = lseg->pls_layout->plh_inode;
 
-        BUG_ON(test_bit(NFS_LSEG_VALID, &lseg->pls_flags));
+        WARN_ON(test_bit(NFS_LSEG_VALID, &lseg->pls_flags));
         list_del_init(&lseg->pls_list);
         if (list_empty(&lseg->pls_layout->plh_segs)) {
                 set_bit(NFS_LAYOUT_DESTROYED, &lseg->pls_layout->plh_flags);
@@ -261,11 +276,72 @@ put_lseg(struct pnfs_layout_segment *lseg)
 }
 EXPORT_SYMBOL_GPL(put_lseg);
 
+static inline u64
+end_offset(u64 start, u64 len)
+{
+        u64 end;
+
+        end = start + len;
+        return end >= start ? end : NFS4_MAX_UINT64;
+}
+
+/* last octet in a range */
+static inline u64
+last_byte_offset(u64 start, u64 len)
+{
+        u64 end;
+
+        BUG_ON(!len);
+        end = start + len;
+        return end > start ? end - 1 : NFS4_MAX_UINT64;
+}
+
+/*
+ * is l2 fully contained in l1?
+ *   start1                             end1
+ *   [----------------------------------)
+ *           start2           end2
+ *           [----------------)
+ */
+static inline int
+lo_seg_contained(struct pnfs_layout_range *l1,
+                 struct pnfs_layout_range *l2)
+{
+        u64 start1 = l1->offset;
+        u64 end1 = end_offset(start1, l1->length);
+        u64 start2 = l2->offset;
+        u64 end2 = end_offset(start2, l2->length);
+
+        return (start1 <= start2) && (end1 >= end2);
+}
+
+/*
+ * is l1 and l2 intersecting?
+ *   start1                             end1
+ *   [----------------------------------)
+ *                              start2           end2
+ *                              [----------------)
+ */
+static inline int
+lo_seg_intersecting(struct pnfs_layout_range *l1,
+                    struct pnfs_layout_range *l2)
+{
+        u64 start1 = l1->offset;
+        u64 end1 = end_offset(start1, l1->length);
+        u64 start2 = l2->offset;
+        u64 end2 = end_offset(start2, l2->length);
+
+        return (end1 == NFS4_MAX_UINT64 || end1 > start2) &&
+               (end2 == NFS4_MAX_UINT64 || end2 > start1);
+}
+
 static bool
-should_free_lseg(u32 lseg_iomode, u32 recall_iomode)
+should_free_lseg(struct pnfs_layout_range *lseg_range,
+                 struct pnfs_layout_range *recall_range)
 {
-        return (recall_iomode == IOMODE_ANY ||
-                lseg_iomode == recall_iomode);
+        return (recall_range->iomode == IOMODE_ANY ||
+                lseg_range->iomode == recall_range->iomode) &&
+               lo_seg_intersecting(lseg_range, recall_range);
 }
 
 /* Returns 1 if lseg is removed from list, 0 otherwise */
@@ -296,7 +372,7 @@ static int mark_lseg_invalid(struct pnfs_layout_segment *lseg,
 int
 mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
                             struct list_head *tmp_list,
-                            u32 iomode)
+                            struct pnfs_layout_range *recall_range)
 {
         struct pnfs_layout_segment *lseg, *next;
         int invalid = 0, removed = 0;
@@ -309,7 +385,8 @@ mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
                 return 0;
         }
         list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list)
-                if (should_free_lseg(lseg->pls_range.iomode, iomode)) {
+                if (!recall_range ||
+                    should_free_lseg(&lseg->pls_range, recall_range)) {
                         dprintk("%s: freeing lseg %p iomode %d "
                                 "offset %llu length %llu\n", __func__,
                                 lseg, lseg->pls_range.iomode, lseg->pls_range.offset,
@@ -358,7 +435,7 @@ pnfs_destroy_layout(struct nfs_inode *nfsi)
         lo = nfsi->layout;
         if (lo) {
                 lo->plh_block_lgets++; /* permanently block new LAYOUTGETs */
-                mark_matching_lsegs_invalid(lo, &tmp_list, IOMODE_ANY);
+                mark_matching_lsegs_invalid(lo, &tmp_list, NULL);
         }
         spin_unlock(&nfsi->vfs_inode.i_lock);
         pnfs_free_lseg_list(&tmp_list);
@@ -467,7 +544,7 @@ pnfs_choose_layoutget_stateid(nfs4_stateid *dst, struct pnfs_layout_hdr *lo,
 static struct pnfs_layout_segment *
 send_layoutget(struct pnfs_layout_hdr *lo,
            struct nfs_open_context *ctx,
-           u32 iomode,
+           struct pnfs_layout_range *range,
            gfp_t gfp_flags)
 {
         struct inode *ino = lo->plh_inode;
@@ -499,11 +576,11 @@ send_layoutget(struct pnfs_layout_hdr *lo,
                         goto out_err_free;
         }
 
-        lgp->args.minlength = NFS4_MAX_UINT64;
+        lgp->args.minlength = PAGE_CACHE_SIZE;
+        if (lgp->args.minlength > range->length)
+                lgp->args.minlength = range->length;
         lgp->args.maxcount = PNFS_LAYOUT_MAXSIZE;
-        lgp->args.range.iomode = iomode;
-        lgp->args.range.offset = 0;
-        lgp->args.range.length = NFS4_MAX_UINT64;
+        lgp->args.range = *range;
         lgp->args.type = server->pnfs_curr_ld->id;
         lgp->args.inode = ino;
         lgp->args.ctx = get_nfs_open_context(ctx);
@@ -518,7 +595,7 @@ send_layoutget(struct pnfs_layout_hdr *lo,
         nfs4_proc_layoutget(lgp);
         if (!lseg) {
                 /* remember that LAYOUTGET failed and suspend trying */
-                set_bit(lo_fail_bit(iomode), &lo->plh_flags);
+                set_bit(lo_fail_bit(range->iomode), &lo->plh_flags);
         }
 
         /* free xdr pages */
@@ -542,6 +619,51 @@ out_err_free:
         return NULL;
 }
 
+/* Initiates a LAYOUTRETURN(FILE) */
+int
+_pnfs_return_layout(struct inode *ino)
+{
+        struct pnfs_layout_hdr *lo = NULL;
+        struct nfs_inode *nfsi = NFS_I(ino);
+        LIST_HEAD(tmp_list);
+        struct nfs4_layoutreturn *lrp;
+        nfs4_stateid stateid;
+        int status = 0;
+
+        dprintk("--> %s\n", __func__);
+
+        spin_lock(&ino->i_lock);
+        lo = nfsi->layout;
+        if (!lo || !mark_matching_lsegs_invalid(lo, &tmp_list, NULL)) {
+                spin_unlock(&ino->i_lock);
+                dprintk("%s: no layout segments to return\n", __func__);
+                goto out;
+        }
+        stateid = nfsi->layout->plh_stateid;
+        /* Reference matched in nfs4_layoutreturn_release */
+        get_layout_hdr(lo);
+        spin_unlock(&ino->i_lock);
+        pnfs_free_lseg_list(&tmp_list);
+
+        WARN_ON(test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags));
+
+        lrp = kzalloc(sizeof(*lrp), GFP_KERNEL);
+        if (unlikely(lrp == NULL)) {
+                status = -ENOMEM;
+                goto out;
+        }
+
+        lrp->args.stateid = stateid;
+        lrp->args.layout_type = NFS_SERVER(ino)->pnfs_curr_ld->id;
+        lrp->args.inode = ino;
+        lrp->clp = NFS_SERVER(ino)->nfs_client;
+
+        status = nfs4_proc_layoutreturn(lrp);
+out:
+        dprintk("<-- %s status: %d\n", __func__, status);
+        return status;
+}
+
 bool pnfs_roc(struct inode *ino)
 {
         struct pnfs_layout_hdr *lo;
@@ -625,10 +747,23 @@ bool pnfs_roc_drain(struct inode *ino, u32 *barrier)
  * are seen first.
  */
 static s64
-cmp_layout(u32 iomode1, u32 iomode2)
+cmp_layout(struct pnfs_layout_range *l1,
+           struct pnfs_layout_range *l2)
 {
+        s64 d;
+
+        /* high offset > low offset */
+        d = l1->offset - l2->offset;
+        if (d)
+                return d;
+
+        /* short length > long length */
+        d = l2->length - l1->length;
+        if (d)
+                return d;
+
         /* read > read/write */
-        return (int)(iomode2 == IOMODE_READ) - (int)(iomode1 == IOMODE_READ);
+        return (int)(l1->iomode == IOMODE_READ) - (int)(l2->iomode == IOMODE_READ);
 }
 
 static void
@@ -636,13 +771,12 @@ pnfs_insert_layout(struct pnfs_layout_hdr *lo,
                    struct pnfs_layout_segment *lseg)
 {
         struct pnfs_layout_segment *lp;
-        int found = 0;
 
         dprintk("%s:Begin\n", __func__);
 
         assert_spin_locked(&lo->plh_inode->i_lock);
         list_for_each_entry(lp, &lo->plh_segs, pls_list) {
-                if (cmp_layout(lp->pls_range.iomode, lseg->pls_range.iomode) > 0)
+                if (cmp_layout(&lseg->pls_range, &lp->pls_range) > 0)
                         continue;
                 list_add_tail(&lseg->pls_list, &lp->pls_list);
                 dprintk("%s: inserted lseg %p "
@@ -652,16 +786,14 @@ pnfs_insert_layout(struct pnfs_layout_hdr *lo,
                         lseg->pls_range.offset, lseg->pls_range.length,
                         lp, lp->pls_range.iomode, lp->pls_range.offset,
                         lp->pls_range.length);
-                found = 1;
-                break;
-        }
-        if (!found) {
-                list_add_tail(&lseg->pls_list, &lo->plh_segs);
-                dprintk("%s: inserted lseg %p "
-                        "iomode %d offset %llu length %llu at tail\n",
-                        __func__, lseg, lseg->pls_range.iomode,
-                        lseg->pls_range.offset, lseg->pls_range.length);
+                goto out;
         }
+        list_add_tail(&lseg->pls_list, &lo->plh_segs);
+        dprintk("%s: inserted lseg %p "
+                "iomode %d offset %llu length %llu at tail\n",
+                __func__, lseg, lseg->pls_range.iomode,
+                lseg->pls_range.offset, lseg->pls_range.length);
+out:
         get_layout_hdr(lo);
 
         dprintk("%s:Return\n", __func__);
@@ -672,7 +804,7 @@ alloc_init_layout_hdr(struct inode *ino, gfp_t gfp_flags)
 {
         struct pnfs_layout_hdr *lo;
 
-        lo = kzalloc(sizeof(struct pnfs_layout_hdr), gfp_flags);
+        lo = pnfs_alloc_layout_hdr(ino, gfp_flags);
         if (!lo)
                 return NULL;
         atomic_set(&lo->plh_refcount, 1);
@@ -705,7 +837,7 @@ pnfs_find_alloc_layout(struct inode *ino, gfp_t gfp_flags)
         if (likely(nfsi->layout == NULL))       /* Won the race? */
                 nfsi->layout = new;
         else
-                kfree(new);
+                pnfs_free_layout_hdr(new);
         return nfsi->layout;
 }
 
@@ -721,16 +853,28 @@ pnfs_find_alloc_layout(struct inode *ino, gfp_t gfp_flags)
  * READ         RW      true
  */
 static int
-is_matching_lseg(struct pnfs_layout_segment *lseg, u32 iomode)
+is_matching_lseg(struct pnfs_layout_range *ls_range,
+                 struct pnfs_layout_range *range)
 {
-        return (iomode != IOMODE_RW || lseg->pls_range.iomode == IOMODE_RW);
+        struct pnfs_layout_range range1;
+
+        if ((range->iomode == IOMODE_RW &&
+             ls_range->iomode != IOMODE_RW) ||
+            !lo_seg_intersecting(ls_range, range))
+                return 0;
+
+        /* range1 covers only the first byte in the range */
+        range1 = *range;
+        range1.length = 1;
+        return lo_seg_contained(ls_range, &range1);
 }
 
 /*
  * lookup range in layout
  */
 static struct pnfs_layout_segment *
-pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)
+pnfs_find_lseg(struct pnfs_layout_hdr *lo,
+                struct pnfs_layout_range *range)
 {
         struct pnfs_layout_segment *lseg, *ret = NULL;
 
@@ -739,11 +883,11 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)
         assert_spin_locked(&lo->plh_inode->i_lock);
         list_for_each_entry(lseg, &lo->plh_segs, pls_list) {
                 if (test_bit(NFS_LSEG_VALID, &lseg->pls_flags) &&
-                    is_matching_lseg(lseg, iomode)) {
+                    is_matching_lseg(&lseg->pls_range, range)) {
                         ret = get_lseg(lseg);
                         break;
                 }
-                if (cmp_layout(iomode, lseg->pls_range.iomode) > 0)
+                if (cmp_layout(range, &lseg->pls_range) > 0)
                         break;
         }
 
@@ -759,9 +903,17 @@ pnfs_find_lseg(struct pnfs_layout_hdr *lo, u32 iomode)
 struct pnfs_layout_segment *
 pnfs_update_layout(struct inode *ino,
                    struct nfs_open_context *ctx,
+                   loff_t pos,
+                   u64 count,
                    enum pnfs_iomode iomode,
                    gfp_t gfp_flags)
 {
+        struct pnfs_layout_range arg = {
+                .iomode = iomode,
+                .offset = pos,
+                .length = count,
+        };
+        unsigned pg_offset;
         struct nfs_inode *nfsi = NFS_I(ino);
         struct nfs_client *clp = NFS_SERVER(ino)->nfs_client;
         struct pnfs_layout_hdr *lo;
@@ -789,7 +941,7 @@ pnfs_update_layout(struct inode *ino,
                 goto out_unlock;
 
         /* Check to see if the layout for the given range already exists */
-        lseg = pnfs_find_lseg(lo, iomode);
+        lseg = pnfs_find_lseg(lo, &arg);
         if (lseg)
                 goto out_unlock;
 
@@ -811,7 +963,14 @@ pnfs_update_layout(struct inode *ino,
                 spin_unlock(&clp->cl_lock);
         }
 
-        lseg = send_layoutget(lo, ctx, iomode, gfp_flags);
+        pg_offset = arg.offset & ~PAGE_CACHE_MASK;
+        if (pg_offset) {
+                arg.offset -= pg_offset;
+                arg.length += pg_offset;
+        }
+        arg.length = PAGE_CACHE_ALIGN(arg.length);
+
+        lseg = send_layoutget(lo, ctx, &arg, gfp_flags);
         if (!lseg && first) {
                 spin_lock(&clp->cl_lock);
                 list_del_init(&lo->plh_layouts);
@@ -838,17 +997,6 @@ pnfs_layout_process(struct nfs4_layoutget *lgp)
         struct nfs_client *clp = NFS_SERVER(ino)->nfs_client;
         int status = 0;
 
-        /* Verify we got what we asked for.
-         * Note that because the xdr parsing only accepts a single
-         * element array, this can fail even if the server is behaving
-         * correctly.
-         */
-        if (lgp->args.range.iomode > res->range.iomode ||
-            res->range.offset != 0 ||
-            res->range.length != NFS4_MAX_UINT64) {
-                status = -EINVAL;
-                goto out;
-        }
         /* Inject layout blob into I/O device driver */
         lseg = NFS_SERVER(ino)->pnfs_curr_ld->alloc_lseg(lo, res, lgp->gfp_flags);
         if (!lseg || IS_ERR(lseg)) {
@@ -895,51 +1043,64 @@ out_forget_reply:
         goto out;
 }
 
-static int pnfs_read_pg_test(struct nfs_pageio_descriptor *pgio,
-                             struct nfs_page *prev,
-                             struct nfs_page *req)
+bool
+pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
+                     struct nfs_page *req)
 {
+        enum pnfs_iomode access_type;
+        gfp_t gfp_flags;
+
+        /* We assume that pg_ioflags == 0 iff we're reading a page */
+        if (pgio->pg_ioflags == 0) {
+                access_type = IOMODE_READ;
+                gfp_flags = GFP_KERNEL;
+        } else {
+                access_type = IOMODE_RW;
+                gfp_flags = GFP_NOFS;
+        }
+
         if (pgio->pg_count == prev->wb_bytes) {
                 /* This is first coelesce call for a series of nfs_pages */
                 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
                                                    prev->wb_context,
-                                                   IOMODE_READ,
-                                                   GFP_KERNEL);
+                                                   req_offset(req),
+                                                   pgio->pg_count,
+                                                   access_type,
+                                                   gfp_flags);
+                return true;
         }
-        return NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->pg_test(pgio, prev, req);
-}
 
-void
-pnfs_pageio_init_read(struct nfs_pageio_descriptor *pgio, struct inode *inode)
-{
-        struct pnfs_layoutdriver_type *ld;
+        if (pgio->pg_lseg &&
+            req_offset(req) > end_offset(pgio->pg_lseg->pls_range.offset,
+                                         pgio->pg_lseg->pls_range.length))
+                return false;
 
-        ld = NFS_SERVER(inode)->pnfs_curr_ld;
-        pgio->pg_test = (ld && ld->pg_test) ? pnfs_read_pg_test : NULL;
+        return true;
 }
+EXPORT_SYMBOL_GPL(pnfs_generic_pg_test);
 
-static int pnfs_write_pg_test(struct nfs_pageio_descriptor *pgio,
-                              struct nfs_page *prev,
-                              struct nfs_page *req)
+/*
+ * Called by non rpc-based layout drivers
+ */
+int
+pnfs_ld_write_done(struct nfs_write_data *data)
 {
-        if (pgio->pg_count == prev->wb_bytes) {
-                /* This is first coelesce call for a series of nfs_pages */
-                pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
-                                                   prev->wb_context,
-                                                   IOMODE_RW,
-                                                   GFP_NOFS);
-        }
-        return NFS_SERVER(pgio->pg_inode)->pnfs_curr_ld->pg_test(pgio, prev, req);
-}
+        int status;
 
-void
-pnfs_pageio_init_write(struct nfs_pageio_descriptor *pgio, struct inode *inode)
-{
-        struct pnfs_layoutdriver_type *ld;
+        if (!data->pnfs_error) {
+                pnfs_set_layoutcommit(data);
+                data->mds_ops->rpc_call_done(&data->task, data);
+                data->mds_ops->rpc_release(data);
+                return 0;
+        }
 
-        ld = NFS_SERVER(inode)->pnfs_curr_ld;
-        pgio->pg_test = (ld && ld->pg_test) ? pnfs_write_pg_test : NULL;
+        dprintk("%s: pnfs_error=%d, retry via MDS\n", __func__,
+                data->pnfs_error);
+        status = nfs_initiate_write(data, NFS_CLIENT(data->inode),
+                                    data->mds_ops, NFS_FILE_SYNC);
+        return status ? : -EAGAIN;
 }
+EXPORT_SYMBOL_GPL(pnfs_ld_write_done);
 
 enum pnfs_try_status
 pnfs_try_to_write_data(struct nfs_write_data *wdata,
@@ -966,6 +1127,29 @@ pnfs_try_to_write_data(struct nfs_write_data *wdata,
 }
 
 /*
+ * Called by non rpc-based layout drivers
+ */
+int
+pnfs_ld_read_done(struct nfs_read_data *data)
+{
+        int status;
+
+        if (!data->pnfs_error) {
+                __nfs4_read_done_cb(data);
+                data->mds_ops->rpc_call_done(&data->task, data);
+                data->mds_ops->rpc_release(data);
+                return 0;
+        }
+
+        dprintk("%s: pnfs_error=%d, retry via MDS\n", __func__,
+                data->pnfs_error);
+        status = nfs_initiate_read(data, NFS_CLIENT(data->inode),
+                                   data->mds_ops);
+        return status ? : -EAGAIN;
+}
+EXPORT_SYMBOL_GPL(pnfs_ld_read_done);
+
+/*
  * Call the appropriate parallel I/O subsystem read function.
  */
 enum pnfs_try_status
@@ -1009,7 +1193,7 @@ void
 pnfs_set_layoutcommit(struct nfs_write_data *wdata)
 {
         struct nfs_inode *nfsi = NFS_I(wdata->inode);
-        loff_t end_pos = wdata->args.offset + wdata->res.count;
+        loff_t end_pos = wdata->mds_offset + wdata->res.count;
         bool mark_as_dirty = false;
 
         spin_lock(&nfsi->vfs_inode.i_lock);
diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index 0c015bad9e7a..48d0a8e4d062 100644
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -30,6 +30,7 @@
 #ifndef FS_NFS_PNFS_H
 #define FS_NFS_PNFS_H
 
+#include <linux/nfs_fs.h>
 #include <linux/nfs_page.h>
 
 enum {
@@ -64,17 +65,29 @@ enum {
         NFS_LAYOUT_DESTROYED,           /* no new use of layout allowed */
 };
 
+enum layoutdriver_policy_flags {
+        /* Should the pNFS client commit and return the layout upon a setattr */
+        PNFS_LAYOUTRET_ON_SETATTR       = 1 << 0,
+};
+
+struct nfs4_deviceid_node;
+
 /* Per-layout driver specific registration structure */
 struct pnfs_layoutdriver_type {
         struct list_head pnfs_tblid;
         const u32 id;
         const char *name;
         struct module *owner;
+        unsigned flags;
+
+        struct pnfs_layout_hdr * (*alloc_layout_hdr) (struct inode *inode, gfp_t gfp_flags);
+        void (*free_layout_hdr) (struct pnfs_layout_hdr *);
+
         struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr, gfp_t gfp_flags);
         void (*free_lseg) (struct pnfs_layout_segment *lseg);
 
         /* test for nfs page cache coalescing */
-        int (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
+        bool (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
 
         /* Returns true if layoutdriver wants to divert this request to
          * driver's commit routine.
@@ -89,6 +102,16 @@ struct pnfs_layoutdriver_type {
          */
         enum pnfs_try_status (*read_pagelist) (struct nfs_read_data *nfs_data);
         enum pnfs_try_status (*write_pagelist) (struct nfs_write_data *nfs_data, int how);
+
+        void (*free_deviceid_node) (struct nfs4_deviceid_node *);
+
+        void (*encode_layoutreturn) (struct pnfs_layout_hdr *layoutid,
+                                     struct xdr_stream *xdr,
+                                     const struct nfs4_layoutreturn_args *args);
+
+        void (*encode_layoutcommit) (struct pnfs_layout_hdr *layoutid,
+                                     struct xdr_stream *xdr,
+                                     const struct nfs4_layoutcommit_args *args);
 };
 
 struct pnfs_layout_hdr {
@@ -120,21 +143,22 @@ extern void pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *);
 extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
                                    struct pnfs_device *dev);
 extern int nfs4_proc_layoutget(struct nfs4_layoutget *lgp);
+extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp);
 
 /* pnfs.c */
 void get_layout_hdr(struct pnfs_layout_hdr *lo);
 void put_lseg(struct pnfs_layout_segment *lseg);
 struct pnfs_layout_segment *
 pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
-                   enum pnfs_iomode access_type, gfp_t gfp_flags);
+                   loff_t pos, u64 count, enum pnfs_iomode access_type,
+                   gfp_t gfp_flags);
 void set_pnfs_layoutdriver(struct nfs_server *, u32 id);
 void unset_pnfs_layoutdriver(struct nfs_server *);
 enum pnfs_try_status pnfs_try_to_write_data(struct nfs_write_data *,
                                              const struct rpc_call_ops *, int);
 enum pnfs_try_status pnfs_try_to_read_data(struct nfs_read_data *,
                                             const struct rpc_call_ops *);
-void pnfs_pageio_init_read(struct nfs_pageio_descriptor *, struct inode *);
-void pnfs_pageio_init_write(struct nfs_pageio_descriptor *, struct inode *);
+bool pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev, struct nfs_page *req);
 int pnfs_layout_process(struct nfs4_layoutget *lgp);
 void pnfs_free_lseg_list(struct list_head *tmp_list);
 void pnfs_destroy_layout(struct nfs_inode *);
@@ -148,13 +172,37 @@ int pnfs_choose_layoutget_stateid(nfs4_stateid *dst,
                                   struct nfs4_state *open_state);
 int mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
                                 struct list_head *tmp_list,
-                                u32 iomode);
+                                struct pnfs_layout_range *recall_range);
 bool pnfs_roc(struct inode *ino);
 void pnfs_roc_release(struct inode *ino);
 void pnfs_roc_set_barrier(struct inode *ino, u32 barrier);
 bool pnfs_roc_drain(struct inode *ino, u32 *barrier);
 void pnfs_set_layoutcommit(struct nfs_write_data *wdata);
 int pnfs_layoutcommit_inode(struct inode *inode, bool sync);
+int _pnfs_return_layout(struct inode *);
+int pnfs_ld_write_done(struct nfs_write_data *);
+int pnfs_ld_read_done(struct nfs_read_data *);
+
+/* pnfs_dev.c */
+struct nfs4_deviceid_node {
+        struct hlist_node               node;
+        const struct pnfs_layoutdriver_type *ld;
+        const struct nfs_client         *nfs_client;
+        struct nfs4_deviceid            deviceid;
+        atomic_t                        ref;
+};
+
+void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id);
+struct nfs4_deviceid_node *nfs4_find_get_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
+struct nfs4_deviceid_node *nfs4_unhash_put_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
+void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
+void nfs4_init_deviceid_node(struct nfs4_deviceid_node *,
+                             const struct pnfs_layoutdriver_type *,
+                             const struct nfs_client *,
+                             const struct nfs4_deviceid *);
+struct nfs4_deviceid_node *nfs4_insert_deviceid_node(struct nfs4_deviceid_node *);
+bool nfs4_put_deviceid_node(struct nfs4_deviceid_node *);
+void nfs4_deviceid_purge_client(const struct nfs_client *);
 
 static inline int lo_fail_bit(u32 iomode)
 {
@@ -223,6 +271,36 @@ static inline void pnfs_clear_request_commit(struct nfs_page *req)
                 put_lseg(req->wb_commit_lseg);
 }
 
+/* Should the pNFS client commit and return the layout upon a setattr */
+static inline bool
+pnfs_ld_layoutret_on_setattr(struct inode *inode)
+{
+        if (!pnfs_enabled_sb(NFS_SERVER(inode)))
+                return false;
+        return NFS_SERVER(inode)->pnfs_curr_ld->flags &
+                PNFS_LAYOUTRET_ON_SETATTR;
+}
+
+static inline int pnfs_return_layout(struct inode *ino)
+{
+        struct nfs_inode *nfsi = NFS_I(ino);
+        struct nfs_server *nfss = NFS_SERVER(ino);
+
+        if (pnfs_enabled_sb(nfss) && nfsi->layout)
+                return _pnfs_return_layout(ino);
+
+        return 0;
+}
+
+static inline void pnfs_pageio_init(struct nfs_pageio_descriptor *pgio,
+                                    struct inode *inode)
+{
+        struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
+
+        if (ld)
+                pgio->pg_test = ld->pg_test;
+}
+
 #else  /* CONFIG_NFS_V4_1 */
 
 static inline void pnfs_destroy_all_layouts(struct nfs_client *clp)
@@ -245,7 +323,8 @@ static inline void put_lseg(struct pnfs_layout_segment *lseg)
 
 static inline struct pnfs_layout_segment *
 pnfs_update_layout(struct inode *ino, struct nfs_open_context *ctx,
-                   enum pnfs_iomode access_type, gfp_t gfp_flags)
+                   loff_t pos, u64 count, enum pnfs_iomode access_type,
+                   gfp_t gfp_flags)
 {
         return NULL;
 }
@@ -264,6 +343,17 @@ pnfs_try_to_write_data(struct nfs_write_data *data,
         return PNFS_NOT_ATTEMPTED;
 }
 
+static inline int pnfs_return_layout(struct inode *ino)
+{
+        return 0;
+}
+
+static inline bool
+pnfs_ld_layoutret_on_setattr(struct inode *inode)
+{
+        return false;
+}
+
 static inline bool
 pnfs_roc(struct inode *ino)
 {
@@ -294,16 +384,9 @@ static inline void unset_pnfs_layoutdriver(struct nfs_server *s)
 {
 }
 
-static inline void
-pnfs_pageio_init_read(struct nfs_pageio_descriptor *pgio, struct inode *ino)
-{
-        pgio->pg_test = NULL;
-}
-
-static inline void
-pnfs_pageio_init_write(struct nfs_pageio_descriptor *pgio, struct inode *ino)
+static inline void pnfs_pageio_init(struct nfs_pageio_descriptor *pgio,
+                                    struct inode *inode)
 {
-        pgio->pg_test = NULL;
 }
 
 static inline void
@@ -331,6 +414,10 @@ static inline int pnfs_layoutcommit_inode(struct inode *inode, bool sync)
 {
         return 0;
 }
+
+static inline void nfs4_deviceid_purge_client(struct nfs_client *ncl)
+{
+}
 #endif /* CONFIG_NFS_V4_1 */
 
 #endif /* FS_NFS_PNFS_H */
diff --git a/fs/nfs/pnfs_dev.c b/fs/nfs/pnfs_dev.c
new file mode 100644
index 000000000000..c65e133ce9c0
--- /dev/null
+++ b/fs/nfs/pnfs_dev.c
@@ -0,0 +1,270 @@
+/*
+ *  Device operations for the pnfs client.
+ *
+ *  Copyright (c) 2002
+ *  The Regents of the University of Michigan
+ *  All Rights Reserved
+ *
+ *  Dean Hildebrand <dhildebz@umich.edu>
+ *  Garth Goodson   <Garth.Goodson@netapp.com>
+ *
+ *  Permission is granted to use, copy, create derivative works, and
+ *  redistribute this software and such derivative works for any purpose,
+ *  so long as the name of the University of Michigan is not used in
+ *  any advertising or publicity pertaining to the use or distribution
+ *  of this software without specific, written prior authorization. If
+ *  the above copyright notice or any other identification of the
+ *  University of Michigan is included in any copy of any portion of
+ *  this software, then the disclaimer below must also be included.
+ *
+ *  This software is provided as is, without representation or warranty
+ *  of any kind either express or implied, including without limitation
+ *  the implied warranties of merchantability, fitness for a particular
+ *  purpose, or noninfringement.  The Regents of the University of
+ *  Michigan shall not be liable for any damages, including special,
+ *  indirect, incidental, or consequential damages, with respect to any
+ *  claim arising out of or in connection with the use of the software,
+ *  even if it has been or is hereafter advised of the possibility of
+ *  such damages.
+ */
+
+#include "pnfs.h"
+
+#define NFSDBG_FACILITY         NFSDBG_PNFS
+
+/*
+ * Device ID RCU cache. A device ID is unique per server and layout type.
+ */
+#define NFS4_DEVICE_ID_HASH_BITS        5
+#define NFS4_DEVICE_ID_HASH_SIZE        (1 << NFS4_DEVICE_ID_HASH_BITS)
+#define NFS4_DEVICE_ID_HASH_MASK        (NFS4_DEVICE_ID_HASH_SIZE - 1)
+
+static struct hlist_head nfs4_deviceid_cache[NFS4_DEVICE_ID_HASH_SIZE];
+static DEFINE_SPINLOCK(nfs4_deviceid_lock);
+
+void
+nfs4_print_deviceid(const struct nfs4_deviceid *id)
+{
+        u32 *p = (u32 *)id;
+
+        dprintk("%s: device id= [%x%x%x%x]\n", __func__,
+                p[0], p[1], p[2], p[3]);
+}
+EXPORT_SYMBOL_GPL(nfs4_print_deviceid);
+
+static inline u32
+nfs4_deviceid_hash(const struct nfs4_deviceid *id)
+{
+        unsigned char *cptr = (unsigned char *)id->data;
+        unsigned int nbytes = NFS4_DEVICEID4_SIZE;
+        u32 x = 0;
+
+        while (nbytes--) {
+                x *= 37;
+                x += *cptr++;
+        }
+        return x & NFS4_DEVICE_ID_HASH_MASK;
+}
+
+static struct nfs4_deviceid_node *
+_lookup_deviceid(const struct pnfs_layoutdriver_type *ld,
+                 const struct nfs_client *clp, const struct nfs4_deviceid *id,
+                 long hash)
+{
+        struct nfs4_deviceid_node *d;
+        struct hlist_node *n;
+
+        hlist_for_each_entry_rcu(d, n, &nfs4_deviceid_cache[hash], node)
+                if (d->ld == ld && d->nfs_client == clp &&
+                    !memcmp(&d->deviceid, id, sizeof(*id))) {
+                        if (atomic_read(&d->ref))
+                                return d;
+                        else
+                                continue;
+                }
+        return NULL;
+}
+
+/*
+ * Lookup a deviceid in cache and get a reference count on it if found
+ *
+ * @clp nfs_client associated with deviceid
+ * @id deviceid to look up
+ */
+struct nfs4_deviceid_node *
+_find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
+                   const struct nfs_client *clp, const struct nfs4_deviceid *id,
+                   long hash)
+{
+        struct nfs4_deviceid_node *d;
+
+        rcu_read_lock();
+        d = _lookup_deviceid(ld, clp, id, hash);
+        if (d && !atomic_inc_not_zero(&d->ref))
+                d = NULL;
+        rcu_read_unlock();
+        return d;
+}
+
+struct nfs4_deviceid_node *
+nfs4_find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
+                       const struct nfs_client *clp, const struct nfs4_deviceid *id)
+{
+        return _find_get_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
+}
+EXPORT_SYMBOL_GPL(nfs4_find_get_deviceid);
+
+/*
+ * Unhash and put deviceid
+ *
+ * @clp nfs_client associated with deviceid
+ * @id the deviceid to unhash
+ *
+ * @ret the unhashed node, if found and dereferenced to zero, NULL otherwise.
+ */
+struct nfs4_deviceid_node *
+nfs4_unhash_put_deviceid(const struct pnfs_layoutdriver_type *ld,
+                         const struct nfs_client *clp, const struct nfs4_deviceid *id)
+{
+        struct nfs4_deviceid_node *d;
+
+        spin_lock(&nfs4_deviceid_lock);
+        rcu_read_lock();
+        d = _lookup_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
+        rcu_read_unlock();
+        if (!d) {
+                spin_unlock(&nfs4_deviceid_lock);
+                return NULL;
+        }
+        hlist_del_init_rcu(&d->node);
+        spin_unlock(&nfs4_deviceid_lock);
+        synchronize_rcu();
+
+        /* balance the initial ref set in pnfs_insert_deviceid */
+        if (atomic_dec_and_test(&d->ref))
+                return d;
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(nfs4_unhash_put_deviceid);
+
+/*
+ * Delete a deviceid from cache
+ *
+ * @clp struct nfs_client qualifying the deviceid
+ * @id deviceid to delete
+ */
+void
+nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld,
+                     const struct nfs_client *clp, const struct nfs4_deviceid *id)
+{
+        struct nfs4_deviceid_node *d;
+
+        d = nfs4_unhash_put_deviceid(ld, clp, id);
+        if (!d)
+                return;
+        d->ld->free_deviceid_node(d);
+}
+EXPORT_SYMBOL_GPL(nfs4_delete_deviceid);
+
+void
+nfs4_init_deviceid_node(struct nfs4_deviceid_node *d,
+                        const struct pnfs_layoutdriver_type *ld,
+                        const struct nfs_client *nfs_client,
+                        const struct nfs4_deviceid *id)
+{
+        INIT_HLIST_NODE(&d->node);
+        d->ld = ld;
+        d->nfs_client = nfs_client;
+        d->deviceid = *id;
+        atomic_set(&d->ref, 1);
+}
+EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node);
+
+/*
+ * Uniquely initialize and insert a deviceid node into cache
+ *
+ * @new new deviceid node
+ *      Note that the caller must set up the following members:
+ *        new->ld
+ *        new->nfs_client
+ *        new->deviceid
+ *
+ * @ret the inserted node, if none found, otherwise, the found entry.
+ */
+struct nfs4_deviceid_node *
+nfs4_insert_deviceid_node(struct nfs4_deviceid_node *new)
+{
+        struct nfs4_deviceid_node *d;
+        long hash;
+
+        spin_lock(&nfs4_deviceid_lock);
+        hash = nfs4_deviceid_hash(&new->deviceid);
+        d = _find_get_deviceid(new->ld, new->nfs_client, &new->deviceid, hash);
+        if (d) {
+                spin_unlock(&nfs4_deviceid_lock);
+                return d;
+        }
+
+        hlist_add_head_rcu(&new->node, &nfs4_deviceid_cache[hash]);
+        spin_unlock(&nfs4_deviceid_lock);
+
+        return new;
+}
+EXPORT_SYMBOL_GPL(nfs4_insert_deviceid_node);
+
+/*
+ * Dereference a deviceid node and delete it when its reference count drops
+ * to zero.
+ *
+ * @d deviceid node to put
+ *
+ * @ret true iff the node was deleted
+ */
+bool
+nfs4_put_deviceid_node(struct nfs4_deviceid_node *d)
+{
+        if (!atomic_dec_and_lock(&d->ref, &nfs4_deviceid_lock))
+                return false;
+        hlist_del_init_rcu(&d->node);
+        spin_unlock(&nfs4_deviceid_lock);
+        synchronize_rcu();
+        d->ld->free_deviceid_node(d);
+        return true;
+}
+EXPORT_SYMBOL_GPL(nfs4_put_deviceid_node);
+
+static void
+_deviceid_purge_client(const struct nfs_client *clp, long hash)
+{
+        struct nfs4_deviceid_node *d;
+        struct hlist_node *n, *next;
+        HLIST_HEAD(tmp);
+
+        rcu_read_lock();
+        hlist_for_each_entry_rcu(d, n, &nfs4_deviceid_cache[hash], node)
+                if (d->nfs_client == clp && atomic_read(&d->ref)) {
+                        hlist_del_init_rcu(&d->node);
+                        hlist_add_head(&d->node, &tmp);
+                }
+        rcu_read_unlock();
+
+        if (hlist_empty(&tmp))
+                return;
+
+        synchronize_rcu();
+        hlist_for_each_entry_safe(d, n, next, &tmp, node)
+                if (atomic_dec_and_test(&d->ref))
+                        d->ld->free_deviceid_node(d);
+}
+
+void
+nfs4_deviceid_purge_client(const struct nfs_client *clp)
+{
+        long h;
+
+        spin_lock(&nfs4_deviceid_lock);
+        for (h = 0; h < NFS4_DEVICE_ID_HASH_SIZE; h++)
+                _deviceid_purge_client(clp, h);
+        spin_unlock(&nfs4_deviceid_lock);
+}
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 2bcf0dc306a1..20a7f952e244 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -288,7 +288,9 @@ static int nfs_pagein_multi(struct nfs_pageio_descriptor *desc)
         atomic_set(&req->wb_complete, requests);
 
         BUG_ON(desc->pg_lseg != NULL);
-        lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_READ, GFP_KERNEL);
+        lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                  req_offset(req), desc->pg_count,
+                                  IOMODE_READ, GFP_KERNEL);
         ClearPageError(page);
         offset = 0;
         nbytes = desc->pg_count;
@@ -351,7 +353,9 @@ static int nfs_pagein_one(struct nfs_pageio_descriptor *desc)
         }
         req = nfs_list_entry(data->pages.next);
         if ((!lseg) && list_is_singular(&data->pages))
-                lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_READ, GFP_KERNEL);
+                lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                          req_offset(req), desc->pg_count,
+                                          IOMODE_READ, GFP_KERNEL);
 
         ret = nfs_read_rpcsetup(req, data, &nfs_read_full_ops, desc->pg_count,
                                 0, lseg);
@@ -660,7 +664,6 @@ int nfs_readpages(struct file *filp, struct address_space *mapping,
         if (ret == 0)
                 goto read_complete; /* all pages were read */
 
-        pnfs_pageio_init_read(&pgio, inode);
         if (rsize < PAGE_CACHE_SIZE)
                 nfs_pageio_init(&pgio, inode, nfs_pagein_multi, rsize, 0);
         else
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index e288f06d3fa7..ce40e5c568ba 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -63,6 +63,7 @@
 #include "iostat.h"
 #include "internal.h"
 #include "fscache.h"
+#include "pnfs.h"
 
 #define NFSDBG_FACILITY         NFSDBG_VFS
 
@@ -732,6 +733,28 @@ static int nfs_show_options(struct seq_file *m, struct vfsmount *mnt)
 
         return 0;
 }
+#ifdef CONFIG_NFS_V4_1
+void show_sessions(struct seq_file *m, struct nfs_server *server)
+{
+        if (nfs4_has_session(server->nfs_client))
+                seq_printf(m, ",sessions");
+}
+#else
+void show_sessions(struct seq_file *m, struct nfs_server *server) {}
+#endif
+
+#ifdef CONFIG_NFS_V4_1
+void show_pnfs(struct seq_file *m, struct nfs_server *server)
+{
+        seq_printf(m, ",pnfs=");
+        if (server->pnfs_curr_ld)
+                seq_printf(m, "%s", server->pnfs_curr_ld->name);
+        else
+                seq_printf(m, "not configured");
+}
+#else  /* CONFIG_NFS_V4_1 */
+void show_pnfs(struct seq_file *m, struct nfs_server *server) {}
+#endif /* CONFIG_NFS_V4_1 */
 
 static int nfs_show_devname(struct seq_file *m, struct vfsmount *mnt)
 {
@@ -792,6 +815,8 @@ static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
                 seq_printf(m, "bm0=0x%x", nfss->attr_bitmask[0]);
                 seq_printf(m, ",bm1=0x%x", nfss->attr_bitmask[1]);
                 seq_printf(m, ",acl=0x%x", nfss->acl_bitmask);
+                show_sessions(m, nfss);
+                show_pnfs(m, nfss);
         }
 #endif
 
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 49c715b4ac92..e268e3b23497 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -939,7 +939,9 @@ static int nfs_flush_multi(struct nfs_pageio_descriptor *desc)
         atomic_set(&req->wb_complete, requests);
 
         BUG_ON(desc->pg_lseg);
-        lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW, GFP_NOFS);
+        lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                  req_offset(req), desc->pg_count,
+                                  IOMODE_RW, GFP_NOFS);
         ClearPageError(page);
         offset = 0;
         nbytes = desc->pg_count;
@@ -1013,7 +1015,9 @@ static int nfs_flush_one(struct nfs_pageio_descriptor *desc)
         }
         req = nfs_list_entry(data->pages.next);
         if ((!lseg) && list_is_singular(&data->pages))
-                lseg = pnfs_update_layout(desc->pg_inode, req->wb_context, IOMODE_RW, GFP_NOFS);
+                lseg = pnfs_update_layout(desc->pg_inode, req->wb_context,
+                                          req_offset(req), desc->pg_count,
+                                          IOMODE_RW, GFP_NOFS);
 
         if ((desc->pg_ioflags & FLUSH_COND_STABLE) &&
             (desc->pg_moreio || NFS_I(desc->pg_inode)->ncommit))
@@ -1032,8 +1036,6 @@ static void nfs_pageio_init_write(struct nfs_pageio_descriptor *pgio,
 {
         size_t wsize = NFS_SERVER(inode)->wsize;
 
-        pnfs_pageio_init_write(pgio, inode);
-
         if (wsize < PAGE_CACHE_SIZE)
                 nfs_pageio_init(pgio, inode, nfs_flush_multi, wsize, ioflags);
         else
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index ad000aeb21a2..b9566e46219f 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -1354,12 +1354,6 @@ exp_pseudoroot(struct svc_rqst *rqstp, struct svc_fh *fhp)
         if (IS_ERR(exp))
                 return nfserrno(PTR_ERR(exp));
         rv = fh_compose(fhp, exp, exp->ex_path.dentry, NULL);
-        if (rv)
-                goto out;
-        rv = check_nfsd_access(exp, rqstp);
-        if (rv)
-                fh_put(fhp);
-out:
         exp_put(exp);
         return rv;
 }
diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
index 2247fc91d5e9..9095f3c21df9 100644
--- a/fs/nfsd/nfs3proc.c
+++ b/fs/nfsd/nfs3proc.c
@@ -245,7 +245,7 @@ nfsd3_proc_create(struct svc_rqst *rqstp, struct nfsd3_createargs *argp,
         }
 
         /* Now create the file and set attributes */
-        nfserr = nfsd_create_v3(rqstp, dirfhp, argp->name, argp->len,
+        nfserr = do_nfsd_create(rqstp, dirfhp, argp->name, argp->len,
                                 attr, newfhp,
                                 argp->createmode, argp->verf, NULL, NULL);
 
diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
index ad48faca20fc..08c6e36ab2eb 100644
--- a/fs/nfsd/nfs3xdr.c
+++ b/fs/nfsd/nfs3xdr.c
@@ -842,7 +842,7 @@ out:
         return rv;
 }
 
-__be32 *encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, int namlen)
+static __be32 *encode_entryplus_baggage(struct nfsd3_readdirres *cd, __be32 *p, const char *name, int namlen)
 {
         struct svc_fh   fh;
         int err;
diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
index 5fcb1396a7e3..3a6dbd70b34b 100644
--- a/fs/nfsd/nfs4proc.c
+++ b/fs/nfsd/nfs4proc.c
@@ -196,9 +196,9 @@ do_open_lookup(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_o
 
                 /*
                  * Note: create modes (UNCHECKED,GUARDED...) are the same
-                 * in NFSv4 as in v3.
+                 * in NFSv4 as in v3 except EXCLUSIVE4_1.
                  */
-                status = nfsd_create_v3(rqstp, current_fh, open->op_fname.data,
+                status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
                                         open->op_fname.len, &open->op_iattr,
                                         &resfh, open->op_createmode,
                                         (u32 *)open->op_verf.data,
@@ -403,7 +403,7 @@ nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
         memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
                putfh->pf_fhlen);
-        return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
+        return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
 }
 
 static __be32
@@ -762,6 +762,9 @@ nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
         __be32 err;
 
         fh_init(&resfh, NFS4_FHSIZE);
+        err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
+        if (err)
+                return err;
         err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
                                     secinfo->si_name, secinfo->si_namelen,
                                     &exp, &dentry);
@@ -986,6 +989,9 @@ enum nfsd4_op_flags {
         ALLOWED_WITHOUT_FH = 1 << 0,    /* No current filehandle required */
         ALLOWED_ON_ABSENT_FS = 1 << 1,  /* ops processed on absent fs */
         ALLOWED_AS_FIRST_OP = 1 << 2,   /* ops reqired first in compound */
+        /* For rfc 5661 section 2.6.3.1.1: */
+        OP_HANDLES_WRONGSEC = 1 << 3,
+        OP_IS_PUTFH_LIKE = 1 << 4,
 };
 
 struct nfsd4_operation {
@@ -1031,6 +1037,44 @@ static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
         return nfs_ok;
 }
 
+static inline struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
+{
+        return &nfsd4_ops[op->opnum];
+}
+
+static bool need_wrongsec_check(struct svc_rqst *rqstp)
+{
+        struct nfsd4_compoundres *resp = rqstp->rq_resp;
+        struct nfsd4_compoundargs *argp = rqstp->rq_argp;
+        struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
+        struct nfsd4_op *next = &argp->ops[resp->opcnt];
+        struct nfsd4_operation *thisd;
+        struct nfsd4_operation *nextd;
+
+        thisd = OPDESC(this);
+        /*
+         * Most ops check wronsec on our own; only the putfh-like ops
+         * have special rules.
+         */
+        if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
+                return false;
+        /*
+         * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
+         * put-filehandle operation if we're not going to use the
+         * result:
+         */
+        if (argp->opcnt == resp->opcnt)
+                return false;
+
+        nextd = OPDESC(next);
+        /*
+         * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
+         * errors themselves as necessary; others should check for them
+         * now:
+         */
+        return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
+}
+
 /*
  * COMPOUND call.
  */
@@ -1108,7 +1152,7 @@ nfsd4_proc_compound(struct svc_rqst *rqstp,
                         goto encode_op;
                 }
 
-                opdesc = &nfsd4_ops[op->opnum];
+                opdesc = OPDESC(op);
 
                 if (!cstate->current_fh.fh_dentry) {
                         if (!(opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
@@ -1126,6 +1170,9 @@ nfsd4_proc_compound(struct svc_rqst *rqstp,
                 else
                         BUG_ON(op->status == nfs_ok);
 
+                if (!op->status && need_wrongsec_check(rqstp))
+                        op->status = check_nfsd_access(cstate->current_fh.fh_export, rqstp);
+
 encode_op:
                 /* Only from SEQUENCE */
                 if (resp->cstate.status == nfserr_replay_cache) {
@@ -1217,10 +1264,12 @@ static struct nfsd4_operation nfsd4_ops[] = {
         },
         [OP_LOOKUP] = {
                 .op_func = (nfsd4op_func)nfsd4_lookup,
+                .op_flags = OP_HANDLES_WRONGSEC,
                 .op_name = "OP_LOOKUP",
         },
         [OP_LOOKUPP] = {
                 .op_func = (nfsd4op_func)nfsd4_lookupp,
+                .op_flags = OP_HANDLES_WRONGSEC,
                 .op_name = "OP_LOOKUPP",
         },
         [OP_NVERIFY] = {
@@ -1229,6 +1278,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
         },
         [OP_OPEN] = {
                 .op_func = (nfsd4op_func)nfsd4_open,
+                .op_flags = OP_HANDLES_WRONGSEC,
                 .op_name = "OP_OPEN",
         },
         [OP_OPEN_CONFIRM] = {
@@ -1241,17 +1291,20 @@ static struct nfsd4_operation nfsd4_ops[] = {
         },
         [OP_PUTFH] = {
                 .op_func = (nfsd4op_func)nfsd4_putfh,
-                .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
+                .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
+                                | OP_IS_PUTFH_LIKE,
                 .op_name = "OP_PUTFH",
         },
         [OP_PUTPUBFH] = {
                 .op_func = (nfsd4op_func)nfsd4_putrootfh,
-                .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
+                .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
+                                | OP_IS_PUTFH_LIKE,
                 .op_name = "OP_PUTPUBFH",
         },
         [OP_PUTROOTFH] = {
                 .op_func = (nfsd4op_func)nfsd4_putrootfh,
-                .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
+                .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
+                                | OP_IS_PUTFH_LIKE,
                 .op_name = "OP_PUTROOTFH",
         },
         [OP_READ] = {
@@ -1281,15 +1334,18 @@ static struct nfsd4_operation nfsd4_ops[] = {
         },
         [OP_RESTOREFH] = {
                 .op_func = (nfsd4op_func)nfsd4_restorefh,
-                .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS,
+                .op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
+                                | OP_IS_PUTFH_LIKE,
                 .op_name = "OP_RESTOREFH",
         },
         [OP_SAVEFH] = {
                 .op_func = (nfsd4op_func)nfsd4_savefh,
+                .op_flags = OP_HANDLES_WRONGSEC,
                 .op_name = "OP_SAVEFH",
         },
         [OP_SECINFO] = {
                 .op_func = (nfsd4op_func)nfsd4_secinfo,
+                .op_flags = OP_HANDLES_WRONGSEC,
                 .op_name = "OP_SECINFO",
         },
         [OP_SETATTR] = {
@@ -1353,6 +1409,7 @@ static struct nfsd4_operation nfsd4_ops[] = {
         },
         [OP_SECINFO_NO_NAME] = {
                 .op_func = (nfsd4op_func)nfsd4_secinfo_no_name,
+                .op_flags = OP_HANDLES_WRONGSEC,
                 .op_name = "OP_SECINFO_NO_NAME",
         },
 };
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 4cf04e11c66c..e98f3c2e9492 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -1519,6 +1519,9 @@ nfsd4_create_session(struct svc_rqst *rqstp,
         bool confirm_me = false;
         int status = 0;
 
+        if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
+                return nfserr_inval;
+
         nfs4_lock_state();
         unconf = find_unconfirmed_client(&cr_ses->clientid);
         conf = find_confirmed_client(&cr_ses->clientid);
@@ -1637,8 +1640,9 @@ __be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
                 return nfserr_badsession;
 
         status = nfsd4_map_bcts_dir(&bcts->dir);
-        nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
-        return nfs_ok;
+        if (!status)
+                nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
+        return status;
 }
 
 static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
@@ -1725,6 +1729,13 @@ static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_sessi
         return;
 }
 
+static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
+{
+        struct nfsd4_compoundargs *args = rqstp->rq_argp;
+
+        return args->opcnt > session->se_fchannel.maxops;
+}
+
 __be32
 nfsd4_sequence(struct svc_rqst *rqstp,
                struct nfsd4_compound_state *cstate,
@@ -1753,6 +1764,10 @@ nfsd4_sequence(struct svc_rqst *rqstp,
         if (!session)
                 goto out;
 
+        status = nfserr_too_many_ops;
+        if (nfsd4_session_too_many_ops(rqstp, session))
+                goto out;
+
         status = nfserr_badslot;
         if (seq->slotid >= session->se_fchannel.maxreqs)
                 goto out;
@@ -1808,6 +1823,8 @@ out:
 __be32
 nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
 {
+        int status = 0;
+
         if (rc->rca_one_fs) {
                 if (!cstate->current_fh.fh_dentry)
                         return nfserr_nofilehandle;
@@ -1817,9 +1834,14 @@ nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *csta
                  */
                  return nfs_ok;
         }
+
         nfs4_lock_state();
-        if (is_client_expired(cstate->session->se_client)) {
-                nfs4_unlock_state();
+        status = nfserr_complete_already;
+        if (cstate->session->se_client->cl_firststate)
+                goto out;
+
+        status = nfserr_stale_clientid;
+        if (is_client_expired(cstate->session->se_client))
                 /*
                  * The following error isn't really legal.
                  * But we only get here if the client just explicitly
@@ -1827,11 +1849,13 @@ nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *csta
                  * error it gets back on an operation for the dead
                  * client.
                  */
-                return nfserr_stale_clientid;
-        }
+                goto out;
+
+        status = nfs_ok;
         nfsd4_create_clid_dir(cstate->session->se_client);
+out:
         nfs4_unlock_state();
-        return nfs_ok;
+        return status;
 }
 
 __be32
@@ -2462,7 +2486,7 @@ find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
         return NULL;
 }
 
-int share_access_to_flags(u32 share_access)
+static int share_access_to_flags(u32 share_access)
 {
         share_access &= ~NFS4_SHARE_WANT_MASK;
 
@@ -2882,7 +2906,7 @@ out:
         return status;
 }
 
-struct lock_manager nfsd4_manager = {
+static struct lock_manager nfsd4_manager = {
 };
 
 static void
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index c6766af00d98..990181103214 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -424,15 +424,12 @@ nfsd4_decode_access(struct nfsd4_compoundargs *argp, struct nfsd4_access *access
 static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts)
 {
         DECODE_HEAD;
-        u32 dummy;
 
         READ_BUF(NFS4_MAX_SESSIONID_LEN + 8);
         COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN);
         READ32(bcts->dir);
-        /* XXX: Perhaps Tom Tucker could help us figure out how we
-         * should be using ctsa_use_conn_in_rdma_mode: */
-        READ32(dummy);
-
+        /* XXX: skipping ctsa_use_conn_in_rdma_mode.  Perhaps Tom Tucker
+         * could help us figure out we should be using it. */
         DECODE_TAIL;
 }
 
@@ -588,8 +585,6 @@ nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)
         READ_BUF(lockt->lt_owner.len);
         READMEM(lockt->lt_owner.data, lockt->lt_owner.len);
 
-        if (argp->minorversion && !zero_clientid(&lockt->lt_clientid))
-                return nfserr_inval;
         DECODE_TAIL;
 }
 
@@ -3120,7 +3115,7 @@ nfsd4_encode_destroy_session(struct nfsd4_compoundres *resp, int nfserr,
         return nfserr;
 }
 
-__be32
+static __be32
 nfsd4_encode_sequence(struct nfsd4_compoundres *resp, int nfserr,
                       struct nfsd4_sequence *seq)
 {
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 55c8e63af0be..90c6aa6d5e0f 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -344,7 +344,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
          * which clients virtually always use auth_sys for,
          * even while using RPCSEC_GSS for NFS.
          */
-        if (access & NFSD_MAY_LOCK)
+        if (access & NFSD_MAY_LOCK || access & NFSD_MAY_BYPASS_GSS)
                 goto skip_pseudoflavor_check;
         /*
          * Clients may expect to be able to use auth_sys during mount,
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 129f3c9f62d5..d5718273bb32 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -181,16 +181,10 @@ nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,
         struct svc_export       *exp;
         struct dentry           *dparent;
         struct dentry           *dentry;
-        __be32                  err;
         int                     host_err;
 
         dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name);
 
-        /* Obtain dentry and export. */
-        err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
-        if (err)
-                return err;
-
         dparent = fhp->fh_dentry;
         exp  = fhp->fh_export;
         exp_get(exp);
@@ -254,6 +248,9 @@ nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
         struct dentry           *dentry;
         __be32 err;
 
+        err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
+        if (err)
+                return err;
         err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry);
         if (err)
                 return err;
@@ -877,13 +874,11 @@ static __be32
 nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
               loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
 {
-        struct inode *inode;
         mm_segment_t    oldfs;
         __be32          err;
         int             host_err;
 
         err = nfserr_perm;
-        inode = file->f_path.dentry->d_inode;
 
         if (file->f_op->splice_read && rqstp->rq_splice_ok) {
                 struct splice_desc sd = {
@@ -1340,11 +1335,18 @@ out_nfserr:
 }
 
 #ifdef CONFIG_NFSD_V3
+
+static inline int nfsd_create_is_exclusive(int createmode)
+{
+        return createmode == NFS3_CREATE_EXCLUSIVE
+               || createmode == NFS4_CREATE_EXCLUSIVE4_1;
+}
+
 /*
- * NFSv3 version of nfsd_create
+ * NFSv3 and NFSv4 version of nfsd_create
  */
 __be32
-nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
+do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
                 char *fname, int flen, struct iattr *iap,
                 struct svc_fh *resfhp, int createmode, u32 *verifier,
                 int *truncp, int *created)
@@ -1396,7 +1398,7 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
         if (err)
                 goto out;
 
-        if (createmode == NFS3_CREATE_EXCLUSIVE) {
+        if (nfsd_create_is_exclusive(createmode)) {
                 /* solaris7 gets confused (bugid 4218508) if these have
                  * the high bit set, so just clear the high bits. If this is
                  * ever changed to use different attrs for storing the
@@ -1437,6 +1439,11 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
                             && dchild->d_inode->i_atime.tv_sec == v_atime
                             && dchild->d_inode->i_size  == 0 )
                                 break;
+                case NFS4_CREATE_EXCLUSIVE4_1:
+                        if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
+                            && dchild->d_inode->i_atime.tv_sec == v_atime
+                            && dchild->d_inode->i_size  == 0 )
+                                goto set_attr;
                          /* fallthru */
                 case NFS3_CREATE_GUARDED:
                         err = nfserr_exist;
@@ -1455,7 +1462,7 @@ nfsd_create_v3(struct svc_rqst *rqstp, struct svc_fh *fhp,
 
         nfsd_check_ignore_resizing(iap);
 
-        if (createmode == NFS3_CREATE_EXCLUSIVE) {
+        if (nfsd_create_is_exclusive(createmode)) {
                 /* Cram the verifier into atime/mtime */
                 iap->ia_valid = ATTR_MTIME|ATTR_ATIME
                         | ATTR_MTIME_SET|ATTR_ATIME_SET;
@@ -2034,7 +2041,7 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
         struct inode    *inode = dentry->d_inode;
         int             err;
 
-        if (acc == NFSD_MAY_NOP)
+        if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP)
                 return 0;
 #if 0
         dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
index 9a370a5e36b7..e0bbac04d1dd 100644
--- a/fs/nfsd/vfs.h
+++ b/fs/nfsd/vfs.h
@@ -17,10 +17,14 @@
 #define NFSD_MAY_SATTR          8
 #define NFSD_MAY_TRUNC          16
 #define NFSD_MAY_LOCK           32
+#define NFSD_MAY_MASK           63
+
+/* extra hints to permission and open routines: */
 #define NFSD_MAY_OWNER_OVERRIDE 64
 #define NFSD_MAY_LOCAL_ACCESS   128 /* IRIX doing local access check on device special file*/
 #define NFSD_MAY_BYPASS_GSS_ON_ROOT 256
 #define NFSD_MAY_NOT_BREAK_LEASE 512
+#define NFSD_MAY_BYPASS_GSS     1024
 
 #define NFSD_MAY_CREATE         (NFSD_MAY_EXEC|NFSD_MAY_WRITE)
 #define NFSD_MAY_REMOVE         (NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC)
@@ -54,7 +58,7 @@ __be32		nfsd_create(struct svc_rqst *, struct svc_fh *,
                                 int type, dev_t rdev, struct svc_fh *res);
 #ifdef CONFIG_NFSD_V3
 __be32          nfsd_access(struct svc_rqst *, struct svc_fh *, u32 *, u32 *);
-__be32          nfsd_create_v3(struct svc_rqst *, struct svc_fh *,
+__be32          do_nfsd_create(struct svc_rqst *, struct svc_fh *,
                                 char *name, int len, struct iattr *attrs,
                                 struct svc_fh *res, int createmode,
                                 u32 *verifier, int *truncp, int *created);
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 4ede550517a6..14def991d9dd 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -83,6 +83,9 @@
 #include <linux/pid_namespace.h>
 #include <linux/fs_struct.h>
 #include <linux/slab.h>
+#ifdef CONFIG_HARDWALL
+#include <asm/hardwall.h>
+#endif
 #include "internal.h"
 
 /* NOTE:
@@ -2842,6 +2845,9 @@ static const struct pid_entry tgid_base_stuff[] = {
 #ifdef CONFIG_TASK_IO_ACCOUNTING
         INF("io",       S_IRUGO, proc_tgid_io_accounting),
 #endif
+#ifdef CONFIG_HARDWALL
+        INF("hardwall",   S_IRUGO, proc_pid_hardwall),
+#endif
 };
 
 static int proc_tgid_base_readdir(struct file * filp,
@@ -3181,6 +3187,9 @@ static const struct pid_entry tid_base_stuff[] = {
 #ifdef CONFIG_TASK_IO_ACCOUNTING
         INF("io",       S_IRUGO, proc_tid_io_accounting),
 #endif
+#ifdef CONFIG_HARDWALL
+        INF("hardwall",   S_IRUGO, proc_pid_hardwall),
+#endif
 };
 
 static int proc_tid_base_readdir(struct file * filp,
diff --git a/fs/squashfs/export.c b/fs/squashfs/export.c
index 730c56248c9b..5e1101ff276f 100644
--- a/fs/squashfs/export.c
+++ b/fs/squashfs/export.c
@@ -147,7 +147,7 @@ __le64 *squashfs_read_inode_lookup_table(struct super_block *sb,
          * table[0] points to the first inode lookup table metadata block,
          * this should be less than lookup_table_start
          */
-        if (!IS_ERR(table) && table[0] >= lookup_table_start) {
+        if (!IS_ERR(table) && le64_to_cpu(table[0]) >= lookup_table_start) {
                 kfree(table);
                 return ERR_PTR(-EINVAL);
         }
diff --git a/fs/squashfs/fragment.c b/fs/squashfs/fragment.c
index 1516a6490bfb..0ed6edbc5c71 100644
--- a/fs/squashfs/fragment.c
+++ b/fs/squashfs/fragment.c
@@ -90,7 +90,7 @@ __le64 *squashfs_read_fragment_index_table(struct super_block *sb,
          * table[0] points to the first fragment table metadata block, this
          * should be less than fragment_table_start
          */
-        if (!IS_ERR(table) && table[0] >= fragment_table_start) {
+        if (!IS_ERR(table) && le64_to_cpu(table[0]) >= fragment_table_start) {
                 kfree(table);
                 return ERR_PTR(-EINVAL);
         }
diff --git a/fs/squashfs/id.c b/fs/squashfs/id.c
index a70858e0fb44..d38ea3dab951 100644
--- a/fs/squashfs/id.c
+++ b/fs/squashfs/id.c
@@ -93,7 +93,7 @@ __le64 *squashfs_read_id_index_table(struct super_block *sb,
          * table[0] points to the first id lookup table metadata block, this
          * should be less than id_table_start
          */
-        if (!IS_ERR(table) && table[0] >= id_table_start) {
+        if (!IS_ERR(table) && le64_to_cpu(table[0]) >= id_table_start) {
                 kfree(table);
                 return ERR_PTR(-EINVAL);
         }
diff --git a/fs/squashfs/super.c b/fs/squashfs/super.c
index 6f26abee3597..7438850c62d0 100644
--- a/fs/squashfs/super.c
+++ b/fs/squashfs/super.c
@@ -245,7 +245,7 @@ allocate_id_index_table:
                 msblk->id_table = NULL;
                 goto failed_mount;
         }
-        next_table = msblk->id_table[0];
+        next_table = le64_to_cpu(msblk->id_table[0]);
 
         /* Handle inode lookup table */
         lookup_table_start = le64_to_cpu(sblk->lookup_table_start);
@@ -261,7 +261,7 @@ allocate_id_index_table:
                 msblk->inode_lookup_table = NULL;
                 goto failed_mount;
         }
-        next_table = msblk->inode_lookup_table[0];
+        next_table = le64_to_cpu(msblk->inode_lookup_table[0]);
 
         sb->s_export_op = &squashfs_export_ops;
 
@@ -286,7 +286,7 @@ handle_fragments:
                 msblk->fragment_index = NULL;
                 goto failed_mount;
         }
-        next_table = msblk->fragment_index[0];
+        next_table = le64_to_cpu(msblk->fragment_index[0]);
 
 check_directory_table:
         /* Sanity check directory_table */
diff --git a/fs/ubifs/shrinker.c b/fs/ubifs/shrinker.c
index 46961c003236..ca953a945029 100644
--- a/fs/ubifs/shrinker.c
+++ b/fs/ubifs/shrinker.c
@@ -277,8 +277,9 @@ static int kick_a_thread(void)
         return 0;
 }
 
-int ubifs_shrinker(struct shrinker *shrink, int nr, gfp_t gfp_mask)
+int ubifs_shrinker(struct shrinker *shrink, struct shrink_control *sc)
 {
+        int nr = sc->nr_to_scan;
         int freed, contention = 0;
         long clean_zn_cnt = atomic_long_read(&ubifs_clean_zn_cnt);
 
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index 93d1412a06f0..a70d7b4ffb25 100644
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -1614,7 +1614,7 @@ int ubifs_tnc_start_commit(struct ubifs_info *c, struct ubifs_zbranch *zroot);
 int ubifs_tnc_end_commit(struct ubifs_info *c);
 
 /* shrinker.c */
-int ubifs_shrinker(struct shrinker *shrink, int nr_to_scan, gfp_t gfp_mask);
+int ubifs_shrinker(struct shrinker *shrink, struct shrink_control *sc);
 
 /* commit.c */
 int ubifs_bg_thread(void *info);
diff --git a/include/acpi/acpiosxf.h b/include/acpi/acpiosxf.h
index a3252a5ead66..a756bc8d866d 100644
--- a/include/acpi/acpiosxf.h
+++ b/include/acpi/acpiosxf.h
@@ -98,6 +98,9 @@ acpi_os_table_override(struct acpi_table_header *existing_table,
 /*
  * Spinlock primitives
  */
+acpi_status
+acpi_os_create_lock(acpi_spinlock *out_handle);
+
 void acpi_os_delete_lock(acpi_spinlock handle);
 
 acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock handle);
diff --git a/include/acpi/acpixf.h b/include/acpi/acpixf.h
index f6ad63d25b73..2ed0a8486c19 100644
--- a/include/acpi/acpixf.h
+++ b/include/acpi/acpixf.h
@@ -47,7 +47,7 @@
 
 /* Current ACPICA subsystem version in YYYYMMDD format */
 
-#define ACPI_CA_VERSION                 0x20110316
+#define ACPI_CA_VERSION                 0x20110413
 
 #include "actypes.h"
 #include "actbl.h"
diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
index 64f838beaabf..b67231bef632 100644
--- a/include/acpi/actypes.h
+++ b/include/acpi/actypes.h
@@ -501,8 +501,9 @@ typedef u64 acpi_integer;
 #define ACPI_STATE_D1                   (u8) 1
 #define ACPI_STATE_D2                   (u8) 2
 #define ACPI_STATE_D3                   (u8) 3
-#define ACPI_D_STATES_MAX               ACPI_STATE_D3
-#define ACPI_D_STATE_COUNT              4
+#define ACPI_STATE_D3_COLD              (u8) 4
+#define ACPI_D_STATES_MAX               ACPI_STATE_D3_COLD
+#define ACPI_D_STATE_COUNT              5
 
 #define ACPI_STATE_C0                   (u8) 0
 #define ACPI_STATE_C1                   (u8) 1
@@ -712,8 +713,24 @@ typedef u8 acpi_adr_space_type;
 #define ACPI_ADR_SPACE_CMOS             (acpi_adr_space_type) 5
 #define ACPI_ADR_SPACE_PCI_BAR_TARGET   (acpi_adr_space_type) 6
 #define ACPI_ADR_SPACE_IPMI             (acpi_adr_space_type) 7
-#define ACPI_ADR_SPACE_DATA_TABLE       (acpi_adr_space_type) 8
-#define ACPI_ADR_SPACE_FIXED_HARDWARE   (acpi_adr_space_type) 127
+
+#define ACPI_NUM_PREDEFINED_REGIONS     8
+
+/*
+ * Special Address Spaces
+ *
+ * Note: A Data Table region is a special type of operation region
+ * that has its own AML opcode. However, internally, the AML
+ * interpreter simply creates an operation region with an an address
+ * space type of ACPI_ADR_SPACE_DATA_TABLE.
+ */
+#define ACPI_ADR_SPACE_DATA_TABLE       (acpi_adr_space_type) 0x7E      /* Internal to ACPICA only */
+#define ACPI_ADR_SPACE_FIXED_HARDWARE   (acpi_adr_space_type) 0x7F
+
+/* Values for _REG connection code */
+
+#define ACPI_REG_DISCONNECT             0
+#define ACPI_REG_CONNECT                1
 
 /*
  * bit_register IDs
diff --git a/include/acpi/processor.h b/include/acpi/processor.h
index 55192ac0cede..ba4928cae473 100644
--- a/include/acpi/processor.h
+++ b/include/acpi/processor.h
@@ -310,14 +310,7 @@ static inline int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)
 
 /* in processor_core.c */
 void acpi_processor_set_pdc(acpi_handle handle);
-#ifdef CONFIG_SMP
 int acpi_get_cpuid(acpi_handle, int type, u32 acpi_id);
-#else
-static inline int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
-{
-        return -1;
-}
-#endif
 
 /* in processor_throttling.c */
 int acpi_processor_tstate_has_changed(struct acpi_processor *pr);
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index a2e910e01293..1deb2a73c2da 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -150,8 +150,7 @@ extern int ec_read(u8 addr, u8 *val);
 extern int ec_write(u8 addr, u8 val);
 extern int ec_transaction(u8 command,
                           const u8 *wdata, unsigned wdata_len,
-                          u8 *rdata, unsigned rdata_len,
-                          int force_poll);
+                          u8 *rdata, unsigned rdata_len);
 
 #if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)
 
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 32a4423710f5..4427e0454051 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -191,6 +191,12 @@ struct dm_target {
 
         /* Used to provide an error string from the ctr */
         char *error;
+
+        /*
+         * Set if this target needs to receive discards regardless of
+         * whether or not its underlying devices have support.
+         */
+        unsigned discards_supported:1;
 };
 
 /* Each target can link one of these into the table */
diff --git a/include/linux/dm-io.h b/include/linux/dm-io.h
index 5c9186b93fff..f4b0aa3126f5 100644
--- a/include/linux/dm-io.h
+++ b/include/linux/dm-io.h
@@ -69,8 +69,7 @@ struct dm_io_request {
  *
  * Create/destroy may block.
  */
-struct dm_io_client *dm_io_client_create(unsigned num_pages);
-int dm_io_client_resize(unsigned num_pages, struct dm_io_client *client);
+struct dm_io_client *dm_io_client_create(void);
 void dm_io_client_destroy(struct dm_io_client *client);
 
 /*
diff --git a/include/linux/dm-kcopyd.h b/include/linux/dm-kcopyd.h
index 5db216311695..298d587e349b 100644
--- a/include/linux/dm-kcopyd.h
+++ b/include/linux/dm-kcopyd.h
@@ -25,8 +25,7 @@
  * To use kcopyd you must first create a dm_kcopyd_client object.
  */
 struct dm_kcopyd_client;
-int dm_kcopyd_client_create(unsigned num_pages,
-                            struct dm_kcopyd_client **result);
+struct dm_kcopyd_client *dm_kcopyd_client_create(void);
 void dm_kcopyd_client_destroy(struct dm_kcopyd_client *kc);
 
 /*
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 2a78aae78c69..027935c86c68 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -264,6 +264,8 @@ struct mm_struct {
 
         struct linux_binfmt *binfmt;
 
+        cpumask_var_t cpu_vm_mask_var;
+
         /* Architecture-specific MM context */
         mm_context_t context;
 
@@ -311,10 +313,18 @@ struct mm_struct {
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
         pgtable_t pmd_huge_pte; /* protected by page_table_lock */
 #endif
-
-        cpumask_var_t cpu_vm_mask_var;
+#ifdef CONFIG_CPUMASK_OFFSTACK
+        struct cpumask cpumask_allocation;
+#endif
 };
 
+static inline void mm_init_cpumask(struct mm_struct *mm)
+{
+#ifdef CONFIG_CPUMASK_OFFSTACK
+        mm->cpu_vm_mask_var = &mm->cpumask_allocation;
+#endif
+}
+
 /* Future-safe accessor for struct mm_struct's cpu_vm_mask. */
 static inline cpumask_t *mm_cpumask(struct mm_struct *mm)
 {
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 178fafe0ff93..504b289ba680 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -562,6 +562,7 @@ enum {
         NFSPROC4_CLNT_LAYOUTGET,
         NFSPROC4_CLNT_GETDEVICEINFO,
         NFSPROC4_CLNT_LAYOUTCOMMIT,
+        NFSPROC4_CLNT_LAYOUTRETURN,
 };
 
 /* nfs41 types */
@@ -570,9 +571,11 @@ struct nfs4_sessionid {
 };
 
 /* Create Session Flags */
-#define SESSION4_PERSIST         0x001
-#define SESSION4_BACK_CHAN       0x002
-#define SESSION4_RDMA            0x004
+#define SESSION4_PERSIST        0x001
+#define SESSION4_BACK_CHAN      0x002
+#define SESSION4_RDMA           0x004
+
+#define SESSION4_FLAG_MASK_A    0x007
 
 enum state_protect_how4 {
         SP4_NONE        = 0,
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 91af2e49fa3a..3a34e80ae92f 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -68,7 +68,7 @@ struct nfs_pageio_descriptor {
         int                     pg_ioflags;
         int                     pg_error;
         struct pnfs_layout_segment *pg_lseg;
-        int                     (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
+        bool                    (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
 };
 
 #define NFS_WBACK_BUSY(req)     (test_bit(PG_BUSY,&(req)->wb_flags))
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 7e371f7df9c4..5e8444a11adf 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -269,6 +269,27 @@ struct nfs4_layoutcommit_data {
         struct nfs4_layoutcommit_res res;
 };
 
+struct nfs4_layoutreturn_args {
+        __u32   layout_type;
+        struct inode *inode;
+        nfs4_stateid stateid;
+        struct nfs4_sequence_args seq_args;
+};
+
+struct nfs4_layoutreturn_res {
+        struct nfs4_sequence_res seq_res;
+        u32 lrs_present;
+        nfs4_stateid stateid;
+};
+
+struct nfs4_layoutreturn {
+        struct nfs4_layoutreturn_args args;
+        struct nfs4_layoutreturn_res res;
+        struct rpc_cred *cred;
+        struct nfs_client *clp;
+        int rpc_status;
+};
+
 /*
  * Arguments to the open call.
  */
@@ -1087,6 +1108,7 @@ struct nfs_read_data {
         const struct rpc_call_ops *mds_ops;
         int (*read_done_cb) (struct rpc_task *task, struct nfs_read_data *data);
         __u64                   mds_offset;
+        int                     pnfs_error;
         struct page             *page_array[NFS_PAGEVEC_SIZE];
 };
 
@@ -1112,6 +1134,7 @@ struct nfs_write_data {
         unsigned long           timestamp;      /* For lease renewal */
 #endif
         __u64                   mds_offset;     /* Filelayout dense stripe */
+        int                     pnfs_error;
         struct page             *page_array[NFS_PAGEVEC_SIZE];
 };
 
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 79a6700b7162..6081493db68f 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -308,7 +308,7 @@ static inline void SetPageUptodate(struct page *page)
 {
 #ifdef CONFIG_S390
         if (!test_and_set_bit(PG_uptodate, &page->flags))
-                page_set_storage_key(page_to_pfn(page), PAGE_DEFAULT_KEY, 0);
+                page_set_storage_key(page_to_phys(page), PAGE_DEFAULT_KEY, 0);
 #else
         /*
          * Memory barrier must be issued before setting the PG_uptodate bit,
diff --git a/include/linux/pm_qos_params.h b/include/linux/pm_qos_params.h
index 77cbddb3784c..a7d87f911cab 100644
--- a/include/linux/pm_qos_params.h
+++ b/include/linux/pm_qos_params.h
@@ -16,6 +16,10 @@
 #define PM_QOS_NUM_CLASSES 4
 #define PM_QOS_DEFAULT_VALUE -1
 
+#define PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
+#define PM_QOS_NETWORK_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
+#define PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE 0
+
 struct pm_qos_request_list {
         struct plist_node list;
         int pm_qos_class;
diff --git a/include/linux/pnfs_osd_xdr.h b/include/linux/pnfs_osd_xdr.h
new file mode 100644
index 000000000000..76efbdd01622
--- /dev/null
+++ b/include/linux/pnfs_osd_xdr.h
@@ -0,0 +1,345 @@
+/*
+ *  pNFS-osd on-the-wire data structures
+ *
+ *  Copyright (C) 2007 Panasas Inc. [year of first publication]
+ *  All rights reserved.
+ *
+ *  Benny Halevy <bhalevy@panasas.com>
+ *  Boaz Harrosh <bharrosh@panasas.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2
+ *  See the file COPYING included with this distribution for more details.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. Neither the name of the Panasas company nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef __PNFS_OSD_XDR_H__
+#define __PNFS_OSD_XDR_H__
+
+#include <linux/nfs_fs.h>
+#include <linux/nfs_page.h>
+#include <scsi/osd_protocol.h>
+
+#define PNFS_OSD_OSDNAME_MAXSIZE 256
+
+/*
+ * draft-ietf-nfsv4-minorversion-22
+ * draft-ietf-nfsv4-pnfs-obj-12
+ */
+
+/* Layout Structure */
+
+enum pnfs_osd_raid_algorithm4 {
+        PNFS_OSD_RAID_0         = 1,
+        PNFS_OSD_RAID_4         = 2,
+        PNFS_OSD_RAID_5         = 3,
+        PNFS_OSD_RAID_PQ        = 4     /* Reed-Solomon P+Q */
+};
+
+/*   struct pnfs_osd_data_map4 {
+ *       uint32_t                    odm_num_comps;
+ *       length4                     odm_stripe_unit;
+ *       uint32_t                    odm_group_width;
+ *       uint32_t                    odm_group_depth;
+ *       uint32_t                    odm_mirror_cnt;
+ *       pnfs_osd_raid_algorithm4    odm_raid_algorithm;
+ *   };
+ */
+struct pnfs_osd_data_map {
+        u32     odm_num_comps;
+        u64     odm_stripe_unit;
+        u32     odm_group_width;
+        u32     odm_group_depth;
+        u32     odm_mirror_cnt;
+        u32     odm_raid_algorithm;
+};
+
+/*   struct pnfs_osd_objid4 {
+ *       deviceid4       oid_device_id;
+ *       uint64_t        oid_partition_id;
+ *       uint64_t        oid_object_id;
+ *   };
+ */
+struct pnfs_osd_objid {
+        struct nfs4_deviceid    oid_device_id;
+        u64                     oid_partition_id;
+        u64                     oid_object_id;
+};
+
+/* For printout. I use:
+ * kprint("dev(%llx:%llx)", _DEVID_LO(pointer), _DEVID_HI(pointer));
+ * BE style
+ */
+#define _DEVID_LO(oid_device_id) \
+        (unsigned long long)be64_to_cpup((__be64 *)(oid_device_id)->data)
+
+#define _DEVID_HI(oid_device_id) \
+        (unsigned long long)be64_to_cpup(((__be64 *)(oid_device_id)->data) + 1)
+
+static inline int
+pnfs_osd_objid_xdr_sz(void)
+{
+        return (NFS4_DEVICEID4_SIZE / 4) + 2 + 2;
+}
+
+enum pnfs_osd_version {
+        PNFS_OSD_MISSING              = 0,
+        PNFS_OSD_VERSION_1            = 1,
+        PNFS_OSD_VERSION_2            = 2
+};
+
+struct pnfs_osd_opaque_cred {
+        u32 cred_len;
+        void *cred;
+};
+
+enum pnfs_osd_cap_key_sec {
+        PNFS_OSD_CAP_KEY_SEC_NONE     = 0,
+        PNFS_OSD_CAP_KEY_SEC_SSV      = 1,
+};
+
+/*   struct pnfs_osd_object_cred4 {
+ *       pnfs_osd_objid4         oc_object_id;
+ *       pnfs_osd_version4       oc_osd_version;
+ *       pnfs_osd_cap_key_sec4   oc_cap_key_sec;
+ *       opaque                  oc_capability_key<>;
+ *       opaque                  oc_capability<>;
+ *   };
+ */
+struct pnfs_osd_object_cred {
+        struct pnfs_osd_objid           oc_object_id;
+        u32                             oc_osd_version;
+        u32                             oc_cap_key_sec;
+        struct pnfs_osd_opaque_cred     oc_cap_key;
+        struct pnfs_osd_opaque_cred     oc_cap;
+};
+
+/*   struct pnfs_osd_layout4 {
+ *       pnfs_osd_data_map4      olo_map;
+ *       uint32_t                olo_comps_index;
+ *       pnfs_osd_object_cred4   olo_components<>;
+ *   };
+ */
+struct pnfs_osd_layout {
+        struct pnfs_osd_data_map        olo_map;
+        u32                             olo_comps_index;
+        u32                             olo_num_comps;
+        struct pnfs_osd_object_cred     *olo_comps;
+};
+
+/* Device Address */
+enum pnfs_osd_targetid_type {
+        OBJ_TARGET_ANON = 1,
+        OBJ_TARGET_SCSI_NAME = 2,
+        OBJ_TARGET_SCSI_DEVICE_ID = 3,
+};
+
+/*   union pnfs_osd_targetid4 switch (pnfs_osd_targetid_type4 oti_type) {
+ *       case OBJ_TARGET_SCSI_NAME:
+ *           string              oti_scsi_name<>;
+ *
+ *       case OBJ_TARGET_SCSI_DEVICE_ID:
+ *           opaque              oti_scsi_device_id<>;
+ *
+ *       default:
+ *           void;
+ *   };
+ *
+ *   union pnfs_osd_targetaddr4 switch (bool ota_available) {
+ *       case TRUE:
+ *           netaddr4            ota_netaddr;
+ *       case FALSE:
+ *           void;
+ *   };
+ *
+ *   struct pnfs_osd_deviceaddr4 {
+ *       pnfs_osd_targetid4      oda_targetid;
+ *       pnfs_osd_targetaddr4    oda_targetaddr;
+ *       uint64_t                oda_lun;
+ *       opaque                  oda_systemid<>;
+ *       pnfs_osd_object_cred4   oda_root_obj_cred;
+ *       opaque                  oda_osdname<>;
+ *   };
+ */
+struct pnfs_osd_targetid {
+        u32                             oti_type;
+        struct nfs4_string              oti_scsi_device_id;
+};
+
+enum { PNFS_OSD_TARGETID_MAX = 1 + PNFS_OSD_OSDNAME_MAXSIZE / 4 };
+
+/*   struct netaddr4 {
+ *       // see struct rpcb in RFC1833
+ *       string r_netid<>;    // network id
+ *       string r_addr<>;     // universal address
+ *   };
+ */
+struct pnfs_osd_net_addr {
+        struct nfs4_string      r_netid;
+        struct nfs4_string      r_addr;
+};
+
+struct pnfs_osd_targetaddr {
+        u32                             ota_available;
+        struct pnfs_osd_net_addr        ota_netaddr;
+};
+
+enum {
+        NETWORK_ID_MAX = 16 / 4,
+        UNIVERSAL_ADDRESS_MAX = 64 / 4,
+        PNFS_OSD_TARGETADDR_MAX = 3 +  NETWORK_ID_MAX + UNIVERSAL_ADDRESS_MAX,
+};
+
+struct pnfs_osd_deviceaddr {
+        struct pnfs_osd_targetid        oda_targetid;
+        struct pnfs_osd_targetaddr      oda_targetaddr;
+        u8                              oda_lun[8];
+        struct nfs4_string              oda_systemid;
+        struct pnfs_osd_object_cred     oda_root_obj_cred;
+        struct nfs4_string              oda_osdname;
+};
+
+enum {
+        ODA_OSDNAME_MAX = PNFS_OSD_OSDNAME_MAXSIZE / 4,
+        PNFS_OSD_DEVICEADDR_MAX =
+                PNFS_OSD_TARGETID_MAX + PNFS_OSD_TARGETADDR_MAX +
+                2 /*oda_lun*/ +
+                1 + OSD_SYSTEMID_LEN +
+                1 + ODA_OSDNAME_MAX,
+};
+
+/* LAYOUTCOMMIT: layoutupdate */
+
+/*   union pnfs_osd_deltaspaceused4 switch (bool dsu_valid) {
+ *       case TRUE:
+ *           int64_t     dsu_delta;
+ *       case FALSE:
+ *           void;
+ *   };
+ *
+ *   struct pnfs_osd_layoutupdate4 {
+ *       pnfs_osd_deltaspaceused4    olu_delta_space_used;
+ *       bool                        olu_ioerr_flag;
+ *   };
+ */
+struct pnfs_osd_layoutupdate {
+        u32     dsu_valid;
+        s64     dsu_delta;
+        u32     olu_ioerr_flag;
+};
+
+/* LAYOUTRETURN: I/O Rrror Report */
+
+enum pnfs_osd_errno {
+        PNFS_OSD_ERR_EIO                = 1,
+        PNFS_OSD_ERR_NOT_FOUND          = 2,
+        PNFS_OSD_ERR_NO_SPACE           = 3,
+        PNFS_OSD_ERR_BAD_CRED           = 4,
+        PNFS_OSD_ERR_NO_ACCESS          = 5,
+        PNFS_OSD_ERR_UNREACHABLE        = 6,
+        PNFS_OSD_ERR_RESOURCE           = 7
+};
+
+/*   struct pnfs_osd_ioerr4 {
+ *       pnfs_osd_objid4     oer_component;
+ *       length4             oer_comp_offset;
+ *       length4             oer_comp_length;
+ *       bool                oer_iswrite;
+ *       pnfs_osd_errno4     oer_errno;
+ *   };
+ */
+struct pnfs_osd_ioerr {
+        struct pnfs_osd_objid   oer_component;
+        u64                     oer_comp_offset;
+        u64                     oer_comp_length;
+        u32                     oer_iswrite;
+        u32                     oer_errno;
+};
+
+/* OSD XDR API */
+/* Layout helpers */
+/* Layout decoding is done in two parts:
+ * 1. First Call pnfs_osd_xdr_decode_layout_map to read in only the header part
+ *    of the layout. @iter members need not be initialized.
+ *    Returned:
+ *             @layout members are set. (@layout->olo_comps set to NULL).
+ *
+ *             Zero on success, or negative error if passed xdr is broken.
+ *
+ * 2. 2nd Call pnfs_osd_xdr_decode_layout_comp() in a loop until it returns
+ *    false, to decode the next component.
+ *    Returned:
+ *       true if there is more to decode or false if we are done or error.
+ *
+ * Example:
+ *      struct pnfs_osd_xdr_decode_layout_iter iter;
+ *      struct pnfs_osd_layout layout;
+ *      struct pnfs_osd_object_cred comp;
+ *      int status;
+ *
+ *      status = pnfs_osd_xdr_decode_layout_map(&layout, &iter, xdr);
+ *      if (unlikely(status))
+ *              goto err;
+ *      while(pnfs_osd_xdr_decode_layout_comp(&comp, &iter, xdr, &status)) {
+ *              // All of @comp strings point to inside the xdr_buffer
+ *              // or scrach buffer. Copy them out to user memory eg.
+ *              copy_single_comp(dest_comp++, &comp);
+ *      }
+ *      if (unlikely(status))
+ *              goto err;
+ */
+
+struct pnfs_osd_xdr_decode_layout_iter {
+        unsigned total_comps;
+        unsigned decoded_comps;
+};
+
+extern int pnfs_osd_xdr_decode_layout_map(struct pnfs_osd_layout *layout,
+        struct pnfs_osd_xdr_decode_layout_iter *iter, struct xdr_stream *xdr);
+
+extern bool pnfs_osd_xdr_decode_layout_comp(struct pnfs_osd_object_cred *comp,
+        struct pnfs_osd_xdr_decode_layout_iter *iter, struct xdr_stream *xdr,
+        int *err);
+
+/* Device Info helpers */
+
+/* Note: All strings inside @deviceaddr point to space inside @p.
+ * @p should stay valid while @deviceaddr is in use.
+ */
+extern void pnfs_osd_xdr_decode_deviceaddr(
+        struct pnfs_osd_deviceaddr *deviceaddr, __be32 *p);
+
+/* layoutupdate (layout_commit) xdr helpers */
+extern int
+pnfs_osd_xdr_encode_layoutupdate(struct xdr_stream *xdr,
+                                 struct pnfs_osd_layoutupdate *lou);
+
+/* osd_ioerror encoding/decoding (layout_return) */
+/* Client */
+extern __be32 *pnfs_osd_xdr_ioerr_reserve_space(struct xdr_stream *xdr);
+extern void pnfs_osd_xdr_encode_ioerr(__be32 *p, struct pnfs_osd_ioerr *ioerr);
+
+#endif /* __PNFS_OSD_XDR_H__ */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index bcddd0138105..2a8621c4be1e 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -2194,7 +2194,6 @@ static inline void mmdrop(struct mm_struct * mm)
         if (unlikely(atomic_dec_and_test(&mm->mm_count)))
                 __mmdrop(mm);
 }
-extern int mm_init_cpumask(struct mm_struct *mm, struct mm_struct *oldmm);
 
 /* mmput gets rid of the mappings and all user-space */
 extern void mmput(struct mm_struct *);
diff --git a/include/linux/sunrpc/msg_prot.h b/include/linux/sunrpc/msg_prot.h
index 77e624883393..c68a147939a6 100644
--- a/include/linux/sunrpc/msg_prot.h
+++ b/include/linux/sunrpc/msg_prot.h
@@ -145,6 +145,7 @@ typedef __be32	rpc_fraghdr;
 #define RPCBIND_NETID_TCP       "tcp"
 #define RPCBIND_NETID_UDP6      "udp6"
 #define RPCBIND_NETID_TCP6      "tcp6"
+#define RPCBIND_NETID_LOCAL     "local"
 
 /*
  * Note that RFC 1833 does not put any size restrictions on the
diff --git a/include/linux/sunrpc/svcsock.h b/include/linux/sunrpc/svcsock.h
index 04dba23c59f2..85c50b40759d 100644
--- a/include/linux/sunrpc/svcsock.h
+++ b/include/linux/sunrpc/svcsock.h
@@ -28,6 +28,7 @@ struct svc_sock {
         /* private TCP part */
         u32                     sk_reclen;      /* length of record */
         u32                     sk_tcplen;      /* current read length */
+        struct page *           sk_pages[RPCSVC_MAXPAGES];      /* received data */
 };
 
 /*
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index fc84b7a19ca3..a20970ef9e4e 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -216,6 +216,8 @@ extern __be32 *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
 extern void xdr_write_pages(struct xdr_stream *xdr, struct page **pages,
                 unsigned int base, unsigned int len);
 extern void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p);
+extern void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
+                struct page **pages, unsigned int len);
 extern void xdr_set_scratch_buffer(struct xdr_stream *xdr, void *buf, size_t buflen);
 extern __be32 *xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes);
 extern void xdr_read_pages(struct xdr_stream *xdr, unsigned int len);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index a0f998c07c65..81cce3b3ee66 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -141,7 +141,8 @@ enum xprt_transports {
         XPRT_TRANSPORT_UDP      = IPPROTO_UDP,
         XPRT_TRANSPORT_TCP      = IPPROTO_TCP,
         XPRT_TRANSPORT_BC_TCP   = IPPROTO_TCP | XPRT_TRANSPORT_BC,
-        XPRT_TRANSPORT_RDMA     = 256
+        XPRT_TRANSPORT_RDMA     = 256,
+        XPRT_TRANSPORT_LOCAL    = 257,
 };
 
 struct rpc_xprt {
diff --git a/init/main.c b/init/main.c
index d2f1e086bf33..cafba67c13bf 100644
--- a/init/main.c
+++ b/init/main.c
@@ -487,6 +487,7 @@ asmlinkage void __init start_kernel(void)
         printk(KERN_NOTICE "%s", linux_banner);
         setup_arch(&command_line);
         mm_init_owner(&init_mm, &init_task);
+        mm_init_cpumask(&init_mm);
         setup_command_line(command_line);
         setup_nr_cpu_ids();
         setup_per_cpu_areas();
@@ -510,7 +511,6 @@ asmlinkage void __init start_kernel(void)
         sort_main_extable();
         trap_init();
         mm_init();
-        BUG_ON(mm_init_cpumask(&init_mm, 0));
 
         /*
          * Set up the scheduler prior starting any interrupts (such as the
diff --git a/kernel/fork.c b/kernel/fork.c
index ca406d916713..0276c30401a0 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -484,20 +484,6 @@ static void mm_init_aio(struct mm_struct *mm)
 #endif
 }
 
-int mm_init_cpumask(struct mm_struct *mm, struct mm_struct *oldmm)
-{
-#ifdef CONFIG_CPUMASK_OFFSTACK
-        if (!alloc_cpumask_var(&mm->cpu_vm_mask_var, GFP_KERNEL))
-                return -ENOMEM;
-
-        if (oldmm)
-                cpumask_copy(mm_cpumask(mm), mm_cpumask(oldmm));
-        else
-                memset(mm_cpumask(mm), 0, cpumask_size());
-#endif
-        return 0;
-}
-
 static struct mm_struct * mm_init(struct mm_struct * mm, struct task_struct *p)
 {
         atomic_set(&mm->mm_users, 1);
@@ -538,17 +524,8 @@ struct mm_struct * mm_alloc(void)
                 return NULL;
 
         memset(mm, 0, sizeof(*mm));
-        mm = mm_init(mm, current);
-        if (!mm)
-                return NULL;
-
-        if (mm_init_cpumask(mm, NULL)) {
-                mm_free_pgd(mm);
-                free_mm(mm);
-                return NULL;
-        }
-
-        return mm;
+        mm_init_cpumask(mm);
+        return mm_init(mm, current);
 }
 
 /*
@@ -559,7 +536,6 @@ struct mm_struct * mm_alloc(void)
 void __mmdrop(struct mm_struct *mm)
 {
         BUG_ON(mm == &init_mm);
-        free_cpumask_var(mm->cpu_vm_mask_var);
         mm_free_pgd(mm);
         destroy_context(mm);
         mmu_notifier_mm_destroy(mm);
@@ -753,6 +729,7 @@ struct mm_struct *dup_mm(struct task_struct *tsk)
                 goto fail_nomem;
 
         memcpy(mm, oldmm, sizeof(*mm));
+        mm_init_cpumask(mm);
 
         /* Initializing for Swap token stuff */
         mm->token_priority = 0;
@@ -765,9 +742,6 @@ struct mm_struct *dup_mm(struct task_struct *tsk)
         if (!mm_init(mm, tsk))
                 goto fail_nomem;
 
-        if (mm_init_cpumask(mm, oldmm))
-                goto fail_nocpumask;
-
         if (init_new_context(tsk, mm))
                 goto fail_nocontext;
 
@@ -794,9 +768,6 @@ fail_nomem:
         return NULL;
 
 fail_nocontext:
-        free_cpumask_var(mm->cpu_vm_mask_var);
-
-fail_nocpumask:
         /*
          * If init_new_context() failed, we cannot use mmput() to free the mm
          * because it calls destroy_context()
@@ -1591,6 +1562,13 @@ void __init proc_caches_init(void)
         fs_cachep = kmem_cache_create("fs_cache",
                         sizeof(struct fs_struct), 0,
                         SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);
+        /*
+         * FIXME! The "sizeof(struct mm_struct)" currently includes the
+         * whole struct cpumask for the OFFSTACK case. We could change
+         * this to *only* allocate as much of it as required by the
+         * maximum number of CPU's we can ever have.  The cpumask_allocation
+         * is at the end of the structure, exactly for that reason.
+         */
         mm_cachep = kmem_cache_create("mm_struct",
                         sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
                         SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);
diff --git a/kernel/pm_qos_params.c b/kernel/pm_qos_params.c
index fd8d1e035df9..6824ca7d4d0c 100644
--- a/kernel/pm_qos_params.c
+++ b/kernel/pm_qos_params.c
@@ -54,11 +54,17 @@ enum pm_qos_type {
         PM_QOS_MIN              /* return the smallest value */
 };
 
+/*
+ * Note: The lockless read path depends on the CPU accessing
+ * target_value atomically.  Atomic access is only guaranteed on all CPU
+ * types linux supports for 32 bit quantites
+ */
 struct pm_qos_object {
         struct plist_head requests;
         struct blocking_notifier_head *notifiers;
         struct miscdevice pm_qos_power_miscdev;
         char *name;
+        s32 target_value;       /* Do not change to 64 bit */
         s32 default_value;
         enum pm_qos_type type;
 };
@@ -71,7 +77,8 @@ static struct pm_qos_object cpu_dma_pm_qos = {
         .requests = PLIST_HEAD_INIT(cpu_dma_pm_qos.requests, pm_qos_lock),
         .notifiers = &cpu_dma_lat_notifier,
         .name = "cpu_dma_latency",
-        .default_value = 2000 * USEC_PER_SEC,
+        .target_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
+        .default_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
         .type = PM_QOS_MIN,
 };
 
@@ -80,7 +87,8 @@ static struct pm_qos_object network_lat_pm_qos = {
         .requests = PLIST_HEAD_INIT(network_lat_pm_qos.requests, pm_qos_lock),
         .notifiers = &network_lat_notifier,
         .name = "network_latency",
-        .default_value = 2000 * USEC_PER_SEC,
+        .target_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
+        .default_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
         .type = PM_QOS_MIN
 };
 
@@ -90,7 +98,8 @@ static struct pm_qos_object network_throughput_pm_qos = {
         .requests = PLIST_HEAD_INIT(network_throughput_pm_qos.requests, pm_qos_lock),
         .notifiers = &network_throughput_notifier,
         .name = "network_throughput",
-        .default_value = 0,
+        .target_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
+        .default_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
         .type = PM_QOS_MAX,
 };
 
@@ -136,6 +145,16 @@ static inline int pm_qos_get_value(struct pm_qos_object *o)
         }
 }
 
+static inline s32 pm_qos_read_value(struct pm_qos_object *o)
+{
+        return o->target_value;
+}
+
+static inline void pm_qos_set_value(struct pm_qos_object *o, s32 value)
+{
+        o->target_value = value;
+}
+
 static void update_target(struct pm_qos_object *o, struct plist_node *node,
                           int del, int value)
 {
@@ -160,6 +179,7 @@ static void update_target(struct pm_qos_object *o, struct plist_node *node,
                 plist_add(node, &o->requests);
         }
         curr_value = pm_qos_get_value(o);
+        pm_qos_set_value(o, curr_value);
         spin_unlock_irqrestore(&pm_qos_lock, flags);
 
         if (prev_value != curr_value)
@@ -194,18 +214,11 @@ static int find_pm_qos_object_by_minor(int minor)
  * pm_qos_request - returns current system wide qos expectation
  * @pm_qos_class: identification of which qos value is requested
  *
- * This function returns the current target value in an atomic manner.
+ * This function returns the current target value.
  */
 int pm_qos_request(int pm_qos_class)
 {
-        unsigned long flags;
-        int value;
-
-        spin_lock_irqsave(&pm_qos_lock, flags);
-        value = pm_qos_get_value(pm_qos_array[pm_qos_class]);
-        spin_unlock_irqrestore(&pm_qos_lock, flags);
-
-        return value;
+        return pm_qos_read_value(pm_qos_array[pm_qos_class]);
 }
 EXPORT_SYMBOL_GPL(pm_qos_request);
 
diff --git a/mm/rmap.c b/mm/rmap.c
index 6bada99cd61c..0eb463ea88dd 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -352,6 +352,11 @@ void __init anon_vma_init(void)
  * The page might have been remapped to a different anon_vma or the anon_vma
  * returned may already be freed (and even reused).
  *
+ * In case it was remapped to a different anon_vma, the new anon_vma will be a
+ * child of the old anon_vma, and the anon_vma lifetime rules will therefore
+ * ensure that any anon_vma obtained from the page will still be valid for as
+ * long as we observe page_mapped() [ hence all those page_mapped() tests ].
+ *
  * All users of this function must be very careful when walking the anon_vma
  * chain and verify that the page in question is indeed mapped in it
  * [ something equivalent to page_mapped_in_vma() ].
@@ -421,7 +426,7 @@ struct anon_vma *page_lock_anon_vma(struct page *page)
                 /*
                  * If the page is still mapped, then this anon_vma is still
                  * its anon_vma, and holding the mutex ensures that it will
-                 * not go away, see __put_anon_vma().
+                 * not go away, see anon_vma_free().
                  */
                 if (!page_mapped(page)) {
                         mutex_unlock(&root_anon_vma->mutex);
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index 8d83f9d48713..b84d7395535e 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -13,10 +13,6 @@
  *      and need to be refreshed, or when a packet was damaged in transit.
  *      This may be have to be moved to the VFS layer.
  *
- *  NB: BSD uses a more intelligent approach to guessing when a request
- *  or reply has been lost by keeping the RTO estimate for each procedure.
- *  We currently make do with a constant timeout value.
- *
  *  Copyright (C) 1992,1993 Rick Sladkey <jrs@world.std.com>
  *  Copyright (C) 1995,1996 Olaf Kirch <okir@monad.swb.de>
  */
@@ -32,7 +28,9 @@
 #include <linux/slab.h>
 #include <linux/utsname.h>
 #include <linux/workqueue.h>
+#include <linux/in.h>
 #include <linux/in6.h>
+#include <linux/un.h>
 
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/rpc_pipe_fs.h>
@@ -298,22 +296,27 @@ struct rpc_clnt *rpc_create(struct rpc_create_args *args)
          * up a string representation of the passed-in address.
          */
         if (args->servername == NULL) {
+                struct sockaddr_un *sun =
+                                (struct sockaddr_un *)args->address;
+                struct sockaddr_in *sin =
+                                (struct sockaddr_in *)args->address;
+                struct sockaddr_in6 *sin6 =
+                                (struct sockaddr_in6 *)args->address;
+
                 servername[0] = '\0';
                 switch (args->address->sa_family) {
-                case AF_INET: {
-                        struct sockaddr_in *sin =
-                                        (struct sockaddr_in *)args->address;
+                case AF_LOCAL:
+                        snprintf(servername, sizeof(servername), "%s",
+                                 sun->sun_path);
+                        break;
+                case AF_INET:
                         snprintf(servername, sizeof(servername), "%pI4",
                                  &sin->sin_addr.s_addr);
                         break;
-                }
-                case AF_INET6: {
-                        struct sockaddr_in6 *sin =
-                                        (struct sockaddr_in6 *)args->address;
+                case AF_INET6:
                         snprintf(servername, sizeof(servername), "%pI6",
-                                 &sin->sin6_addr);
+                                 &sin6->sin6_addr);
                         break;
-                }
                 default:
                         /* caller wants default server name, but
                          * address family isn't recognized. */
diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c
index c652e4cc9fe9..9a80a922c527 100644
--- a/net/sunrpc/rpcb_clnt.c
+++ b/net/sunrpc/rpcb_clnt.c
@@ -16,6 +16,7 @@
 
 #include <linux/types.h>
 #include <linux/socket.h>
+#include <linux/un.h>
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/kernel.h>
@@ -32,6 +33,8 @@
 # define RPCDBG_FACILITY        RPCDBG_BIND
 #endif
 
+#define RPCBIND_SOCK_PATHNAME   "/var/run/rpcbind.sock"
+
 #define RPCBIND_PROGRAM         (100000u)
 #define RPCBIND_PORT            (111u)
 
@@ -158,20 +161,69 @@ static void rpcb_map_release(void *data)
         kfree(map);
 }
 
-static const struct sockaddr_in rpcb_inaddr_loopback = {
-        .sin_family             = AF_INET,
-        .sin_addr.s_addr        = htonl(INADDR_LOOPBACK),
-        .sin_port               = htons(RPCBIND_PORT),
-};
+/*
+ * Returns zero on success, otherwise a negative errno value
+ * is returned.
+ */
+static int rpcb_create_local_unix(void)
+{
+        static const struct sockaddr_un rpcb_localaddr_rpcbind = {
+                .sun_family             = AF_LOCAL,
+                .sun_path               = RPCBIND_SOCK_PATHNAME,
+        };
+        struct rpc_create_args args = {
+                .net            = &init_net,
+                .protocol       = XPRT_TRANSPORT_LOCAL,
+                .address        = (struct sockaddr *)&rpcb_localaddr_rpcbind,
+                .addrsize       = sizeof(rpcb_localaddr_rpcbind),
+                .servername     = "localhost",
+                .program        = &rpcb_program,
+                .version        = RPCBVERS_2,
+                .authflavor     = RPC_AUTH_NULL,
+        };
+        struct rpc_clnt *clnt, *clnt4;
+        int result = 0;
+
+        /*
+         * Because we requested an RPC PING at transport creation time,
+         * this works only if the user space portmapper is rpcbind, and
+         * it's listening on AF_LOCAL on the named socket.
+         */
+        clnt = rpc_create(&args);
+        if (IS_ERR(clnt)) {
+                dprintk("RPC:       failed to create AF_LOCAL rpcbind "
+                                "client (errno %ld).\n", PTR_ERR(clnt));
+                result = -PTR_ERR(clnt);
+                goto out;
+        }
+
+        clnt4 = rpc_bind_new_program(clnt, &rpcb_program, RPCBVERS_4);
+        if (IS_ERR(clnt4)) {
+                dprintk("RPC:       failed to bind second program to "
+                                "rpcbind v4 client (errno %ld).\n",
+                                PTR_ERR(clnt4));
+                clnt4 = NULL;
+        }
+
+        /* Protected by rpcb_create_local_mutex */
+        rpcb_local_clnt = clnt;
+        rpcb_local_clnt4 = clnt4;
 
-static DEFINE_MUTEX(rpcb_create_local_mutex);
+out:
+        return result;
+}
 
 /*
  * Returns zero on success, otherwise a negative errno value
  * is returned.
  */
-static int rpcb_create_local(void)
+static int rpcb_create_local_net(void)
 {
+        static const struct sockaddr_in rpcb_inaddr_loopback = {
+                .sin_family             = AF_INET,
+                .sin_addr.s_addr        = htonl(INADDR_LOOPBACK),
+                .sin_port               = htons(RPCBIND_PORT),
+        };
         struct rpc_create_args args = {
                 .net            = &init_net,
                 .protocol       = XPRT_TRANSPORT_TCP,
@@ -186,13 +238,6 @@ static int rpcb_create_local(void)
         struct rpc_clnt *clnt, *clnt4;
         int result = 0;
 
-        if (rpcb_local_clnt)
-                return result;
-
-        mutex_lock(&rpcb_create_local_mutex);
-        if (rpcb_local_clnt)
-                goto out;
-
         clnt = rpc_create(&args);
         if (IS_ERR(clnt)) {
                 dprintk("RPC:       failed to create local rpcbind "
@@ -214,10 +259,34 @@ static int rpcb_create_local(void)
                 clnt4 = NULL;
         }
 
+        /* Protected by rpcb_create_local_mutex */
         rpcb_local_clnt = clnt;
         rpcb_local_clnt4 = clnt4;
 
 out:
+        return result;
+}
+
+/*
+ * Returns zero on success, otherwise a negative errno value
+ * is returned.
+ */
+static int rpcb_create_local(void)
+{
+        static DEFINE_MUTEX(rpcb_create_local_mutex);
+        int result = 0;
+
+        if (rpcb_local_clnt)
+                return result;
+
+        mutex_lock(&rpcb_create_local_mutex);
+        if (rpcb_local_clnt)
+                goto out;
+
+        if (rpcb_create_local_unix() != 0)
+                result = rpcb_create_local_net();
+
+out:
         mutex_unlock(&rpcb_create_local_mutex);
         return result;
 }
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index 08e05a8ce025..2b90292e9505 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -942,6 +942,8 @@ static void svc_unregister(const struct svc_serv *serv)
                         if (progp->pg_vers[i]->vs_hidden)
                                 continue;
 
+                        dprintk("svc: attempting to unregister %sv%u\n",
+                                progp->pg_name, i);
                         __svc_unregister(progp->pg_prog, i, progp->pg_name);
                 }
         }
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index b7d435c3f19e..af04f779ce9f 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -387,6 +387,33 @@ static int svc_recvfrom(struct svc_rqst *rqstp, struct kvec *iov, int nr,
         return len;
 }
 
+static int svc_partial_recvfrom(struct svc_rqst *rqstp,
+                                struct kvec *iov, int nr,
+                                int buflen, unsigned int base)
+{
+        size_t save_iovlen;
+        void __user *save_iovbase;
+        unsigned int i;
+        int ret;
+
+        if (base == 0)
+                return svc_recvfrom(rqstp, iov, nr, buflen);
+
+        for (i = 0; i < nr; i++) {
+                if (iov[i].iov_len > base)
+                        break;
+                base -= iov[i].iov_len;
+        }
+        save_iovlen = iov[i].iov_len;
+        save_iovbase = iov[i].iov_base;
+        iov[i].iov_len -= base;
+        iov[i].iov_base += base;
+        ret = svc_recvfrom(rqstp, &iov[i], nr - i, buflen);
+        iov[i].iov_len = save_iovlen;
+        iov[i].iov_base = save_iovbase;
+        return ret;
+}
+
 /*
  * Set socket snd and rcv buffer lengths
  */
@@ -409,7 +436,6 @@ static void svc_sock_setbufsize(struct socket *sock, unsigned int snd,
         lock_sock(sock->sk);
         sock->sk->sk_sndbuf = snd * 2;
         sock->sk->sk_rcvbuf = rcv * 2;
-        sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK|SOCK_RCVBUF_LOCK;
         sock->sk->sk_write_space(sock->sk);
         release_sock(sock->sk);
 #endif
@@ -884,6 +910,56 @@ failed:
         return NULL;
 }
 
+static unsigned int svc_tcp_restore_pages(struct svc_sock *svsk, struct svc_rqst *rqstp)
+{
+        unsigned int i, len, npages;
+
+        if (svsk->sk_tcplen <= sizeof(rpc_fraghdr))
+                return 0;
+        len = svsk->sk_tcplen - sizeof(rpc_fraghdr);
+        npages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        for (i = 0; i < npages; i++) {
+                if (rqstp->rq_pages[i] != NULL)
+                        put_page(rqstp->rq_pages[i]);
+                BUG_ON(svsk->sk_pages[i] == NULL);
+                rqstp->rq_pages[i] = svsk->sk_pages[i];
+                svsk->sk_pages[i] = NULL;
+        }
+        rqstp->rq_arg.head[0].iov_base = page_address(rqstp->rq_pages[0]);
+        return len;
+}
+
+static void svc_tcp_save_pages(struct svc_sock *svsk, struct svc_rqst *rqstp)
+{
+        unsigned int i, len, npages;
+
+        if (svsk->sk_tcplen <= sizeof(rpc_fraghdr))
+                return;
+        len = svsk->sk_tcplen - sizeof(rpc_fraghdr);
+        npages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        for (i = 0; i < npages; i++) {
+                svsk->sk_pages[i] = rqstp->rq_pages[i];
+                rqstp->rq_pages[i] = NULL;
+        }
+}
+
+static void svc_tcp_clear_pages(struct svc_sock *svsk)
+{
+        unsigned int i, len, npages;
+
+        if (svsk->sk_tcplen <= sizeof(rpc_fraghdr))
+                goto out;
+        len = svsk->sk_tcplen - sizeof(rpc_fraghdr);
+        npages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        for (i = 0; i < npages; i++) {
+                BUG_ON(svsk->sk_pages[i] == NULL);
+                put_page(svsk->sk_pages[i]);
+                svsk->sk_pages[i] = NULL;
+        }
+out:
+        svsk->sk_tcplen = 0;
+}
+
 /*
  * Receive data.
  * If we haven't gotten the record length yet, get the next four bytes.
@@ -893,31 +969,15 @@ failed:
 static int svc_tcp_recv_record(struct svc_sock *svsk, struct svc_rqst *rqstp)
 {
         struct svc_serv *serv = svsk->sk_xprt.xpt_server;
+        unsigned int want;
         int len;
 
-        if (test_and_clear_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags))
-                /* sndbuf needs to have room for one request
-                 * per thread, otherwise we can stall even when the
-                 * network isn't a bottleneck.
-                 *
-                 * We count all threads rather than threads in a
-                 * particular pool, which provides an upper bound
-                 * on the number of threads which will access the socket.
-                 *
-                 * rcvbuf just needs to be able to hold a few requests.
-                 * Normally they will be removed from the queue
-                 * as soon a a complete request arrives.
-                 */
-                svc_sock_setbufsize(svsk->sk_sock,
-                                    (serv->sv_nrthreads+3) * serv->sv_max_mesg,
-                                    3 * serv->sv_max_mesg);
-
         clear_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
 
         if (svsk->sk_tcplen < sizeof(rpc_fraghdr)) {
-                int             want = sizeof(rpc_fraghdr) - svsk->sk_tcplen;
                 struct kvec     iov;
 
+                want = sizeof(rpc_fraghdr) - svsk->sk_tcplen;
                 iov.iov_base = ((char *) &svsk->sk_reclen) + svsk->sk_tcplen;
                 iov.iov_len  = want;
                 if ((len = svc_recvfrom(rqstp, &iov, 1, want)) < 0)
@@ -927,7 +987,7 @@ static int svc_tcp_recv_record(struct svc_sock *svsk, struct svc_rqst *rqstp)
                 if (len < want) {
                         dprintk("svc: short recvfrom while reading record "
                                 "length (%d of %d)\n", len, want);
-                        goto err_again; /* record header not complete */
+                        return -EAGAIN;
                 }
 
                 svsk->sk_reclen = ntohl(svsk->sk_reclen);
@@ -954,83 +1014,75 @@ static int svc_tcp_recv_record(struct svc_sock *svsk, struct svc_rqst *rqstp)
                 }
         }
 
-        /* Check whether enough data is available */
-        len = svc_recv_available(svsk);
-        if (len < 0)
-                goto error;
+        if (svsk->sk_reclen < 8)
+                goto err_delete; /* client is nuts. */
 
-        if (len < svsk->sk_reclen) {
-                dprintk("svc: incomplete TCP record (%d of %d)\n",
-                        len, svsk->sk_reclen);
-                goto err_again; /* record not complete */
-        }
         len = svsk->sk_reclen;
-        set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
 
         return len;
- error:
-        if (len == -EAGAIN)
-                dprintk("RPC: TCP recv_record got EAGAIN\n");
+error:
+        dprintk("RPC: TCP recv_record got %d\n", len);
         return len;
- err_delete:
+err_delete:
         set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
- err_again:
         return -EAGAIN;
 }
 
-static int svc_process_calldir(struct svc_sock *svsk, struct svc_rqst *rqstp,
-                               struct rpc_rqst **reqpp, struct kvec *vec)
+static int receive_cb_reply(struct svc_sock *svsk, struct svc_rqst *rqstp)
 {
+        struct rpc_xprt *bc_xprt = svsk->sk_xprt.xpt_bc_xprt;
         struct rpc_rqst *req = NULL;
-        u32 *p;
-        u32 xid;
-        u32 calldir;
-        int len;
-
-        len = svc_recvfrom(rqstp, vec, 1, 8);
-        if (len < 0)
-                goto error;
+        struct kvec *src, *dst;
+        __be32 *p = (__be32 *)rqstp->rq_arg.head[0].iov_base;
+        __be32 xid;
+        __be32 calldir;
 
-        p = (u32 *)rqstp->rq_arg.head[0].iov_base;
         xid = *p++;
         calldir = *p;
 
-        if (calldir == 0) {
-                /* REQUEST is the most common case */
-                vec[0] = rqstp->rq_arg.head[0];
-        } else {
-                /* REPLY */
-                struct rpc_xprt *bc_xprt = svsk->sk_xprt.xpt_bc_xprt;
-
-                if (bc_xprt)
-                        req = xprt_lookup_rqst(bc_xprt, xid);
-
-                if (!req) {
-                        printk(KERN_NOTICE
-                                "%s: Got unrecognized reply: "
-                                "calldir 0x%x xpt_bc_xprt %p xid %08x\n",
-                                __func__, ntohl(calldir),
-                                bc_xprt, xid);
-                        vec[0] = rqstp->rq_arg.head[0];
-                        goto out;
-                }
+        if (bc_xprt)
+                req = xprt_lookup_rqst(bc_xprt, xid);
 
-                memcpy(&req->rq_private_buf, &req->rq_rcv_buf,
-                       sizeof(struct xdr_buf));
-                /* copy the xid and call direction */
-                memcpy(req->rq_private_buf.head[0].iov_base,
-                       rqstp->rq_arg.head[0].iov_base, 8);
-                vec[0] = req->rq_private_buf.head[0];
+        if (!req) {
+                printk(KERN_NOTICE
+                        "%s: Got unrecognized reply: "
+                        "calldir 0x%x xpt_bc_xprt %p xid %08x\n",
+                        __func__, ntohl(calldir),
+                        bc_xprt, xid);
+                return -EAGAIN;
         }
- out:
-        vec[0].iov_base += 8;
-        vec[0].iov_len -= 8;
-        len = svsk->sk_reclen - 8;
- error:
-        *reqpp = req;
-        return len;
+
+        memcpy(&req->rq_private_buf, &req->rq_rcv_buf, sizeof(struct xdr_buf));
+        /*
+         * XXX!: cheating for now!  Only copying HEAD.
+         * But we know this is good enough for now (in fact, for any
+         * callback reply in the forseeable future).
+         */
+        dst = &req->rq_private_buf.head[0];
+        src = &rqstp->rq_arg.head[0];
+        if (dst->iov_len < src->iov_len)
+                return -EAGAIN; /* whatever; just giving up. */
+        memcpy(dst->iov_base, src->iov_base, src->iov_len);
+        xprt_complete_rqst(req->rq_task, svsk->sk_reclen);
+        rqstp->rq_arg.len = 0;
+        return 0;
 }
 
+static int copy_pages_to_kvecs(struct kvec *vec, struct page **pages, int len)
+{
+        int i = 0;
+        int t = 0;
+
+        while (t < len) {
+                vec[i].iov_base = page_address(pages[i]);
+                vec[i].iov_len = PAGE_SIZE;
+                i++;
+                t += PAGE_SIZE;
+        }
+        return i;
+}
+
+
 /*
  * Receive data from a TCP socket.
  */
@@ -1041,8 +1093,10 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
         struct svc_serv *serv = svsk->sk_xprt.xpt_server;
         int             len;
         struct kvec *vec;
-        int pnum, vlen;
-        struct rpc_rqst *req = NULL;
+        unsigned int want, base;
+        __be32 *p;
+        __be32 calldir;
+        int pnum;
 
         dprintk("svc: tcp_recv %p data %d conn %d close %d\n",
                 svsk, test_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags),
@@ -1053,87 +1107,73 @@ static int svc_tcp_recvfrom(struct svc_rqst *rqstp)
         if (len < 0)
                 goto error;
 
+        base = svc_tcp_restore_pages(svsk, rqstp);
+        want = svsk->sk_reclen - base;
+
         vec = rqstp->rq_vec;
-        vec[0] = rqstp->rq_arg.head[0];
-        vlen = PAGE_SIZE;
 
-        /*
-         * We have enough data for the whole tcp record. Let's try and read the
-         * first 8 bytes to get the xid and the call direction. We can use this
-         * to figure out if this is a call or a reply to a callback. If
-         * sk_reclen is < 8 (xid and calldir), then this is a malformed packet.
-         * In that case, don't bother with the calldir and just read the data.
-         * It will be rejected in svc_process.
-         */
-        if (len >= 8) {
-                len = svc_process_calldir(svsk, rqstp, &req, vec);
-                if (len < 0)
-                        goto err_again;
-                vlen -= 8;
-        }
+        pnum = copy_pages_to_kvecs(&vec[0], &rqstp->rq_pages[0],
+                                                svsk->sk_reclen);
 
-        pnum = 1;
-        while (vlen < len) {
-                vec[pnum].iov_base = (req) ?
-                        page_address(req->rq_private_buf.pages[pnum - 1]) :
-                        page_address(rqstp->rq_pages[pnum]);
-                vec[pnum].iov_len = PAGE_SIZE;
-                pnum++;
-                vlen += PAGE_SIZE;
-        }
         rqstp->rq_respages = &rqstp->rq_pages[pnum];
 
         /* Now receive data */
-        len = svc_recvfrom(rqstp, vec, pnum, len);
-        if (len < 0)
-                goto err_again;
-
-        /*
-         * Account for the 8 bytes we read earlier
-         */
-        len += 8;
-
-        if (req) {
-                xprt_complete_rqst(req->rq_task, len);
-                len = 0;
-                goto out;
+        len = svc_partial_recvfrom(rqstp, vec, pnum, want, base);
+        if (len >= 0)
+                svsk->sk_tcplen += len;
+        if (len != want) {
+                if (len < 0 && len != -EAGAIN)
+                        goto err_other;
+                svc_tcp_save_pages(svsk, rqstp);
+                dprintk("svc: incomplete TCP record (%d of %d)\n",
+                        svsk->sk_tcplen, svsk->sk_reclen);
+                goto err_noclose;
         }
-        dprintk("svc: TCP complete record (%d bytes)\n", len);
-        rqstp->rq_arg.len = len;
+
+        rqstp->rq_arg.len = svsk->sk_reclen;
         rqstp->rq_arg.page_base = 0;
-        if (len <= rqstp->rq_arg.head[0].iov_len) {
-                rqstp->rq_arg.head[0].iov_len = len;
+        if (rqstp->rq_arg.len <= rqstp->rq_arg.head[0].iov_len) {
+                rqstp->rq_arg.head[0].iov_len = rqstp->rq_arg.len;
                 rqstp->rq_arg.page_len = 0;
-        } else {
-                rqstp->rq_arg.page_len = len - rqstp->rq_arg.head[0].iov_len;
-        }
+        } else
+                rqstp->rq_arg.page_len = rqstp->rq_arg.len - rqstp->rq_arg.head[0].iov_len;
 
         rqstp->rq_xprt_ctxt   = NULL;
         rqstp->rq_prot        = IPPROTO_TCP;
 
-out:
+        p = (__be32 *)rqstp->rq_arg.head[0].iov_base;
+        calldir = p[1];
+        if (calldir)
+                len = receive_cb_reply(svsk, rqstp);
+
         /* Reset TCP read info */
         svsk->sk_reclen = 0;
         svsk->sk_tcplen = 0;
+        /* If we have more data, signal svc_xprt_enqueue() to try again */
+        if (svc_recv_available(svsk) > sizeof(rpc_fraghdr))
+                set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
+
+        if (len < 0)
+                goto error;
 
         svc_xprt_copy_addrs(rqstp, &svsk->sk_xprt);
         if (serv->sv_stats)
                 serv->sv_stats->nettcpcnt++;
 
-        return len;
+        dprintk("svc: TCP complete record (%d bytes)\n", rqstp->rq_arg.len);
+        return rqstp->rq_arg.len;
 
-err_again:
-        if (len == -EAGAIN) {
-                dprintk("RPC: TCP recvfrom got EAGAIN\n");
-                return len;
-        }
 error:
-        if (len != -EAGAIN) {
-                printk(KERN_NOTICE "%s: recvfrom returned errno %d\n",
-                       svsk->sk_xprt.xpt_server->sv_name, -len);
-                set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
-        }
+        if (len != -EAGAIN)
+                goto err_other;
+        dprintk("RPC: TCP recvfrom got EAGAIN\n");
         return -EAGAIN;
+err_other:
+        printk(KERN_NOTICE "%s: recvfrom returned errno %d\n",
+               svsk->sk_xprt.xpt_server->sv_name, -len);
+        set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
+err_noclose:
+        return -EAGAIN; /* record not complete */
 }
 
 /*
@@ -1304,18 +1344,10 @@ static void svc_tcp_init(struct svc_sock *svsk, struct svc_serv *serv)
 
                 svsk->sk_reclen = 0;
                 svsk->sk_tcplen = 0;
+                memset(&svsk->sk_pages[0], 0, sizeof(svsk->sk_pages));
 
                 tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
 
-                /* initialise setting must have enough space to
-                 * receive and respond to one request.
-                 * svc_tcp_recvfrom will re-adjust if necessary
-                 */
-                svc_sock_setbufsize(svsk->sk_sock,
-                                    3 * svsk->sk_xprt.xpt_server->sv_max_mesg,
-                                    3 * svsk->sk_xprt.xpt_server->sv_max_mesg);
-
-                set_bit(XPT_CHNGBUF, &svsk->sk_xprt.xpt_flags);
                 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags);
                 if (sk->sk_state != TCP_ESTABLISHED)
                         set_bit(XPT_CLOSE, &svsk->sk_xprt.xpt_flags);
@@ -1379,8 +1411,14 @@ static struct svc_sock *svc_setup_socket(struct svc_serv *serv,
         /* Initialize the socket */
         if (sock->type == SOCK_DGRAM)
                 svc_udp_init(svsk, serv);
-        else
+        else {
+                /* initialise setting must have enough space to
+                 * receive and respond to one request.
+                 */
+                svc_sock_setbufsize(svsk->sk_sock, 4 * serv->sv_max_mesg,
+                                        4 * serv->sv_max_mesg);
                 svc_tcp_init(svsk, serv);
+        }
 
         dprintk("svc: svc_setup_socket created %p (inet %p)\n",
                                 svsk, svsk->sk_sk);
@@ -1562,8 +1600,10 @@ static void svc_tcp_sock_detach(struct svc_xprt *xprt)
 
         svc_sock_detach(xprt);
 
-        if (!test_bit(XPT_LISTENER, &xprt->xpt_flags))
+        if (!test_bit(XPT_LISTENER, &xprt->xpt_flags)) {
+                svc_tcp_clear_pages(svsk);
                 kernel_sock_shutdown(svsk->sk_sock, SHUT_RDWR);
+        }
 }
 
 /*
diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c
index 679cd674b81d..f008c14ad34c 100644
--- a/net/sunrpc/xdr.c
+++ b/net/sunrpc/xdr.c
@@ -638,6 +638,25 @@ void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf, __be32 *p)
 }
 EXPORT_SYMBOL_GPL(xdr_init_decode);
 
+/**
+ * xdr_init_decode - Initialize an xdr_stream for decoding data.
+ * @xdr: pointer to xdr_stream struct
+ * @buf: pointer to XDR buffer from which to decode data
+ * @pages: list of pages to decode into
+ * @len: length in bytes of buffer in pages
+ */
+void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
+                           struct page **pages, unsigned int len)
+{
+        memset(buf, 0, sizeof(*buf));
+        buf->pages =  pages;
+        buf->page_len =  len;
+        buf->buflen =  len;
+        buf->len = len;
+        xdr_init_decode(xdr, buf, NULL);
+}
+EXPORT_SYMBOL_GPL(xdr_init_decode_pages);
+
 static __be32 * __xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes)
 {
         __be32 *p = xdr->p;
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index bf005d3c65ef..72abb7358933 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -19,6 +19,7 @@
  */
 
 #include <linux/types.h>
+#include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/capability.h>
@@ -28,6 +29,7 @@
 #include <linux/in.h>
 #include <linux/net.h>
 #include <linux/mm.h>
+#include <linux/un.h>
 #include <linux/udp.h>
 #include <linux/tcp.h>
 #include <linux/sunrpc/clnt.h>
@@ -45,6 +47,9 @@
 #include <net/tcp.h>
 
 #include "sunrpc.h"
+
+static void xs_close(struct rpc_xprt *xprt);
+
 /*
  * xprtsock tunables
  */
@@ -261,6 +266,11 @@ static inline struct sockaddr *xs_addr(struct rpc_xprt *xprt)
         return (struct sockaddr *) &xprt->addr;
 }
 
+static inline struct sockaddr_un *xs_addr_un(struct rpc_xprt *xprt)
+{
+        return (struct sockaddr_un *) &xprt->addr;
+}
+
 static inline struct sockaddr_in *xs_addr_in(struct rpc_xprt *xprt)
 {
         return (struct sockaddr_in *) &xprt->addr;
@@ -276,23 +286,34 @@ static void xs_format_common_peer_addresses(struct rpc_xprt *xprt)
         struct sockaddr *sap = xs_addr(xprt);
         struct sockaddr_in6 *sin6;
         struct sockaddr_in *sin;
+        struct sockaddr_un *sun;
         char buf[128];
 
-        (void)rpc_ntop(sap, buf, sizeof(buf));
-        xprt->address_strings[RPC_DISPLAY_ADDR] = kstrdup(buf, GFP_KERNEL);
-
         switch (sap->sa_family) {
+        case AF_LOCAL:
+                sun = xs_addr_un(xprt);
+                strlcpy(buf, sun->sun_path, sizeof(buf));
+                xprt->address_strings[RPC_DISPLAY_ADDR] =
+                                                kstrdup(buf, GFP_KERNEL);
+                break;
         case AF_INET:
+                (void)rpc_ntop(sap, buf, sizeof(buf));
+                xprt->address_strings[RPC_DISPLAY_ADDR] =
+                                                kstrdup(buf, GFP_KERNEL);
                 sin = xs_addr_in(xprt);
                 snprintf(buf, sizeof(buf), "%08x", ntohl(sin->sin_addr.s_addr));
                 break;
         case AF_INET6:
+                (void)rpc_ntop(sap, buf, sizeof(buf));
+                xprt->address_strings[RPC_DISPLAY_ADDR] =
+                                                kstrdup(buf, GFP_KERNEL);
                 sin6 = xs_addr_in6(xprt);
                 snprintf(buf, sizeof(buf), "%pi6", &sin6->sin6_addr);
                 break;
         default:
                 BUG();
         }
+
         xprt->address_strings[RPC_DISPLAY_HEX_ADDR] = kstrdup(buf, GFP_KERNEL);
 }
 
@@ -495,6 +516,70 @@ static int xs_nospace(struct rpc_task *task)
         return ret;
 }
 
+/*
+ * Construct a stream transport record marker in @buf.
+ */
+static inline void xs_encode_stream_record_marker(struct xdr_buf *buf)
+{
+        u32 reclen = buf->len - sizeof(rpc_fraghdr);
+        rpc_fraghdr *base = buf->head[0].iov_base;
+        *base = cpu_to_be32(RPC_LAST_STREAM_FRAGMENT | reclen);
+}
+
+/**
+ * xs_local_send_request - write an RPC request to an AF_LOCAL socket
+ * @task: RPC task that manages the state of an RPC request
+ *
+ * Return values:
+ *        0:    The request has been sent
+ *   EAGAIN:    The socket was blocked, please call again later to
+ *              complete the request
+ * ENOTCONN:    Caller needs to invoke connect logic then call again
+ *    other:    Some other error occured, the request was not sent
+ */
+static int xs_local_send_request(struct rpc_task *task)
+{
+        struct rpc_rqst *req = task->tk_rqstp;
+        struct rpc_xprt *xprt = req->rq_xprt;
+        struct sock_xprt *transport =
+                                container_of(xprt, struct sock_xprt, xprt);
+        struct xdr_buf *xdr = &req->rq_snd_buf;
+        int status;
+
+        xs_encode_stream_record_marker(&req->rq_snd_buf);
+
+        xs_pktdump("packet data:",
+                        req->rq_svec->iov_base, req->rq_svec->iov_len);
+
+        status = xs_sendpages(transport->sock, NULL, 0,
+                                                xdr, req->rq_bytes_sent);
+        dprintk("RPC:       %s(%u) = %d\n",
+                        __func__, xdr->len - req->rq_bytes_sent, status);
+        if (likely(status >= 0)) {
+                req->rq_bytes_sent += status;
+                req->rq_xmit_bytes_sent += status;
+                if (likely(req->rq_bytes_sent >= req->rq_slen)) {
+                        req->rq_bytes_sent = 0;
+                        return 0;
+                }
+                status = -EAGAIN;
+        }
+
+        switch (status) {
+        case -EAGAIN:
+                status = xs_nospace(task);
+                break;
+        default:
+                dprintk("RPC:       sendmsg returned unrecognized error %d\n",
+                        -status);
+        case -EPIPE:
+                xs_close(xprt);
+                status = -ENOTCONN;
+        }
+
+        return status;
+}
+
 /**
  * xs_udp_send_request - write an RPC request to a UDP socket
  * @task: address of RPC task that manages the state of an RPC request
@@ -574,13 +659,6 @@ static void xs_tcp_shutdown(struct rpc_xprt *xprt)
                 kernel_sock_shutdown(sock, SHUT_WR);
 }
 
-static inline void xs_encode_tcp_record_marker(struct xdr_buf *buf)
-{
-        u32 reclen = buf->len - sizeof(rpc_fraghdr);
-        rpc_fraghdr *base = buf->head[0].iov_base;
-        *base = htonl(RPC_LAST_STREAM_FRAGMENT | reclen);
-}
-
 /**
  * xs_tcp_send_request - write an RPC request to a TCP socket
  * @task: address of RPC task that manages the state of an RPC request
@@ -603,7 +681,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
         struct xdr_buf *xdr = &req->rq_snd_buf;
         int status;
 
-        xs_encode_tcp_record_marker(&req->rq_snd_buf);
+        xs_encode_stream_record_marker(&req->rq_snd_buf);
 
         xs_pktdump("packet data:",
                                 req->rq_svec->iov_base,
@@ -785,6 +863,88 @@ static inline struct rpc_xprt *xprt_from_sock(struct sock *sk)
         return (struct rpc_xprt *) sk->sk_user_data;
 }
 
+static int xs_local_copy_to_xdr(struct xdr_buf *xdr, struct sk_buff *skb)
+{
+        struct xdr_skb_reader desc = {
+                .skb            = skb,
+                .offset         = sizeof(rpc_fraghdr),
+                .count          = skb->len - sizeof(rpc_fraghdr),
+        };
+
+        if (xdr_partial_copy_from_skb(xdr, 0, &desc, xdr_skb_read_bits) < 0)
+                return -1;
+        if (desc.count)
+                return -1;
+        return 0;
+}
+
+/**
+ * xs_local_data_ready - "data ready" callback for AF_LOCAL sockets
+ * @sk: socket with data to read
+ * @len: how much data to read
+ *
+ * Currently this assumes we can read the whole reply in a single gulp.
+ */
+static void xs_local_data_ready(struct sock *sk, int len)
+{
+        struct rpc_task *task;
+        struct rpc_xprt *xprt;
+        struct rpc_rqst *rovr;
+        struct sk_buff *skb;
+        int err, repsize, copied;
+        u32 _xid;
+        __be32 *xp;
+
+        read_lock_bh(&sk->sk_callback_lock);
+        dprintk("RPC:       %s...\n", __func__);
+        xprt = xprt_from_sock(sk);
+        if (xprt == NULL)
+                goto out;
+
+        skb = skb_recv_datagram(sk, 0, 1, &err);
+        if (skb == NULL)
+                goto out;
+
+        if (xprt->shutdown)
+                goto dropit;
+
+        repsize = skb->len - sizeof(rpc_fraghdr);
+        if (repsize < 4) {
+                dprintk("RPC:       impossible RPC reply size %d\n", repsize);
+                goto dropit;
+        }
+
+        /* Copy the XID from the skb... */
+        xp = skb_header_pointer(skb, sizeof(rpc_fraghdr), sizeof(_xid), &_xid);
+        if (xp == NULL)
+                goto dropit;
+
+        /* Look up and lock the request corresponding to the given XID */
+        spin_lock(&xprt->transport_lock);
+        rovr = xprt_lookup_rqst(xprt, *xp);
+        if (!rovr)
+                goto out_unlock;
+        task = rovr->rq_task;
+
+        copied = rovr->rq_private_buf.buflen;
+        if (copied > repsize)
+                copied = repsize;
+
+        if (xs_local_copy_to_xdr(&rovr->rq_private_buf, skb)) {
+                dprintk("RPC:       sk_buff copy failed\n");
+                goto out_unlock;
+        }
+
+        xprt_complete_rqst(task, copied);
+
+ out_unlock:
+        spin_unlock(&xprt->transport_lock);
+ dropit:
+        skb_free_datagram(sk, skb);
+ out:
+        read_unlock_bh(&sk->sk_callback_lock);
+}
+
 /**
  * xs_udp_data_ready - "data ready" callback for UDP sockets
  * @sk: socket with data to read
@@ -1344,7 +1504,6 @@ static void xs_tcp_state_change(struct sock *sk)
         case TCP_CLOSE_WAIT:
                 /* The server initiated a shutdown of the socket */
                 xprt_force_disconnect(xprt);
-        case TCP_SYN_SENT:
                 xprt->connect_cookie++;
         case TCP_CLOSING:
                 /*
@@ -1571,11 +1730,31 @@ static int xs_bind(struct sock_xprt *transport, struct socket *sock)
         return err;
 }
 
+/*
+ * We don't support autobind on AF_LOCAL sockets
+ */
+static void xs_local_rpcbind(struct rpc_task *task)
+{
+        xprt_set_bound(task->tk_xprt);
+}
+
+static void xs_local_set_port(struct rpc_xprt *xprt, unsigned short port)
+{
+}
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 static struct lock_class_key xs_key[2];
 static struct lock_class_key xs_slock_key[2];
 
+static inline void xs_reclassify_socketu(struct socket *sock)
+{
+        struct sock *sk = sock->sk;
+
+        BUG_ON(sock_owned_by_user(sk));
+        sock_lock_init_class_and_name(sk, "slock-AF_LOCAL-RPC",
+                &xs_slock_key[1], "sk_lock-AF_LOCAL-RPC", &xs_key[1]);
+}
+
 static inline void xs_reclassify_socket4(struct socket *sock)
 {
         struct sock *sk = sock->sk;
@@ -1597,6 +1776,9 @@ static inline void xs_reclassify_socket6(struct socket *sock)
 static inline void xs_reclassify_socket(int family, struct socket *sock)
 {
         switch (family) {
+        case AF_LOCAL:
+                xs_reclassify_socketu(sock);
+                break;
         case AF_INET:
                 xs_reclassify_socket4(sock);
                 break;
@@ -1606,6 +1788,10 @@ static inline void xs_reclassify_socket(int family, struct socket *sock)
         }
 }
 #else
+static inline void xs_reclassify_socketu(struct socket *sock)
+{
+}
+
 static inline void xs_reclassify_socket4(struct socket *sock)
 {
 }
@@ -1644,6 +1830,94 @@ out:
         return ERR_PTR(err);
 }
 
+static int xs_local_finish_connecting(struct rpc_xprt *xprt,
+                                      struct socket *sock)
+{
+        struct sock_xprt *transport = container_of(xprt, struct sock_xprt,
+                                                                        xprt);
+
+        if (!transport->inet) {
+                struct sock *sk = sock->sk;
+
+                write_lock_bh(&sk->sk_callback_lock);
+
+                xs_save_old_callbacks(transport, sk);
+
+                sk->sk_user_data = xprt;
+                sk->sk_data_ready = xs_local_data_ready;
+                sk->sk_write_space = xs_udp_write_space;
+                sk->sk_error_report = xs_error_report;
+                sk->sk_allocation = GFP_ATOMIC;
+
+                xprt_clear_connected(xprt);
+
+                /* Reset to new socket */
+                transport->sock = sock;
+                transport->inet = sk;
+
+                write_unlock_bh(&sk->sk_callback_lock);
+        }
+
+        /* Tell the socket layer to start connecting... */
+        xprt->stat.connect_count++;
+        xprt->stat.connect_start = jiffies;
+        return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, 0);
+}
+
+/**
+ * xs_local_setup_socket - create AF_LOCAL socket, connect to a local endpoint
+ * @xprt: RPC transport to connect
+ * @transport: socket transport to connect
+ * @create_sock: function to create a socket of the correct type
+ *
+ * Invoked by a work queue tasklet.
+ */
+static void xs_local_setup_socket(struct work_struct *work)
+{
+        struct sock_xprt *transport =
+                container_of(work, struct sock_xprt, connect_worker.work);
+        struct rpc_xprt *xprt = &transport->xprt;
+        struct socket *sock;
+        int status = -EIO;
+
+        if (xprt->shutdown)
+                goto out;
+
+        clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
+        status = __sock_create(xprt->xprt_net, AF_LOCAL,
+                                        SOCK_STREAM, 0, &sock, 1);
+        if (status < 0) {
+                dprintk("RPC:       can't create AF_LOCAL "
+                        "transport socket (%d).\n", -status);
+                goto out;
+        }
+        xs_reclassify_socketu(sock);
+
+        dprintk("RPC:       worker connecting xprt %p via AF_LOCAL to %s\n",
+                        xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
+
+        status = xs_local_finish_connecting(xprt, sock);
+        switch (status) {
+        case 0:
+                dprintk("RPC:       xprt %p connected to %s\n",
+                                xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
+                xprt_set_connected(xprt);
+                break;
+        case -ENOENT:
+                dprintk("RPC:       xprt %p: socket %s does not exist\n",
+                                xprt, xprt->address_strings[RPC_DISPLAY_ADDR]);
+                break;
+        default:
+                printk(KERN_ERR "%s: unhandled error (%d) connecting to %s\n",
+                                __func__, -status,
+                                xprt->address_strings[RPC_DISPLAY_ADDR]);
+        }
+
+out:
+        xprt_clear_connecting(xprt);
+        xprt_wake_pending_tasks(xprt, status);
+}
+
 static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
 {
         struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
@@ -1758,6 +2032,7 @@ static void xs_tcp_reuse_connection(struct sock_xprt *transport)
 static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
 {
         struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
+        int ret = -ENOTCONN;
 
         if (!transport->inet) {
                 struct sock *sk = sock->sk;
@@ -1789,12 +2064,22 @@ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
         }
 
         if (!xprt_bound(xprt))
-                return -ENOTCONN;
+                goto out;
 
         /* Tell the socket layer to start connecting... */
         xprt->stat.connect_count++;
         xprt->stat.connect_start = jiffies;
-        return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
+        ret = kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
+        switch (ret) {
+        case 0:
+        case -EINPROGRESS:
+                /* SYN_SENT! */
+                xprt->connect_cookie++;
+                if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
+                        xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
+        }
+out:
+        return ret;
 }
 
 /**
@@ -1917,6 +2202,32 @@ static void xs_connect(struct rpc_task *task)
 }
 
 /**
+ * xs_local_print_stats - display AF_LOCAL socket-specifc stats
+ * @xprt: rpc_xprt struct containing statistics
+ * @seq: output file
+ *
+ */
+static void xs_local_print_stats(struct rpc_xprt *xprt, struct seq_file *seq)
+{
+        long idle_time = 0;
+
+        if (xprt_connected(xprt))
+                idle_time = (long)(jiffies - xprt->last_used) / HZ;
+
+        seq_printf(seq, "\txprt:\tlocal %lu %lu %lu %ld %lu %lu %lu "
+                        "%llu %llu\n",
+                        xprt->stat.bind_count,
+                        xprt->stat.connect_count,
+                        xprt->stat.connect_time,
+                        idle_time,
+                        xprt->stat.sends,
+                        xprt->stat.recvs,
+                        xprt->stat.bad_xids,
+                        xprt->stat.req_u,
+                        xprt->stat.bklog_u);
+}
+
+/**
  * xs_udp_print_stats - display UDP socket-specifc stats
  * @xprt: rpc_xprt struct containing statistics
  * @seq: output file
@@ -2014,10 +2325,7 @@ static int bc_sendto(struct rpc_rqst *req)
         unsigned long headoff;
         unsigned long tailoff;
 
-        /*
-         * Set up the rpc header and record marker stuff
-         */
-        xs_encode_tcp_record_marker(xbufp);
+        xs_encode_stream_record_marker(xbufp);
 
         tailoff = (unsigned long)xbufp->tail[0].iov_base & ~PAGE_MASK;
         headoff = (unsigned long)xbufp->head[0].iov_base & ~PAGE_MASK;
@@ -2089,6 +2397,21 @@ static void bc_destroy(struct rpc_xprt *xprt)
 {
 }
 
+static struct rpc_xprt_ops xs_local_ops = {
+        .reserve_xprt           = xprt_reserve_xprt,
+        .release_xprt           = xs_tcp_release_xprt,
+        .rpcbind                = xs_local_rpcbind,
+        .set_port               = xs_local_set_port,
+        .connect                = xs_connect,
+        .buf_alloc              = rpc_malloc,
+        .buf_free               = rpc_free,
+        .send_request           = xs_local_send_request,
+        .set_retrans_timeout    = xprt_set_retrans_timeout_def,
+        .close                  = xs_close,
+        .destroy                = xs_destroy,
+        .print_stats            = xs_local_print_stats,
+};
+
 static struct rpc_xprt_ops xs_udp_ops = {
         .set_buffer_size        = xs_udp_set_buffer_size,
         .reserve_xprt           = xprt_reserve_xprt_cong,
@@ -2150,6 +2473,8 @@ static int xs_init_anyaddr(const int family, struct sockaddr *sap)
         };
 
         switch (family) {
+        case AF_LOCAL:
+                break;
         case AF_INET:
                 memcpy(sap, &sin, sizeof(sin));
                 break;
@@ -2197,6 +2522,70 @@ static struct rpc_xprt *xs_setup_xprt(struct xprt_create *args,
         return xprt;
 }
 
+static const struct rpc_timeout xs_local_default_timeout = {
+        .to_initval = 10 * HZ,
+        .to_maxval = 10 * HZ,
+        .to_retries = 2,
+};
+
+/**
+ * xs_setup_local - Set up transport to use an AF_LOCAL socket
+ * @args: rpc transport creation arguments
+ *
+ * AF_LOCAL is a "tpi_cots_ord" transport, just like TCP
+ */
+static struct rpc_xprt *xs_setup_local(struct xprt_create *args)
+{
+        struct sockaddr_un *sun = (struct sockaddr_un *)args->dstaddr;
+        struct sock_xprt *transport;
+        struct rpc_xprt *xprt;
+        struct rpc_xprt *ret;
+
+        xprt = xs_setup_xprt(args, xprt_tcp_slot_table_entries);
+        if (IS_ERR(xprt))
+                return xprt;
+        transport = container_of(xprt, struct sock_xprt, xprt);
+
+        xprt->prot = 0;
+        xprt->tsh_size = sizeof(rpc_fraghdr) / sizeof(u32);
+        xprt->max_payload = RPC_MAX_FRAGMENT_SIZE;
+
+        xprt->bind_timeout = XS_BIND_TO;
+        xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
+        xprt->idle_timeout = XS_IDLE_DISC_TO;
+
+        xprt->ops = &xs_local_ops;
+        xprt->timeout = &xs_local_default_timeout;
+
+        switch (sun->sun_family) {
+        case AF_LOCAL:
+                if (sun->sun_path[0] != '/') {
+                        dprintk("RPC:       bad AF_LOCAL address: %s\n",
+                                        sun->sun_path);
+                        ret = ERR_PTR(-EINVAL);
+                        goto out_err;
+                }
+                xprt_set_bound(xprt);
+                INIT_DELAYED_WORK(&transport->connect_worker,
+                                        xs_local_setup_socket);
+                xs_format_peer_addresses(xprt, "local", RPCBIND_NETID_LOCAL);
+                break;
+        default:
+                ret = ERR_PTR(-EAFNOSUPPORT);
+                goto out_err;
+        }
+
+        dprintk("RPC:       set up xprt to %s via AF_LOCAL\n",
+                        xprt->address_strings[RPC_DISPLAY_ADDR]);
+
+        if (try_module_get(THIS_MODULE))
+                return xprt;
+        ret = ERR_PTR(-EINVAL);
+out_err:
+        xprt_free(xprt);
+        return ret;
+}
+
 static const struct rpc_timeout xs_udp_default_timeout = {
         .to_initval = 5 * HZ,
         .to_maxval = 30 * HZ,
@@ -2438,6 +2827,14 @@ out_err:
         return ret;
 }
 
+static struct xprt_class        xs_local_transport = {
+        .list           = LIST_HEAD_INIT(xs_local_transport.list),
+        .name           = "named UNIX socket",
+        .owner          = THIS_MODULE,
+        .ident          = XPRT_TRANSPORT_LOCAL,
+        .setup          = xs_setup_local,
+};
+
 static struct xprt_class        xs_udp_transport = {
         .list           = LIST_HEAD_INIT(xs_udp_transport.list),
         .name           = "udp",
@@ -2473,6 +2870,7 @@ int init_socket_xprt(void)
                 sunrpc_table_header = register_sysctl_table(sunrpc_table);
 #endif
 
+        xprt_register_transport(&xs_local_transport);
         xprt_register_transport(&xs_udp_transport);
         xprt_register_transport(&xs_tcp_transport);
         xprt_register_transport(&xs_bc_tcp_transport);
@@ -2493,6 +2891,7 @@ void cleanup_socket_xprt(void)
         }
 #endif
 
+        xprt_unregister_transport(&xs_local_transport);
         xprt_unregister_transport(&xs_udp_transport);
         xprt_unregister_transport(&xs_tcp_transport);
         xprt_unregister_transport(&xs_bc_tcp_transport);