Merge branch 'master' into upstream

202 files changed, 7332 insertions, 3278 deletions

diff --git a/arch/frv/Makefile b/arch/frv/Makefile
index d163747d17c0..038e3a8457e0 100644
--- a/arch/frv/Makefile
+++ b/arch/frv/Makefile
@@ -108,11 +108,8 @@ Image: vmlinux
 bootstrap:
         $(Q)$(MAKEBOOT) bootstrap
 
-archmrproper:
-        $(Q)$(MAKE) $(build)=arch/frv/boot mrproper
-
 archclean:
-        $(Q)$(MAKE) $(build)=arch/frv/boot clean
+        $(Q)$(MAKE) $(clean)=arch/frv/boot
 
 archdep: scripts/mkdep symlinks
         $(Q)$(MAKE) $(build)=arch/frv/boot dep
diff --git a/arch/frv/boot/Makefile b/arch/frv/boot/Makefile
index 5dfc93fd945a..dc6f03824423 100644
--- a/arch/frv/boot/Makefile
+++ b/arch/frv/boot/Makefile
@@ -8,6 +8,8 @@
 # Copyright (C) 1995-2000 Russell King
 #
 
+targets := Image zImage bootpImage
+
 SYSTEM  =$(TOPDIR)/$(LINUX)
 
 ZTEXTADDR        = 0x02080000
@@ -66,7 +68,6 @@ zinstall: $(CONFIGURE) zImage
 # miscellany
 #
 mrproper clean:
-        $(RM) Image zImage bootpImage
 #       @$(MAKE) -C compressed clean
 #       @$(MAKE) -C bootp clean
 
diff --git a/arch/i386/crypto/Makefile b/arch/i386/crypto/Makefile
index 103c353d0a63..3fd19af18e34 100644
--- a/arch/i386/crypto/Makefile
+++ b/arch/i386/crypto/Makefile
@@ -5,5 +5,8 @@
 # 
 
 obj-$(CONFIG_CRYPTO_AES_586) += aes-i586.o
+obj-$(CONFIG_CRYPTO_TWOFISH_586) += twofish-i586.o
 
 aes-i586-y := aes-i586-asm.o aes.o
+twofish-i586-y := twofish-i586-asm.o twofish.o
+
diff --git a/arch/i386/crypto/aes.c b/arch/i386/crypto/aes.c
index d3806daa3de3..49aad9397f10 100644
--- a/arch/i386/crypto/aes.c
+++ b/arch/i386/crypto/aes.c
@@ -379,12 +379,13 @@ static void gen_tabs(void)
 }
 
 static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
-                       unsigned int key_len, u32 *flags)
+                       unsigned int key_len)
 {
         int i;
         u32 ss[8];
         struct aes_ctx *ctx = crypto_tfm_ctx(tfm);
         const __le32 *key = (const __le32 *)in_key;
+        u32 *flags = &tfm->crt_flags;
 
         /* encryption schedule */
         
diff --git a/arch/i386/crypto/twofish-i586-asm.S b/arch/i386/crypto/twofish-i586-asm.S
new file mode 100644
index 000000000000..39b98ed2c1b9
--- /dev/null
+++ b/arch/i386/crypto/twofish-i586-asm.S
@@ -0,0 +1,335 @@
+/***************************************************************************
+*   Copyright (C) 2006 by Joachim Fritschi, <jfritschi@freenet.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.,                                       *
+*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+***************************************************************************/
+
+.file "twofish-i586-asm.S"
+.text
+
+#include <asm/asm-offsets.h>
+
+/* return adress at 0 */
+
+#define in_blk    12  /* input byte array address parameter*/
+#define out_blk   8  /* output byte array address parameter*/
+#define tfm       4  /* Twofish context structure */
+
+#define a_offset        0
+#define b_offset        4
+#define c_offset        8
+#define d_offset        12
+
+/* Structure of the crypto context struct*/
+
+#define s0      0       /* S0 Array 256 Words each */
+#define s1      1024    /* S1 Array */
+#define s2      2048    /* S2 Array */
+#define s3      3072    /* S3 Array */
+#define w       4096    /* 8 whitening keys (word) */
+#define k       4128    /* key 1-32 ( word ) */
+
+/* define a few register aliases to allow macro substitution */
+
+#define R0D    %eax
+#define R0B    %al
+#define R0H    %ah
+
+#define R1D    %ebx
+#define R1B    %bl
+#define R1H    %bh
+
+#define R2D    %ecx
+#define R2B    %cl
+#define R2H    %ch
+
+#define R3D    %edx
+#define R3B    %dl
+#define R3H    %dh
+
+
+/* performs input whitening */
+#define input_whitening(src,context,offset)\
+        xor     w+offset(context),      src;
+
+/* performs input whitening */
+#define output_whitening(src,context,offset)\
+        xor     w+16+offset(context),   src;
+
+/*
+ * a input register containing a (rotated 16)
+ * b input register containing b
+ * c input register containing c
+ * d input register containing d (already rol $1)
+ * operations on a and b are interleaved to increase performance
+ */
+#define encrypt_round(a,b,c,d,round)\
+        push    d ## D;\
+        movzx   b ## B,         %edi;\
+        mov     s1(%ebp,%edi,4),d ## D;\
+        movzx   a ## B,         %edi;\
+        mov     s2(%ebp,%edi,4),%esi;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     s2(%ebp,%edi,4),d ## D;\
+        movzx   a ## H,         %edi;\
+        ror     $16,            a ## D;\
+        xor     s3(%ebp,%edi,4),%esi;\
+        movzx   b ## B,         %edi;\
+        xor     s3(%ebp,%edi,4),d ## D;\
+        movzx   a ## B,         %edi;\
+        xor     (%ebp,%edi,4),  %esi;\
+        movzx   b ## H,         %edi;\
+        ror     $15,            b ## D;\
+        xor     (%ebp,%edi,4),  d ## D;\
+        movzx   a ## H,         %edi;\
+        xor     s1(%ebp,%edi,4),%esi;\
+        pop     %edi;\
+        add     d ## D,         %esi;\
+        add     %esi,           d ## D;\
+        add     k+round(%ebp),  %esi;\
+        xor     %esi,           c ## D;\
+        rol     $15,            c ## D;\
+        add     k+4+round(%ebp),d ## D;\
+        xor     %edi,           d ## D;
+
+/*
+ * a input register containing a (rotated 16)
+ * b input register containing b
+ * c input register containing c
+ * d input register containing d (already rol $1)
+ * operations on a and b are interleaved to increase performance
+ * last round has different rotations for the output preparation
+ */
+#define encrypt_last_round(a,b,c,d,round)\
+        push    d ## D;\
+        movzx   b ## B,         %edi;\
+        mov     s1(%ebp,%edi,4),d ## D;\
+        movzx   a ## B,         %edi;\
+        mov     s2(%ebp,%edi,4),%esi;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     s2(%ebp,%edi,4),d ## D;\
+        movzx   a ## H,         %edi;\
+        ror     $16,            a ## D;\
+        xor     s3(%ebp,%edi,4),%esi;\
+        movzx   b ## B,         %edi;\
+        xor     s3(%ebp,%edi,4),d ## D;\
+        movzx   a ## B,         %edi;\
+        xor     (%ebp,%edi,4),  %esi;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     (%ebp,%edi,4),  d ## D;\
+        movzx   a ## H,         %edi;\
+        xor     s1(%ebp,%edi,4),%esi;\
+        pop     %edi;\
+        add     d ## D,         %esi;\
+        add     %esi,           d ## D;\
+        add     k+round(%ebp),  %esi;\
+        xor     %esi,           c ## D;\
+        ror     $1,             c ## D;\
+        add     k+4+round(%ebp),d ## D;\
+        xor     %edi,           d ## D;
+
+/*
+ * a input register containing a
+ * b input register containing b (rotated 16)
+ * c input register containing c
+ * d input register containing d (already rol $1)
+ * operations on a and b are interleaved to increase performance
+ */
+#define decrypt_round(a,b,c,d,round)\
+        push    c ## D;\
+        movzx   a ## B,         %edi;\
+        mov     (%ebp,%edi,4),  c ## D;\
+        movzx   b ## B,         %edi;\
+        mov     s3(%ebp,%edi,4),%esi;\
+        movzx   a ## H,         %edi;\
+        ror     $16,            a ## D;\
+        xor     s1(%ebp,%edi,4),c ## D;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     (%ebp,%edi,4),  %esi;\
+        movzx   a ## B,         %edi;\
+        xor     s2(%ebp,%edi,4),c ## D;\
+        movzx   b ## B,         %edi;\
+        xor     s1(%ebp,%edi,4),%esi;\
+        movzx   a ## H,         %edi;\
+        ror     $15,            a ## D;\
+        xor     s3(%ebp,%edi,4),c ## D;\
+        movzx   b ## H,         %edi;\
+        xor     s2(%ebp,%edi,4),%esi;\
+        pop     %edi;\
+        add     %esi,           c ## D;\
+        add     c ## D,         %esi;\
+        add     k+round(%ebp),  c ## D;\
+        xor     %edi,           c ## D;\
+        add     k+4+round(%ebp),%esi;\
+        xor     %esi,           d ## D;\
+        rol     $15,            d ## D;
+
+/*
+ * a input register containing a
+ * b input register containing b (rotated 16)
+ * c input register containing c
+ * d input register containing d (already rol $1)
+ * operations on a and b are interleaved to increase performance
+ * last round has different rotations for the output preparation
+ */
+#define decrypt_last_round(a,b,c,d,round)\
+        push    c ## D;\
+        movzx   a ## B,         %edi;\
+        mov     (%ebp,%edi,4),  c ## D;\
+        movzx   b ## B,         %edi;\
+        mov     s3(%ebp,%edi,4),%esi;\
+        movzx   a ## H,         %edi;\
+        ror     $16,            a ## D;\
+        xor     s1(%ebp,%edi,4),c ## D;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     (%ebp,%edi,4),  %esi;\
+        movzx   a ## B,         %edi;\
+        xor     s2(%ebp,%edi,4),c ## D;\
+        movzx   b ## B,         %edi;\
+        xor     s1(%ebp,%edi,4),%esi;\
+        movzx   a ## H,         %edi;\
+        ror     $16,            a ## D;\
+        xor     s3(%ebp,%edi,4),c ## D;\
+        movzx   b ## H,         %edi;\
+        xor     s2(%ebp,%edi,4),%esi;\
+        pop     %edi;\
+        add     %esi,           c ## D;\
+        add     c ## D,         %esi;\
+        add     k+round(%ebp),  c ## D;\
+        xor     %edi,           c ## D;\
+        add     k+4+round(%ebp),%esi;\
+        xor     %esi,           d ## D;\
+        ror     $1,             d ## D;
+
+.align 4
+.global twofish_enc_blk
+.global twofish_dec_blk
+
+twofish_enc_blk:
+        push    %ebp                    /* save registers according to calling convention*/
+        push    %ebx
+        push    %esi
+        push    %edi
+
+        mov     tfm + 16(%esp), %ebp    /* abuse the base pointer: set new base bointer to the crypto tfm */
+        add     $crypto_tfm_ctx_offset, %ebp    /* ctx adress */
+        mov     in_blk+16(%esp),%edi    /* input adress in edi */
+
+        mov     (%edi),         %eax
+        mov     b_offset(%edi), %ebx
+        mov     c_offset(%edi), %ecx
+        mov     d_offset(%edi), %edx
+        input_whitening(%eax,%ebp,a_offset)
+        ror     $16,    %eax
+        input_whitening(%ebx,%ebp,b_offset)
+        input_whitening(%ecx,%ebp,c_offset)
+        input_whitening(%edx,%ebp,d_offset)
+        rol     $1,     %edx
+
+        encrypt_round(R0,R1,R2,R3,0);
+        encrypt_round(R2,R3,R0,R1,8);
+        encrypt_round(R0,R1,R2,R3,2*8);
+        encrypt_round(R2,R3,R0,R1,3*8);
+        encrypt_round(R0,R1,R2,R3,4*8);
+        encrypt_round(R2,R3,R0,R1,5*8);
+        encrypt_round(R0,R1,R2,R3,6*8);
+        encrypt_round(R2,R3,R0,R1,7*8);
+        encrypt_round(R0,R1,R2,R3,8*8);
+        encrypt_round(R2,R3,R0,R1,9*8);
+        encrypt_round(R0,R1,R2,R3,10*8);
+        encrypt_round(R2,R3,R0,R1,11*8);
+        encrypt_round(R0,R1,R2,R3,12*8);
+        encrypt_round(R2,R3,R0,R1,13*8);
+        encrypt_round(R0,R1,R2,R3,14*8);
+        encrypt_last_round(R2,R3,R0,R1,15*8);
+
+        output_whitening(%eax,%ebp,c_offset)
+        output_whitening(%ebx,%ebp,d_offset)
+        output_whitening(%ecx,%ebp,a_offset)
+        output_whitening(%edx,%ebp,b_offset)
+        mov     out_blk+16(%esp),%edi;
+        mov     %eax,           c_offset(%edi)
+        mov     %ebx,           d_offset(%edi)
+        mov     %ecx,           (%edi)
+        mov     %edx,           b_offset(%edi)
+
+        pop     %edi
+        pop     %esi
+        pop     %ebx
+        pop     %ebp
+        mov     $1,     %eax
+        ret
+
+twofish_dec_blk:
+        push    %ebp                    /* save registers according to calling convention*/
+        push    %ebx
+        push    %esi
+        push    %edi
+
+
+        mov     tfm + 16(%esp), %ebp    /* abuse the base pointer: set new base bointer to the crypto tfm */
+        add     $crypto_tfm_ctx_offset, %ebp    /* ctx adress */
+        mov     in_blk+16(%esp),%edi    /* input adress in edi */
+
+        mov     (%edi),         %eax
+        mov     b_offset(%edi), %ebx
+        mov     c_offset(%edi), %ecx
+        mov     d_offset(%edi), %edx
+        output_whitening(%eax,%ebp,a_offset)
+        output_whitening(%ebx,%ebp,b_offset)
+        ror     $16,    %ebx
+        output_whitening(%ecx,%ebp,c_offset)
+        output_whitening(%edx,%ebp,d_offset)
+        rol     $1,     %ecx
+
+        decrypt_round(R0,R1,R2,R3,15*8);
+        decrypt_round(R2,R3,R0,R1,14*8);
+        decrypt_round(R0,R1,R2,R3,13*8);
+        decrypt_round(R2,R3,R0,R1,12*8);
+        decrypt_round(R0,R1,R2,R3,11*8);
+        decrypt_round(R2,R3,R0,R1,10*8);
+        decrypt_round(R0,R1,R2,R3,9*8);
+        decrypt_round(R2,R3,R0,R1,8*8);
+        decrypt_round(R0,R1,R2,R3,7*8);
+        decrypt_round(R2,R3,R0,R1,6*8);
+        decrypt_round(R0,R1,R2,R3,5*8);
+        decrypt_round(R2,R3,R0,R1,4*8);
+        decrypt_round(R0,R1,R2,R3,3*8);
+        decrypt_round(R2,R3,R0,R1,2*8);
+        decrypt_round(R0,R1,R2,R3,1*8);
+        decrypt_last_round(R2,R3,R0,R1,0);
+
+        input_whitening(%eax,%ebp,c_offset)
+        input_whitening(%ebx,%ebp,d_offset)
+        input_whitening(%ecx,%ebp,a_offset)
+        input_whitening(%edx,%ebp,b_offset)
+        mov     out_blk+16(%esp),%edi;
+        mov     %eax,           c_offset(%edi)
+        mov     %ebx,           d_offset(%edi)
+        mov     %ecx,           (%edi)
+        mov     %edx,           b_offset(%edi)
+
+        pop     %edi
+        pop     %esi
+        pop     %ebx
+        pop     %ebp
+        mov     $1,     %eax
+        ret
diff --git a/arch/i386/crypto/twofish.c b/arch/i386/crypto/twofish.c
new file mode 100644
index 000000000000..e3004dfe9c7a
--- /dev/null
+++ b/arch/i386/crypto/twofish.c
@@ -0,0 +1,97 @@
+/*
+ *  Glue Code for optimized 586 assembler version of TWOFISH
+ *
+ * Originally Twofish for GPG
+ * By Matthew Skala <mskala@ansuz.sooke.bc.ca>, July 26, 1998
+ * 256-bit key length added March 20, 1999
+ * Some modifications to reduce the text size by Werner Koch, April, 1998
+ * Ported to the kerneli patch by Marc Mutz <Marc@Mutz.com>
+ * Ported to CryptoAPI by Colin Slater <hoho@tacomeat.net>
+ *
+ * The original author has disclaimed all copyright interest in this
+ * code and thus put it in the public domain. The subsequent authors
+ * have put this under the GNU General Public License.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
+ * USA
+ *
+ * This code is a "clean room" implementation, written from the paper
+ * _Twofish: A 128-Bit Block Cipher_ by Bruce Schneier, John Kelsey,
+ * Doug Whiting, David Wagner, Chris Hall, and Niels Ferguson, available
+ * through http://www.counterpane.com/twofish.html
+ *
+ * For background information on multiplication in finite fields, used for
+ * the matrix operations in the key schedule, see the book _Contemporary
+ * Abstract Algebra_ by Joseph A. Gallian, especially chapter 22 in the
+ * Third Edition.
+ */
+
+#include <crypto/twofish.h>
+#include <linux/crypto.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/types.h>
+
+
+asmlinkage void twofish_enc_blk(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
+asmlinkage void twofish_dec_blk(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
+
+static void twofish_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        twofish_enc_blk(tfm, dst, src);
+}
+
+static void twofish_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        twofish_dec_blk(tfm, dst, src);
+}
+
+static struct crypto_alg alg = {
+        .cra_name               =       "twofish",
+        .cra_driver_name        =       "twofish-i586",
+        .cra_priority           =       200,
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       TF_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct twofish_ctx),
+        .cra_alignmask          =       3,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(alg.cra_list),
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       TF_MIN_KEY_SIZE,
+                        .cia_max_keysize        =       TF_MAX_KEY_SIZE,
+                        .cia_setkey             =       twofish_setkey,
+                        .cia_encrypt            =       twofish_encrypt,
+                        .cia_decrypt            =       twofish_decrypt
+                }
+        }
+};
+
+static int __init init(void)
+{
+        return crypto_register_alg(&alg);
+}
+
+static void __exit fini(void)
+{
+        crypto_unregister_alg(&alg);
+}
+
+module_init(init);
+module_exit(fini);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION ("Twofish Cipher Algorithm, i586 asm optimized");
+MODULE_ALIAS("twofish");
diff --git a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
index e6ea00edcb54..ea19d091fd41 100644
--- a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -32,6 +32,7 @@
 #include <linux/seq_file.h>
 #include <linux/compiler.h>
 #include <linux/sched.h>        /* current */
+#include <linux/dmi.h>
 #include <asm/io.h>
 #include <asm/delay.h>
 #include <asm/uaccess.h>
@@ -387,6 +388,33 @@ static int acpi_cpufreq_early_init_acpi(void)
         return acpi_processor_preregister_performance(acpi_perf_data);
 }
 
+/*
+ * Some BIOSes do SW_ANY coordination internally, either set it up in hw
+ * or do it in BIOS firmware and won't inform about it to OS. If not
+ * detected, this has a side effect of making CPU run at a different speed
+ * than OS intended it to run at. Detect it and handle it cleanly.
+ */
+static int bios_with_sw_any_bug;
+
+static int __init sw_any_bug_found(struct dmi_system_id *d)
+{
+        bios_with_sw_any_bug = 1;
+        return 0;
+}
+
+static struct dmi_system_id __initdata sw_any_bug_dmi_table[] = {
+        {
+                .callback = sw_any_bug_found,
+                .ident = "Supermicro Server X6DLP",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
+                        DMI_MATCH(DMI_BIOS_VERSION, "080010"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
+                },
+        },
+        { }
+};
+
 static int
 acpi_cpufreq_cpu_init (
         struct cpufreq_policy   *policy)
@@ -422,8 +450,17 @@ acpi_cpufreq_cpu_init (
          * coordination is required.
          */
         if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
-            policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
+            policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
                 policy->cpus = perf->shared_cpu_map;
+        }
+
+#ifdef CONFIG_SMP
+        dmi_check_system(sw_any_bug_dmi_table);
+        if (bios_with_sw_any_bug && cpus_weight(policy->cpus) == 1) {
+                policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
+                policy->cpus = cpu_core_map[cpu];
+        }
+#endif
 
         if (cpu_has(c, X86_FEATURE_CONSTANT_TSC)) {
                 acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
diff --git a/arch/i386/kernel/cpu/cpufreq/longhaul.c b/arch/i386/kernel/cpu/cpufreq/longhaul.c
index 4f2c3aeef724..f5cc9f5c9bab 100644
--- a/arch/i386/kernel/cpu/cpufreq/longhaul.c
+++ b/arch/i386/kernel/cpu/cpufreq/longhaul.c
@@ -27,6 +27,7 @@
 #include <linux/moduleparam.h>
 #include <linux/init.h>
 #include <linux/cpufreq.h>
+#include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 
@@ -52,18 +53,26 @@
 #define CPU_NEHEMIAH    5
 
 static int cpu_model;
-static unsigned int numscales=16, numvscales;
+static unsigned int numscales=16;
 static unsigned int fsb;
-static int minvid, maxvid;
+
+static struct mV_pos *vrm_mV_table;
+static unsigned char *mV_vrm_table;
+struct f_msr {
+        unsigned char vrm;
+};
+static struct f_msr f_msr_table[32];
+
+static unsigned int highest_speed, lowest_speed; /* kHz */
 static unsigned int minmult, maxmult;
 static int can_scale_voltage;
-static int vrmrev;
 static struct acpi_processor *pr = NULL;
 static struct acpi_processor_cx *cx = NULL;
+static int port22_en;
 
 /* Module parameters */
-static int dont_scale_voltage;
-
+static int scale_voltage;
+static int ignore_latency;
 
 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "longhaul", msg)
 
@@ -71,7 +80,6 @@ static int dont_scale_voltage;
 /* Clock ratios multiplied by 10 */
 static int clock_ratio[32];
 static int eblcr_table[32];
-static int voltage_table[32];
 static unsigned int highest_speed, lowest_speed; /* kHz */
 static int longhaul_version;
 static struct cpufreq_frequency_table *longhaul_table;
@@ -124,10 +132,9 @@ static int longhaul_get_cpu_mult(void)
 
 /* For processor with BCR2 MSR */
 
-static void do_longhaul1(int cx_address, unsigned int clock_ratio_index)
+static void do_longhaul1(unsigned int clock_ratio_index)
 {
         union msr_bcr2 bcr2;
-        u32 t;
 
         rdmsrl(MSR_VIA_BCR2, bcr2.val);
         /* Enable software clock multiplier */
@@ -136,13 +143,11 @@ static void do_longhaul1(int cx_address, unsigned int clock_ratio_index)
 
         /* Sync to timer tick */
         safe_halt();
-        ACPI_FLUSH_CPU_CACHE();
         /* Change frequency on next halt or sleep */
         wrmsrl(MSR_VIA_BCR2, bcr2.val);
-        /* Invoke C3 */
-        inb(cx_address);
-        /* Dummy op - must do something useless after P_LVL3 read */
-        t = inl(acpi_fadt.xpm_tmr_blk.address);
+        /* Invoke transition */
+        ACPI_FLUSH_CPU_CACHE();
+        halt();
 
         /* Disable software clock multiplier */
         local_irq_disable();
@@ -164,11 +169,16 @@ static void do_powersaver(int cx_address, unsigned int clock_ratio_index)
         longhaul.bits.SoftBusRatio4 = (clock_ratio_index & 0x10) >> 4;
         longhaul.bits.EnableSoftBusRatio = 1;
 
+        if (can_scale_voltage) {
+                longhaul.bits.SoftVID = f_msr_table[clock_ratio_index].vrm;
+                longhaul.bits.EnableSoftVID = 1;
+        }
+
         /* Sync to timer tick */
         safe_halt();
-        ACPI_FLUSH_CPU_CACHE();
         /* Change frequency on next halt or sleep */
         wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
+        ACPI_FLUSH_CPU_CACHE();
         /* Invoke C3 */
         inb(cx_address);
         /* Dummy op - must do something useless after P_LVL3 read */
@@ -227,10 +237,13 @@ static void longhaul_setstate(unsigned int clock_ratio_index)
         outb(0xFF,0xA1);        /* Overkill */
         outb(0xFE,0x21);        /* TMR0 only */
 
-        /* Disable bus master arbitration */
-        if (pr->flags.bm_check) {
+        if (pr->flags.bm_control) {
+                /* Disable bus master arbitration */
                 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1,
                                   ACPI_MTX_DO_NOT_LOCK);
+        } else if (port22_en) {
+                /* Disable AGP and PCI arbiters */
+                outb(3, 0x22);
         }
 
         switch (longhaul_version) {
@@ -244,7 +257,7 @@ static void longhaul_setstate(unsigned int clock_ratio_index)
          */
         case TYPE_LONGHAUL_V1:
         case TYPE_LONGHAUL_V2:
-                do_longhaul1(cx->address, clock_ratio_index);
+                do_longhaul1(clock_ratio_index);
                 break;
 
         /*
@@ -259,14 +272,20 @@ static void longhaul_setstate(unsigned int clock_ratio_index)
          * to work in practice.
          */
         case TYPE_POWERSAVER:
+                /* Don't allow wakeup */
+                acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0,
+                                  ACPI_MTX_DO_NOT_LOCK);
                 do_powersaver(cx->address, clock_ratio_index);
                 break;
         }
 
-        /* Enable bus master arbitration */
-        if (pr->flags.bm_check) {
+        if (pr->flags.bm_control) {
+                /* Enable bus master arbitration */
                 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0,
                                   ACPI_MTX_DO_NOT_LOCK);
+        } else if (port22_en) {
+                /* Enable arbiters */
+                outb(0, 0x22);
         }
 
         outb(pic2_mask,0xA1);   /* restore mask */
@@ -446,53 +465,57 @@ static int __init longhaul_get_ranges(void)
 static void __init longhaul_setup_voltagescaling(void)
 {
         union msr_longhaul longhaul;
+        struct mV_pos minvid, maxvid;
+        unsigned int j, speed, pos, kHz_step, numvscales;
 
-        rdmsrl (MSR_VIA_LONGHAUL, longhaul.val);
-
-        if (!(longhaul.bits.RevisionID & 1))
+        rdmsrl(MSR_VIA_LONGHAUL, longhaul.val);
+        if (!(longhaul.bits.RevisionID & 1)) {
+                printk(KERN_INFO PFX "Voltage scaling not supported by CPU.\n");
                 return;
+        }
+
+        if (!longhaul.bits.VRMRev) {
+                printk (KERN_INFO PFX "VRM 8.5\n");
+                vrm_mV_table = &vrm85_mV[0];
+                mV_vrm_table = &mV_vrm85[0];
+        } else {
+                printk (KERN_INFO PFX "Mobile VRM\n");
+                vrm_mV_table = &mobilevrm_mV[0];
+                mV_vrm_table = &mV_mobilevrm[0];
+        }
 
-        minvid = longhaul.bits.MinimumVID;
-        maxvid = longhaul.bits.MaximumVID;
-        vrmrev = longhaul.bits.VRMRev;
+        minvid = vrm_mV_table[longhaul.bits.MinimumVID];
+        maxvid = vrm_mV_table[longhaul.bits.MaximumVID];
+        numvscales = maxvid.pos - minvid.pos + 1;
+        kHz_step = (highest_speed - lowest_speed) / numvscales;
 
-        if (minvid == 0 || maxvid == 0) {
+        if (minvid.mV == 0 || maxvid.mV == 0 || minvid.mV > maxvid.mV) {
                 printk (KERN_INFO PFX "Bogus values Min:%d.%03d Max:%d.%03d. "
                                         "Voltage scaling disabled.\n",
-                                        minvid/1000, minvid%1000, maxvid/1000, maxvid%1000);
+                                        minvid.mV/1000, minvid.mV%1000, maxvid.mV/1000, maxvid.mV%1000);
                 return;
         }
 
-        if (minvid == maxvid) {
+        if (minvid.mV == maxvid.mV) {
                 printk (KERN_INFO PFX "Claims to support voltage scaling but min & max are "
                                 "both %d.%03d. Voltage scaling disabled\n",
-                                maxvid/1000, maxvid%1000);
+                                maxvid.mV/1000, maxvid.mV%1000);
                 return;
         }
 
-        if (vrmrev==0) {
-                dprintk ("VRM 8.5\n");
-                memcpy (voltage_table, vrm85scales, sizeof(voltage_table));
-                numvscales = (voltage_table[maxvid]-voltage_table[minvid])/25;
-        } else {
-                dprintk ("Mobile VRM\n");
-                memcpy (voltage_table, mobilevrmscales, sizeof(voltage_table));
-                numvscales = (voltage_table[maxvid]-voltage_table[minvid])/5;
+        printk(KERN_INFO PFX "Max VID=%d.%03d  Min VID=%d.%03d, %d possible voltage scales\n",
+                maxvid.mV/1000, maxvid.mV%1000,
+                minvid.mV/1000, minvid.mV%1000,
+                numvscales);
+        
+        j = 0;
+        while (longhaul_table[j].frequency != CPUFREQ_TABLE_END) {
+                speed = longhaul_table[j].frequency;
+                pos = (speed - lowest_speed) / kHz_step + minvid.pos;
+                f_msr_table[longhaul_table[j].index].vrm = mV_vrm_table[pos];
+                j++;
         }
 
-        /* Current voltage isn't readable at first, so we need to
-           set it to a known value. The spec says to use maxvid */
-        longhaul.bits.RevisionKey = longhaul.bits.RevisionID;   /* FIXME: This is bad. */
-        longhaul.bits.EnableSoftVID = 1;
-        longhaul.bits.SoftVID = maxvid;
-        wrmsrl (MSR_VIA_LONGHAUL, longhaul.val);
-
-        minvid = voltage_table[minvid];
-        maxvid = voltage_table[maxvid];
-
-        dprintk ("Min VID=%d.%03d Max VID=%d.%03d, %d possible voltage scales\n",
-                maxvid/1000, maxvid%1000, minvid/1000, minvid%1000, numvscales);
-
         can_scale_voltage = 1;
 }
 
@@ -540,21 +563,33 @@ static acpi_status longhaul_walk_callback(acpi_handle obj_handle,
         return 1;
 }
 
+/* VIA don't support PM2 reg, but have something similar */
+static int enable_arbiter_disable(void)
+{
+        struct pci_dev *dev;
+        u8 pci_cmd;
+
+        /* Find PLE133 host bridge */
+        dev = pci_find_device(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8601_0, NULL);
+        if (dev != NULL) {
+                /* Enable access to port 0x22 */
+                pci_read_config_byte(dev, 0x78, &pci_cmd);
+                if ( !(pci_cmd & 1<<7) ) {
+                        pci_cmd |= 1<<7;
+                        pci_write_config_byte(dev, 0x78, pci_cmd);
+                }
+                return 1;
+        }
+        return 0;
+}
+
 static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
 {
         struct cpuinfo_x86 *c = cpu_data;
         char *cpuname=NULL;
         int ret;
 
-        /* Check ACPI support for C3 state */
-        acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
-                         &longhaul_walk_callback, NULL, (void *)&pr);
-        if (pr == NULL) goto err_acpi;
-
-        cx = &pr->power.states[ACPI_STATE_C3];
-        if (cx->address == 0 || cx->latency > 1000) goto err_acpi;
-
-        /* Now check what we have on this motherboard */
+        /* Check what we have on this motherboard */
         switch (c->x86_model) {
         case 6:
                 cpu_model = CPU_SAMUEL;
@@ -636,12 +671,36 @@ static int __init longhaul_cpu_init(struct cpufreq_policy *policy)
                 break;
         };
 
+        /* Find ACPI data for processor */
+        acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
+                            &longhaul_walk_callback, NULL, (void *)&pr);
+        if (pr == NULL)
+                goto err_acpi;
+
+        if (longhaul_version == TYPE_POWERSAVER) {
+                /* Check ACPI support for C3 state */
+                cx = &pr->power.states[ACPI_STATE_C3];
+                if (cx->address == 0 ||
+                   (cx->latency > 1000 && ignore_latency == 0) )
+                        goto err_acpi;
+
+        } else {
+                /* Check ACPI support for bus master arbiter disable */
+                if (!pr->flags.bm_control) {
+                        if (!enable_arbiter_disable()) {
+                                printk(KERN_ERR PFX "No ACPI support. No VT8601 host bridge. Aborting.\n");
+                                return -ENODEV;
+                        } else
+                                port22_en = 1;
+                }
+        }
+
         ret = longhaul_get_ranges();
         if (ret != 0)
                 return ret;
 
         if ((longhaul_version==TYPE_LONGHAUL_V2 || longhaul_version==TYPE_POWERSAVER) &&
-                 (dont_scale_voltage==0))
+                 (scale_voltage != 0))
                 longhaul_setup_voltagescaling();
 
         policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
@@ -729,8 +788,10 @@ static void __exit longhaul_exit(void)
         kfree(longhaul_table);
 }
 
-module_param (dont_scale_voltage, int, 0644);
-MODULE_PARM_DESC(dont_scale_voltage, "Don't scale voltage of processor");
+module_param (scale_voltage, int, 0644);
+MODULE_PARM_DESC(scale_voltage, "Scale voltage of processor");
+module_param(ignore_latency, int, 0644);
+MODULE_PARM_DESC(ignore_latency, "Skip ACPI C3 latency test");
 
 MODULE_AUTHOR ("Dave Jones <davej@codemonkey.org.uk>");
 MODULE_DESCRIPTION ("Longhaul driver for VIA Cyrix processors.");
@@ -738,4 +799,3 @@ MODULE_LICENSE ("GPL");
 
 late_initcall(longhaul_init);
 module_exit(longhaul_exit);
-
diff --git a/arch/i386/kernel/cpu/cpufreq/longhaul.h b/arch/i386/kernel/cpu/cpufreq/longhaul.h
index d3a95d77ee85..bc4682aad69b 100644
--- a/arch/i386/kernel/cpu/cpufreq/longhaul.h
+++ b/arch/i386/kernel/cpu/cpufreq/longhaul.h
@@ -450,17 +450,45 @@ static int __initdata nehemiah_c_eblcr[32] = {
  * Voltage scales. Div/Mod by 1000 to get actual voltage.
  * Which scale to use depends on the VRM type in use.
  */
-static int __initdata vrm85scales[32] = {
-        1250, 1200, 1150, 1100, 1050, 1800, 1750, 1700,
-        1650, 1600, 1550, 1500, 1450, 1400, 1350, 1300,
-        1275, 1225, 1175, 1125, 1075, 1825, 1775, 1725,
-        1675, 1625, 1575, 1525, 1475, 1425, 1375, 1325,
+
+struct mV_pos {
+        unsigned short mV;
+        unsigned short pos;
+};
+
+static struct mV_pos __initdata vrm85_mV[32] = {
+        {1250, 8},      {1200, 6},      {1150, 4},      {1100, 2},
+        {1050, 0},      {1800, 30},     {1750, 28},     {1700, 26},
+        {1650, 24},     {1600, 22},     {1550, 20},     {1500, 18},
+        {1450, 16},     {1400, 14},     {1350, 12},     {1300, 10},
+        {1275, 9},      {1225, 7},      {1175, 5},      {1125, 3},
+        {1075, 1},      {1825, 31},     {1775, 29},     {1725, 27},
+        {1675, 25},     {1625, 23},     {1575, 21},     {1525, 19},
+        {1475, 17},     {1425, 15},     {1375, 13},     {1325, 11}
+};
+
+static unsigned char __initdata mV_vrm85[32] = {
+        0x04,   0x14,   0x03,   0x13,   0x02,   0x12,   0x01,   0x11,
+        0x00,   0x10,   0x0f,   0x1f,   0x0e,   0x1e,   0x0d,   0x1d,
+        0x0c,   0x1c,   0x0b,   0x1b,   0x0a,   0x1a,   0x09,   0x19,
+        0x08,   0x18,   0x07,   0x17,   0x06,   0x16,   0x05,   0x15
+};
+
+static struct mV_pos __initdata mobilevrm_mV[32] = {
+        {1750, 31},     {1700, 30},     {1650, 29},     {1600, 28},
+        {1550, 27},     {1500, 26},     {1450, 25},     {1400, 24},
+        {1350, 23},     {1300, 22},     {1250, 21},     {1200, 20},
+        {1150, 19},     {1100, 18},     {1050, 17},     {1000, 16},
+        {975, 15},      {950, 14},      {925, 13},      {900, 12},
+        {875, 11},      {850, 10},      {825, 9},       {800, 8},
+        {775, 7},       {750, 6},       {725, 5},       {700, 4},
+        {675, 3},       {650, 2},       {625, 1},       {600, 0}
 };
 
-static int __initdata mobilevrmscales[32] = {
-        2000, 1950, 1900, 1850, 1800, 1750, 1700, 1650,
-        1600, 1550, 1500, 1450, 1500, 1350, 1300, -1,
-        1275, 1250, 1225, 1200, 1175, 1150, 1125, 1100,
-        1075, 1050, 1025, 1000, 975, 950, 925, -1,
+static unsigned char __initdata mV_mobilevrm[32] = {
+        0x1f,   0x1e,   0x1d,   0x1c,   0x1b,   0x1a,   0x19,   0x18,
+        0x17,   0x16,   0x15,   0x14,   0x13,   0x12,   0x11,   0x10,
+        0x0f,   0x0e,   0x0d,   0x0c,   0x0b,   0x0a,   0x09,   0x08,
+        0x07,   0x06,   0x05,   0x04,   0x03,   0x02,   0x01,   0x00
 };
 
diff --git a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
index b77f1358bd79..7a9325349e94 100644
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -23,6 +23,7 @@
 
 #ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI
 #include <linux/acpi.h>
+#include <linux/dmi.h>
 #include <acpi/processor.h>
 #endif
 
@@ -377,6 +378,35 @@ static int centrino_cpu_early_init_acpi(void)
         return 0;
 }
 
+
+/*
+ * Some BIOSes do SW_ANY coordination internally, either set it up in hw
+ * or do it in BIOS firmware and won't inform about it to OS. If not
+ * detected, this has a side effect of making CPU run at a different speed
+ * than OS intended it to run at. Detect it and handle it cleanly.
+ */
+static int bios_with_sw_any_bug;
+static int __init sw_any_bug_found(struct dmi_system_id *d)
+{
+        bios_with_sw_any_bug = 1;
+        return 0;
+}
+
+
+static struct dmi_system_id sw_any_bug_dmi_table[] = {
+        {
+                .callback = sw_any_bug_found,
+                .ident = "Supermicro Server X6DLP",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
+                        DMI_MATCH(DMI_BIOS_VERSION, "080010"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
+                },
+        },
+        { }
+};
+
+
 /*
  * centrino_cpu_init_acpi - register with ACPI P-States library
  *
@@ -398,14 +428,24 @@ static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
                 dprintk(PFX "obtaining ACPI data failed\n");
                 return -EIO;
         }
+
         policy->shared_type = p->shared_type;
         /*
          * Will let policy->cpus know about dependency only when software 
          * coordination is required.
          */
         if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
-            policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
+            policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
                 policy->cpus = p->shared_cpu_map;
+        }
+
+#ifdef CONFIG_SMP
+        dmi_check_system(sw_any_bug_dmi_table);
+        if (bios_with_sw_any_bug && cpus_weight(policy->cpus) == 1) {
+                policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
+                policy->cpus = cpu_core_map[cpu];
+        }
+#endif
 
         /* verify the acpi_data */
         if (p->state_count <= 1) {
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index 345ffb7d904d..f1682206d304 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -956,6 +956,38 @@ efi_memory_present_wrapper(unsigned long start, unsigned long end, void *arg)
         return 0;
 }
 
+ /*
+  * This function checks if the entire range <start,end> is mapped with type.
+  *
+  * Note: this function only works correct if the e820 table is sorted and
+  * not-overlapping, which is the case
+  */
+int __init
+e820_all_mapped(unsigned long s, unsigned long e, unsigned type)
+{
+        u64 start = s;
+        u64 end = e;
+        int i;
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                if (type && ei->type != type)
+                        continue;
+                /* is the region (part) in overlap with the current region ?*/
+                if (ei->addr >= end || ei->addr + ei->size <= start)
+                        continue;
+                /* if the region is at the beginning of <start,end> we move
+                 * start to the end of the region since it's ok until there
+                 */
+                if (ei->addr <= start)
+                        start = ei->addr + ei->size;
+                /* if start is now at or beyond end, we're done, full
+                 * coverage */
+                if (start >= end)
+                        return 1; /* we're done */
+        }
+        return 0;
+}
+
 /*
  * Find the highest page frame number we have available
  */
diff --git a/arch/i386/pci/common.c b/arch/i386/pci/common.c
index 1220dd828ce3..0a362e3aeac5 100644
--- a/arch/i386/pci/common.c
+++ b/arch/i386/pci/common.c
@@ -237,11 +237,6 @@ char * __devinit  pcibios_setup(char *str)
                 pci_probe &= ~PCI_PROBE_MMCONF;
                 return NULL;
         }
-        /* override DMI blacklist */
-        else if (!strcmp(str, "mmconf")) {
-                pci_probe |= PCI_PROBE_MMCONF_FORCE;
-                return NULL;
-        }
 #endif
         else if (!strcmp(str, "noacpi")) {
                 acpi_noirq_set();
diff --git a/arch/i386/pci/mmconfig.c b/arch/i386/pci/mmconfig.c
index ef5a2faa7d82..972180f738d9 100644
--- a/arch/i386/pci/mmconfig.c
+++ b/arch/i386/pci/mmconfig.c
@@ -12,7 +12,6 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
-#include <linux/dmi.h>
 #include <asm/e820.h>
 #include "pci.h"
 
@@ -188,31 +187,9 @@ static __init void unreachable_devices(void)
         }
 }
 
-static int disable_mcfg(struct dmi_system_id *d)
-{
-        printk("PCI: %s detected. Disabling MCFG.\n", d->ident);
-        pci_probe &= ~PCI_PROBE_MMCONF;
-        return 0;
-}
-
-static struct dmi_system_id __initdata dmi_bad_mcfg[] = {
-        /* Has broken MCFG table that makes the system hang when used */
-        {
-         .callback = disable_mcfg,
-         .ident = "Intel D3C5105 SDV",
-         .matches = {
-                     DMI_MATCH(DMI_BIOS_VENDOR, "Intel"),
-                     DMI_MATCH(DMI_BOARD_NAME, "D26928"),
-                     },
-         },
-         {}
-};
-
 void __init pci_mmcfg_init(void)
 {
-        dmi_check_system(dmi_bad_mcfg);
-
-        if ((pci_probe & (PCI_PROBE_MMCONF_FORCE|PCI_PROBE_MMCONF)) == 0)
+        if ((pci_probe & PCI_PROBE_MMCONF) == 0)
                 return;
 
         acpi_table_parse(ACPI_MCFG, acpi_parse_mcfg);
@@ -221,6 +198,15 @@ void __init pci_mmcfg_init(void)
             (pci_mmcfg_config[0].base_address == 0))
                 return;
 
+        if (!e820_all_mapped(pci_mmcfg_config[0].base_address,
+                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
+                        E820_RESERVED)) {
+                printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
+                                pci_mmcfg_config[0].base_address);
+                printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
+                return;
+        }
+
         printk(KERN_INFO "PCI: Using MMCONFIG\n");
         raw_pci_ops = &pci_mmcfg;
         pci_probe = (pci_probe & ~PCI_PROBE_MASK) | PCI_PROBE_MMCONF;
diff --git a/arch/i386/pci/pci.h b/arch/i386/pci/pci.h
index 49a849b3a241..bf4e79335388 100644
--- a/arch/i386/pci/pci.h
+++ b/arch/i386/pci/pci.h
@@ -16,8 +16,7 @@
 #define PCI_PROBE_CONF1         0x0002
 #define PCI_PROBE_CONF2         0x0004
 #define PCI_PROBE_MMCONF        0x0008
-#define PCI_PROBE_MMCONF_FORCE  0x0010
-#define PCI_PROBE_MASK          0x00ff
+#define PCI_PROBE_MASK          0x000f
 
 #define PCI_NO_SORT             0x0100
 #define PCI_BIOS_SORT           0x0200
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 694b0c63ee50..de1ef2fa1a20 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -417,6 +417,17 @@ config PPC_MAPLE
           This option enables support for the Maple 970FX Evaluation Board.
           For more informations, refer to <http://www.970eval.com>
 
+config PPC_PASEMI
+        depends on PPC_MULTIPLATFORM && PPC64
+        bool "PA Semi SoC-based platforms"
+        default n
+        select MPIC
+        select PPC_UDBG_16550
+        select GENERIC_TBSYNC
+        help
+          This option enables support for PA Semi's PWRficient line
+          of SoC processors, including PA6T-1682M
+
 config PPC_CELL
         bool
         default n
@@ -436,7 +447,8 @@ config PPC_IBM_CELL_BLADE
         select UDBG_RTAS_CONSOLE
 
 config UDBG_RTAS_CONSOLE
-        bool
+        bool "RTAS based debug console"
+        depends on PPC_RTAS
         default n
 
 config XICS
diff --git a/arch/powerpc/Kconfig.debug b/arch/powerpc/Kconfig.debug
index e29ef77d3b00..5ad149b47e34 100644
--- a/arch/powerpc/Kconfig.debug
+++ b/arch/powerpc/Kconfig.debug
@@ -18,6 +18,20 @@ config DEBUG_STACK_USAGE
 
           This option will slow down process creation somewhat.
 
+config HCALL_STATS
+        bool "Hypervisor call instrumentation"
+        depends on PPC_PSERIES && DEBUG_FS
+        help
+          Adds code to keep track of the number of hypervisor calls made and
+          the amount of time spent in hypervisor callsr.  Wall time spent in
+          each call is always calculated, and if available CPU cycles spent
+          are also calculated.  A directory named hcall_inst is added at the
+          root of the debugfs filesystem.  Within the hcall_inst directory
+          are files that contain CPU specific call statistics.
+
+          This option will add a small amount of overhead to all hypervisor
+          calls.
+
 config DEBUGGER
         bool "Enable debugger hooks"
         depends on DEBUG_KERNEL
@@ -74,6 +88,8 @@ config XMON
           very early during boot. 'xmon=on' will just enable the xmon
           debugger hooks.  'xmon=off' will disable the debugger hooks
           if CONFIG_XMON_DEFAULT is set.
+          xmon will print a backtrace on the very first invocation.
+          'xmon=nobt' will disable this autobacktrace.
 
 config XMON_DEFAULT
         bool "Enable xmon by default"
diff --git a/arch/powerpc/boot/Makefile b/arch/powerpc/boot/Makefile
index d961bfeed05f..e73774136b55 100644
--- a/arch/powerpc/boot/Makefile
+++ b/arch/powerpc/boot/Makefile
@@ -36,11 +36,16 @@ zliblinuxheader := zlib.h zconf.h zutil.h
 $(addprefix $(obj)/,$(zlib) main.o): $(addprefix $(obj)/,$(zliblinuxheader)) $(addprefix $(obj)/,$(zlibheader))
 #$(addprefix $(obj)/,main.o): $(addprefix $(obj)/,zlib.h)
 
-src-boot := crt0.S string.S prom.c stdio.c main.c div64.S
+src-boot-$(CONFIG_PPC_MULTIPLATFORM) := of.c
+src-boot := crt0.S string.S stdio.c main.c div64.S $(src-boot-y)
 src-boot += $(zlib)
 src-boot := $(addprefix $(obj)/, $(src-boot))
 obj-boot := $(addsuffix .o, $(basename $(src-boot)))
 
+ifeq ($(call cc-option-yn, -fstack-protector),y)
+BOOTCFLAGS      += -fno-stack-protector
+endif
+
 BOOTCFLAGS      += -I$(obj) -I$(srctree)/$(obj)
 
 quiet_cmd_copy_zlib = COPY    $@
diff --git a/arch/powerpc/boot/dts/mpc8349emds.dts b/arch/powerpc/boot/dts/mpc8349emds.dts
index 12f5dbf3055f..efceb3432653 100644
--- a/arch/powerpc/boot/dts/mpc8349emds.dts
+++ b/arch/powerpc/boot/dts/mpc8349emds.dts
@@ -214,10 +214,10 @@
                                          b800 0 0 4 700 15 8
 
                                         /* IDSEL 0x18 */
-                                         b000 0 0 1 700 15 8
-                                         b000 0 0 2 700 16 8
-                                         b000 0 0 3 700 17 8
-                                         b000 0 0 4 700 14 8>;
+                                         c000 0 0 1 700 15 8
+                                         c000 0 0 2 700 16 8
+                                         c000 0 0 3 700 17 8
+                                         c000 0 0 4 700 14 8>;
                         interrupt-parent = <700>;
                         interrupts = <42 8>;
                         bus-range = <0 0>;
@@ -274,10 +274,10 @@
                                          b800 0 0 4 700 15 8
 
                                         /* IDSEL 0x18 */
-                                         b000 0 0 1 700 15 8
-                                         b000 0 0 2 700 16 8
-                                         b000 0 0 3 700 17 8
-                                         b000 0 0 4 700 14 8>;
+                                         c000 0 0 1 700 15 8
+                                         c000 0 0 2 700 16 8
+                                         c000 0 0 3 700 17 8
+                                         c000 0 0 4 700 14 8>;
                         interrupt-parent = <700>;
                         interrupts = <42 8>;
                         bus-range = <0 0>;
diff --git a/arch/powerpc/boot/flatdevtree.h b/arch/powerpc/boot/flatdevtree.h
new file mode 100644
index 000000000000..761c8dc84008
--- /dev/null
+++ b/arch/powerpc/boot/flatdevtree.h
@@ -0,0 +1,46 @@
+/*
+ * 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, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef FLATDEVTREE_H
+#define FLATDEVTREE_H
+
+#include "types.h"
+
+/* Definitions used by the flattened device tree */
+#define OF_DT_HEADER            0xd00dfeed      /* marker */
+#define OF_DT_BEGIN_NODE        0x1     /* Start of node, full name */
+#define OF_DT_END_NODE          0x2     /* End node */
+#define OF_DT_PROP              0x3     /* Property: name off, size, content */
+#define OF_DT_NOP               0x4     /* nop */
+#define OF_DT_END               0x9
+
+#define OF_DT_VERSION           0x10
+
+struct boot_param_header {
+        u32 magic;              /* magic word OF_DT_HEADER */
+        u32 totalsize;          /* total size of DT block */
+        u32 off_dt_struct;      /* offset to structure */
+        u32 off_dt_strings;     /* offset to strings */
+        u32 off_mem_rsvmap;     /* offset to memory reserve map */
+        u32 version;            /* format version */
+        u32 last_comp_version;  /* last compatible version */
+        /* version 2 fields below */
+        u32 boot_cpuid_phys;    /* Physical CPU id we're booting on */
+        /* version 3 fields below */
+        u32 dt_strings_size;    /* size of the DT strings block */
+};
+
+#endif /* FLATDEVTREE_H */
diff --git a/arch/powerpc/boot/main.c b/arch/powerpc/boot/main.c
index b66634c9ea34..d719bb9333d1 100644
--- a/arch/powerpc/boot/main.c
+++ b/arch/powerpc/boot/main.c
@@ -14,17 +14,12 @@
 #include "page.h"
 #include "string.h"
 #include "stdio.h"
-#include "prom.h"
 #include "zlib.h"
+#include "ops.h"
+#include "flatdevtree.h"
 
 extern void flush_cache(void *, unsigned long);
 
-
-/* Value picked to match that used by yaboot */
-#define PROG_START      0x01400000      /* only used on 64-bit systems */
-#define RAM_END         (512<<20)       /* Fixme: use OF */
-#define ONE_MB          0x100000
-
 extern char _start[];
 extern char __bss_start[];
 extern char _end[];
@@ -33,14 +28,6 @@ extern char _vmlinux_end[];
 extern char _initrd_start[];
 extern char _initrd_end[];
 
-/* A buffer that may be edited by tools operating on a zImage binary so as to
- * edit the command line passed to vmlinux (by setting /chosen/bootargs).
- * The buffer is put in it's own section so that tools may locate it easier.
- */
-static char builtin_cmdline[512]
-        __attribute__((section("__builtin_cmdline")));
-
-
 struct addr_range {
         unsigned long addr;
         unsigned long size;
@@ -51,21 +38,16 @@ static struct addr_range vmlinuz;
 static struct addr_range initrd;
 
 static unsigned long elfoffset;
+static int is_64bit;
 
-static char scratch[46912];     /* scratch space for gunzip, from zlib_inflate_workspacesize() */
+/* scratch space for gunzip; 46912 is from zlib_inflate_workspacesize() */
+static char scratch[46912];
 static char elfheader[256];
 
-
-typedef void (*kernel_entry_t)( unsigned long,
-                                unsigned long,
-                                void *,
-                                void *);
-
+typedef void (*kernel_entry_t)(unsigned long, unsigned long, void *);
 
 #undef DEBUG
 
-static unsigned long claim_base;
-
 #define HEAD_CRC        2
 #define EXTRA_FIELD     4
 #define ORIG_NAME       8
@@ -123,24 +105,6 @@ static void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp)
         zlib_inflateEnd(&s);
 }
 
-static unsigned long try_claim(unsigned long size)
-{
-        unsigned long addr = 0;
-
-        for(; claim_base < RAM_END; claim_base += ONE_MB) {
-#ifdef DEBUG
-                printf("    trying: 0x%08lx\n\r", claim_base);
-#endif
-                addr = (unsigned long)claim(claim_base, size, 0);
-                if ((void *)addr != (void *)-1)
-                        break;
-        }
-        if (addr == 0)
-                return 0;
-        claim_base = PAGE_ALIGN(claim_base + size);
-        return addr;
-}
-
 static int is_elf64(void *hdr)
 {
         Elf64_Ehdr *elf64 = hdr;
@@ -169,16 +133,7 @@ static int is_elf64(void *hdr)
         vmlinux.size = (unsigned long)elf64ph->p_filesz + elfoffset;
         vmlinux.memsize = (unsigned long)elf64ph->p_memsz + elfoffset;
 
-#if defined(PROG_START)
-        /*
-         * Maintain a "magic" minimum address. This keeps some older
-         * firmware platforms running.
-         */
-
-        if (claim_base < PROG_START)
-                claim_base = PROG_START;
-#endif
-
+        is_64bit = 1;
         return 1;
 }
 
@@ -212,47 +167,9 @@ static int is_elf32(void *hdr)
         return 1;
 }
 
-void export_cmdline(void* chosen_handle)
-{
-        int len;
-        char cmdline[2] = { 0, 0 };
-
-        if (builtin_cmdline[0] == 0)
-                return;
-
-        len = getprop(chosen_handle, "bootargs", cmdline, sizeof(cmdline));
-        if (len > 0 && cmdline[0] != 0)
-                return;
-
-        setprop(chosen_handle, "bootargs", builtin_cmdline,
-                strlen(builtin_cmdline) + 1);
-}
-
-
-void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
+static void prep_kernel(unsigned long *a1, unsigned long *a2)
 {
         int len;
-        kernel_entry_t kernel_entry;
-
-        memset(__bss_start, 0, _end - __bss_start);
-
-        prom = (int (*)(void *)) promptr;
-        chosen_handle = finddevice("/chosen");
-        if (chosen_handle == (void *) -1)
-                exit();
-        if (getprop(chosen_handle, "stdout", &stdout, sizeof(stdout)) != 4)
-                exit();
-
-        printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r", _start, sp);
-
-        /*
-         * The first available claim_base must be above the end of the
-         * the loaded kernel wrapper file (_start to _end includes the
-         * initrd image if it is present) and rounded up to a nice
-         * 1 MB boundary for good measure.
-         */
-
-        claim_base = _ALIGN_UP((unsigned long)_end, ONE_MB);
 
         vmlinuz.addr = (unsigned long)_vmlinux_start;
         vmlinuz.size = (unsigned long)(_vmlinux_end - _vmlinux_start);
@@ -263,43 +180,51 @@ void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
                 gunzip(elfheader, sizeof(elfheader),
                                 (unsigned char *)vmlinuz.addr, &len);
         } else
-                memcpy(elfheader, (const void *)vmlinuz.addr, sizeof(elfheader));
+                memcpy(elfheader, (const void *)vmlinuz.addr,
+                       sizeof(elfheader));
 
         if (!is_elf64(elfheader) && !is_elf32(elfheader)) {
                 printf("Error: not a valid PPC32 or PPC64 ELF file!\n\r");
                 exit();
         }
+        if (platform_ops.image_hdr)
+                platform_ops.image_hdr(elfheader);
 
-        /* We need to claim the memsize plus the file offset since gzip
+        /* We need to alloc the memsize plus the file offset since gzip
          * will expand the header (file offset), then the kernel, then
          * possible rubbish we don't care about. But the kernel bss must
          * be claimed (it will be zero'd by the kernel itself)
          */
         printf("Allocating 0x%lx bytes for kernel ...\n\r", vmlinux.memsize);
-        vmlinux.addr = try_claim(vmlinux.memsize);
+        vmlinux.addr = (unsigned long)malloc(vmlinux.memsize);
         if (vmlinux.addr == 0) {
                 printf("Can't allocate memory for kernel image !\n\r");
                 exit();
         }
 
         /*
-         * Now we try to claim memory for the initrd (and copy it there)
+         * Now we try to alloc memory for the initrd (and copy it there)
          */
         initrd.size = (unsigned long)(_initrd_end - _initrd_start);
         initrd.memsize = initrd.size;
         if ( initrd.size > 0 ) {
-                printf("Allocating 0x%lx bytes for initrd ...\n\r", initrd.size);
-                initrd.addr = try_claim(initrd.size);
+                printf("Allocating 0x%lx bytes for initrd ...\n\r",
+                       initrd.size);
+                initrd.addr = (unsigned long)malloc((u32)initrd.size);
                 if (initrd.addr == 0) {
-                        printf("Can't allocate memory for initial ramdisk !\n\r");
+                        printf("Can't allocate memory for initial "
+                                        "ramdisk !\n\r");
                         exit();
                 }
-                a1 = initrd.addr;
-                a2 = initrd.size;
-                printf("initial ramdisk moving 0x%lx <- 0x%lx (0x%lx bytes)\n\r",
-                       initrd.addr, (unsigned long)_initrd_start, initrd.size);
-                memmove((void *)initrd.addr, (void *)_initrd_start, initrd.size);
-                printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd.addr));
+                *a1 = initrd.addr;
+                *a2 = initrd.size;
+                printf("initial ramdisk moving 0x%lx <- 0x%lx "
+                        "(0x%lx bytes)\n\r", initrd.addr,
+                        (unsigned long)_initrd_start, initrd.size);
+                memmove((void *)initrd.addr, (void *)_initrd_start,
+                        initrd.size);
+                printf("initrd head: 0x%lx\n\r",
+                                *((unsigned long *)initrd.addr));
         }
 
         /* Eventually gunzip the kernel */
@@ -311,11 +236,10 @@ void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
                         (unsigned char *)vmlinuz.addr, &len);
                 printf("done 0x%lx bytes\n\r", len);
         } else {
-                memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,vmlinuz.size);
+                memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,
+                        vmlinuz.size);
         }
 
-        export_cmdline(chosen_handle);
-
         /* Skip over the ELF header */
 #ifdef DEBUG
         printf("... skipping 0x%lx bytes of ELF header\n\r",
@@ -324,23 +248,107 @@ void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
         vmlinux.addr += elfoffset;
 
         flush_cache((void *)vmlinux.addr, vmlinux.size);
+}
 
-        kernel_entry = (kernel_entry_t)vmlinux.addr;
-#ifdef DEBUG
-        printf( "kernel:\n\r"
-                "        entry addr = 0x%lx\n\r"
-                "        a1         = 0x%lx,\n\r"
-                "        a2         = 0x%lx,\n\r"
-                "        prom       = 0x%lx,\n\r"
-                "        bi_recs    = 0x%lx,\n\r",
-                (unsigned long)kernel_entry, a1, a2,
-                (unsigned long)prom, NULL);
-#endif
+void __attribute__ ((weak)) ft_init(void *dt_blob)
+{
+}
 
-        kernel_entry(a1, a2, prom, NULL);
+/* A buffer that may be edited by tools operating on a zImage binary so as to
+ * edit the command line passed to vmlinux (by setting /chosen/bootargs).
+ * The buffer is put in it's own section so that tools may locate it easier.
+ */
+static char builtin_cmdline[COMMAND_LINE_SIZE]
+        __attribute__((__section__("__builtin_cmdline")));
 
-        printf("Error: Linux kernel returned to zImage bootloader!\n\r");
+static void get_cmdline(char *buf, int size)
+{
+        void *devp;
+        int len = strlen(builtin_cmdline);
 
-        exit();
+        buf[0] = '\0';
+
+        if (len > 0) { /* builtin_cmdline overrides dt's /chosen/bootargs */
+                len = min(len, size-1);
+                strncpy(buf, builtin_cmdline, len);
+                buf[len] = '\0';
+        }
+        else if ((devp = finddevice("/chosen")))
+                getprop(devp, "bootargs", buf, size);
+}
+
+static void set_cmdline(char *buf)
+{
+        void *devp;
+
+        if ((devp = finddevice("/chosen")))
+                setprop(devp, "bootargs", buf, strlen(buf) + 1);
 }
 
+/* Section where ft can be tacked on after zImage is built */
+union blobspace {
+        struct boot_param_header hdr;
+        char space[8*1024];
+} dt_blob __attribute__((__section__("__builtin_ft")));
+
+struct platform_ops platform_ops;
+struct dt_ops dt_ops;
+struct console_ops console_ops;
+
+void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
+{
+        int have_dt = 0;
+        kernel_entry_t kentry;
+        char cmdline[COMMAND_LINE_SIZE];
+
+        memset(__bss_start, 0, _end - __bss_start);
+        memset(&platform_ops, 0, sizeof(platform_ops));
+        memset(&dt_ops, 0, sizeof(dt_ops));
+        memset(&console_ops, 0, sizeof(console_ops));
+
+        /* Override the dt_ops and device tree if there was an flat dev
+         * tree attached to the zImage.
+         */
+        if (dt_blob.hdr.magic == OF_DT_HEADER) {
+                have_dt = 1;
+                ft_init(&dt_blob);
+        }
+
+        if (platform_init(promptr))
+                exit();
+        if (console_ops.open && (console_ops.open() < 0))
+                exit();
+        if (platform_ops.fixups)
+                platform_ops.fixups();
+
+        printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
+               _start, sp);
+
+        prep_kernel(&a1, &a2);
+
+        /* If cmdline came from zimage wrapper or if we can edit the one
+         * in the dt, print it out and edit it, if possible.
+         */
+        if ((strlen(builtin_cmdline) > 0) || console_ops.edit_cmdline) {
+                get_cmdline(cmdline, COMMAND_LINE_SIZE);
+                printf("\n\rLinux/PowerPC load: %s", cmdline);
+                if (console_ops.edit_cmdline)
+                        console_ops.edit_cmdline(cmdline, COMMAND_LINE_SIZE);
+                printf("\n\r");
+                set_cmdline(cmdline);
+        }
+
+        if (console_ops.close)
+                console_ops.close();
+
+        kentry = (kernel_entry_t) vmlinux.addr;
+        if (have_dt)
+                kentry(dt_ops.ft_addr(), 0, NULL);
+        else
+                /* XXX initrd addr/size should be passed in properties */
+                kentry(a1, a2, promptr);
+
+        /* console closed so printf below may not work */
+        printf("Error: Linux kernel returned to zImage boot wrapper!\n\r");
+        exit();
+}
diff --git a/arch/powerpc/boot/prom.c b/arch/powerpc/boot/of.c
index fa0057736f6b..fd99f789a37b 100644
--- a/arch/powerpc/boot/prom.c
+++ b/arch/powerpc/boot/of.c
@@ -8,15 +8,29 @@
  */
 #include <stdarg.h>
 #include <stddef.h>
+#include "types.h"
+#include "elf.h"
 #include "string.h"
 #include "stdio.h"
-#include "prom.h"
+#include "page.h"
+#include "ops.h"
 
-int (*prom)(void *);
-phandle chosen_handle;
-ihandle stdout;
+typedef void *ihandle;
+typedef void *phandle;
 
-int call_prom(const char *service, int nargs, int nret, ...)
+extern char _end[];
+
+/* Value picked to match that used by yaboot */
+#define PROG_START      0x01400000      /* only used on 64-bit systems */
+#define RAM_END         (512<<20)       /* Fixme: use OF */
+#define ONE_MB          0x100000
+
+int (*prom) (void *);
+
+
+static unsigned long claim_base;
+
+static int call_prom(const char *service, int nargs, int nret, ...)
 {
         int i;
         struct prom_args {
@@ -45,7 +59,7 @@ int call_prom(const char *service, int nargs, int nret, ...)
         return (nret > 0)? args.args[nargs]: 0;
 }
 
-int call_prom_ret(const char *service, int nargs, int nret,
+static int call_prom_ret(const char *service, int nargs, int nret,
                   unsigned int *rets, ...)
 {
         int i;
@@ -79,11 +93,6 @@ int call_prom_ret(const char *service, int nargs, int nret,
         return (nret > 0)? args.args[nargs]: 0;
 }
 
-int write(void *handle, void *ptr, int nb)
-{
-        return call_prom("write", 3, 1, handle, ptr, nb);
-}
-
 /*
  * Older OF's require that when claiming a specific range of addresses,
  * we claim the physical space in the /memory node and the virtual
@@ -142,7 +151,7 @@ static int check_of_version(void)
         return 1;
 }
 
-void *claim(unsigned long virt, unsigned long size, unsigned long align)
+static void *claim(unsigned long virt, unsigned long size, unsigned long align)
 {
         int ret;
         unsigned int result;
@@ -151,7 +160,7 @@ void *claim(unsigned long virt, unsigned long size, unsigned long align)
                 need_map = check_of_version();
         if (align || !need_map)
                 return (void *) call_prom("claim", 3, 1, virt, size, align);
-        
+
         ret = call_prom_ret("call-method", 5, 2, &result, "claim", memory,
                             align, size, virt);
         if (ret != 0 || result == -1)
@@ -163,3 +172,112 @@ void *claim(unsigned long virt, unsigned long size, unsigned long align)
                         0x12, size, virt, virt);
         return (void *) virt;
 }
+
+static void *of_try_claim(u32 size)
+{
+        unsigned long addr = 0;
+        static u8 first_time = 1;
+
+        if (first_time) {
+                claim_base = _ALIGN_UP((unsigned long)_end, ONE_MB);
+                first_time = 0;
+        }
+
+        for(; claim_base < RAM_END; claim_base += ONE_MB) {
+#ifdef DEBUG
+                printf("    trying: 0x%08lx\n\r", claim_base);
+#endif
+                addr = (unsigned long)claim(claim_base, size, 0);
+                if ((void *)addr != (void *)-1)
+                        break;
+        }
+        if (addr == 0)
+                return NULL;
+        claim_base = PAGE_ALIGN(claim_base + size);
+        return (void *)addr;
+}
+
+static void of_image_hdr(const void *hdr)
+{
+        const Elf64_Ehdr *elf64 = hdr;
+
+        if (elf64->e_ident[EI_CLASS] == ELFCLASS64) {
+                /*
+                 * Maintain a "magic" minimum address. This keeps some older
+                 * firmware platforms running.
+                 */
+                if (claim_base < PROG_START)
+                        claim_base = PROG_START;
+        }
+}
+
+static void of_exit(void)
+{
+        call_prom("exit", 0, 0);
+}
+
+/*
+ * OF device tree routines
+ */
+static void *of_finddevice(const char *name)
+{
+        return (phandle) call_prom("finddevice", 1, 1, name);
+}
+
+static int of_getprop(const void *phandle, const char *name, void *buf,
+                const int buflen)
+{
+        return call_prom("getprop", 4, 1, phandle, name, buf, buflen);
+}
+
+static int of_setprop(const void *phandle, const char *name, const void *buf,
+                const int buflen)
+{
+        return call_prom("setprop", 4, 1, phandle, name, buf, buflen);
+}
+
+/*
+ * OF console routines
+ */
+static void *of_stdout_handle;
+
+static int of_console_open(void)
+{
+        void *devp;
+
+        if (((devp = finddevice("/chosen")) != NULL)
+                        && (getprop(devp, "stdout", &of_stdout_handle,
+                                sizeof(of_stdout_handle))
+                                == sizeof(of_stdout_handle)))
+                return 0;
+
+        return -1;
+}
+
+static void of_console_write(char *buf, int len)
+{
+        call_prom("write", 3, 1, of_stdout_handle, buf, len);
+}
+
+int platform_init(void *promptr)
+{
+        platform_ops.fixups = NULL;
+        platform_ops.image_hdr = of_image_hdr;
+        platform_ops.malloc = of_try_claim;
+        platform_ops.free = NULL;
+        platform_ops.exit = of_exit;
+
+        dt_ops.finddevice = of_finddevice;
+        dt_ops.getprop = of_getprop;
+        dt_ops.setprop = of_setprop;
+        dt_ops.translate_addr = NULL;
+
+        console_ops.open = of_console_open;
+        console_ops.write = of_console_write;
+        console_ops.edit_cmdline = NULL;
+        console_ops.close = NULL;
+        console_ops.data = NULL;
+
+        prom = (int (*)(void *))promptr;
+        return 0;
+}
diff --git a/arch/powerpc/boot/ops.h b/arch/powerpc/boot/ops.h
new file mode 100644
index 000000000000..135eb4bb03b4
--- /dev/null
+++ b/arch/powerpc/boot/ops.h
@@ -0,0 +1,100 @@
+/*
+ * Global definition of all the bootwrapper operations.
+ *
+ * Author: Mark A. Greer <mgreer@mvista.com>
+ *
+ * 2006 (c) MontaVista Software, Inc.  This file is licensed under
+ * the terms of the GNU General Public License version 2.  This program
+ * is licensed "as is" without any warranty of any kind, whether express
+ * or implied.
+ */
+#ifndef _PPC_BOOT_OPS_H_
+#define _PPC_BOOT_OPS_H_
+
+#include "types.h"
+
+#define COMMAND_LINE_SIZE       512
+#define MAX_PATH_LEN            256
+#define MAX_PROP_LEN            256 /* What should this be? */
+
+/* Platform specific operations */
+struct platform_ops {
+        void    (*fixups)(void);
+        void    (*image_hdr)(const void *);
+        void *  (*malloc)(u32 size);
+        void    (*free)(void *ptr, u32 size);
+        void    (*exit)(void);
+};
+extern struct platform_ops platform_ops;
+
+/* Device Tree operations */
+struct dt_ops {
+        void *  (*finddevice)(const char *name);
+        int     (*getprop)(const void *node, const char *name, void *buf,
+                        const int buflen);
+        int     (*setprop)(const void *node, const char *name,
+                        const void *buf, const int buflen);
+        u64     (*translate_addr)(const char *path, const u32 *in_addr,
+                        const u32 addr_len);
+        unsigned long (*ft_addr)(void);
+};
+extern struct dt_ops dt_ops;
+
+/* Console operations */
+struct console_ops {
+        int     (*open)(void);
+        void    (*write)(char *buf, int len);
+        void    (*edit_cmdline)(char *buf, int len);
+        void    (*close)(void);
+        void    *data;
+};
+extern struct console_ops console_ops;
+
+/* Serial console operations */
+struct serial_console_data {
+        int             (*open)(void);
+        void            (*putc)(unsigned char c);
+        unsigned char   (*getc)(void);
+        u8              (*tstc)(void);
+        void            (*close)(void);
+};
+
+extern int platform_init(void *promptr);
+extern void simple_alloc_init(void);
+extern void ft_init(void *dt_blob);
+extern int serial_console_init(void);
+
+static inline void *finddevice(const char *name)
+{
+        return (dt_ops.finddevice) ? dt_ops.finddevice(name) : NULL;
+}
+
+static inline int getprop(void *devp, const char *name, void *buf, int buflen)
+{
+        return (dt_ops.getprop) ? dt_ops.getprop(devp, name, buf, buflen) : -1;
+}
+
+static inline int setprop(void *devp, const char *name, void *buf, int buflen)
+{
+        return (dt_ops.setprop) ? dt_ops.setprop(devp, name, buf, buflen) : -1;
+}
+
+static inline void *malloc(u32 size)
+{
+        return (platform_ops.malloc) ? platform_ops.malloc(size) : NULL;
+}
+
+static inline void free(void *ptr, u32 size)
+{
+        if (platform_ops.free)
+                platform_ops.free(ptr, size);
+}
+
+static inline void exit(void)
+{
+        if (platform_ops.exit)
+                platform_ops.exit();
+        for(;;);
+}
+
+#endif /* _PPC_BOOT_OPS_H_ */
diff --git a/arch/powerpc/boot/prom.h b/arch/powerpc/boot/prom.h
deleted file mode 100644
index a57b184c564f..000000000000
--- a/arch/powerpc/boot/prom.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef _PPC_BOOT_PROM_H_
-#define _PPC_BOOT_PROM_H_
-
-typedef void *phandle;
-typedef void *ihandle;
-
-extern int (*prom) (void *);
-extern phandle chosen_handle;
-extern ihandle stdout;
-
-int     call_prom(const char *service, int nargs, int nret, ...);
-int     call_prom_ret(const char *service, int nargs, int nret,
-                      unsigned int *rets, ...);
-
-extern int write(void *handle, void *ptr, int nb);
-extern void *claim(unsigned long virt, unsigned long size, unsigned long aln);
-
-static inline void exit(void)
-{
-        call_prom("exit", 0, 0);
-}
-
-static inline phandle finddevice(const char *name)
-{
-        return (phandle) call_prom("finddevice", 1, 1, name);
-}
-
-static inline int getprop(void *phandle, const char *name,
-                          void *buf, int buflen)
-{
-        return call_prom("getprop", 4, 1, phandle, name, buf, buflen);
-}
-
-
-static inline int setprop(void *phandle, const char *name,
-                          void *buf, int buflen)
-{
-        return call_prom("setprop", 4, 1, phandle, name, buf, buflen);
-}
-
-#endif                          /* _PPC_BOOT_PROM_H_ */
diff --git a/arch/powerpc/boot/stdio.c b/arch/powerpc/boot/stdio.c
index b5aa522f8b77..6d5f6382e1ce 100644
--- a/arch/powerpc/boot/stdio.c
+++ b/arch/powerpc/boot/stdio.c
@@ -10,7 +10,7 @@
 #include <stddef.h>
 #include "string.h"
 #include "stdio.h"
-#include "prom.h"
+#include "ops.h"
 
 size_t strnlen(const char * s, size_t count)
 {
@@ -320,6 +320,6 @@ printf(const char *fmt, ...)
         va_start(args, fmt);
         n = vsprintf(sprint_buf, fmt, args);
         va_end(args);
-        write(stdout, sprint_buf, n);
+        console_ops.write(sprint_buf, n);
         return n;
 }
diff --git a/arch/powerpc/boot/stdio.h b/arch/powerpc/boot/stdio.h
index eb9e16c87aef..73b8a91bfb34 100644
--- a/arch/powerpc/boot/stdio.h
+++ b/arch/powerpc/boot/stdio.h
@@ -1,8 +1,16 @@
 #ifndef _PPC_BOOT_STDIO_H_
 #define _PPC_BOOT_STDIO_H_
 
+#include <stdarg.h>
+
+#define ENOMEM          12      /* Out of Memory */
+#define EINVAL          22      /* Invalid argument */
+#define ENOSPC          28      /* No space left on device */
+
 extern int printf(const char *fmt, ...);
 
+#define fprintf(fmt, args...)   printf(args)
+
 extern int sprintf(char *buf, const char *fmt, ...);
 
 extern int vsprintf(char *buf, const char *fmt, va_list args);
diff --git a/arch/powerpc/boot/types.h b/arch/powerpc/boot/types.h
new file mode 100644
index 000000000000..79d26e708677
--- /dev/null
+++ b/arch/powerpc/boot/types.h
@@ -0,0 +1,23 @@
+#ifndef _TYPES_H_
+#define _TYPES_H_
+
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+typedef unsigned char           u8;
+typedef unsigned short          u16;
+typedef unsigned int            u32;
+typedef unsigned long long      u64;
+
+#define min(x,y) ({ \
+        typeof(x) _x = (x);     \
+        typeof(y) _y = (y);     \
+        (void) (&_x == &_y);    \
+        _x < _y ? _x : _y; })
+
+#define max(x,y) ({ \
+        typeof(x) _x = (x);     \
+        typeof(y) _y = (y);     \
+        (void) (&_x == &_y);    \
+        _x > _y ? _x : _y; })
+
+#endif /* _TYPES_H_ */
diff --git a/arch/powerpc/configs/maple_defconfig b/arch/powerpc/configs/maple_defconfig
index 2860be106f4f..62ba66091a13 100644
--- a/arch/powerpc/configs/maple_defconfig
+++ b/arch/powerpc/configs/maple_defconfig
@@ -496,7 +496,7 @@ CONFIG_E1000=y
 # CONFIG_SKY2 is not set
 # CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
-# CONFIG_TIGON3 is not set
+CONFIG_TIGON3=y
 # CONFIG_BNX2 is not set
 # CONFIG_MV643XX_ETH is not set
 
diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index 7d32ad0194a4..8b133afbdc20 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -16,7 +16,7 @@ obj-y				:= semaphore.o cputable.o ptrace.o syscalls.o \
 obj-y                           += vdso32/
 obj-$(CONFIG_PPC64)             += setup_64.o binfmt_elf32.o sys_ppc32.o \
                                    signal_64.o ptrace32.o \
-                                   paca.o cpu_setup_power4.o \
+                                   paca.o cpu_setup_ppc970.o \
                                    firmware.o sysfs.o
 obj-$(CONFIG_PPC64)             += vdso64/
 obj-$(CONFIG_ALTIVEC)           += vecemu.o vector.o
@@ -51,7 +51,7 @@ extra-$(CONFIG_8xx)		:= head_8xx.o
 extra-y                         += vmlinux.lds
 
 obj-y                           += time.o prom.o traps.o setup-common.o \
-                                   udbg.o misc.o
+                                   udbg.o misc.o io.o
 obj-$(CONFIG_PPC32)             += entry_32.o setup_32.o misc_32.o
 obj-$(CONFIG_PPC64)             += misc_64.o dma_64.o iommu.o
 obj-$(CONFIG_PPC_MULTIPLATFORM) += prom_init.o
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index 7ee84968087b..d06f378597bb 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -40,9 +40,10 @@
 #ifdef CONFIG_PPC64
 #include <asm/paca.h>
 #include <asm/lppaca.h>
-#include <asm/iseries/hv_lp_event.h>
 #include <asm/cache.h>
 #include <asm/compat.h>
+#include <asm/mmu.h>
+#include <asm/hvcall.h>
 #endif
 
 #define DEFINE(sym, val) \
@@ -136,11 +137,18 @@ int main(void)
         DEFINE(PACA_STARTPURR, offsetof(struct paca_struct, startpurr));
         DEFINE(PACA_USER_TIME, offsetof(struct paca_struct, user_time));
         DEFINE(PACA_SYSTEM_TIME, offsetof(struct paca_struct, system_time));
+        DEFINE(PACA_SLBSHADOWPTR, offsetof(struct paca_struct, slb_shadow_ptr));
+        DEFINE(PACA_DATA_OFFSET, offsetof(struct paca_struct, data_offset));
 
+        DEFINE(SLBSHADOW_STACKVSID,
+               offsetof(struct slb_shadow, save_area[SLB_NUM_BOLTED - 1].vsid));
+        DEFINE(SLBSHADOW_STACKESID,
+               offsetof(struct slb_shadow, save_area[SLB_NUM_BOLTED - 1].esid));
         DEFINE(LPPACASRR0, offsetof(struct lppaca, saved_srr0));
         DEFINE(LPPACASRR1, offsetof(struct lppaca, saved_srr1));
         DEFINE(LPPACAANYINT, offsetof(struct lppaca, int_dword.any_int));
         DEFINE(LPPACADECRINT, offsetof(struct lppaca, int_dword.fields.decr_int));
+        DEFINE(SLBSHADOW_SAVEAREA, offsetof(struct slb_shadow, save_area));
 #endif /* CONFIG_PPC64 */
 
         /* RTAS */
@@ -159,6 +167,12 @@ int main(void)
         /* Create extra stack space for SRR0 and SRR1 when calling prom/rtas. */
         DEFINE(PROM_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 16);
         DEFINE(RTAS_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs) + 16);
+
+        /* hcall statistics */
+        DEFINE(HCALL_STAT_SIZE, sizeof(struct hcall_stats));
+        DEFINE(HCALL_STAT_CALLS, offsetof(struct hcall_stats, num_calls));
+        DEFINE(HCALL_STAT_TB, offsetof(struct hcall_stats, tb_total));
+        DEFINE(HCALL_STAT_PURR, offsetof(struct hcall_stats, purr_total));
 #endif /* CONFIG_PPC64 */
         DEFINE(GPR0, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[0]));
         DEFINE(GPR1, STACK_FRAME_OVERHEAD+offsetof(struct pt_regs, gpr[1]));
@@ -240,6 +254,7 @@ int main(void)
         DEFINE(CPU_SPEC_PVR_VALUE, offsetof(struct cpu_spec, pvr_value));
         DEFINE(CPU_SPEC_FEATURES, offsetof(struct cpu_spec, cpu_features));
         DEFINE(CPU_SPEC_SETUP, offsetof(struct cpu_spec, cpu_setup));
+        DEFINE(CPU_SPEC_RESTORE, offsetof(struct cpu_spec, cpu_restore));
 
 #ifndef CONFIG_PPC64
         DEFINE(pbe_address, offsetof(struct pbe, address));
diff --git a/arch/powerpc/kernel/btext.c b/arch/powerpc/kernel/btext.c
index f4e5e14ee2b6..995fcef156fd 100644
--- a/arch/powerpc/kernel/btext.c
+++ b/arch/powerpc/kernel/btext.c
@@ -158,35 +158,35 @@ int btext_initialize(struct device_node *np)
 {
         unsigned int width, height, depth, pitch;
         unsigned long address = 0;
-        u32 *prop;
+        const u32 *prop;
 
-        prop = (u32 *)get_property(np, "linux,bootx-width", NULL);
+        prop = get_property(np, "linux,bootx-width", NULL);
         if (prop == NULL)
-                prop = (u32 *)get_property(np, "width", NULL);
+                prop = get_property(np, "width", NULL);
         if (prop == NULL)
                 return -EINVAL;
         width = *prop;
-        prop = (u32 *)get_property(np, "linux,bootx-height", NULL);
+        prop = get_property(np, "linux,bootx-height", NULL);
         if (prop == NULL)
-                prop = (u32 *)get_property(np, "height", NULL);
+                prop = get_property(np, "height", NULL);
         if (prop == NULL)
                 return -EINVAL;
         height = *prop;
-        prop = (u32 *)get_property(np, "linux,bootx-depth", NULL);
+        prop = get_property(np, "linux,bootx-depth", NULL);
         if (prop == NULL)
-                prop = (u32 *)get_property(np, "depth", NULL);
+                prop = get_property(np, "depth", NULL);
         if (prop == NULL)
                 return -EINVAL;
         depth = *prop;
         pitch = width * ((depth + 7) / 8);
-        prop = (u32 *)get_property(np, "linux,bootx-linebytes", NULL);
+        prop = get_property(np, "linux,bootx-linebytes", NULL);
         if (prop == NULL)
-                prop = (u32 *)get_property(np, "linebytes", NULL);
+                prop = get_property(np, "linebytes", NULL);
         if (prop)
                 pitch = *prop;
         if (pitch == 1)
                 pitch = 0x1000;
-        prop = (u32 *)get_property(np, "address", NULL);
+        prop = get_property(np, "address", NULL);
         if (prop)
                 address = *prop;
 
@@ -214,11 +214,11 @@ int btext_initialize(struct device_node *np)
 
 int __init btext_find_display(int allow_nonstdout)
 {
-        char *name;
+        const char *name;
         struct device_node *np = NULL; 
         int rc = -ENODEV;
 
-        name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
+        name = get_property(of_chosen, "linux,stdout-path", NULL);
         if (name != NULL) {
                 np = of_find_node_by_path(name);
                 if (np != NULL) {
diff --git a/arch/powerpc/kernel/cpu_setup_power4.S b/arch/powerpc/kernel/cpu_setup_ppc970.S
index 76e97aa71c45..652594891d58 100644
--- a/arch/powerpc/kernel/cpu_setup_power4.S
+++ b/arch/powerpc/kernel/cpu_setup_ppc970.S
@@ -16,27 +16,12 @@
 #include <asm/asm-offsets.h>
 #include <asm/cache.h>
 
-_GLOBAL(__970_cpu_preinit)
-        /*
-         * Do nothing if not running in HV mode
-         */
+_GLOBAL(__cpu_preinit_ppc970)
+        /* Do nothing if not running in HV mode */
         mfmsr   r0
         rldicl. r0,r0,4,63
         beqlr
 
-        /*
-         * Deal only with PPC970 and PPC970FX.
-         */
-        mfspr   r0,SPRN_PVR
-        srwi    r0,r0,16
-        cmpwi   r0,0x39
-        beq     1f
-        cmpwi   r0,0x3c
-        beq     1f
-        cmpwi   r0,0x44
-        bnelr
-1:
-
         /* Make sure HID4:rm_ci is off before MMU is turned off, that large
          * pages are enabled with HID4:61 and clear HID5:DCBZ_size and
          * HID5:DCBZ32_ill
@@ -72,23 +57,6 @@ _GLOBAL(__970_cpu_preinit)
         isync
         blr
 
-_GLOBAL(__setup_cpu_ppc970)
-        mfspr   r0,SPRN_HID0
-        li      r11,5                   /* clear DOZE and SLEEP */
-        rldimi  r0,r11,52,8             /* set NAP and DPM */
-        li      r11,0
-        rldimi  r0,r11,32,31            /* clear EN_ATTN */
-        mtspr   SPRN_HID0,r0
-        mfspr   r0,SPRN_HID0
-        mfspr   r0,SPRN_HID0
-        mfspr   r0,SPRN_HID0
-        mfspr   r0,SPRN_HID0
-        mfspr   r0,SPRN_HID0
-        mfspr   r0,SPRN_HID0
-        sync
-        isync
-        blr
-
 /* Definitions for the table use to save CPU states */
 #define CS_HID0         0
 #define CS_HID1         8
@@ -103,33 +71,30 @@ cpu_state_storage:
         .balign L1_CACHE_BYTES,0
         .text
 
-/* Called in normal context to backup CPU 0 state. This
- * does not include cache settings. This function is also
- * called for machine sleep. This does not include the MMU
- * setup, BATs, etc... but rather the "special" registers
- * like HID0, HID1, HID4, etc...
- */
-_GLOBAL(__save_cpu_setup)
-        /* Some CR fields are volatile, we back it up all */
-        mfcr    r7
-
-        /* Get storage ptr */
-        LOAD_REG_IMMEDIATE(r5,cpu_state_storage)
 
-        /* We only deal with 970 for now */
-        mfspr   r0,SPRN_PVR
-        srwi    r0,r0,16
-        cmpwi   r0,0x39
-        beq     1f
-        cmpwi   r0,0x3c
-        beq     1f
-        cmpwi   r0,0x44
-        bne     2f
-
-1:      /* skip if not running in HV mode */
+_GLOBAL(__setup_cpu_ppc970)
+        /* Do nothing if not running in HV mode */
         mfmsr   r0
         rldicl. r0,r0,4,63
-        beq     2f
+        beqlr
+
+        mfspr   r0,SPRN_HID0
+        li      r11,5                   /* clear DOZE and SLEEP */
+        rldimi  r0,r11,52,8             /* set NAP and DPM */
+        li      r11,0
+        rldimi  r0,r11,32,31            /* clear EN_ATTN */
+        mtspr   SPRN_HID0,r0
+        mfspr   r0,SPRN_HID0
+        mfspr   r0,SPRN_HID0
+        mfspr   r0,SPRN_HID0
+        mfspr   r0,SPRN_HID0
+        mfspr   r0,SPRN_HID0
+        mfspr   r0,SPRN_HID0
+        sync
+        isync
+
+        /* Save away cpu state */
+        LOAD_REG_IMMEDIATE(r5,cpu_state_storage)
 
         /* Save HID0,1,4 and 5 */
         mfspr   r3,SPRN_HID0
@@ -141,35 +106,19 @@ _GLOBAL(__save_cpu_setup)
         mfspr   r3,SPRN_HID5
         std     r3,CS_HID5(r5)
 
-2:
-        mtcr    r7
         blr
 
 /* Called with no MMU context (typically MSR:IR/DR off) to
  * restore CPU state as backed up by the previous
  * function. This does not include cache setting
  */
-_GLOBAL(__restore_cpu_setup)
-        /* Get storage ptr (FIXME when using anton reloc as we
-         * are running with translation disabled here
-         */
-        LOAD_REG_IMMEDIATE(r5,cpu_state_storage)
-
-        /* We only deal with 970 for now */
-        mfspr   r0,SPRN_PVR
-        srwi    r0,r0,16
-        cmpwi   r0,0x39
-        beq     1f
-        cmpwi   r0,0x3c
-        beq     1f
-        cmpwi   r0,0x44
-        bnelr
-
-1:      /* skip if not running in HV mode */
+_GLOBAL(__restore_cpu_ppc970)
+        /* Do nothing if not running in HV mode */
         mfmsr   r0
         rldicl. r0,r0,4,63
         beqlr
 
+        LOAD_REG_IMMEDIATE(r5,cpu_state_storage)
         /* Before accessing memory, we make sure rm_ci is clear */
         li      r0,0
         mfspr   r3,SPRN_HID4
diff --git a/arch/powerpc/kernel/cputable.c b/arch/powerpc/kernel/cputable.c
index 272e43622fd6..190a57e20765 100644
--- a/arch/powerpc/kernel/cputable.c
+++ b/arch/powerpc/kernel/cputable.c
@@ -39,7 +39,10 @@ extern void __setup_cpu_7400(unsigned long offset, struct cpu_spec* spec);
 extern void __setup_cpu_7410(unsigned long offset, struct cpu_spec* spec);
 extern void __setup_cpu_745x(unsigned long offset, struct cpu_spec* spec);
 #endif /* CONFIG_PPC32 */
+#ifdef CONFIG_PPC64
 extern void __setup_cpu_ppc970(unsigned long offset, struct cpu_spec* spec);
+extern void __restore_cpu_ppc970(void);
+#endif /* CONFIG_PPC64 */
 
 /* This table only contains "desktop" CPUs, it need to be filled with embedded
  * ones as well...
@@ -55,6 +58,9 @@ extern void __setup_cpu_ppc970(unsigned long offset, struct cpu_spec* spec);
 #define COMMON_USER_POWER6      (COMMON_USER_PPC64 | PPC_FEATURE_ARCH_2_05 |\
                                  PPC_FEATURE_SMT | PPC_FEATURE_ICACHE_SNOOP | \
                                  PPC_FEATURE_TRUE_LE)
+#define COMMON_USER_PA6T        (COMMON_USER_PPC64 | PPC_FEATURE_PA6T |\
+                                 PPC_FEATURE_TRUE_LE | \
+                                 PPC_FEATURE_HAS_ALTIVEC_COMP)
 #define COMMON_USER_BOOKE       (PPC_FEATURE_32 | PPC_FEATURE_HAS_MMU | \
                                  PPC_FEATURE_BOOKE)
 
@@ -184,6 +190,7 @@ struct cpu_spec	cpu_specs[] = {
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_ppc970,
+                .cpu_restore            = __restore_cpu_ppc970,
                 .oprofile_cpu_type      = "ppc64/970",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "ppc970",
@@ -199,6 +206,7 @@ struct cpu_spec	cpu_specs[] = {
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_ppc970,
+                .cpu_restore            = __restore_cpu_ppc970,
                 .oprofile_cpu_type      = "ppc64/970",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "ppc970",
@@ -214,6 +222,7 @@ struct cpu_spec	cpu_specs[] = {
                 .dcache_bsize           = 128,
                 .num_pmcs               = 8,
                 .cpu_setup              = __setup_cpu_ppc970,
+                .cpu_restore            = __restore_cpu_ppc970,
                 .oprofile_cpu_type      = "ppc64/970",
                 .oprofile_type          = PPC_OPROFILE_POWER4,
                 .platform               = "ppc970",
@@ -280,6 +289,17 @@ struct cpu_spec	cpu_specs[] = {
                 .dcache_bsize           = 128,
                 .platform               = "ppc-cell-be",
         },
+        {       /* PA Semi PA6T */
+                .pvr_mask               = 0x7fff0000,
+                .pvr_value              = 0x00900000,
+                .cpu_name               = "PA6T",
+                .cpu_features           = CPU_FTRS_PA6T,
+                .cpu_user_features      = COMMON_USER_PA6T,
+                .icache_bsize           = 64,
+                .dcache_bsize           = 64,
+                .num_pmcs               = 6,
+                .platform               = "pa6t",
+        },
         {       /* default match */
                 .pvr_mask               = 0x00000000,
                 .pvr_value              = 0x00000000,
@@ -929,6 +949,7 @@ struct cpu_spec	cpu_specs[] = {
                         PPC_FEATURE_HAS_MMU | PPC_FEATURE_HAS_4xxMAC,
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
+                .platform               = "ppc405",
         },
         {       /* 405EP */
                 .pvr_mask               = 0xffff0000,
diff --git a/arch/powerpc/kernel/crash_dump.c b/arch/powerpc/kernel/crash_dump.c
index 371973be8d71..2f6f5a7bc69e 100644
--- a/arch/powerpc/kernel/crash_dump.c
+++ b/arch/powerpc/kernel/crash_dump.c
@@ -80,7 +80,7 @@ static int __init parse_savemaxmem(char *p)
 }
 __setup("savemaxmem=", parse_savemaxmem);
 
-/*
+/**
  * copy_oldmem_page - copy one page from "oldmem"
  * @pfn: page frame number to be copied
  * @buf: target memory address for the copy; this can be in kernel address
diff --git a/arch/powerpc/kernel/dma_64.c b/arch/powerpc/kernel/dma_64.c
index 36aaa7663f02..6c168f6ea142 100644
--- a/arch/powerpc/kernel/dma_64.c
+++ b/arch/powerpc/kernel/dma_64.c
@@ -35,10 +35,9 @@ int dma_supported(struct device *dev, u64 mask)
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                return dma_ops->dma_supported(dev, mask);
-        BUG();
-        return 0;
+        BUG_ON(!dma_ops);
+
+        return dma_ops->dma_supported(dev, mask);
 }
 EXPORT_SYMBOL(dma_supported);
 
@@ -66,10 +65,9 @@ void *dma_alloc_coherent(struct device *dev, size_t size,
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                return dma_ops->alloc_coherent(dev, size, dma_handle, flag);
-        BUG();
-        return NULL;
+        BUG_ON(!dma_ops);
+
+        return dma_ops->alloc_coherent(dev, size, dma_handle, flag);
 }
 EXPORT_SYMBOL(dma_alloc_coherent);
 
@@ -78,10 +76,9 @@ void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                dma_ops->free_coherent(dev, size, cpu_addr, dma_handle);
-        else
-                BUG();
+        BUG_ON(!dma_ops);
+
+        dma_ops->free_coherent(dev, size, cpu_addr, dma_handle);
 }
 EXPORT_SYMBOL(dma_free_coherent);
 
@@ -90,10 +87,9 @@ dma_addr_t dma_map_single(struct device *dev, void *cpu_addr, size_t size,
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                return dma_ops->map_single(dev, cpu_addr, size, direction);
-        BUG();
-        return (dma_addr_t)0;
+        BUG_ON(!dma_ops);
+
+        return dma_ops->map_single(dev, cpu_addr, size, direction);
 }
 EXPORT_SYMBOL(dma_map_single);
 
@@ -102,10 +98,9 @@ void dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                dma_ops->unmap_single(dev, dma_addr, size, direction);
-        else
-                BUG();
+        BUG_ON(!dma_ops);
+
+        dma_ops->unmap_single(dev, dma_addr, size, direction);
 }
 EXPORT_SYMBOL(dma_unmap_single);
 
@@ -115,11 +110,10 @@ dma_addr_t dma_map_page(struct device *dev, struct page *page,
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                return dma_ops->map_single(dev,
-                                (page_address(page) + offset), size, direction);
-        BUG();
-        return (dma_addr_t)0;
+        BUG_ON(!dma_ops);
+
+        return dma_ops->map_single(dev, page_address(page) + offset, size,
+                        direction);
 }
 EXPORT_SYMBOL(dma_map_page);
 
@@ -128,10 +122,9 @@ void dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                dma_ops->unmap_single(dev, dma_address, size, direction);
-        else
-                BUG();
+        BUG_ON(!dma_ops);
+
+        dma_ops->unmap_single(dev, dma_address, size, direction);
 }
 EXPORT_SYMBOL(dma_unmap_page);
 
@@ -140,10 +133,9 @@ int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                return dma_ops->map_sg(dev, sg, nents, direction);
-        BUG();
-        return 0;
+        BUG_ON(!dma_ops);
+
+        return dma_ops->map_sg(dev, sg, nents, direction);
 }
 EXPORT_SYMBOL(dma_map_sg);
 
@@ -152,9 +144,8 @@ void dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
 {
         struct dma_mapping_ops *dma_ops = get_dma_ops(dev);
 
-        if (dma_ops)
-                dma_ops->unmap_sg(dev, sg, nhwentries, direction);
-        else
-                BUG();
+        BUG_ON(!dma_ops);
+
+        dma_ops->unmap_sg(dev, sg, nhwentries, direction);
 }
 EXPORT_SYMBOL(dma_unmap_sg);
diff --git a/arch/powerpc/kernel/entry_64.S b/arch/powerpc/kernel/entry_64.S
index 54d9f5cdaab4..2cd872b5283b 100644
--- a/arch/powerpc/kernel/entry_64.S
+++ b/arch/powerpc/kernel/entry_64.S
@@ -375,6 +375,14 @@ BEGIN_FTR_SECTION
         ld      r7,KSP_VSID(r4) /* Get new stack's VSID */
         oris    r0,r6,(SLB_ESID_V)@h
         ori     r0,r0,(SLB_NUM_BOLTED-1)@l
+
+        /* Update the last bolted SLB */
+        ld      r9,PACA_SLBSHADOWPTR(r13)
+        li      r12,0
+        std     r12,SLBSHADOW_STACKESID(r9) /* Clear ESID */
+        std     r7,SLBSHADOW_STACKVSID(r9)  /* Save VSID */
+        std     r0,SLBSHADOW_STACKESID(r9)  /* Save ESID */
+
         slbie   r6
         slbie   r6              /* Workaround POWER5 < DD2.1 issue */
         slbmte  r7,r0
diff --git a/arch/powerpc/kernel/head_64.S b/arch/powerpc/kernel/head_64.S
index 6ff3cf506088..3065b472b95d 100644
--- a/arch/powerpc/kernel/head_64.S
+++ b/arch/powerpc/kernel/head_64.S
@@ -132,7 +132,7 @@ _GLOBAL(__secondary_hold)
         bne     100b
 
 #if defined(CONFIG_SMP) || defined(CONFIG_KEXEC)
-        LOAD_REG_IMMEDIATE(r4, .pSeries_secondary_smp_init)
+        LOAD_REG_IMMEDIATE(r4, .generic_secondary_smp_init)
         mtctr   r4
         mr      r3,r24
         bctr
@@ -1484,19 +1484,17 @@ fwnmi_data_area:
         . = 0x8000
 
 /*
- * On pSeries, secondary processors spin in the following code.
+ * On pSeries and most other platforms, secondary processors spin
+ * in the following code.
  * At entry, r3 = this processor's number (physical cpu id)
  */
-_GLOBAL(pSeries_secondary_smp_init)
+_GLOBAL(generic_secondary_smp_init)
         mr      r24,r3
         
         /* turn on 64-bit mode */
         bl      .enable_64b_mode
         isync
 
-        /* Copy some CPU settings from CPU 0 */
-        bl      .__restore_cpu_setup
-
         /* Set up a paca value for this processor. Since we have the
          * physical cpu id in r24, we need to search the pacas to find
          * which logical id maps to our physical one.
@@ -1522,15 +1520,28 @@ _GLOBAL(pSeries_secondary_smp_init)
                                         /* start.                        */
         sync
 
-        /* Create a temp kernel stack for use before relocation is on.  */
+#ifndef CONFIG_SMP
+        b       3b                      /* Never go on non-SMP           */
+#else
+        cmpwi   0,r23,0
+        beq     3b                      /* Loop until told to go         */
+
+        /* See if we need to call a cpu state restore handler */
+        LOAD_REG_IMMEDIATE(r23, cur_cpu_spec)
+        ld      r23,0(r23)
+        ld      r23,CPU_SPEC_RESTORE(r23)
+        cmpdi   0,r23,0
+        beq     4f
+        ld      r23,0(r23)
+        mtctr   r23
+        bctrl
+
+4:      /* Create a temp kernel stack for use before relocation is on.  */
         ld      r1,PACAEMERGSP(r13)
         subi    r1,r1,STACK_FRAME_OVERHEAD
 
-        cmpwi   0,r23,0
-#ifdef CONFIG_SMP
-        bne     .__secondary_start
+        b       .__secondary_start
 #endif
-        b       3b                      /* Loop until told to go         */
 
 #ifdef CONFIG_PPC_ISERIES
 _STATIC(__start_initialization_iSeries)
@@ -1611,7 +1622,16 @@ _GLOBAL(__start_initialization_multiplatform)
         bl      .enable_64b_mode
 
         /* Setup some critical 970 SPRs before switching MMU off */
-        bl      .__970_cpu_preinit
+        mfspr   r0,SPRN_PVR
+        srwi    r0,r0,16
+        cmpwi   r0,0x39         /* 970 */
+        beq     1f
+        cmpwi   r0,0x3c         /* 970FX */
+        beq     1f
+        cmpwi   r0,0x44         /* 970MP */
+        bne     2f
+1:      bl      .__cpu_preinit_ppc970
+2:
 
         /* Switch off MMU if not already */
         LOAD_REG_IMMEDIATE(r4, .__after_prom_start - KERNELBASE)
@@ -1728,7 +1748,7 @@ _STATIC(__after_prom_start)
 _GLOBAL(copy_and_flush)
         addi    r5,r5,-8
         addi    r6,r6,-8
-4:      li      r0,16                   /* Use the least common         */
+4:      li      r0,8                    /* Use the smallest common      */
                                         /* denominator cache line       */
                                         /* size.  This results in       */
                                         /* extra cache line flushes     */
@@ -1782,7 +1802,7 @@ _GLOBAL(pmac_secondary_start)
         isync
 
         /* Copy some CPU settings from CPU 0 */
-        bl      .__restore_cpu_setup
+        bl      .__restore_cpu_ppc970
 
         /* pSeries do that early though I don't think we really need it */
         mfmsr   r3
@@ -1932,12 +1952,6 @@ _STATIC(start_here_multiplatform)
         mr      r5,r26
         bl      .identify_cpu
 
-        /* Save some low level config HIDs of CPU0 to be copied to
-         * other CPUs later on, or used for suspend/resume
-         */
-        bl      .__save_cpu_setup
-        sync
-
         /* Do very early kernel initializations, including initial hash table,
          * stab and slb setup before we turn on relocation.     */
 
diff --git a/arch/powerpc/kernel/ibmebus.c b/arch/powerpc/kernel/ibmebus.c
index 68e5ab0443d2..124dbcba94a8 100644
--- a/arch/powerpc/kernel/ibmebus.c
+++ b/arch/powerpc/kernel/ibmebus.c
@@ -167,7 +167,7 @@ static DEVICE_ATTR(name, S_IRUSR | S_IRGRP | S_IROTH, ibmebusdev_show_name,
                    NULL);
 
 static struct ibmebus_dev* __devinit ibmebus_register_device_common(
-        struct ibmebus_dev *dev, char *name)
+        struct ibmebus_dev *dev, const char *name)
 {
         int err = 0;
 
@@ -194,10 +194,10 @@ static struct ibmebus_dev* __devinit ibmebus_register_device_node(
         struct device_node *dn)
 {
         struct ibmebus_dev *dev;
-        char *loc_code;
+        const char *loc_code;
         int length;
 
-        loc_code = (char *)get_property(dn, "ibm,loc-code", NULL);
+        loc_code = get_property(dn, "ibm,loc-code", NULL);
         if (!loc_code) {
                 printk(KERN_WARNING "%s: node %s missing 'ibm,loc-code'\n",
                        __FUNCTION__, dn->name ? dn->name : "<unknown>");
diff --git a/arch/powerpc/kernel/io.c b/arch/powerpc/kernel/io.c
new file mode 100644
index 000000000000..e98180686b35
--- /dev/null
+++ b/arch/powerpc/kernel/io.c
@@ -0,0 +1,131 @@
+/*
+ * I/O string operations
+ *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
+ *    Copyright (C) 2006 IBM Corporation
+ *
+ * Largely rewritten by Cort Dougan (cort@cs.nmt.edu)
+ * and Paul Mackerras.
+ *
+ * Adapted for iSeries by Mike Corrigan (mikejc@us.ibm.com)
+ * PPC64 updates by Dave Engebretsen (engebret@us.ibm.com)
+ *
+ * Rewritten in C by Stephen Rothwell.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/compiler.h>
+#include <linux/module.h>
+
+#include <asm/io.h>
+#include <asm/firmware.h>
+#include <asm/bug.h>
+
+void _insb(volatile u8 __iomem *port, void *buf, long count)
+{
+        u8 *tbuf = buf;
+        u8 tmp;
+
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        if (unlikely(count <= 0))
+                return;
+        asm volatile("sync");
+        do {
+                tmp = *port;
+                asm volatile("eieio");
+                *tbuf++ = tmp;
+        } while (--count != 0);
+        asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
+}
+EXPORT_SYMBOL(_insb);
+
+void _outsb(volatile u8 __iomem *port, const void *buf, long count)
+{
+        const u8 *tbuf = buf;
+
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        if (unlikely(count <= 0))
+                return;
+        asm volatile("sync");
+        do {
+                *port = *tbuf++;
+        } while (--count != 0);
+        asm volatile("sync");
+}
+EXPORT_SYMBOL(_outsb);
+
+void _insw_ns(volatile u16 __iomem *port, void *buf, long count)
+{
+        u16 *tbuf = buf;
+        u16 tmp;
+
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        if (unlikely(count <= 0))
+                return;
+        asm volatile("sync");
+        do {
+                tmp = *port;
+                asm volatile("eieio");
+                *tbuf++ = tmp;
+        } while (--count != 0);
+        asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
+}
+EXPORT_SYMBOL(_insw_ns);
+
+void _outsw_ns(volatile u16 __iomem *port, const void *buf, long count)
+{
+        const u16 *tbuf = buf;
+
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        if (unlikely(count <= 0))
+                return;
+        asm volatile("sync");
+        do {
+                *port = *tbuf++;
+        } while (--count != 0);
+        asm volatile("sync");
+}
+EXPORT_SYMBOL(_outsw_ns);
+
+void _insl_ns(volatile u32 __iomem *port, void *buf, long count)
+{
+        u32 *tbuf = buf;
+        u32 tmp;
+
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        if (unlikely(count <= 0))
+                return;
+        asm volatile("sync");
+        do {
+                tmp = *port;
+                asm volatile("eieio");
+                *tbuf++ = tmp;
+        } while (--count != 0);
+        asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
+}
+EXPORT_SYMBOL(_insl_ns);
+
+void _outsl_ns(volatile u32 __iomem *port, const void *buf, long count)
+{
+        const u32 *tbuf = buf;
+
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        if (unlikely(count <= 0))
+                return;
+        asm volatile("sync");
+        do {
+                *port = *tbuf++;
+        } while (--count != 0);
+        asm volatile("sync");
+}
+EXPORT_SYMBOL(_outsl_ns);
diff --git a/arch/powerpc/kernel/irq.c b/arch/powerpc/kernel/irq.c
index 12c5971d6565..b4432332341f 100644
--- a/arch/powerpc/kernel/irq.c
+++ b/arch/powerpc/kernel/irq.c
@@ -52,6 +52,7 @@
 #include <linux/radix-tree.h>
 #include <linux/mutex.h>
 #include <linux/bootmem.h>
+#include <linux/pci.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -875,12 +876,14 @@ int pci_enable_msi(struct pci_dev * pdev)
         else
                 return -1;
 }
+EXPORT_SYMBOL(pci_enable_msi);
 
 void pci_disable_msi(struct pci_dev * pdev)
 {
         if (ppc_md.disable_msi)
                 ppc_md.disable_msi(pdev);
 }
+EXPORT_SYMBOL(pci_disable_msi);
 
 void pci_scan_msi_device(struct pci_dev *dev) {}
 int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec) {return -1;}
@@ -888,6 +891,8 @@ void pci_disable_msix(struct pci_dev *dev) {}
 void msi_remove_pci_irq_vectors(struct pci_dev *dev) {}
 void disable_msi_mode(struct pci_dev *dev, int pos, int type) {}
 void pci_no_msi(void) {}
+EXPORT_SYMBOL(pci_enable_msix);
+EXPORT_SYMBOL(pci_disable_msix);
 
 #endif
 
diff --git a/arch/powerpc/kernel/legacy_serial.c b/arch/powerpc/kernel/legacy_serial.c
index 40a39291861f..5e6ddfa474c0 100644
--- a/arch/powerpc/kernel/legacy_serial.c
+++ b/arch/powerpc/kernel/legacy_serial.c
@@ -39,16 +39,17 @@ static int __init add_legacy_port(struct device_node *np, int want_index,
                                   phys_addr_t taddr, unsigned long irq,
                                   upf_t flags, int irq_check_parent)
 {
-        u32 *clk, *spd, clock = BASE_BAUD * 16;
+        const u32 *clk, *spd;
+        u32 clock = BASE_BAUD * 16;
         int index;
 
         /* get clock freq. if present */
-        clk = (u32 *)get_property(np, "clock-frequency", NULL);
+        clk = get_property(np, "clock-frequency", NULL);
         if (clk && *clk)
                 clock = *clk;
 
         /* get default speed if present */
-        spd = (u32 *)get_property(np, "current-speed", NULL);
+        spd = get_property(np, "current-speed", NULL);
 
         /* If we have a location index, then try to use it */
         if (want_index >= 0 && want_index < MAX_LEGACY_SERIAL_PORTS)
@@ -113,7 +114,7 @@ static int __init add_legacy_soc_port(struct device_node *np,
                                       struct device_node *soc_dev)
 {
         u64 addr;
-        u32 *addrp;
+        const u32 *addrp;
         upf_t flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
         struct device_node *tsi = of_get_parent(np);
 
@@ -144,15 +145,15 @@ static int __init add_legacy_soc_port(struct device_node *np,
 static int __init add_legacy_isa_port(struct device_node *np,
                                       struct device_node *isa_brg)
 {
-        u32 *reg;
-        char *typep;
+        const u32 *reg;
+        const char *typep;
         int index = -1;
         u64 taddr;
 
         DBG(" -> add_legacy_isa_port(%s)\n", np->full_name);
 
         /* Get the ISA port number */
-        reg = (u32 *)get_property(np, "reg", NULL);
+        reg = get_property(np, "reg", NULL);
         if (reg == NULL)
                 return -1;
 
@@ -163,7 +164,7 @@ static int __init add_legacy_isa_port(struct device_node *np,
         /* Now look for an "ibm,aix-loc" property that gives us ordering
          * if any...
          */
-        typep = (char *)get_property(np, "ibm,aix-loc", NULL);
+        typep = get_property(np, "ibm,aix-loc", NULL);
 
         /* If we have a location index, then use it */
         if (typep && *typep == 'S')
@@ -188,7 +189,7 @@ static int __init add_legacy_pci_port(struct device_node *np,
                                       struct device_node *pci_dev)
 {
         u64 addr, base;
-        u32 *addrp;
+        const u32 *addrp;
         unsigned int flags;
         int iotype, index = -1, lindex = 0;
 
@@ -227,7 +228,7 @@ static int __init add_legacy_pci_port(struct device_node *np,
          * we get to their "reg" property
          */
         if (np != pci_dev) {
-                u32 *reg = (u32 *)get_property(np, "reg", NULL);
+                const u32 *reg = get_property(np, "reg", NULL);
                 if (reg && (*reg < 4))
                         index = lindex = *reg;
         }
@@ -285,13 +286,13 @@ static void __init setup_legacy_serial_console(int console)
 void __init find_legacy_serial_ports(void)
 {
         struct device_node *np, *stdout = NULL;
-        char *path;
+        const char *path;
         int index;
 
         DBG(" -> find_legacy_serial_port()\n");
 
         /* Now find out if one of these is out firmware console */
-        path = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
+        path = get_property(of_chosen, "linux,stdout-path", NULL);
         if (path != NULL) {
                 stdout = of_find_node_by_path(path);
                 if (stdout)
@@ -491,8 +492,8 @@ static int __init check_legacy_serial_console(void)
 {
         struct device_node *prom_stdout = NULL;
         int speed = 0, offset = 0;
-        char *name;
-        u32 *spd;
+        const char *name;
+        const u32 *spd;
 
         DBG(" -> check_legacy_serial_console()\n");
 
@@ -513,7 +514,7 @@ static int __init check_legacy_serial_console(void)
         }
         /* We are getting a weird phandle from OF ... */
         /* ... So use the full path instead */
-        name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
+        name = get_property(of_chosen, "linux,stdout-path", NULL);
         if (name == NULL) {
                 DBG(" no linux,stdout-path !\n");
                 return -ENODEV;
@@ -525,12 +526,12 @@ static int __init check_legacy_serial_console(void)
         }
         DBG("stdout is %s\n", prom_stdout->full_name);
 
-        name = (char *)get_property(prom_stdout, "name", NULL);
+        name = get_property(prom_stdout, "name", NULL);
         if (!name) {
                 DBG(" stdout package has no name !\n");
                 goto not_found;
         }
-        spd = (u32 *)get_property(prom_stdout, "current-speed", NULL);
+        spd = get_property(prom_stdout, "current-speed", NULL);
         if (spd)
                 speed = *spd;
 
diff --git a/arch/powerpc/kernel/lparcfg.c b/arch/powerpc/kernel/lparcfg.c
index 23f34daa044a..41c05dcd68f4 100644
--- a/arch/powerpc/kernel/lparcfg.c
+++ b/arch/powerpc/kernel/lparcfg.c
@@ -32,7 +32,6 @@
 #include <asm/rtas.h>
 #include <asm/system.h>
 #include <asm/time.h>
-#include <asm/iseries/it_exp_vpd_panel.h>
 #include <asm/prom.h>
 #include <asm/vdso_datapage.h>
 
@@ -183,8 +182,14 @@ static unsigned int h_get_ppp(unsigned long *entitled,
                               unsigned long *resource)
 {
         unsigned long rc;
-        rc = plpar_hcall_4out(H_GET_PPP, 0, 0, 0, 0, entitled, unallocated,
-                              aggregation, resource);
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
+
+        rc = plpar_hcall(H_GET_PPP, retbuf);
+
+        *entitled = retbuf[0];
+        *unallocated = retbuf[1];
+        *aggregation = retbuf[2];
+        *resource = retbuf[3];
 
         log_plpar_hcall_return(rc, "H_GET_PPP");
 
@@ -194,8 +199,12 @@ static unsigned int h_get_ppp(unsigned long *entitled,
 static void h_pic(unsigned long *pool_idle_time, unsigned long *num_procs)
 {
         unsigned long rc;
-        unsigned long dummy;
-        rc = plpar_hcall(H_PIC, 0, 0, 0, 0, pool_idle_time, num_procs, &dummy);
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
+
+        rc = plpar_hcall(H_PIC, retbuf);
+
+        *pool_idle_time = retbuf[0];
+        *num_procs = retbuf[1];
 
         if (rc != H_AUTHORITY)
                 log_plpar_hcall_return(rc, "H_PIC");
@@ -310,12 +319,11 @@ static int pseries_lparcfg_data(struct seq_file *m, void *v)
         int partition_potential_processors;
         int partition_active_processors;
         struct device_node *rtas_node;
-        int *lrdrp = NULL;
+        const int *lrdrp = NULL;
 
         rtas_node = find_path_device("/rtas");
         if (rtas_node)
-                lrdrp = (int *)get_property(rtas_node, "ibm,lrdr-capacity",
-                                            NULL);
+                lrdrp = get_property(rtas_node, "ibm,lrdr-capacity", NULL);
 
         if (lrdrp == NULL) {
                 partition_potential_processors = vdso_data->processorCount;
@@ -520,7 +528,8 @@ static int lparcfg_data(struct seq_file *m, void *v)
         const char *model = "";
         const char *system_id = "";
         const char *tmp;
-        unsigned int *lp_index_ptr, lp_index = 0;
+        const unsigned int *lp_index_ptr;
+        unsigned int lp_index = 0;
 
         seq_printf(m, "%s %s \n", MODULE_NAME, MODULE_VERS);
 
@@ -540,8 +549,7 @@ static int lparcfg_data(struct seq_file *m, void *v)
                         if (firmware_has_feature(FW_FEATURE_ISERIES))
                                 system_id += 4;
                 }
-                lp_index_ptr = (unsigned int *)
-                        get_property(rootdn, "ibm,partition-no", NULL);
+                lp_index_ptr = get_property(rootdn, "ibm,partition-no", NULL);
                 if (lp_index_ptr)
                         lp_index = *lp_index_ptr;
         }
diff --git a/arch/powerpc/kernel/machine_kexec_64.c b/arch/powerpc/kernel/machine_kexec_64.c
index be58985c7681..a24b09c27718 100644
--- a/arch/powerpc/kernel/machine_kexec_64.c
+++ b/arch/powerpc/kernel/machine_kexec_64.c
@@ -31,8 +31,8 @@ int default_machine_kexec_prepare(struct kimage *image)
         unsigned long begin, end;       /* limits of segment */
         unsigned long low, high;        /* limits of blocked memory range */
         struct device_node *node;
-        unsigned long *basep;
-        unsigned int *sizep;
+        const unsigned long *basep;
+        const unsigned int *sizep;
 
         if (!ppc_md.hpte_clear_all)
                 return -ENOENT;
@@ -72,10 +72,8 @@ int default_machine_kexec_prepare(struct kimage *image)
         /* We also should not overwrite the tce tables */
         for (node = of_find_node_by_type(NULL, "pci"); node != NULL;
                         node = of_find_node_by_type(node, "pci")) {
-                basep = (unsigned long *)get_property(node, "linux,tce-base",
-                                                        NULL);
-                sizep = (unsigned int *)get_property(node, "linux,tce-size",
-                                                        NULL);
+                basep = get_property(node, "linux,tce-base", NULL);
+                sizep = get_property(node, "linux,tce-size", NULL);
                 if (basep == NULL || sizep == NULL)
                         continue;
 
diff --git a/arch/powerpc/kernel/misc.S b/arch/powerpc/kernel/misc.S
index f770805f1215..330c9dc7db86 100644
--- a/arch/powerpc/kernel/misc.S
+++ b/arch/powerpc/kernel/misc.S
@@ -43,162 +43,3 @@ _GLOBAL(add_reloc_offset)
         add     r3,r3,r5
         mtlr    r0
         blr
-
-/*
- * I/O string operations
- *
- * insb(port, buf, len)
- * outsb(port, buf, len)
- * insw(port, buf, len)
- * outsw(port, buf, len)
- * insl(port, buf, len)
- * outsl(port, buf, len)
- * insw_ns(port, buf, len)
- * outsw_ns(port, buf, len)
- * insl_ns(port, buf, len)
- * outsl_ns(port, buf, len)
- *
- * The *_ns versions don't do byte-swapping.
- */
-_GLOBAL(_insb)
-        sync
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,1
-        blelr-
-00:     lbz     r5,0(r3)
-        eieio
-        stbu    r5,1(r4)
-        bdnz    00b
-        twi     0,r5,0
-        isync
-        blr
-
-_GLOBAL(_outsb)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,1
-        blelr-
-        sync
-00:     lbzu    r5,1(r4)
-        stb     r5,0(r3)
-        bdnz    00b
-        sync
-        blr
-
-_GLOBAL(_insw)
-        sync
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,2
-        blelr-
-00:     lhbrx   r5,0,r3
-        eieio
-        sthu    r5,2(r4)
-        bdnz    00b
-        twi     0,r5,0
-        isync
-        blr
-
-_GLOBAL(_outsw)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,2
-        blelr-
-        sync
-00:     lhzu    r5,2(r4)
-        sthbrx  r5,0,r3
-        bdnz    00b
-        sync
-        blr
-
-_GLOBAL(_insl)
-        sync
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,4
-        blelr-
-00:     lwbrx   r5,0,r3
-        eieio
-        stwu    r5,4(r4)
-        bdnz    00b
-        twi     0,r5,0
-        isync
-        blr
-
-_GLOBAL(_outsl)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,4
-        blelr-
-        sync
-00:     lwzu    r5,4(r4)
-        stwbrx  r5,0,r3
-        bdnz    00b
-        sync
-        blr
-
-#ifdef CONFIG_PPC32
-_GLOBAL(__ide_mm_insw)
-#endif
-_GLOBAL(_insw_ns)
-        sync
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,2
-        blelr-
-00:     lhz     r5,0(r3)
-        eieio
-        sthu    r5,2(r4)
-        bdnz    00b
-        twi     0,r5,0
-        isync
-        blr
-
-#ifdef CONFIG_PPC32
-_GLOBAL(__ide_mm_outsw)
-#endif
-_GLOBAL(_outsw_ns)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,2
-        blelr-
-        sync
-00:     lhzu    r5,2(r4)
-        sth     r5,0(r3)
-        bdnz    00b
-        sync
-        blr
-
-#ifdef CONFIG_PPC32
-_GLOBAL(__ide_mm_insl)
-#endif
-_GLOBAL(_insl_ns)
-        sync
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,4
-        blelr-
-00:     lwz     r5,0(r3)
-        eieio
-        stwu    r5,4(r4)
-        bdnz    00b
-        twi     0,r5,0
-        isync
-        blr
-
-#ifdef CONFIG_PPC32
-_GLOBAL(__ide_mm_outsl)
-#endif
-_GLOBAL(_outsl_ns)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,4
-        blelr-
-        sync
-00:     lwzu    r5,4(r4)
-        stw     r5,0(r3)
-        bdnz    00b
-        sync
-        blr
-
diff --git a/arch/powerpc/kernel/of_device.c b/arch/powerpc/kernel/of_device.c
index 3262b73a3a68..397c83eda20e 100644
--- a/arch/powerpc/kernel/of_device.c
+++ b/arch/powerpc/kernel/of_device.c
@@ -189,27 +189,9 @@ void of_release_dev(struct device *dev)
 int of_device_register(struct of_device *ofdev)
 {
         int rc;
-        struct of_device **odprop;
 
         BUG_ON(ofdev->node == NULL);
 
-        odprop = (struct of_device **)get_property(ofdev->node, "linux,device", NULL);
-        if (!odprop) {
-                struct property *new_prop;
-        
-                new_prop = kmalloc(sizeof(struct property) + sizeof(struct of_device *),
-                        GFP_KERNEL);
-                if (new_prop == NULL)
-                        return -ENOMEM;
-                new_prop->name = "linux,device";
-                new_prop->length = sizeof(sizeof(struct of_device *));
-                new_prop->value = (unsigned char *)&new_prop[1];
-                odprop = (struct of_device **)new_prop->value;
-                *odprop = NULL;
-                prom_add_property(ofdev->node, new_prop);
-        }
-        *odprop = ofdev;
-
         rc = device_register(&ofdev->dev);
         if (rc)
                 return rc;
@@ -221,14 +203,8 @@ int of_device_register(struct of_device *ofdev)
 
 void of_device_unregister(struct of_device *ofdev)
 {
-        struct of_device **odprop;
-
         device_remove_file(&ofdev->dev, &dev_attr_devspec);
 
-        odprop = (struct of_device **)get_property(ofdev->node, "linux,device", NULL);
-        if (odprop)
-                *odprop = NULL;
-
         device_unregister(&ofdev->dev);
 }
 
diff --git a/arch/powerpc/kernel/paca.c b/arch/powerpc/kernel/paca.c
index c68741fed14b..55f1a25085cd 100644
--- a/arch/powerpc/kernel/paca.c
+++ b/arch/powerpc/kernel/paca.c
@@ -17,6 +17,7 @@
 #include <asm/lppaca.h>
 #include <asm/iseries/it_lp_reg_save.h>
 #include <asm/paca.h>
+#include <asm/mmu.h>
 
 
 /* This symbol is provided by the linker - let it fill in the paca
@@ -45,6 +46,17 @@ struct lppaca lppaca[] = {
         },
 };
 
+/*
+ * 3 persistent SLBs are registered here.  The buffer will be zero
+ * initially, hence will all be invaild until we actually write them.
+ */
+struct slb_shadow slb_shadow[] __cacheline_aligned = {
+        [0 ... (NR_CPUS-1)] = {
+                .persistent = SLB_NUM_BOLTED,
+                .buffer_length = sizeof(struct slb_shadow),
+        },
+};
+
 /* The Paca is an array with one entry per processor.  Each contains an
  * lppaca, which contains the information shared between the
  * hypervisor and Linux.
@@ -59,7 +71,8 @@ struct lppaca lppaca[] = {
         .lock_token = 0x8000,                                               \
         .paca_index = (number),         /* Paca Index */                    \
         .kernel_toc = (unsigned long)(&__toc_start) + 0x8000UL,             \
-        .hw_cpu_id = 0xffff,
+        .hw_cpu_id = 0xffff,                                                \
+        .slb_shadow_ptr = &slb_shadow[number],
 
 #ifdef CONFIG_PPC_ISERIES
 #define PACA_INIT_ISERIES(number)                                           \
diff --git a/arch/powerpc/kernel/pci_32.c b/arch/powerpc/kernel/pci_32.c
index 09b1e1bbb29b..9b49f8691d29 100644
--- a/arch/powerpc/kernel/pci_32.c
+++ b/arch/powerpc/kernel/pci_32.c
@@ -633,12 +633,12 @@ pcibios_alloc_controller(void)
 static void
 make_one_node_map(struct device_node* node, u8 pci_bus)
 {
-        int *bus_range;
+        const int *bus_range;
         int len;
 
         if (pci_bus >= pci_bus_count)
                 return;
-        bus_range = (int *) get_property(node, "bus-range", &len);
+        bus_range = get_property(node, "bus-range", &len);
         if (bus_range == NULL || len < 2 * sizeof(int)) {
                 printk(KERN_WARNING "Can't get bus-range for %s, "
                        "assuming it starts at 0\n", node->full_name);
@@ -648,13 +648,13 @@ make_one_node_map(struct device_node* node, u8 pci_bus)
 
         for (node=node->child; node != 0;node = node->sibling) {
                 struct pci_dev* dev;
-                unsigned int *class_code, *reg;
+                const unsigned int *class_code, *reg;
         
-                class_code = (unsigned int *) get_property(node, "class-code", NULL);
+                class_code = get_property(node, "class-code", NULL);
                 if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
                         (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
                         continue;
-                reg = (unsigned int *)get_property(node, "reg", NULL);
+                reg = get_property(node, "reg", NULL);
                 if (!reg)
                         continue;
                 dev = pci_find_slot(pci_bus, ((reg[0] >> 8) & 0xff));
@@ -669,7 +669,7 @@ pcibios_make_OF_bus_map(void)
 {
         int i;
         struct pci_controller* hose;
-        u8* of_prop_map;
+        struct property *map_prop;
 
         pci_to_OF_bus_map = (u8*)kmalloc(pci_bus_count, GFP_KERNEL);
         if (!pci_to_OF_bus_map) {
@@ -691,9 +691,12 @@ pcibios_make_OF_bus_map(void)
                         continue;
                 make_one_node_map(node, hose->first_busno);
         }
-        of_prop_map = get_property(find_path_device("/"), "pci-OF-bus-map", NULL);
-        if (of_prop_map)
-                memcpy(of_prop_map, pci_to_OF_bus_map, pci_bus_count);
+        map_prop = of_find_property(find_path_device("/"),
+                        "pci-OF-bus-map", NULL);
+        if (map_prop) {
+                BUG_ON(pci_bus_count > map_prop->length);
+                memcpy(map_prop->value, pci_to_OF_bus_map, pci_bus_count);
+        }
 #ifdef DEBUG
         printk("PCI->OF bus map:\n");
         for (i=0; i<pci_bus_count; i++) {
@@ -712,7 +715,7 @@ scan_OF_pci_childs(struct device_node* node, pci_OF_scan_iterator filter, void*
         struct device_node* sub_node;
 
         for (; node != 0;node = node->sibling) {
-                unsigned int *class_code;
+                const unsigned int *class_code;
         
                 if (filter(node, data))
                         return node;
@@ -722,7 +725,7 @@ scan_OF_pci_childs(struct device_node* node, pci_OF_scan_iterator filter, void*
                  * a fake root for all functions of a multi-function device,
                  * we go down them as well.
                  */
-                class_code = (unsigned int *) get_property(node, "class-code", NULL);
+                class_code = get_property(node, "class-code", NULL);
                 if ((!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
                         (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS)) &&
                         strcmp(node->name, "multifunc-device"))
@@ -737,10 +740,10 @@ scan_OF_pci_childs(struct device_node* node, pci_OF_scan_iterator filter, void*
 static int
 scan_OF_pci_childs_iterator(struct device_node* node, void* data)
 {
-        unsigned int *reg;
+        const unsigned int *reg;
         u8* fdata = (u8*)data;
         
-        reg = (unsigned int *) get_property(node, "reg", NULL);
+        reg = get_property(node, "reg", NULL);
         if (reg && ((reg[0] >> 8) & 0xff) == fdata[1]
                 && ((reg[0] >> 16) & 0xff) == fdata[0])
                 return 1;
@@ -841,7 +844,7 @@ find_OF_pci_device_filter(struct device_node* node, void* data)
 int
 pci_device_from_OF_node(struct device_node* node, u8* bus, u8* devfn)
 {
-        unsigned int *reg;
+        const unsigned int *reg;
         struct pci_controller* hose;
         struct pci_dev* dev = NULL;
         
@@ -854,7 +857,7 @@ pci_device_from_OF_node(struct device_node* node, u8* bus, u8* devfn)
         if (!scan_OF_pci_childs(((struct device_node*)hose->arch_data)->child,
                         find_OF_pci_device_filter, (void *)node))
                 return -ENODEV;
-        reg = (unsigned int *) get_property(node, "reg", NULL);
+        reg = get_property(node, "reg", NULL);
         if (!reg)
                 return -ENODEV;
         *bus = (reg[0] >> 16) & 0xff;
@@ -885,8 +888,8 @@ pci_process_bridge_OF_ranges(struct pci_controller *hose,
                            struct device_node *dev, int primary)
 {
         static unsigned int static_lc_ranges[256] __initdata;
-        unsigned int *dt_ranges, *lc_ranges, *ranges, *prev;
-        unsigned int size;
+        const unsigned int *dt_ranges;
+        unsigned int *lc_ranges, *ranges, *prev, size;
         int rlen = 0, orig_rlen;
         int memno = 0;
         struct resource *res;
@@ -897,7 +900,7 @@ pci_process_bridge_OF_ranges(struct pci_controller *hose,
          * that can have more than 3 ranges, fortunately using contiguous
          * addresses -- BenH
          */
-        dt_ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
+        dt_ranges = get_property(dev, "ranges", &rlen);
         if (!dt_ranges)
                 return;
         /* Sanity check, though hopefully that never happens */
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index 138134c8c17d..c1b1e14775e4 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -185,34 +185,6 @@ static void __devinit pci_setup_pci_controller(struct pci_controller *hose)
         spin_unlock(&hose_spinlock);
 }
 
-static void add_linux_pci_domain(struct device_node *dev,
-                                 struct pci_controller *phb)
-{
-        struct property *of_prop;
-        unsigned int size;
-
-        of_prop = (struct property *)
-                get_property(dev, "linux,pci-domain", &size);
-        if (of_prop != NULL)
-                return;
-        WARN_ON(of_prop && size < sizeof(int));
-        if (of_prop && size < sizeof(int))
-                of_prop = NULL;
-        size = sizeof(struct property) + sizeof(int);
-        if (of_prop == NULL) {
-                if (mem_init_done)
-                        of_prop = kmalloc(size, GFP_KERNEL);
-                else
-                        of_prop = alloc_bootmem(size);
-        }
-        memset(of_prop, 0, sizeof(struct property));
-        of_prop->name = "linux,pci-domain";
-        of_prop->length = sizeof(int);
-        of_prop->value = (unsigned char *)&of_prop[1];
-        *((int *)of_prop->value) = phb->global_number;
-        prom_add_property(dev, of_prop);
-}
-
 struct pci_controller * pcibios_alloc_controller(struct device_node *dev)
 {
         struct pci_controller *phb;
@@ -226,22 +198,13 @@ struct pci_controller * pcibios_alloc_controller(struct device_node *dev)
         pci_setup_pci_controller(phb);
         phb->arch_data = dev;
         phb->is_dynamic = mem_init_done;
-        if (dev) {
+        if (dev)
                 PHB_SET_NODE(phb, of_node_to_nid(dev));
-                add_linux_pci_domain(dev, phb);
-        }
         return phb;
 }
 
 void pcibios_free_controller(struct pci_controller *phb)
 {
-        if (phb->arch_data) {
-                struct device_node *np = phb->arch_data;
-                int *domain = (int *)get_property(np,
-                                                  "linux,pci-domain", NULL);
-                if (domain)
-                        *domain = -1;
-        }
         if (phb->is_dynamic)
                 kfree(phb);
 }
@@ -283,10 +246,10 @@ static void __init pcibios_claim_of_setup(void)
 #ifdef CONFIG_PPC_MULTIPLATFORM
 static u32 get_int_prop(struct device_node *np, const char *name, u32 def)
 {
-        u32 *prop;
+        const u32 *prop;
         int len;
 
-        prop = (u32 *) get_property(np, name, &len);
+        prop = get_property(np, name, &len);
         if (prop && len >= 4)
                 return *prop;
         return def;
@@ -315,10 +278,11 @@ static void pci_parse_of_addrs(struct device_node *node, struct pci_dev *dev)
         u64 base, size;
         unsigned int flags;
         struct resource *res;
-        u32 *addrs, i;
+        const u32 *addrs;
+        u32 i;
         int proplen;
 
-        addrs = (u32 *) get_property(node, "assigned-addresses", &proplen);
+        addrs = get_property(node, "assigned-addresses", &proplen);
         if (!addrs)
                 return;
         DBG("    parse addresses (%d bytes) @ %p\n", proplen, addrs);
@@ -418,7 +382,7 @@ void __devinit of_scan_bus(struct device_node *node,
                                   struct pci_bus *bus)
 {
         struct device_node *child = NULL;
-        u32 *reg;
+        const u32 *reg;
         int reglen, devfn;
         struct pci_dev *dev;
 
@@ -426,7 +390,7 @@ void __devinit of_scan_bus(struct device_node *node,
 
         while ((child = of_get_next_child(node, child)) != NULL) {
                 DBG("  * %s\n", child->full_name);
-                reg = (u32 *) get_property(child, "reg", &reglen);
+                reg = get_property(child, "reg", &reglen);
                 if (reg == NULL || reglen < 20)
                         continue;
                 devfn = (reg[0] >> 8) & 0xff;
@@ -450,7 +414,7 @@ void __devinit of_scan_pci_bridge(struct device_node *node,
                                 struct pci_dev *dev)
 {
         struct pci_bus *bus;
-        u32 *busrange, *ranges;
+        const u32 *busrange, *ranges;
         int len, i, mode;
         struct resource *res;
         unsigned int flags;
@@ -459,13 +423,13 @@ void __devinit of_scan_pci_bridge(struct device_node *node,
         DBG("of_scan_pci_bridge(%s)\n", node->full_name);
 
         /* parse bus-range property */
-        busrange = (u32 *) get_property(node, "bus-range", &len);
+        busrange = get_property(node, "bus-range", &len);
         if (busrange == NULL || len != 8) {
                 printk(KERN_DEBUG "Can't get bus-range for PCI-PCI bridge %s\n",
                        node->full_name);
                 return;
         }
-        ranges = (u32 *) get_property(node, "ranges", &len);
+        ranges = get_property(node, "ranges", &len);
         if (ranges == NULL) {
                 printk(KERN_DEBUG "Can't get ranges for PCI-PCI bridge %s\n",
                        node->full_name);
@@ -929,13 +893,13 @@ static void __devinit pci_process_ISA_OF_ranges(struct device_node *isa_node,
                 unsigned int size;
         };
 
-        struct isa_range *range;
+        const struct isa_range *range;
         unsigned long pci_addr;
         unsigned int isa_addr;
         unsigned int size;
         int rlen = 0;
 
-        range = (struct isa_range *) get_property(isa_node, "ranges", &rlen);
+        range = get_property(isa_node, "ranges", &rlen);
         if (range == NULL || (rlen < sizeof(struct isa_range))) {
                 printk(KERN_ERR "no ISA ranges or unexpected isa range size,"
                        "mapping 64k\n");
@@ -976,7 +940,8 @@ static void __devinit pci_process_ISA_OF_ranges(struct device_node *isa_node,
 void __devinit pci_process_bridge_OF_ranges(struct pci_controller *hose,
                                             struct device_node *dev, int prim)
 {
-        unsigned int *ranges, pci_space;
+        const unsigned int *ranges;
+        unsigned int pci_space;
         unsigned long size;
         int rlen = 0;
         int memno = 0;
@@ -994,7 +959,7 @@ void __devinit pci_process_bridge_OF_ranges(struct pci_controller *hose,
          *                      (size depending on dev->n_addr_cells)
          *   cells 4+5 or 5+6:  the size of the range
          */
-        ranges = (unsigned int *) get_property(dev, "ranges", &rlen);
+        ranges = get_property(dev, "ranges", &rlen);
         if (ranges == NULL)
                 return;
         hose->io_base_phys = 0;
diff --git a/arch/powerpc/kernel/pci_dn.c b/arch/powerpc/kernel/pci_dn.c
index 1c18953514c3..68df018dae0e 100644
--- a/arch/powerpc/kernel/pci_dn.c
+++ b/arch/powerpc/kernel/pci_dn.c
@@ -40,8 +40,8 @@
 static void * __devinit update_dn_pci_info(struct device_node *dn, void *data)
 {
         struct pci_controller *phb = data;
-        int *type = (int *)get_property(dn, "ibm,pci-config-space-type", NULL);
-        u32 *regs;
+        const int *type = get_property(dn, "ibm,pci-config-space-type", NULL);
+        const u32 *regs;
         struct pci_dn *pdn;
 
         if (mem_init_done)
@@ -54,14 +54,14 @@ static void * __devinit update_dn_pci_info(struct device_node *dn, void *data)
         dn->data = pdn;
         pdn->node = dn;
         pdn->phb = phb;
-        regs = (u32 *)get_property(dn, "reg", NULL);
+        regs = get_property(dn, "reg", NULL);
         if (regs) {
                 /* First register entry is addr (00BBSS00)  */
                 pdn->busno = (regs[0] >> 16) & 0xff;
                 pdn->devfn = (regs[0] >> 8) & 0xff;
         }
         if (firmware_has_feature(FW_FEATURE_ISERIES)) {
-                u32 *busp = (u32 *)get_property(dn, "linux,subbus", NULL);
+                const u32 *busp = get_property(dn, "linux,subbus", NULL);
                 if (busp)
                         pdn->bussubno = *busp;
         }
@@ -96,10 +96,11 @@ void *traverse_pci_devices(struct device_node *start, traverse_func pre,
 
         /* We started with a phb, iterate all childs */
         for (dn = start->child; dn; dn = nextdn) {
-                u32 *classp, class;
+                const u32 *classp;
+                u32 class;
 
                 nextdn = NULL;
-                classp = (u32 *)get_property(dn, "class-code", NULL);
+                classp = get_property(dn, "class-code", NULL);
                 class = classp ? *classp : 0;
 
                 if (pre && ((ret = pre(dn, data)) != NULL))
diff --git a/arch/powerpc/kernel/ppc_ksyms.c b/arch/powerpc/kernel/ppc_ksyms.c
index 39d3bfcabcd2..807193a3c784 100644
--- a/arch/powerpc/kernel/ppc_ksyms.c
+++ b/arch/powerpc/kernel/ppc_ksyms.c
@@ -91,25 +91,10 @@ EXPORT_SYMBOL(__copy_tofrom_user);
 EXPORT_SYMBOL(__clear_user);
 EXPORT_SYMBOL(__strncpy_from_user);
 EXPORT_SYMBOL(__strnlen_user);
-
-#ifndef  __powerpc64__
-EXPORT_SYMBOL(__ide_mm_insl);
-EXPORT_SYMBOL(__ide_mm_outsw);
-EXPORT_SYMBOL(__ide_mm_insw);
-EXPORT_SYMBOL(__ide_mm_outsl);
+#ifdef CONFIG_PPC64
+EXPORT_SYMBOL(copy_4K_page);
 #endif
 
-EXPORT_SYMBOL(_insb);
-EXPORT_SYMBOL(_outsb);
-EXPORT_SYMBOL(_insw);
-EXPORT_SYMBOL(_outsw);
-EXPORT_SYMBOL(_insl);
-EXPORT_SYMBOL(_outsl);
-EXPORT_SYMBOL(_insw_ns);
-EXPORT_SYMBOL(_outsw_ns);
-EXPORT_SYMBOL(_insl_ns);
-EXPORT_SYMBOL(_outsl_ns);
-
 #if defined(CONFIG_PPC32) && (defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE))
 EXPORT_SYMBOL(ppc_ide_md);
 #endif
diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
index a1787ffb6319..eb913f80bfb1 100644
--- a/arch/powerpc/kernel/prom.c
+++ b/arch/powerpc/kernel/prom.c
@@ -757,24 +757,9 @@ static int __init early_init_dt_scan_root(unsigned long node,
 static unsigned long __init dt_mem_next_cell(int s, cell_t **cellp)
 {
         cell_t *p = *cellp;
-        unsigned long r;
 
-        /* Ignore more than 2 cells */
-        while (s > sizeof(unsigned long) / 4) {
-                p++;
-                s--;
-        }
-        r = *p++;
-#ifdef CONFIG_PPC64
-        if (s > 1) {
-                r <<= 32;
-                r |= *(p++);
-                s--;
-        }
-#endif
-
-        *cellp = p;
-        return r;
+        *cellp = p + s;
+        return of_read_ulong(p, s);
 }
 
 
@@ -942,11 +927,11 @@ void __init early_init_devtree(void *params)
 int
 prom_n_addr_cells(struct device_node* np)
 {
-        int* ip;
+        const int *ip;
         do {
                 if (np->parent)
                         np = np->parent;
-                ip = (int *) get_property(np, "#address-cells", NULL);
+                ip = get_property(np, "#address-cells", NULL);
                 if (ip != NULL)
                         return *ip;
         } while (np->parent);
@@ -958,11 +943,11 @@ EXPORT_SYMBOL(prom_n_addr_cells);
 int
 prom_n_size_cells(struct device_node* np)
 {
-        int* ip;
+        const int* ip;
         do {
                 if (np->parent)
                         np = np->parent;
-                ip = (int *) get_property(np, "#size-cells", NULL);
+                ip = get_property(np, "#size-cells", NULL);
                 if (ip != NULL)
                         return *ip;
         } while (np->parent);
@@ -1034,7 +1019,7 @@ int device_is_compatible(struct device_node *device, const char *compat)
         const char* cp;
         int cplen, l;
 
-        cp = (char *) get_property(device, "compatible", &cplen);
+        cp = get_property(device, "compatible", &cplen);
         if (cp == NULL)
                 return 0;
         while (cplen > 0) {
@@ -1449,7 +1434,7 @@ static int of_finish_dynamic_node(struct device_node *node)
 {
         struct device_node *parent = of_get_parent(node);
         int err = 0;
-        phandle *ibm_phandle;
+        const phandle *ibm_phandle;
 
         node->name = get_property(node, "name", NULL);
         node->type = get_property(node, "device_type", NULL);
@@ -1466,8 +1451,7 @@ static int of_finish_dynamic_node(struct device_node *node)
                 return -ENODEV;
 
         /* fix up new node's linux_phandle field */
-        if ((ibm_phandle = (unsigned int *)get_property(node,
-                                                        "ibm,phandle", NULL)))
+        if ((ibm_phandle = get_property(node, "ibm,phandle", NULL)))
                 node->linux_phandle = *ibm_phandle;
 
 out:
@@ -1528,7 +1512,7 @@ struct property *of_find_property(struct device_node *np, const char *name,
  * Find a property with a given name for a given node
  * and return the value.
  */
-void *get_property(struct device_node *np, const char *name, int *lenp)
+const void *get_property(struct device_node *np, const char *name, int *lenp)
 {
         struct property *pp = of_find_property(np,name,lenp);
         return pp ? pp->value : NULL;
@@ -1658,16 +1642,16 @@ struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
         hardid = get_hard_smp_processor_id(cpu);
 
         for_each_node_by_type(np, "cpu") {
-                u32 *intserv;
+                const u32 *intserv;
                 unsigned int plen, t;
 
                 /* Check for ibm,ppc-interrupt-server#s. If it doesn't exist
                  * fallback to "reg" property and assume no threads
                  */
-                intserv = (u32 *)get_property(np, "ibm,ppc-interrupt-server#s",
-                                              &plen);
+                intserv = get_property(np, "ibm,ppc-interrupt-server#s",
+                                &plen);
                 if (intserv == NULL) {
-                        u32 *reg = (u32 *)get_property(np, "reg", NULL);
+                        const u32 *reg = get_property(np, "reg", NULL);
                         if (reg == NULL)
                                 continue;
                         if (*reg == hardid) {
diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index 4394e545f9f7..b91761639d96 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -2033,16 +2033,22 @@ static void __init fixup_device_tree_maple(void)
 #endif
 
 #ifdef CONFIG_PPC_CHRP
-/* Pegasos lacks the "ranges" property in the isa node */
+/* Pegasos and BriQ lacks the "ranges" property in the isa node */
 static void __init fixup_device_tree_chrp(void)
 {
         phandle isa;
         u32 isa_ranges[6];
+        u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
         char *name;
         int rc;
 
         name = "/pci@80000000/isa@c";
         isa = call_prom("finddevice", 1, 1, ADDR(name));
+        if (!PHANDLE_VALID(isa)) {
+                name = "/pci@ff500000/isa@6";
+                isa = call_prom("finddevice", 1, 1, ADDR(name));
+                rloc = 0x01003000; /* IO space; PCI device = 6 */
+        }
         if (!PHANDLE_VALID(isa))
                 return;
 
@@ -2054,7 +2060,7 @@ static void __init fixup_device_tree_chrp(void)
 
         isa_ranges[0] = 0x1;
         isa_ranges[1] = 0x0;
-        isa_ranges[2] = 0x01006000;
+        isa_ranges[2] = rloc;
         isa_ranges[3] = 0x0;
         isa_ranges[4] = 0x0;
         isa_ranges[5] = 0x00010000;
diff --git a/arch/powerpc/kernel/prom_parse.c b/arch/powerpc/kernel/prom_parse.c
index a10825a5dfe6..603dff3ad62a 100644
--- a/arch/powerpc/kernel/prom_parse.c
+++ b/arch/powerpc/kernel/prom_parse.c
@@ -27,7 +27,7 @@
 
 /* Debug utility */
 #ifdef DEBUG
-static void of_dump_addr(const char *s, u32 *addr, int na)
+static void of_dump_addr(const char *s, const u32 *addr, int na)
 {
         printk("%s", s);
         while(na--)
@@ -35,7 +35,7 @@ static void of_dump_addr(const char *s, u32 *addr, int na)
         printk("\n");
 }
 #else
-static void of_dump_addr(const char *s, u32 *addr, int na) { }
+static void of_dump_addr(const char *s, const u32 *addr, int na) { }
 #endif
 
 
@@ -46,9 +46,10 @@ struct of_bus {
         int             (*match)(struct device_node *parent);
         void            (*count_cells)(struct device_node *child,
                                        int *addrc, int *sizec);
-        u64             (*map)(u32 *addr, u32 *range, int na, int ns, int pna);
+        u64             (*map)(u32 *addr, const u32 *range,
+                                int na, int ns, int pna);
         int             (*translate)(u32 *addr, u64 offset, int na);
-        unsigned int    (*get_flags)(u32 *addr);
+        unsigned int    (*get_flags)(const u32 *addr);
 };
 
 
@@ -65,7 +66,8 @@ static void of_bus_default_count_cells(struct device_node *dev,
                 *sizec = prom_n_size_cells(dev);
 }
 
-static u64 of_bus_default_map(u32 *addr, u32 *range, int na, int ns, int pna)
+static u64 of_bus_default_map(u32 *addr, const u32 *range,
+                int na, int ns, int pna)
 {
         u64 cp, s, da;
 
@@ -93,7 +95,7 @@ static int of_bus_default_translate(u32 *addr, u64 offset, int na)
         return 0;
 }
 
-static unsigned int of_bus_default_get_flags(u32 *addr)
+static unsigned int of_bus_default_get_flags(const u32 *addr)
 {
         return IORESOURCE_MEM;
 }
@@ -118,7 +120,7 @@ static void of_bus_pci_count_cells(struct device_node *np,
                 *sizec = 2;
 }
 
-static u64 of_bus_pci_map(u32 *addr, u32 *range, int na, int ns, int pna)
+static u64 of_bus_pci_map(u32 *addr, const u32 *range, int na, int ns, int pna)
 {
         u64 cp, s, da;
 
@@ -143,7 +145,7 @@ static int of_bus_pci_translate(u32 *addr, u64 offset, int na)
         return of_bus_default_translate(addr + 1, offset, na - 1);
 }
 
-static unsigned int of_bus_pci_get_flags(u32 *addr)
+static unsigned int of_bus_pci_get_flags(const u32 *addr)
 {
         unsigned int flags = 0;
         u32 w = addr[0];
@@ -178,7 +180,7 @@ static void of_bus_isa_count_cells(struct device_node *child,
                 *sizec = 1;
 }
 
-static u64 of_bus_isa_map(u32 *addr, u32 *range, int na, int ns, int pna)
+static u64 of_bus_isa_map(u32 *addr, const u32 *range, int na, int ns, int pna)
 {
         u64 cp, s, da;
 
@@ -203,7 +205,7 @@ static int of_bus_isa_translate(u32 *addr, u64 offset, int na)
         return of_bus_default_translate(addr + 1, offset, na - 1);
 }
 
-static unsigned int of_bus_isa_get_flags(u32 *addr)
+static unsigned int of_bus_isa_get_flags(const u32 *addr)
 {
         unsigned int flags = 0;
         u32 w = addr[0];
@@ -268,7 +270,7 @@ static int of_translate_one(struct device_node *parent, struct of_bus *bus,
                             struct of_bus *pbus, u32 *addr,
                             int na, int ns, int pna)
 {
-        u32 *ranges;
+        const u32 *ranges;
         unsigned int rlen;
         int rone;
         u64 offset = OF_BAD_ADDR;
@@ -285,7 +287,7 @@ static int of_translate_one(struct device_node *parent, struct of_bus *bus,
          * to translate addresses that aren't supposed to be translated in
          * the first place. --BenH.
          */
-        ranges = (u32 *)get_property(parent, "ranges", &rlen);
+        ranges = get_property(parent, "ranges", &rlen);
         if (ranges == NULL || rlen == 0) {
                 offset = of_read_number(addr, na);
                 memset(addr, 0, pna * 4);
@@ -328,7 +330,7 @@ static int of_translate_one(struct device_node *parent, struct of_bus *bus,
  * that can be mapped to a cpu physical address). This is not really specified
  * that way, but this is traditionally the way IBM at least do things
  */
-u64 of_translate_address(struct device_node *dev, u32 *in_addr)
+u64 of_translate_address(struct device_node *dev, const u32 *in_addr)
 {
         struct device_node *parent = NULL;
         struct of_bus *bus, *pbus;
@@ -405,10 +407,10 @@ u64 of_translate_address(struct device_node *dev, u32 *in_addr)
 }
 EXPORT_SYMBOL(of_translate_address);
 
-u32 *of_get_address(struct device_node *dev, int index, u64 *size,
+const u32 *of_get_address(struct device_node *dev, int index, u64 *size,
                     unsigned int *flags)
 {
-        u32 *prop;
+        const u32 *prop;
         unsigned int psize;
         struct device_node *parent;
         struct of_bus *bus;
@@ -425,7 +427,7 @@ u32 *of_get_address(struct device_node *dev, int index, u64 *size,
                 return NULL;
 
         /* Get "reg" or "assigned-addresses" property */
-        prop = (u32 *)get_property(dev, bus->addresses, &psize);
+        prop = get_property(dev, bus->addresses, &psize);
         if (prop == NULL)
                 return NULL;
         psize /= 4;
@@ -443,10 +445,10 @@ u32 *of_get_address(struct device_node *dev, int index, u64 *size,
 }
 EXPORT_SYMBOL(of_get_address);
 
-u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
+const u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
                         unsigned int *flags)
 {
-        u32 *prop;
+        const u32 *prop;
         unsigned int psize;
         struct device_node *parent;
         struct of_bus *bus;
@@ -467,7 +469,7 @@ u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
                 return NULL;
 
         /* Get "reg" or "assigned-addresses" property */
-        prop = (u32 *)get_property(dev, bus->addresses, &psize);
+        prop = get_property(dev, bus->addresses, &psize);
         if (prop == NULL)
                 return NULL;
         psize /= 4;
@@ -485,7 +487,7 @@ u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
 }
 EXPORT_SYMBOL(of_get_pci_address);
 
-static int __of_address_to_resource(struct device_node *dev, u32 *addrp,
+static int __of_address_to_resource(struct device_node *dev, const u32 *addrp,
                                     u64 size, unsigned int flags,
                                     struct resource *r)
 {
@@ -516,7 +518,7 @@ static int __of_address_to_resource(struct device_node *dev, u32 *addrp,
 int of_address_to_resource(struct device_node *dev, int index,
                            struct resource *r)
 {
-        u32             *addrp;
+        const u32       *addrp;
         u64             size;
         unsigned int    flags;
 
@@ -530,7 +532,7 @@ EXPORT_SYMBOL_GPL(of_address_to_resource);
 int of_pci_address_to_resource(struct device_node *dev, int bar,
                                struct resource *r)
 {
-        u32             *addrp;
+        const u32       *addrp;
         u64             size;
         unsigned int    flags;
 
@@ -541,13 +543,14 @@ int of_pci_address_to_resource(struct device_node *dev, int bar,
 }
 EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
 
-void of_parse_dma_window(struct device_node *dn, unsigned char *dma_window_prop,
+void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop,
                 unsigned long *busno, unsigned long *phys, unsigned long *size)
 {
-        u32 *dma_window, cells;
-        unsigned char *prop;
+        const u32 *dma_window;
+        u32 cells;
+        const unsigned char *prop;
 
-        dma_window = (u32 *)dma_window_prop;
+        dma_window = dma_window_prop;
 
         /* busno is always one cell */
         *busno = *(dma_window++);
@@ -576,13 +579,13 @@ static struct device_node *of_irq_dflt_pic;
 static struct device_node *of_irq_find_parent(struct device_node *child)
 {
         struct device_node *p;
-        phandle *parp;
+        const phandle *parp;
 
         if (!of_node_get(child))
                 return NULL;
 
         do {
-                parp = (phandle *)get_property(child, "interrupt-parent", NULL);
+                parp = get_property(child, "interrupt-parent", NULL);
                 if (parp == NULL)
                         p = of_get_parent(child);
                 else {
@@ -639,11 +642,11 @@ void of_irq_map_init(unsigned int flags)
 
 }
 
-int of_irq_map_raw(struct device_node *parent, u32 *intspec, u32 ointsize,
-                   u32 *addr, struct of_irq *out_irq)
+int of_irq_map_raw(struct device_node *parent, const u32 *intspec, u32 ointsize,
+                const u32 *addr, struct of_irq *out_irq)
 {
         struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL;
-        u32 *tmp, *imap, *imask;
+        const u32 *tmp, *imap, *imask;
         u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0;
         int imaplen, match, i;
 
@@ -657,7 +660,7 @@ int of_irq_map_raw(struct device_node *parent, u32 *intspec, u32 ointsize,
          * is none, we are nice and just walk up the tree
          */
         do {
-                tmp = (u32 *)get_property(ipar, "#interrupt-cells", NULL);
+                tmp = get_property(ipar, "#interrupt-cells", NULL);
                 if (tmp != NULL) {
                         intsize = *tmp;
                         break;
@@ -681,7 +684,7 @@ int of_irq_map_raw(struct device_node *parent, u32 *intspec, u32 ointsize,
          */
         old = of_node_get(ipar);
         do {
-                tmp = (u32 *)get_property(old, "#address-cells", NULL);
+                tmp = get_property(old, "#address-cells", NULL);
                 tnode = of_get_parent(old);
                 of_node_put(old);
                 old = tnode;
@@ -708,7 +711,7 @@ int of_irq_map_raw(struct device_node *parent, u32 *intspec, u32 ointsize,
                 }
 
                 /* Now look for an interrupt-map */
-                imap = (u32 *)get_property(ipar, "interrupt-map", &imaplen);
+                imap = get_property(ipar, "interrupt-map", &imaplen);
                 /* No interrupt map, check for an interrupt parent */
                 if (imap == NULL) {
                         DBG(" -> no map, getting parent\n");
@@ -718,7 +721,7 @@ int of_irq_map_raw(struct device_node *parent, u32 *intspec, u32 ointsize,
                 imaplen /= sizeof(u32);
 
                 /* Look for a mask */
-                imask = (u32 *)get_property(ipar, "interrupt-map-mask", NULL);
+                imask = get_property(ipar, "interrupt-map-mask", NULL);
 
                 /* If we were passed no "reg" property and we attempt to parse
                  * an interrupt-map, then #address-cells must be 0.
@@ -765,14 +768,14 @@ int of_irq_map_raw(struct device_node *parent, u32 *intspec, u32 ointsize,
                         /* Get #interrupt-cells and #address-cells of new
                          * parent
                          */
-                        tmp = (u32 *)get_property(newpar, "#interrupt-cells",
+                        tmp = get_property(newpar, "#interrupt-cells",
                                                   NULL);
                         if (tmp == NULL) {
                                 DBG(" -> parent lacks #interrupt-cells !\n");
                                 goto fail;
                         }
                         newintsize = *tmp;
-                        tmp = (u32 *)get_property(newpar, "#address-cells",
+                        tmp = get_property(newpar, "#address-cells",
                                                   NULL);
                         newaddrsize = (tmp == NULL) ? 0 : *tmp;
 
@@ -818,14 +821,14 @@ EXPORT_SYMBOL_GPL(of_irq_map_raw);
 static int of_irq_map_oldworld(struct device_node *device, int index,
                                struct of_irq *out_irq)
 {
-        u32 *ints;
+        const u32 *ints;
         int intlen;
 
         /*
          * Old machines just have a list of interrupt numbers
          * and no interrupt-controller nodes.
          */
-        ints = (u32 *) get_property(device, "AAPL,interrupts", &intlen);
+        ints = get_property(device, "AAPL,interrupts", &intlen);
         if (ints == NULL)
                 return -EINVAL;
         intlen /= sizeof(u32);
@@ -850,7 +853,8 @@ static int of_irq_map_oldworld(struct device_node *device, int index,
 int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq)
 {
         struct device_node *p;
-        u32 *intspec, *tmp, intsize, intlen, *addr;
+        const u32 *intspec, *tmp, *addr;
+        u32 intsize, intlen;
         int res;
 
         DBG("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index);
@@ -860,13 +864,13 @@ int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq
                 return of_irq_map_oldworld(device, index, out_irq);
 
         /* Get the interrupts property */
-        intspec = (u32 *)get_property(device, "interrupts", &intlen);
+        intspec = get_property(device, "interrupts", &intlen);
         if (intspec == NULL)
                 return -EINVAL;
         intlen /= sizeof(u32);
 
         /* Get the reg property (if any) */
-        addr = (u32 *)get_property(device, "reg", NULL);
+        addr = get_property(device, "reg", NULL);
 
         /* Look for the interrupt parent. */
         p = of_irq_find_parent(device);
@@ -874,7 +878,7 @@ int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq
                 return -EINVAL;
 
         /* Get size of interrupt specifier */
-        tmp = (u32 *)get_property(p, "#interrupt-cells", NULL);
+        tmp = get_property(p, "#interrupt-cells", NULL);
         if (tmp == NULL) {
                 of_node_put(p);
                 return -EINVAL;
diff --git a/arch/powerpc/kernel/rtas-proc.c b/arch/powerpc/kernel/rtas-proc.c
index 9c9ad1fa9cce..2fe82abf1c52 100644
--- a/arch/powerpc/kernel/rtas-proc.c
+++ b/arch/powerpc/kernel/rtas-proc.c
@@ -246,12 +246,12 @@ struct file_operations ppc_rtas_rmo_buf_ops = {
 
 static int ppc_rtas_find_all_sensors(void);
 static void ppc_rtas_process_sensor(struct seq_file *m,
-        struct individual_sensor *s, int state, int error, char *loc);
+        struct individual_sensor *s, int state, int error, const char *loc);
 static char *ppc_rtas_process_error(int error);
 static void get_location_code(struct seq_file *m,
-        struct individual_sensor *s, char *loc);
-static void check_location_string(struct seq_file *m, char *c);
-static void check_location(struct seq_file *m, char *c);
+        struct individual_sensor *s, const char *loc);
+static void check_location_string(struct seq_file *m, const char *c);
+static void check_location(struct seq_file *m, const char *c);
 
 static int __init proc_rtas_init(void)
 {
@@ -446,11 +446,11 @@ static int ppc_rtas_sensors_show(struct seq_file *m, void *v)
         for (i=0; i<sensors.quant; i++) {
                 struct individual_sensor *p = &sensors.sensor[i];
                 char rstr[64];
-                char *loc;
+                const char *loc;
                 int llen, offs;
 
                 sprintf (rstr, SENSOR_PREFIX"%04d", p->token);
-                loc = (char *) get_property(rtas_node, rstr, &llen);
+                loc = get_property(rtas_node, rstr, &llen);
 
                 /* A sensor may have multiple instances */
                 for (j = 0, offs = 0; j <= p->quant; j++) {
@@ -474,10 +474,10 @@ static int ppc_rtas_sensors_show(struct seq_file *m, void *v)
 
 static int ppc_rtas_find_all_sensors(void)
 {
-        unsigned int *utmp;
+        const unsigned int *utmp;
         int len, i;
 
-        utmp = (unsigned int *) get_property(rtas_node, "rtas-sensors", &len);
+        utmp = get_property(rtas_node, "rtas-sensors", &len);
         if (utmp == NULL) {
                 printk (KERN_ERR "error: could not get rtas-sensors\n");
                 return 1;
@@ -530,7 +530,7 @@ static char *ppc_rtas_process_error(int error)
  */
 
 static void ppc_rtas_process_sensor(struct seq_file *m,
-        struct individual_sensor *s, int state, int error, char *loc)
+        struct individual_sensor *s, int state, int error, const char *loc)
 {
         /* Defined return vales */
         const char * key_switch[]        = { "Off\t", "Normal\t", "Secure\t", 
@@ -682,7 +682,7 @@ static void ppc_rtas_process_sensor(struct seq_file *m,
 
 /* ****************************************************************** */
 
-static void check_location(struct seq_file *m, char *c)
+static void check_location(struct seq_file *m, const char *c)
 {
         switch (c[0]) {
                 case LOC_PLANAR:
@@ -719,7 +719,7 @@ static void check_location(struct seq_file *m, char *c)
  * ${LETTER}${NUMBER}[[-/]${LETTER}${NUMBER} [ ... ] ]
  * the '.' may be an abbrevation
  */
-static void check_location_string(struct seq_file *m, char *c)
+static void check_location_string(struct seq_file *m, const char *c)
 {
         while (*c) {
                 if (isalpha(*c) || *c == '.')
@@ -733,7 +733,8 @@ static void check_location_string(struct seq_file *m, char *c)
 
 /* ****************************************************************** */
 
-static void get_location_code(struct seq_file *m, struct individual_sensor *s, char *loc)
+static void get_location_code(struct seq_file *m, struct individual_sensor *s,
+                const char *loc)
 {
         if (!loc || !*loc) {
                 seq_printf(m, "---");/* does not have a location */
diff --git a/arch/powerpc/kernel/rtas.c b/arch/powerpc/kernel/rtas.c
index 77f1e06d208d..6ef80d4e38d3 100644
--- a/arch/powerpc/kernel/rtas.c
+++ b/arch/powerpc/kernel/rtas.c
@@ -177,10 +177,12 @@ void __init udbg_init_rtas_console(void)
 void rtas_progress(char *s, unsigned short hex)
 {
         struct device_node *root;
-        int width, *p;
+        int width;
+        const int *p;
         char *os;
         static int display_character, set_indicator;
-        static int display_width, display_lines, *row_width, form_feed;
+        static int display_width, display_lines, form_feed;
+        const static int *row_width;
         static DEFINE_SPINLOCK(progress_lock);
         static int current_line;
         static int pending_newline = 0;  /* did last write end with unprinted newline? */
@@ -191,16 +193,16 @@ void rtas_progress(char *s, unsigned short hex)
         if (display_width == 0) {
                 display_width = 0x10;
                 if ((root = find_path_device("/rtas"))) {
-                        if ((p = (unsigned int *)get_property(root,
+                        if ((p = get_property(root,
                                         "ibm,display-line-length", NULL)))
                                 display_width = *p;
-                        if ((p = (unsigned int *)get_property(root,
+                        if ((p = get_property(root,
                                         "ibm,form-feed", NULL)))
                                 form_feed = *p;
-                        if ((p = (unsigned int *)get_property(root,
+                        if ((p = get_property(root,
                                         "ibm,display-number-of-lines", NULL)))
                                 display_lines = *p;
-                        row_width = (unsigned int *)get_property(root,
+                        row_width = get_property(root,
                                         "ibm,display-truncation-length", NULL);
                 }
                 display_character = rtas_token("display-character");
@@ -293,10 +295,10 @@ EXPORT_SYMBOL(rtas_progress);		/* needed by rtas_flash module */
 
 int rtas_token(const char *service)
 {
-        int *tokp;
+        const int *tokp;
         if (rtas.dev == NULL)
                 return RTAS_UNKNOWN_SERVICE;
-        tokp = (int *) get_property(rtas.dev, service, NULL);
+        tokp = get_property(rtas.dev, service, NULL);
         return tokp ? *tokp : RTAS_UNKNOWN_SERVICE;
 }
 EXPORT_SYMBOL(rtas_token);
@@ -626,6 +628,9 @@ void rtas_os_term(char *str)
 {
         int status;
 
+        if (panic_timeout)
+                return;
+
         if (RTAS_UNKNOWN_SERVICE == rtas_token("ibm,os-term"))
                 return;
 
@@ -687,15 +692,14 @@ static int rtas_ibm_suspend_me(struct rtas_args *args)
         int i;
         long state;
         long rc;
-        unsigned long dummy;
-
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
         struct rtas_suspend_me_data data;
 
         /* Make sure the state is valid */
-        rc = plpar_hcall(H_VASI_STATE,
-                         ((u64)args->args[0] << 32) | args->args[1],
-                         0, 0, 0,
-                         &state, &dummy, &dummy);
+        rc = plpar_hcall(H_VASI_STATE, retbuf,
+                         ((u64)args->args[0] << 32) | args->args[1]);
+
+        state = retbuf[0];
 
         if (rc) {
                 printk(KERN_ERR "rtas_ibm_suspend_me: vasi_state returned %ld\n",rc);
@@ -845,15 +849,15 @@ void __init rtas_initialize(void)
          */
         rtas.dev = of_find_node_by_name(NULL, "rtas");
         if (rtas.dev) {
-                u32 *basep, *entryp;
-                u32 *sizep;
+                const u32 *basep, *entryp, *sizep;
 
-                basep = (u32 *)get_property(rtas.dev, "linux,rtas-base", NULL);
-                sizep = (u32 *)get_property(rtas.dev, "rtas-size", NULL);
+                basep = get_property(rtas.dev, "linux,rtas-base", NULL);
+                sizep = get_property(rtas.dev, "rtas-size", NULL);
                 if (basep != NULL && sizep != NULL) {
                         rtas.base = *basep;
                         rtas.size = *sizep;
-                        entryp = (u32 *)get_property(rtas.dev, "linux,rtas-entry", NULL);
+                        entryp = get_property(rtas.dev,
+                                        "linux,rtas-entry", NULL);
                         if (entryp == NULL) /* Ugh */
                                 rtas.entry = rtas.base;
                         else
@@ -909,6 +913,11 @@ int __init early_init_dt_scan_rtas(unsigned long node,
         basep = of_get_flat_dt_prop(node, "get-term-char", NULL);
         if (basep)
                 rtas_getchar_token = *basep;
+
+        if (rtas_putchar_token != RTAS_UNKNOWN_SERVICE &&
+            rtas_getchar_token != RTAS_UNKNOWN_SERVICE)
+                udbg_init_rtas_console();
+
 #endif
 
         /* break now */
diff --git a/arch/powerpc/kernel/rtas_pci.c b/arch/powerpc/kernel/rtas_pci.c
index cda022657324..b4a0de79c060 100644
--- a/arch/powerpc/kernel/rtas_pci.c
+++ b/arch/powerpc/kernel/rtas_pci.c
@@ -57,7 +57,7 @@ static inline int config_access_valid(struct pci_dn *dn, int where)
 
 static int of_device_available(struct device_node * dn)
 {
-        char * status;
+        const char *status;
 
         status = get_property(dn, "status", NULL);
 
@@ -81,8 +81,7 @@ int rtas_read_config(struct pci_dn *pdn, int where, int size, u32 *val)
         if (!config_access_valid(pdn, where))
                 return PCIBIOS_BAD_REGISTER_NUMBER;
 
-        addr = ((where & 0xf00) << 20) | (pdn->busno << 16) |
-                (pdn->devfn << 8) | (where & 0xff);
+        addr = rtas_config_addr(pdn->busno, pdn->devfn, where);
         buid = pdn->phb->buid;
         if (buid) {
                 ret = rtas_call(ibm_read_pci_config, 4, 2, &returnval,
@@ -134,8 +133,7 @@ int rtas_write_config(struct pci_dn *pdn, int where, int size, u32 val)
         if (!config_access_valid(pdn, where))
                 return PCIBIOS_BAD_REGISTER_NUMBER;
 
-        addr = ((where & 0xf00) << 20) | (pdn->busno << 16) |
-                (pdn->devfn << 8) | (where & 0xff);
+        addr = rtas_config_addr(pdn->busno, pdn->devfn, where);
         buid = pdn->phb->buid;
         if (buid) {
                 ret = rtas_call(ibm_write_pci_config, 5, 1, NULL, addr,
@@ -178,7 +176,7 @@ struct pci_ops rtas_pci_ops = {
 
 int is_python(struct device_node *dev)
 {
-        char *model = (char *)get_property(dev, "model", NULL);
+        const char *model = get_property(dev, "model", NULL);
 
         if (model && strstr(model, "Python"))
                 return 1;
@@ -234,7 +232,7 @@ void __init init_pci_config_tokens (void)
 unsigned long __devinit get_phb_buid (struct device_node *phb)
 {
         int addr_cells;
-        unsigned int *buid_vals;
+        const unsigned int *buid_vals;
         unsigned int len;
         unsigned long buid;
 
@@ -247,7 +245,7 @@ unsigned long __devinit get_phb_buid (struct device_node *phb)
         if (phb->parent->parent)
                 return 0;
 
-        buid_vals = (unsigned int *) get_property(phb, "reg", &len);
+        buid_vals = get_property(phb, "reg", &len);
         if (buid_vals == NULL)
                 return 0;
 
@@ -264,10 +262,10 @@ unsigned long __devinit get_phb_buid (struct device_node *phb)
 static int phb_set_bus_ranges(struct device_node *dev,
                               struct pci_controller *phb)
 {
-        int *bus_range;
+        const int *bus_range;
         unsigned int len;
 
-        bus_range = (int *) get_property(dev, "bus-range", &len);
+        bus_range = get_property(dev, "bus-range", &len);
         if (bus_range == NULL || len < 2 * sizeof(int)) {
                 return 1;
         }
@@ -325,15 +323,15 @@ unsigned long __init find_and_init_phbs(void)
          * in chosen.
          */
         if (of_chosen) {
-                int *prop;
+                const int *prop;
 
-                prop = (int *)get_property(of_chosen, "linux,pci-probe-only",
-                                           NULL);
+                prop = get_property(of_chosen,
+                                "linux,pci-probe-only", NULL);
                 if (prop)
                         pci_probe_only = *prop;
 
-                prop = (int *)get_property(of_chosen,
-                                           "linux,pci-assign-all-buses", NULL);
+                prop = get_property(of_chosen,
+                                "linux,pci-assign-all-buses", NULL);
                 if (prop)
                         pci_assign_all_buses = *prop;
         }
diff --git a/arch/powerpc/kernel/setup-common.c b/arch/powerpc/kernel/setup-common.c
index 499c3861074f..0af3fc1bdcc9 100644
--- a/arch/powerpc/kernel/setup-common.c
+++ b/arch/powerpc/kernel/setup-common.c
@@ -304,19 +304,21 @@ struct seq_operations cpuinfo_op = {
 void __init check_for_initrd(void)
 {
 #ifdef CONFIG_BLK_DEV_INITRD
-        unsigned long *prop;
+        const unsigned int *prop;
+        int len;
 
         DBG(" -> check_for_initrd()\n");
 
         if (of_chosen) {
-                prop = (unsigned long *)get_property(of_chosen,
-                                "linux,initrd-start", NULL);
+                prop = get_property(of_chosen, "linux,initrd-start", &len);
                 if (prop != NULL) {
-                        initrd_start = (unsigned long)__va(*prop);
-                        prop = (unsigned long *)get_property(of_chosen,
-                                        "linux,initrd-end", NULL);
+                        initrd_start = (unsigned long)
+                                __va(of_read_ulong(prop, len / 4));
+                        prop = get_property(of_chosen,
+                                        "linux,initrd-end", &len);
                         if (prop != NULL) {
-                                initrd_end = (unsigned long)__va(*prop);
+                                initrd_end = (unsigned long)
+                                        __va(of_read_ulong(prop, len / 4));
                                 initrd_below_start_ok = 1;
                         } else
                                 initrd_start = 0;
@@ -366,15 +368,14 @@ void __init smp_setup_cpu_maps(void)
         int cpu = 0;
 
         while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < NR_CPUS) {
-                int *intserv;
+                const int *intserv;
                 int j, len = sizeof(u32), nthreads = 1;
 
-                intserv = (int *)get_property(dn, "ibm,ppc-interrupt-server#s",
-                                              &len);
+                intserv = get_property(dn, "ibm,ppc-interrupt-server#s", &len);
                 if (intserv)
                         nthreads = len / sizeof(int);
                 else {
-                        intserv = (int *) get_property(dn, "reg", NULL);
+                        intserv = get_property(dn, "reg", NULL);
                         if (!intserv)
                                 intserv = &cpu; /* assume logical == phys */
                 }
@@ -395,13 +396,12 @@ void __init smp_setup_cpu_maps(void)
         if (machine_is(pseries) && firmware_has_feature(FW_FEATURE_LPAR) &&
             (dn = of_find_node_by_path("/rtas"))) {
                 int num_addr_cell, num_size_cell, maxcpus;
-                unsigned int *ireg;
+                const unsigned int *ireg;
 
                 num_addr_cell = prom_n_addr_cells(dn);
                 num_size_cell = prom_n_size_cells(dn);
 
-                ireg = (unsigned int *)
-                        get_property(dn, "ibm,lrdr-capacity", NULL);
+                ireg = get_property(dn, "ibm,lrdr-capacity", NULL);
 
                 if (!ireg)
                         goto out;
@@ -444,6 +444,8 @@ void __init smp_setup_cpu_maps(void)
 
 int __initdata do_early_xmon;
 #ifdef CONFIG_XMON
+extern int xmon_no_auto_backtrace;
+
 static int __init early_xmon(char *p)
 {
         /* ensure xmon is enabled */
@@ -452,6 +454,8 @@ static int __init early_xmon(char *p)
                         xmon_init(1);
                 if (strncmp(p, "off", 3) == 0)
                         xmon_init(0);
+                if (strncmp(p, "nobt", 4) == 0)
+                        xmon_no_auto_backtrace = 1;
                 if (strncmp(p, "early", 5) != 0)
                         return 0;
         }
diff --git a/arch/powerpc/kernel/setup_64.c b/arch/powerpc/kernel/setup_64.c
index fd1785e4c9bb..00d6b8addd78 100644
--- a/arch/powerpc/kernel/setup_64.c
+++ b/arch/powerpc/kernel/setup_64.c
@@ -56,7 +56,6 @@
 #include <asm/page.h>
 #include <asm/mmu.h>
 #include <asm/lmb.h>
-#include <asm/iseries/it_lp_naca.h>
 #include <asm/firmware.h>
 #include <asm/xmon.h>
 #include <asm/udbg.h>
@@ -79,10 +78,10 @@ u64 ppc64_pft_size;
  * before we've read this from the device tree.
  */
 struct ppc64_caches ppc64_caches = {
-        .dline_size = 0x80,
-        .log_dline_size = 7,
-        .iline_size = 0x80,
-        .log_iline_size = 7
+        .dline_size = 0x40,
+        .log_dline_size = 6,
+        .iline_size = 0x40,
+        .log_iline_size = 6
 };
 EXPORT_SYMBOL_GPL(ppc64_caches);
 
@@ -107,7 +106,7 @@ static int smt_enabled_cmdline;
 static void check_smt_enabled(void)
 {
         struct device_node *dn;
-        char *smt_option;
+        const char *smt_option;
 
         /* Allow the command line to overrule the OF option */
         if (smt_enabled_cmdline)
@@ -116,7 +115,7 @@ static void check_smt_enabled(void)
         dn = of_find_node_by_path("/options");
 
         if (dn) {
-                smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL);
+                smt_option = get_property(dn, "ibm,smt-enabled", NULL);
 
                 if (smt_option) {
                         if (!strcmp(smt_option, "on"))
@@ -293,7 +292,7 @@ static void __init initialize_cache_info(void)
                  */
 
                 if ( num_cpus == 1 ) {
-                        u32 *sizep, *lsizep;
+                        const u32 *sizep, *lsizep;
                         u32 size, lsize;
                         const char *dc, *ic;
 
@@ -308,10 +307,10 @@ static void __init initialize_cache_info(void)
 
                         size = 0;
                         lsize = cur_cpu_spec->dcache_bsize;
-                        sizep = (u32 *)get_property(np, "d-cache-size", NULL);
+                        sizep = get_property(np, "d-cache-size", NULL);
                         if (sizep != NULL)
                                 size = *sizep;
-                        lsizep = (u32 *) get_property(np, dc, NULL);
+                        lsizep = get_property(np, dc, NULL);
                         if (lsizep != NULL)
                                 lsize = *lsizep;
                         if (sizep == 0 || lsizep == 0)
@@ -325,10 +324,10 @@ static void __init initialize_cache_info(void)
 
                         size = 0;
                         lsize = cur_cpu_spec->icache_bsize;
-                        sizep = (u32 *)get_property(np, "i-cache-size", NULL);
+                        sizep = get_property(np, "i-cache-size", NULL);
                         if (sizep != NULL)
                                 size = *sizep;
-                        lsizep = (u32 *)get_property(np, ic, NULL);
+                        lsizep = get_property(np, ic, NULL);
                         if (lsizep != NULL)
                                 lsize = *lsizep;
                         if (sizep == 0 || lsizep == 0)
diff --git a/arch/powerpc/kernel/sysfs.c b/arch/powerpc/kernel/sysfs.c
index fec228cd0163..406f308ddead 100644
--- a/arch/powerpc/kernel/sysfs.c
+++ b/arch/powerpc/kernel/sysfs.c
@@ -60,7 +60,7 @@ static int smt_snooze_cmdline;
 static int __init smt_setup(void)
 {
         struct device_node *options;
-        unsigned int *val;
+        const unsigned int *val;
         unsigned int cpu;
 
         if (!cpu_has_feature(CPU_FTR_SMT))
@@ -70,8 +70,7 @@ static int __init smt_setup(void)
         if (!options)
                 return -ENODEV;
 
-        val = (unsigned int *)get_property(options, "ibm,smt-snooze-delay",
-                                           NULL);
+        val = get_property(options, "ibm,smt-snooze-delay", NULL);
         if (!smt_snooze_cmdline && val) {
                 for_each_possible_cpu(cpu)
                         per_cpu(smt_snooze_delay, cpu) = *val;
@@ -231,7 +230,7 @@ static void register_cpu_online(unsigned int cpu)
         if (cur_cpu_spec->num_pmcs >= 8)
                 sysdev_create_file(s, &attr_pmc8);
 
-        if (cpu_has_feature(CPU_FTR_SMT))
+        if (cpu_has_feature(CPU_FTR_PURR))
                 sysdev_create_file(s, &attr_purr);
 }
 
@@ -273,7 +272,7 @@ static void unregister_cpu_online(unsigned int cpu)
         if (cur_cpu_spec->num_pmcs >= 8)
                 sysdev_remove_file(s, &attr_pmc8);
 
-        if (cpu_has_feature(CPU_FTR_SMT))
+        if (cpu_has_feature(CPU_FTR_PURR))
                 sysdev_remove_file(s, &attr_purr);
 }
 #endif /* CONFIG_HOTPLUG_CPU */
diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index a124499e65d9..7a3c3f791ade 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -860,19 +860,17 @@ EXPORT_SYMBOL(do_settimeofday);
 static int __init get_freq(char *name, int cells, unsigned long *val)
 {
         struct device_node *cpu;
-        unsigned int *fp;
+        const unsigned int *fp;
         int found = 0;
 
         /* The cpu node should have timebase and clock frequency properties */
         cpu = of_find_node_by_type(NULL, "cpu");
 
         if (cpu) {
-                fp = (unsigned int *)get_property(cpu, name, NULL);
+                fp = get_property(cpu, name, NULL);
                 if (fp) {
                         found = 1;
-                        *val = 0;
-                        while (cells--)
-                                *val = (*val << 32) | *fp++;
+                        *val = of_read_ulong(fp, cells);
                 }
 
                 of_node_put(cpu);
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index 9b352bd0a460..d9f10f2fc372 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -598,6 +598,9 @@ static void parse_fpe(struct pt_regs *regs)
 #define INST_STSWI              0x7c0005aa
 #define INST_STSWX              0x7c00052a
 
+#define INST_POPCNTB            0x7c0000f4
+#define INST_POPCNTB_MASK       0xfc0007fe
+
 static int emulate_string_inst(struct pt_regs *regs, u32 instword)
 {
         u8 rT = (instword >> 21) & 0x1f;
@@ -666,6 +669,23 @@ static int emulate_string_inst(struct pt_regs *regs, u32 instword)
         return 0;
 }
 
+static int emulate_popcntb_inst(struct pt_regs *regs, u32 instword)
+{
+        u32 ra,rs;
+        unsigned long tmp;
+
+        ra = (instword >> 16) & 0x1f;
+        rs = (instword >> 21) & 0x1f;
+
+        tmp = regs->gpr[rs];
+        tmp = tmp - ((tmp >> 1) & 0x5555555555555555ULL);
+        tmp = (tmp & 0x3333333333333333ULL) + ((tmp >> 2) & 0x3333333333333333ULL);
+        tmp = (tmp + (tmp >> 4)) & 0x0f0f0f0f0f0f0f0fULL;
+        regs->gpr[ra] = tmp;
+
+        return 0;
+}
+
 static int emulate_instruction(struct pt_regs *regs)
 {
         u32 instword;
@@ -703,6 +723,11 @@ static int emulate_instruction(struct pt_regs *regs)
         if ((instword & INST_STRING_GEN_MASK) == INST_STRING)
                 return emulate_string_inst(regs, instword);
 
+        /* Emulate the popcntb (Population Count Bytes) instruction. */
+        if ((instword & INST_POPCNTB_MASK) == INST_POPCNTB) {
+                return emulate_popcntb_inst(regs, instword);
+        }
+
         return -EINVAL;
 }
 
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index fad8580f9081..cb87e71eec66 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -77,7 +77,7 @@ static struct iommu_table *vio_build_iommu_table(struct vio_dev *dev)
         } else
 #endif
         {
-                unsigned char *dma_window;
+                const unsigned char *dma_window;
                 struct iommu_table *tbl;
                 unsigned long offset, size;
 
@@ -217,7 +217,7 @@ static void __devinit vio_dev_release(struct device *dev)
 struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
 {
         struct vio_dev *viodev;
-        unsigned int *unit_address;
+        const unsigned int *unit_address;
 
         /* we need the 'device_type' property, in order to match with drivers */
         if (of_node->type == NULL) {
@@ -227,7 +227,7 @@ struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
                 return NULL;
         }
 
-        unit_address = (unsigned int *)get_property(of_node, "reg", NULL);
+        unit_address = get_property(of_node, "reg", NULL);
         if (unit_address == NULL) {
                 printk(KERN_WARNING "%s: node %s missing 'reg'\n",
                                 __FUNCTION__,
@@ -249,7 +249,7 @@ struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
         viodev->type = of_node->type;
         viodev->unit_address = *unit_address;
         if (firmware_has_feature(FW_FEATURE_ISERIES)) {
-                unit_address = (unsigned int *)get_property(of_node,
+                unit_address = get_property(of_node,
                                 "linux,unit_address", NULL);
                 if (unit_address != NULL)
                         viodev->unit_address = *unit_address;
@@ -423,7 +423,7 @@ static int vio_hotplug(struct device *dev, char **envp, int num_envp,
 {
         const struct vio_dev *vio_dev = to_vio_dev(dev);
         struct device_node *dn = dev->platform_data;
-        char *cp;
+        const char *cp;
         int length;
 
         if (!num_envp)
@@ -431,7 +431,7 @@ static int vio_hotplug(struct device *dev, char **envp, int num_envp,
 
         if (!dn)
                 return -ENODEV;
-        cp = (char *)get_property(dn, "compatible", &length);
+        cp = get_property(dn, "compatible", &length);
         if (!cp)
                 return -ENODEV;
 
@@ -493,11 +493,11 @@ static struct vio_dev *vio_find_name(const char *kobj_name)
  */
 struct vio_dev *vio_find_node(struct device_node *vnode)
 {
-        uint32_t *unit_address;
+        const uint32_t *unit_address;
         char kobj_name[BUS_ID_SIZE];
 
         /* construct the kobject name from the device node */
-        unit_address = (uint32_t *)get_property(vnode, "reg", NULL);
+        unit_address = get_property(vnode, "reg", NULL);
         if (!unit_address)
                 return NULL;
         snprintf(kobj_name, BUS_ID_SIZE, "%x", *unit_address);
diff --git a/arch/powerpc/lib/Makefile b/arch/powerpc/lib/Makefile
index ff7096458249..336dd191f768 100644
--- a/arch/powerpc/lib/Makefile
+++ b/arch/powerpc/lib/Makefile
@@ -14,7 +14,6 @@ endif
 obj-$(CONFIG_PPC64)     += checksum_64.o copypage_64.o copyuser_64.o \
                            memcpy_64.o usercopy_64.o mem_64.o string.o \
                            strcase.o
-obj-$(CONFIG_PPC_ISERIES) += e2a.o
 obj-$(CONFIG_XMON)      += sstep.o
 
 ifeq ($(CONFIG_PPC64),y)
diff --git a/arch/powerpc/lib/e2a.c b/arch/powerpc/lib/e2a.c
deleted file mode 100644
index 4b72ed8fd50e..000000000000
--- a/arch/powerpc/lib/e2a.c
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- *  EBCDIC to ASCII conversion
- *
- * This function moved here from arch/powerpc/platforms/iseries/viopath.c 
- *
- * (C) Copyright 2000-2004 IBM Corporation
- *
- * This program is free software;  you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) anyu later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- */
-
-#include <linux/module.h>
-
-unsigned char e2a(unsigned char x)
-{
-        switch (x) {
-        case 0xF0:
-                return '0';
-        case 0xF1:
-                return '1';
-        case 0xF2:
-                return '2';
-        case 0xF3:
-                return '3';
-        case 0xF4:
-                return '4';
-        case 0xF5:
-                return '5';
-        case 0xF6:
-                return '6';
-        case 0xF7:
-                return '7';
-        case 0xF8:
-                return '8';
-        case 0xF9:
-                return '9';
-        case 0xC1:
-                return 'A';
-        case 0xC2:
-                return 'B';
-        case 0xC3:
-                return 'C';
-        case 0xC4:
-                return 'D';
-        case 0xC5:
-                return 'E';
-        case 0xC6:
-                return 'F';
-        case 0xC7:
-                return 'G';
-        case 0xC8:
-                return 'H';
-        case 0xC9:
-                return 'I';
-        case 0xD1:
-                return 'J';
-        case 0xD2:
-                return 'K';
-        case 0xD3:
-                return 'L';
-        case 0xD4:
-                return 'M';
-        case 0xD5:
-                return 'N';
-        case 0xD6:
-                return 'O';
-        case 0xD7:
-                return 'P';
-        case 0xD8:
-                return 'Q';
-        case 0xD9:
-                return 'R';
-        case 0xE2:
-                return 'S';
-        case 0xE3:
-                return 'T';
-        case 0xE4:
-                return 'U';
-        case 0xE5:
-                return 'V';
-        case 0xE6:
-                return 'W';
-        case 0xE7:
-                return 'X';
-        case 0xE8:
-                return 'Y';
-        case 0xE9:
-                return 'Z';
-        }
-        return ' ';
-}
-EXPORT_SYMBOL(e2a);
-
-unsigned char* strne2a(unsigned char *dest, const unsigned char *src, size_t n)
-{
-        int i;
-
-        n = strnlen(src, n);
-
-        for (i = 0; i < n; i++)
-                dest[i] = e2a(src[i]);
-
-        return dest;
-}
diff --git a/arch/powerpc/lib/locks.c b/arch/powerpc/lib/locks.c
index 077bed7dc52b..80b482ca30df 100644
--- a/arch/powerpc/lib/locks.c
+++ b/arch/powerpc/lib/locks.c
@@ -23,6 +23,7 @@
 #include <asm/hvcall.h>
 #include <asm/iseries/hv_call.h>
 #include <asm/smp.h>
+#include <asm/firmware.h>
 
 void __spin_yield(raw_spinlock_t *lock)
 {
@@ -39,13 +40,12 @@ void __spin_yield(raw_spinlock_t *lock)
         rmb();
         if (lock->slock != lock_value)
                 return;         /* something has changed */
-#ifdef CONFIG_PPC_ISERIES
-        HvCall2(HvCallBaseYieldProcessor, HvCall_YieldToProc,
-                ((u64)holder_cpu << 32) | yield_count);
-#else
-        plpar_hcall_norets(H_CONFER, get_hard_smp_processor_id(holder_cpu),
-                           yield_count);
-#endif
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                HvCall2(HvCallBaseYieldProcessor, HvCall_YieldToProc,
+                        ((u64)holder_cpu << 32) | yield_count);
+        else
+                plpar_hcall_norets(H_CONFER,
+                        get_hard_smp_processor_id(holder_cpu), yield_count);
 }
 
 /*
@@ -69,13 +69,12 @@ void __rw_yield(raw_rwlock_t *rw)
         rmb();
         if (rw->lock != lock_value)
                 return;         /* something has changed */
-#ifdef CONFIG_PPC_ISERIES
-        HvCall2(HvCallBaseYieldProcessor, HvCall_YieldToProc,
-                ((u64)holder_cpu << 32) | yield_count);
-#else
-        plpar_hcall_norets(H_CONFER, get_hard_smp_processor_id(holder_cpu),
-                           yield_count);
-#endif
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                HvCall2(HvCallBaseYieldProcessor, HvCall_YieldToProc,
+                        ((u64)holder_cpu << 32) | yield_count);
+        else
+                plpar_hcall_norets(H_CONFER,
+                        get_hard_smp_processor_id(holder_cpu), yield_count);
 }
 #endif
 
diff --git a/arch/powerpc/mm/numa.c b/arch/powerpc/mm/numa.c
index fbe23933f731..6c0f1c7d83e5 100644
--- a/arch/powerpc/mm/numa.c
+++ b/arch/powerpc/mm/numa.c
@@ -159,12 +159,12 @@ static struct device_node * __cpuinit find_cpu_node(unsigned int cpu)
 {
         unsigned int hw_cpuid = get_hard_smp_processor_id(cpu);
         struct device_node *cpu_node = NULL;
-        unsigned int *interrupt_server, *reg;
+        const unsigned int *interrupt_server, *reg;
         int len;
 
         while ((cpu_node = of_find_node_by_type(cpu_node, "cpu")) != NULL) {
                 /* Try interrupt server first */
-                interrupt_server = (unsigned int *)get_property(cpu_node,
+                interrupt_server = get_property(cpu_node,
                                         "ibm,ppc-interrupt-server#s", &len);
 
                 len = len / sizeof(u32);
@@ -175,8 +175,7 @@ static struct device_node * __cpuinit find_cpu_node(unsigned int cpu)
                                         return cpu_node;
                         }
                 } else {
-                        reg = (unsigned int *)get_property(cpu_node,
-                                                           "reg", &len);
+                        reg = get_property(cpu_node, "reg", &len);
                         if (reg && (len > 0) && (reg[0] == hw_cpuid))
                                 return cpu_node;
                 }
@@ -186,9 +185,9 @@ static struct device_node * __cpuinit find_cpu_node(unsigned int cpu)
 }
 
 /* must hold reference to node during call */
-static int *of_get_associativity(struct device_node *dev)
+static const int *of_get_associativity(struct device_node *dev)
 {
-        return (unsigned int *)get_property(dev, "ibm,associativity", NULL);
+        return get_property(dev, "ibm,associativity", NULL);
 }
 
 /* Returns nid in the range [0..MAX_NUMNODES-1], or -1 if no useful numa
@@ -197,7 +196,7 @@ static int *of_get_associativity(struct device_node *dev)
 static int of_node_to_nid_single(struct device_node *device)
 {
         int nid = -1;
-        unsigned int *tmp;
+        const unsigned int *tmp;
 
         if (min_common_depth == -1)
                 goto out;
@@ -255,7 +254,7 @@ EXPORT_SYMBOL_GPL(of_node_to_nid);
 static int __init find_min_common_depth(void)
 {
         int depth;
-        unsigned int *ref_points;
+        const unsigned int *ref_points;
         struct device_node *rtas_root;
         unsigned int len;
 
@@ -270,7 +269,7 @@ static int __init find_min_common_depth(void)
          * configuration (should be all 0's) and the second is for a normal
          * NUMA configuration.
          */
-        ref_points = (unsigned int *)get_property(rtas_root,
+        ref_points = get_property(rtas_root,
                         "ibm,associativity-reference-points", &len);
 
         if ((len >= 1) && ref_points) {
@@ -297,7 +296,7 @@ static void __init get_n_mem_cells(int *n_addr_cells, int *n_size_cells)
         of_node_put(memory);
 }
 
-static unsigned long __devinit read_n_cells(int n, unsigned int **buf)
+static unsigned long __devinit read_n_cells(int n, const unsigned int **buf)
 {
         unsigned long result = 0;
 
@@ -435,15 +434,13 @@ static int __init parse_numa_properties(void)
                 unsigned long size;
                 int nid;
                 int ranges;
-                unsigned int *memcell_buf;
+                const unsigned int *memcell_buf;
                 unsigned int len;
 
-                memcell_buf = (unsigned int *)get_property(memory,
+                memcell_buf = get_property(memory,
                         "linux,usable-memory", &len);
                 if (!memcell_buf || len <= 0)
-                        memcell_buf =
-                                (unsigned int *)get_property(memory, "reg",
-                                        &len);
+                        memcell_buf = get_property(memory, "reg", &len);
                 if (!memcell_buf || len <= 0)
                         continue;
 
@@ -787,10 +784,10 @@ int hot_add_scn_to_nid(unsigned long scn_addr)
         while ((memory = of_find_node_by_type(memory, "memory")) != NULL) {
                 unsigned long start, size;
                 int ranges;
-                unsigned int *memcell_buf;
+                const unsigned int *memcell_buf;
                 unsigned int len;
 
-                memcell_buf = (unsigned int *)get_property(memory, "reg", &len);
+                memcell_buf = get_property(memory, "reg", &len);
                 if (!memcell_buf || len <= 0)
                         continue;
 
diff --git a/arch/powerpc/mm/slb.c b/arch/powerpc/mm/slb.c
index de0c8842415c..d3733912adb4 100644
--- a/arch/powerpc/mm/slb.c
+++ b/arch/powerpc/mm/slb.c
@@ -22,6 +22,8 @@
 #include <asm/paca.h>
 #include <asm/cputable.h>
 #include <asm/cacheflush.h>
+#include <asm/smp.h>
+#include <linux/compiler.h>
 
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
@@ -50,9 +52,32 @@ static inline unsigned long mk_vsid_data(unsigned long ea, unsigned long flags)
         return (get_kernel_vsid(ea) << SLB_VSID_SHIFT) | flags;
 }
 
-static inline void create_slbe(unsigned long ea, unsigned long flags,
-                               unsigned long entry)
+static inline void slb_shadow_update(unsigned long esid, unsigned long vsid,
+                                     unsigned long entry)
 {
+        /*
+         * Clear the ESID first so the entry is not valid while we are
+         * updating it.
+         */
+        get_slb_shadow()->save_area[entry].esid = 0;
+        barrier();
+        get_slb_shadow()->save_area[entry].vsid = vsid;
+        barrier();
+        get_slb_shadow()->save_area[entry].esid = esid;
+
+}
+
+static inline void create_shadowed_slbe(unsigned long ea, unsigned long flags,
+                                        unsigned long entry)
+{
+        /*
+         * Updating the shadow buffer before writing the SLB ensures
+         * we don't get a stale entry here if we get preempted by PHYP
+         * between these two statements.
+         */
+        slb_shadow_update(mk_esid_data(ea, entry), mk_vsid_data(ea, flags),
+                          entry);
+
         asm volatile("slbmte  %0,%1" :
                      : "r" (mk_vsid_data(ea, flags)),
                        "r" (mk_esid_data(ea, entry))
@@ -77,6 +102,10 @@ void slb_flush_and_rebolt(void)
         if ((ksp_esid_data & ESID_MASK) == PAGE_OFFSET)
                 ksp_esid_data &= ~SLB_ESID_V;
 
+        /* Only third entry (stack) may change here so only resave that */
+        slb_shadow_update(ksp_esid_data,
+                          mk_vsid_data(ksp_esid_data, lflags), 2);
+
         /* We need to do this all in asm, so we're sure we don't touch
          * the stack between the slbia and rebolting it. */
         asm volatile("isync\n"
@@ -209,9 +238,9 @@ void slb_initialize(void)
         asm volatile("isync":::"memory");
         asm volatile("slbmte  %0,%0"::"r" (0) : "memory");
         asm volatile("isync; slbia; isync":::"memory");
-        create_slbe(PAGE_OFFSET, lflags, 0);
+        create_shadowed_slbe(PAGE_OFFSET, lflags, 0);
 
-        create_slbe(VMALLOC_START, vflags, 1);
+        create_shadowed_slbe(VMALLOC_START, vflags, 1);
 
         /* We don't bolt the stack for the time being - we're in boot,
          * so the stack is in the bolted segment.  By the time it goes
diff --git a/arch/powerpc/mm/tlb_64.c b/arch/powerpc/mm/tlb_64.c
index f6eef78efd29..b58baa65c4a7 100644
--- a/arch/powerpc/mm/tlb_64.c
+++ b/arch/powerpc/mm/tlb_64.c
@@ -146,6 +146,7 @@ void hpte_update(struct mm_struct *mm, unsigned long addr,
                 psize = mmu_huge_psize;
 #else
                 BUG();
+                psize = pte_pagesize_index(pte); /* shutup gcc */
 #endif
         } else
                 psize = pte_pagesize_index(pte);
diff --git a/arch/powerpc/platforms/83xx/mpc834x_itx.c b/arch/powerpc/platforms/83xx/mpc834x_itx.c
index cf3967a66fb5..969fbb6d8c46 100644
--- a/arch/powerpc/platforms/83xx/mpc834x_itx.c
+++ b/arch/powerpc/platforms/83xx/mpc834x_itx.c
@@ -60,8 +60,8 @@ static void __init mpc834x_itx_setup_arch(void)
 
         np = of_find_node_by_type(NULL, "cpu");
         if (np != 0) {
-                unsigned int *fp =
-                    (int *)get_property(np, "clock-frequency", NULL);
+                const unsigned int *fp =
+                        get_property(np, "clock-frequency", NULL);
                 if (fp != 0)
                         loops_per_jiffy = *fp / HZ;
                 else
diff --git a/arch/powerpc/platforms/83xx/mpc834x_sys.c b/arch/powerpc/platforms/83xx/mpc834x_sys.c
index 32df239d1c48..677196187a4e 100644
--- a/arch/powerpc/platforms/83xx/mpc834x_sys.c
+++ b/arch/powerpc/platforms/83xx/mpc834x_sys.c
@@ -57,8 +57,8 @@ static void __init mpc834x_sys_setup_arch(void)
 
         np = of_find_node_by_type(NULL, "cpu");
         if (np != 0) {
-                unsigned int *fp =
-                    (int *)get_property(np, "clock-frequency", NULL);
+                const unsigned int *fp =
+                        get_property(np, "clock-frequency", NULL);
                 if (fp != 0)
                         loops_per_jiffy = *fp / HZ;
                 else
diff --git a/arch/powerpc/platforms/83xx/pci.c b/arch/powerpc/platforms/83xx/pci.c
index 5d84a9ccd103..4557ac5255c1 100644
--- a/arch/powerpc/platforms/83xx/pci.c
+++ b/arch/powerpc/platforms/83xx/pci.c
@@ -59,7 +59,7 @@ int __init add_bridge(struct device_node *dev)
         int len;
         struct pci_controller *hose;
         struct resource rsrc;
-        int *bus_range;
+        const int *bus_range;
         int primary = 1, has_address = 0;
         phys_addr_t immr = get_immrbase();
 
@@ -69,7 +69,7 @@ int __init add_bridge(struct device_node *dev)
         has_address = (of_address_to_resource(dev, 0, &rsrc) == 0);
 
         /* Get bus range if any */
-        bus_range = (int *)get_property(dev, "bus-range", &len);
+        bus_range = get_property(dev, "bus-range", &len);
         if (bus_range == NULL || len < 2 * sizeof(int)) {
                 printk(KERN_WARNING "Can't get bus-range for %s, assume"
                        " bus 0\n", dev->full_name);
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_ads.c b/arch/powerpc/platforms/85xx/mpc85xx_ads.c
index 9d2acfbbeccd..cae6b73357d5 100644
--- a/arch/powerpc/platforms/85xx/mpc85xx_ads.c
+++ b/arch/powerpc/platforms/85xx/mpc85xx_ads.c
@@ -121,9 +121,9 @@ static void __init mpc85xx_ads_setup_arch(void)
 
         cpu = of_find_node_by_type(NULL, "cpu");
         if (cpu != 0) {
-                unsigned int *fp;
+                const unsigned int *fp;
 
-                fp = (int *)get_property(cpu, "clock-frequency", NULL);
+                fp = get_property(cpu, "clock-frequency", NULL);
                 if (fp != 0)
                         loops_per_jiffy = *fp / HZ;
                 else
diff --git a/arch/powerpc/platforms/85xx/mpc85xx_cds.c b/arch/powerpc/platforms/85xx/mpc85xx_cds.c
index 1d357d32a29f..4c1fede6470e 100644
--- a/arch/powerpc/platforms/85xx/mpc85xx_cds.c
+++ b/arch/powerpc/platforms/85xx/mpc85xx_cds.c
@@ -241,9 +241,9 @@ mpc85xx_cds_setup_arch(void)
 
         cpu = of_find_node_by_type(NULL, "cpu");
         if (cpu != 0) {
-                unsigned int *fp;
+                const unsigned int *fp;
 
-                fp = (int *)get_property(cpu, "clock-frequency", NULL);
+                fp = get_property(cpu, "clock-frequency", NULL);
                 if (fp != 0)
                         loops_per_jiffy = *fp / HZ;
                 else
diff --git a/arch/powerpc/platforms/85xx/pci.c b/arch/powerpc/platforms/85xx/pci.c
index 1d51f3242ab1..05930eeb6e7f 100644
--- a/arch/powerpc/platforms/85xx/pci.c
+++ b/arch/powerpc/platforms/85xx/pci.c
@@ -41,7 +41,7 @@ int __init add_bridge(struct device_node *dev)
         int len;
         struct pci_controller *hose;
         struct resource rsrc;
-        int *bus_range;
+        const int *bus_range;
         int primary = 1, has_address = 0;
         phys_addr_t immr = get_immrbase();
 
@@ -51,7 +51,7 @@ int __init add_bridge(struct device_node *dev)
         has_address = (of_address_to_resource(dev, 0, &rsrc) == 0);
 
         /* Get bus range if any */
-        bus_range = (int *) get_property(dev, "bus-range", &len);
+        bus_range = get_property(dev, "bus-range", &len);
         if (bus_range == NULL || len < 2 * sizeof(int)) {
                 printk(KERN_WARNING "Can't get bus-range for %s, assume"
                        " bus 0\n", dev->full_name);
diff --git a/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c b/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
index 5e583cf38786..b637e8157f7b 100644
--- a/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
+++ b/arch/powerpc/platforms/86xx/mpc86xx_hpcn.c
@@ -347,9 +347,9 @@ mpc86xx_hpcn_setup_arch(void)
 
         np = of_find_node_by_type(NULL, "cpu");
         if (np != 0) {
-                unsigned int *fp;
+                const unsigned int *fp;
 
-                fp = (int *)get_property(np, "clock-frequency", NULL);
+                fp = get_property(np, "clock-frequency", NULL);
                 if (fp != 0)
                         loops_per_jiffy = *fp / HZ;
                 else
diff --git a/arch/powerpc/platforms/86xx/pci.c b/arch/powerpc/platforms/86xx/pci.c
index a8c8f0a44055..481e18ed5be9 100644
--- a/arch/powerpc/platforms/86xx/pci.c
+++ b/arch/powerpc/platforms/86xx/pci.c
@@ -153,7 +153,7 @@ int __init add_bridge(struct device_node *dev)
         int len;
         struct pci_controller *hose;
         struct resource rsrc;
-        int *bus_range;
+        const int *bus_range;
         int has_address = 0;
         int primary = 0;
 
@@ -163,7 +163,7 @@ int __init add_bridge(struct device_node *dev)
         has_address = (of_address_to_resource(dev, 0, &rsrc) == 0);
 
         /* Get bus range if any */
-        bus_range = (int *) get_property(dev, "bus-range", &len);
+        bus_range = get_property(dev, "bus-range", &len);
         if (bus_range == NULL || len < 2 * sizeof(int))
                 printk(KERN_WARNING "Can't get bus-range for %s, assume"
                        " bus 0\n", dev->full_name);
diff --git a/arch/powerpc/platforms/Makefile b/arch/powerpc/platforms/Makefile
index 5cf46dc57895..e58fa953a50b 100644
--- a/arch/powerpc/platforms/Makefile
+++ b/arch/powerpc/platforms/Makefile
@@ -13,5 +13,6 @@ obj-$(CONFIG_PPC_86xx)		+= 86xx/
 obj-$(CONFIG_PPC_PSERIES)       += pseries/
 obj-$(CONFIG_PPC_ISERIES)       += iseries/
 obj-$(CONFIG_PPC_MAPLE)         += maple/
+obj-$(CONFIG_PPC_PASEMI)                += pasemi/
 obj-$(CONFIG_PPC_CELL)          += cell/
 obj-$(CONFIG_EMBEDDED6xx)       += embedded6xx/
diff --git a/arch/powerpc/platforms/cell/cbe_regs.c b/arch/powerpc/platforms/cell/cbe_regs.c
index ce696c1cca75..3f3859d12e00 100644
--- a/arch/powerpc/platforms/cell/cbe_regs.c
+++ b/arch/powerpc/platforms/cell/cbe_regs.c
@@ -97,7 +97,7 @@ void __init cbe_regs_init(void)
                 struct cbe_regs_map *map = &cbe_regs_maps[cbe_regs_map_count++];
 
                 /* That hack must die die die ! */
-                struct address_prop {
+                const struct address_prop {
                         unsigned long address;
                         unsigned int len;
                 } __attribute__((packed)) *prop;
@@ -114,13 +114,11 @@ void __init cbe_regs_init(void)
                         if (cbe_thread_map[i].cpu_node == cpu)
                                 cbe_thread_map[i].regs = map;
 
-                prop = (struct address_prop *)get_property(cpu, "pervasive",
-                                                           NULL);
+                prop = get_property(cpu, "pervasive", NULL);
                 if (prop != NULL)
                         map->pmd_regs = ioremap(prop->address, prop->len);
 
-                prop = (struct address_prop *)get_property(cpu, "iic",
-                                                           NULL);
+                prop = get_property(cpu, "iic", NULL);
                 if (prop != NULL)
                         map->iic_regs = ioremap(prop->address, prop->len);
         }
diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index d7bbb61109f9..6b57a47c5d37 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -89,17 +89,17 @@ static struct irq_chip iic_chip = {
 /* Get an IRQ number from the pending state register of the IIC */
 static unsigned int iic_get_irq(struct pt_regs *regs)
 {
-        struct cbe_iic_pending_bits pending;
-        struct iic *iic;
-
-        iic = &__get_cpu_var(iic);
-        *(unsigned long *) &pending =
-                in_be64((unsigned long __iomem *) &iic->regs->pending_destr);
-        iic->eoi_stack[++iic->eoi_ptr] = pending.prio;
-        BUG_ON(iic->eoi_ptr > 15);
+        struct cbe_iic_pending_bits pending;
+        struct iic *iic;
+
+        iic = &__get_cpu_var(iic);
+        *(unsigned long *) &pending =
+                in_be64((unsigned long __iomem *) &iic->regs->pending_destr);
+        iic->eoi_stack[++iic->eoi_ptr] = pending.prio;
+        BUG_ON(iic->eoi_ptr > 15);
         if (pending.flags & CBE_IIC_IRQ_VALID)
                 return irq_linear_revmap(iic->host,
-                                         iic_pending_to_hwnum(pending));
+                                         iic_pending_to_hwnum(pending));
         return NO_IRQ;
 }
 
@@ -250,16 +250,15 @@ static int __init setup_iic(void)
         struct resource r0, r1;
         struct irq_host *host;
         int found = 0;
-        u32 *np;
+        const u32 *np;
 
         for (dn = NULL;
              (dn = of_find_node_by_name(dn,"interrupt-controller")) != NULL;) {
                 if (!device_is_compatible(dn,
                                      "IBM,CBEA-Internal-Interrupt-Controller"))
                         continue;
-                np = (u32 *)get_property(dn, "ibm,interrupt-server-ranges",
-                                         NULL);
-                if (np == NULL) {
+                np = get_property(dn, "ibm,interrupt-server-ranges", NULL);
+                if (np == NULL) {
                         printk(KERN_WARNING "IIC: CPU association not found\n");
                         of_node_put(dn);
                         return -ENODEV;
diff --git a/arch/powerpc/platforms/cell/iommu.c b/arch/powerpc/platforms/cell/iommu.c
index a35004e14c69..d2b20eba5b87 100644
--- a/arch/powerpc/platforms/cell/iommu.c
+++ b/arch/powerpc/platforms/cell/iommu.c
@@ -308,15 +308,16 @@ static void cell_do_map_iommu(struct cell_iommu *iommu,
 
 static void iommu_devnode_setup(struct device_node *d)
 {
-        unsigned int *ioid;
-        unsigned long *dma_window, map_start, map_size, token;
+        const unsigned int *ioid;
+        unsigned long map_start, map_size, token;
+        const unsigned long *dma_window;
         struct cell_iommu *iommu;
 
-        ioid = (unsigned int *)get_property(d, "ioid", NULL);
+        ioid = get_property(d, "ioid", NULL);
         if (!ioid)
                 pr_debug("No ioid entry found !\n");
 
-        dma_window = (unsigned long *)get_property(d, "ibm,dma-window", NULL);
+        dma_window = get_property(d, "ibm,dma-window", NULL);
         if (!dma_window)
                 pr_debug("No ibm,dma-window entry found !\n");
 
@@ -371,8 +372,9 @@ static int cell_map_iommu_hardcoded(int num_nodes)
 
 static int cell_map_iommu(void)
 {
-        unsigned int num_nodes = 0, *node_id;
-        unsigned long *base, *mmio_base;
+        unsigned int num_nodes = 0;
+        const unsigned int *node_id;
+        const unsigned long *base, *mmio_base;
         struct device_node *dn;
         struct cell_iommu *iommu = NULL;
 
@@ -381,7 +383,7 @@ static int cell_map_iommu(void)
         for(dn = of_find_node_by_type(NULL, "cpu");
             dn;
             dn = of_find_node_by_type(dn, "cpu")) {
-                node_id = (unsigned int *)get_property(dn, "node-id", NULL);
+                node_id = get_property(dn, "node-id", NULL);
 
                 if (num_nodes < *node_id)
                         num_nodes = *node_id;
@@ -396,9 +398,9 @@ static int cell_map_iommu(void)
             dn;
             dn = of_find_node_by_type(dn, "cpu")) {
 
-                node_id = (unsigned int *)get_property(dn, "node-id", NULL);
-                base = (unsigned long *)get_property(dn, "ioc-cache", NULL);
-                mmio_base = (unsigned long *)get_property(dn, "ioc-translation", NULL);
+                node_id = get_property(dn, "node-id", NULL);
+                base = get_property(dn, "ioc-cache", NULL);
+                mmio_base = get_property(dn, "ioc-translation", NULL);
 
                 if (!base || !mmio_base || !node_id)
                         return cell_map_iommu_hardcoded(num_nodes);
diff --git a/arch/powerpc/platforms/cell/setup.c b/arch/powerpc/platforms/cell/setup.c
index 282987d6d4a2..22c228a49c33 100644
--- a/arch/powerpc/platforms/cell/setup.c
+++ b/arch/powerpc/platforms/cell/setup.c
@@ -150,10 +150,6 @@ static int __init cell_probe(void)
             !of_flat_dt_is_compatible(root, "IBM,CPBW-1.0"))
                 return 0;
 
-#ifdef CONFIG_UDBG_RTAS_CONSOLE
-        udbg_init_rtas_console();
-#endif
-
         hpte_init_native();
 
         return 1;
diff --git a/arch/powerpc/platforms/cell/smp.c b/arch/powerpc/platforms/cell/smp.c
index 46aef0640742..1c0acbad7425 100644
--- a/arch/powerpc/platforms/cell/smp.c
+++ b/arch/powerpc/platforms/cell/smp.c
@@ -57,7 +57,7 @@
  */
 static cpumask_t of_spin_map;
 
-extern void pSeries_secondary_smp_init(unsigned long);
+extern void generic_secondary_smp_init(unsigned long);
 
 /**
  * smp_startup_cpu() - start the given cpu
@@ -74,7 +74,7 @@ static inline int __devinit smp_startup_cpu(unsigned int lcpu)
 {
         int status;
         unsigned long start_here = __pa((u32)*((unsigned long *)
-                                               pSeries_secondary_smp_init));
+                                               generic_secondary_smp_init));
         unsigned int pcpu;
         int start_cpu;
 
diff --git a/arch/powerpc/platforms/cell/spider-pic.c b/arch/powerpc/platforms/cell/spider-pic.c
index 15217bb0402f..742a03282b44 100644
--- a/arch/powerpc/platforms/cell/spider-pic.c
+++ b/arch/powerpc/platforms/cell/spider-pic.c
@@ -240,7 +240,7 @@ static void spider_irq_cascade(unsigned int irq, struct irq_desc *desc,
 static unsigned int __init spider_find_cascade_and_node(struct spider_pic *pic)
 {
         unsigned int virq;
-        u32 *imap, *tmp;
+        const u32 *imap, *tmp;
         int imaplen, intsize, unit;
         struct device_node *iic;
         struct irq_host *iic_host;
@@ -258,25 +258,25 @@ static unsigned int __init spider_find_cascade_and_node(struct spider_pic *pic)
 #endif
 
         /* Now do the horrible hacks */
-        tmp = (u32 *)get_property(pic->of_node, "#interrupt-cells", NULL);
+        tmp = get_property(pic->of_node, "#interrupt-cells", NULL);
         if (tmp == NULL)
                 return NO_IRQ;
         intsize = *tmp;
-        imap = (u32 *)get_property(pic->of_node, "interrupt-map", &imaplen);
+        imap = get_property(pic->of_node, "interrupt-map", &imaplen);
         if (imap == NULL || imaplen < (intsize + 1))
                 return NO_IRQ;
         iic = of_find_node_by_phandle(imap[intsize]);
         if (iic == NULL)
                 return NO_IRQ;
         imap += intsize + 1;
-        tmp = (u32 *)get_property(iic, "#interrupt-cells", NULL);
+        tmp = get_property(iic, "#interrupt-cells", NULL);
         if (tmp == NULL)
                 return NO_IRQ;
         intsize = *tmp;
         /* Assume unit is last entry of interrupt specifier */
         unit = imap[intsize - 1];
         /* Ok, we have a unit, now let's try to get the node */
-        tmp = (u32 *)get_property(iic, "ibm,interrupt-server-ranges", NULL);
+        tmp = get_property(iic, "ibm,interrupt-server-ranges", NULL);
         if (tmp == NULL) {
                 of_node_put(iic);
                 return NO_IRQ;
diff --git a/arch/powerpc/platforms/cell/spu_base.c b/arch/powerpc/platforms/cell/spu_base.c
index d06042deb021..3bd36d46ab4a 100644
--- a/arch/powerpc/platforms/cell/spu_base.c
+++ b/arch/powerpc/platforms/cell/spu_base.c
@@ -488,10 +488,10 @@ int spu_irq_class_1_bottom(struct spu *spu)
 
 static int __init find_spu_node_id(struct device_node *spe)
 {
-        unsigned int *id;
+        const unsigned int *id;
         struct device_node *cpu;
         cpu = spe->parent->parent;
-        id = (unsigned int *)get_property(cpu, "node-id", NULL);
+        id = get_property(cpu, "node-id", NULL);
         return id ? *id : 0;
 }
 
@@ -500,7 +500,7 @@ static int __init cell_spuprop_present(struct spu *spu, struct device_node *spe,
 {
         static DEFINE_MUTEX(add_spumem_mutex);
 
-        struct address_prop {
+        const struct address_prop {
                 unsigned long address;
                 unsigned int len;
         } __attribute__((packed)) *p;
@@ -511,7 +511,7 @@ static int __init cell_spuprop_present(struct spu *spu, struct device_node *spe,
         struct zone *zone;
         int ret;
 
-        p = (void*)get_property(spe, prop, &proplen);
+        p = get_property(spe, prop, &proplen);
         WARN_ON(proplen != sizeof (*p));
 
         start_pfn = p->address >> PAGE_SHIFT;
@@ -531,12 +531,12 @@ static int __init cell_spuprop_present(struct spu *spu, struct device_node *spe,
 static void __iomem * __init map_spe_prop(struct spu *spu,
                 struct device_node *n, const char *name)
 {
-        struct address_prop {
+        const struct address_prop {
                 unsigned long address;
                 unsigned int len;
         } __attribute__((packed)) *prop;
 
-        void *p;
+        const void *p;
         int proplen;
         void* ret = NULL;
         int err = 0;
@@ -570,14 +570,14 @@ static int __init spu_map_interrupts(struct spu *spu, struct device_node *np)
 {
         struct irq_host *host;
         unsigned int isrc;
-        u32 *tmp;
+        const u32 *tmp;
 
         host = iic_get_irq_host(spu->node);
         if (host == NULL)
                 return -ENODEV;
 
         /* Get the interrupt source from the device-tree */
-        tmp = (u32 *)get_property(np, "isrc", NULL);
+        tmp = get_property(np, "isrc", NULL);
         if (!tmp)
                 return -ENODEV;
         spu->isrc = isrc = tmp[0];
@@ -593,7 +593,7 @@ static int __init spu_map_interrupts(struct spu *spu, struct device_node *np)
 
 static int __init spu_map_device(struct spu *spu, struct device_node *node)
 {
-        char *prop;
+        const char *prop;
         int ret;
 
         ret = -ENODEV;
diff --git a/arch/powerpc/platforms/chrp/nvram.c b/arch/powerpc/platforms/chrp/nvram.c
index 150f67d6f90c..0dd4a64757d9 100644
--- a/arch/powerpc/platforms/chrp/nvram.c
+++ b/arch/powerpc/platforms/chrp/nvram.c
@@ -67,13 +67,14 @@ static void chrp_nvram_write(int addr, unsigned char val)
 void __init chrp_nvram_init(void)
 {
         struct device_node *nvram;
-        unsigned int *nbytes_p, proplen;
+        const unsigned int *nbytes_p;
+        unsigned int proplen;
 
         nvram = of_find_node_by_type(NULL, "nvram");
         if (nvram == NULL)
                 return;
 
-        nbytes_p = (unsigned int *)get_property(nvram, "#bytes", &proplen);
+        nbytes_p = get_property(nvram, "#bytes", &proplen);
         if (nbytes_p == NULL || proplen != sizeof(unsigned int))
                 return;
 
diff --git a/arch/powerpc/platforms/chrp/pci.c b/arch/powerpc/platforms/chrp/pci.c
index 6802cdc3168a..0f4340506c75 100644
--- a/arch/powerpc/platforms/chrp/pci.c
+++ b/arch/powerpc/platforms/chrp/pci.c
@@ -214,11 +214,11 @@ void __init
 chrp_find_bridges(void)
 {
         struct device_node *dev;
-        int *bus_range;
+        const int *bus_range;
         int len, index = -1;
         struct pci_controller *hose;
-        unsigned int *dma;
-        char *model, *machine;
+        const unsigned int *dma;
+        const char *model, *machine;
         int is_longtrail = 0, is_mot = 0, is_pegasos = 0;
         struct device_node *root = find_path_device("/");
         struct resource r;
@@ -246,7 +246,7 @@ chrp_find_bridges(void)
                                dev->full_name);
                         continue;
                 }
-                bus_range = (int *) get_property(dev, "bus-range", &len);
+                bus_range = get_property(dev, "bus-range", &len);
                 if (bus_range == NULL || len < 2 * sizeof(int)) {
                         printk(KERN_WARNING "Can't get bus-range for %s\n",
                                 dev->full_name);
@@ -257,7 +257,7 @@ chrp_find_bridges(void)
                 else
                         printk(KERN_INFO "PCI buses %d..%d",
                                bus_range[0], bus_range[1]);
-                printk(" controlled by %s", dev->type);
+                printk(" controlled by %s", dev->full_name);
                 if (!is_longtrail)
                         printk(" at %llx", (unsigned long long)r.start);
                 printk("\n");
@@ -289,6 +289,19 @@ chrp_find_bridges(void)
                         setup_indirect_pci(hose, 0xfec00cf8, 0xfee00cfc);
                 } else if (is_pegasos == 2) {
                         setup_peg2(hose, dev);
+                } else if (!strncmp(model, "IBM,CPC710", 10)) {
+                        setup_indirect_pci(hose,
+                                           r.start + 0x000f8000,
+                                           r.start + 0x000f8010);
+                        if (index == 0) {
+                                dma = get_property(dev, "system-dma-base",&len);
+                                if (dma && len >= sizeof(*dma)) {
+                                        dma = (unsigned int *)
+                                                (((unsigned long)dma) +
+                                                len - sizeof(*dma));
+                                                pci_dram_offset = *dma;
+                                }
+                        }
                 } else {
                         printk("No methods for %s (model %s), using RTAS\n",
                                dev->full_name, model);
@@ -299,15 +312,35 @@ chrp_find_bridges(void)
 
                 /* check the first bridge for a property that we can
                    use to set pci_dram_offset */
-                dma = (unsigned int *)
-                        get_property(dev, "ibm,dma-ranges", &len);
+                dma = get_property(dev, "ibm,dma-ranges", &len);
                 if (index == 0 && dma != NULL && len >= 6 * sizeof(*dma)) {
                         pci_dram_offset = dma[2] - dma[3];
                         printk("pci_dram_offset = %lx\n", pci_dram_offset);
                 }
         }
+}
+
+/* SL82C105 IDE Control/Status Register */
+#define SL82C105_IDECSR                0x40
+
+/* Fixup for Winbond ATA quirk, required for briq */
+void chrp_pci_fixup_winbond_ata(struct pci_dev *sl82c105)
+{
+        u8 progif;
 
-        /* Do not fixup interrupts from OF tree on pegasos */
-        if (is_pegasos)
-                ppc_md.pcibios_fixup = NULL;
+        /* If non-briq machines need that fixup too, please speak up */
+        if (!machine_is(chrp) || _chrp_type != _CHRP_briq)
+                return;
+
+        if ((sl82c105->class & 5) != 5) {
+                printk("W83C553: Switching SL82C105 IDE to PCI native mode\n");
+                /* Enable SL82C105 PCI native IDE mode */
+                pci_read_config_byte(sl82c105, PCI_CLASS_PROG, &progif);
+                pci_write_config_byte(sl82c105, PCI_CLASS_PROG, progif | 0x05);
+                sl82c105->class |= 0x05;
+                /* Disable SL82C105 second port */
+                pci_write_config_word(sl82c105, SL82C105_IDECSR, 0x0003);
+        }
 }
+DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_WINBOND, PCI_DEVICE_ID_WINBOND_82C105,
+                chrp_pci_fixup_winbond_ata);
diff --git a/arch/powerpc/platforms/chrp/setup.c b/arch/powerpc/platforms/chrp/setup.c
index 9c08ff322290..488dbd9b51ae 100644
--- a/arch/powerpc/platforms/chrp/setup.c
+++ b/arch/powerpc/platforms/chrp/setup.c
@@ -74,6 +74,9 @@ extern irqreturn_t xmon_irq(int, void *, struct pt_regs *);
 
 extern unsigned long loops_per_jiffy;
 
+/* To be replaced by RTAS when available */
+static unsigned int *briq_SPOR;
+
 #ifdef CONFIG_SMP
 extern struct smp_ops_t chrp_smp_ops;
 #endif
@@ -92,6 +95,15 @@ static const char *gg2_cachemodes[4] = {
         "Disabled", "Write-Through", "Copy-Back", "Transparent Mode"
 };
 
+static const char *chrp_names[] = {
+        "Unknown",
+        "","","",
+        "Motorola",
+        "IBM or Longtrail",
+        "Genesi Pegasos",
+        "Total Impact Briq"
+};
+
 void chrp_show_cpuinfo(struct seq_file *m)
 {
         int i, sdramen;
@@ -214,8 +226,7 @@ static void __init pegasos_set_l2cr(void)
         /* Enable L2 cache if needed */
         np = find_type_devices("cpu");
         if (np != NULL) {
-                unsigned int *l2cr = (unsigned int *)
-                        get_property (np, "l2cr", NULL);
+                const unsigned int *l2cr = get_property(np, "l2cr", NULL);
                 if (l2cr == NULL) {
                         printk ("Pegasos l2cr : no cpu l2cr property found\n");
                         return;
@@ -229,10 +240,18 @@ static void __init pegasos_set_l2cr(void)
         }
 }
 
+static void briq_restart(char *cmd)
+{
+        local_irq_disable();
+        if (briq_SPOR)
+                out_be32(briq_SPOR, 0);
+        for(;;);
+}
+
 void __init chrp_setup_arch(void)
 {
         struct device_node *root = find_path_device ("/");
-        char *machine = NULL;
+        const char *machine = NULL;
 
         /* init to some ~sane value until calibrate_delay() runs */
         loops_per_jiffy = 50000000/HZ;
@@ -245,11 +264,16 @@ void __init chrp_setup_arch(void)
                 _chrp_type = _CHRP_IBM;
         } else if (machine && strncmp(machine, "MOT", 3) == 0) {
                 _chrp_type = _CHRP_Motorola;
+        } else if (machine && strncmp(machine, "TotalImpact,BRIQ-1", 18) == 0) {
+                _chrp_type = _CHRP_briq;
+                /* Map the SPOR register on briq and change the restart hook */
+                briq_SPOR = (unsigned int *)ioremap(0xff0000e8, 4);
+                ppc_md.restart = briq_restart;
         } else {
                 /* Let's assume it is an IBM chrp if all else fails */
                 _chrp_type = _CHRP_IBM;
         }
-        printk("chrp type = %x\n", _chrp_type);
+        printk("chrp type = %x [%s]\n", _chrp_type, chrp_names[_chrp_type]);
 
         rtas_initialize();
         if (rtas_token("display-character") >= 0)
@@ -328,7 +352,7 @@ static void __init chrp_find_openpic(void)
         struct device_node *np, *root;
         int len, i, j;
         int isu_size, idu_size;
-        unsigned int *iranges, *opprop = NULL;
+        const unsigned int *iranges, *opprop = NULL;
         int oplen = 0;
         unsigned long opaddr;
         int na = 1;
@@ -338,8 +362,7 @@ static void __init chrp_find_openpic(void)
                 return;
         root = of_find_node_by_path("/");
         if (root) {
-                opprop = (unsigned int *) get_property
-                        (root, "platform-open-pic", &oplen);
+                opprop = get_property(root, "platform-open-pic", &oplen);
                 na = prom_n_addr_cells(root);
         }
         if (opprop && oplen >= na * sizeof(unsigned int)) {
@@ -356,7 +379,7 @@ static void __init chrp_find_openpic(void)
 
         printk(KERN_INFO "OpenPIC at %lx\n", opaddr);
 
-        iranges = (unsigned int *) get_property(np, "interrupt-ranges", &len);
+        iranges = get_property(np, "interrupt-ranges", &len);
         if (iranges == NULL)
                 len = 0;        /* non-distributed mpic */
         else
@@ -442,8 +465,8 @@ static void __init chrp_find_8259(void)
          * from anyway
          */
         for (np = find_devices("pci"); np != NULL; np = np->next) {
-                unsigned int *addrp = (unsigned int *)
-                        get_property(np, "8259-interrupt-acknowledge", NULL);
+                const unsigned int *addrp = get_property(np,
+                                "8259-interrupt-acknowledge", NULL);
 
                 if (addrp == NULL)
                         continue;
@@ -502,7 +525,7 @@ void __init
 chrp_init2(void)
 {
         struct device_node *device;
-        unsigned int *p = NULL;
+        const unsigned int *p = NULL;
 
 #ifdef CONFIG_NVRAM
         chrp_nvram_init();
@@ -520,8 +543,7 @@ chrp_init2(void)
          */
         device = find_devices("rtas");
         if (device)
-                p = (unsigned int *) get_property
-                        (device, "rtas-event-scan-rate", NULL);
+                p = get_property(device, "rtas-event-scan-rate", NULL);
         if (p && *p) {
                 /*
                  * Arrange to call chrp_event_scan at least *p times
diff --git a/arch/powerpc/platforms/embedded6xx/mpc7448_hpc2.c b/arch/powerpc/platforms/embedded6xx/mpc7448_hpc2.c
index 5d393eb94935..e4f2b9df5e17 100644
--- a/arch/powerpc/platforms/embedded6xx/mpc7448_hpc2.c
+++ b/arch/powerpc/platforms/embedded6xx/mpc7448_hpc2.c
@@ -95,7 +95,7 @@ void mpc7448_hpc2_fixup_irq(struct pci_dev *dev)
 {
         struct pci_controller *hose;
         struct device_node *node;
-        unsigned int *interrupt;
+        const unsigned int *interrupt;
         int busnr;
         int len;
         u8 slot;
@@ -112,7 +112,7 @@ void mpc7448_hpc2_fixup_irq(struct pci_dev *dev)
         if (!node)
                 printk(KERN_ERR "No pci node found\n");
 
-        interrupt = (unsigned int *) get_property(node, "interrupt-map", &len);
+        interrupt = get_property(node, "interrupt-map", &len);
         slot = find_slot_by_devfn(interrupt, dev->devfn);
         pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
         if (pin == 0 || pin > 4)
@@ -141,9 +141,9 @@ static void __init mpc7448_hpc2_setup_arch(void)
 
         cpu = of_find_node_by_type(NULL, "cpu");
         if (cpu != 0) {
-                unsigned int *fp;
+                const unsigned int *fp;
 
-                fp = (int *)get_property(cpu, "clock-frequency", NULL);
+                fp = get_property(cpu, "clock-frequency", NULL);
                 if (fp != 0)
                         loops_per_jiffy = *fp / HZ;
                 else
diff --git a/arch/powerpc/platforms/iseries/Kconfig b/arch/powerpc/platforms/iseries/Kconfig
index 3d957a30c8c2..887b68804e6d 100644
--- a/arch/powerpc/platforms/iseries/Kconfig
+++ b/arch/powerpc/platforms/iseries/Kconfig
@@ -3,13 +3,17 @@ menu "iSeries device drivers"
         depends on PPC_ISERIES
 
 config VIOCONS
-        tristate "iSeries Virtual Console Support"
+        tristate "iSeries Virtual Console Support (Obsolete)"
+        help
+          This is the old virtual console driver for legacy iSeries.
+          You should use the iSeries Hypervisor Virtual Console
+          support instead.
 
 config VIODASD
         tristate "iSeries Virtual I/O disk support"
         help
           If you are running on an iSeries system and you want to use
-          virtual disks created and managed by OS/400, say Y.
+          virtual disks created and managed by OS/400, say Y.
 
 config VIOCD
         tristate "iSeries Virtual I/O CD support"
diff --git a/arch/powerpc/platforms/iseries/dt.c b/arch/powerpc/platforms/iseries/dt.c
index d194140c1ebf..e305deee7f44 100644
--- a/arch/powerpc/platforms/iseries/dt.c
+++ b/arch/powerpc/platforms/iseries/dt.c
@@ -1,5 +1,6 @@
 /*
- *    Copyright (c) 2005-2006 Michael Ellerman, IBM Corporation
+ *    Copyright (C) 2005-2006 Michael Ellerman, IBM Corporation
+ *    Copyright (C) 2000-2004, IBM Corporation
  *
  *    Description:
  *      This file contains all the routines to build a flattened device
@@ -33,13 +34,13 @@
 #include <asm/iseries/hv_types.h>
 #include <asm/iseries/hv_lp_config.h>
 #include <asm/iseries/hv_call_xm.h>
-#include <asm/iseries/it_exp_vpd_panel.h>
 #include <asm/udbg.h>
 
 #include "processor_vpd.h"
 #include "call_hpt.h"
 #include "call_pci.h"
 #include "pci.h"
+#include "it_exp_vpd_panel.h"
 
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
@@ -76,6 +77,43 @@ static char __initdata device_type_pci[] = "pci";
 static char __initdata device_type_vdevice[] = "vdevice";
 static char __initdata device_type_vscsi[] = "vscsi";
 
+
+/* EBCDIC to ASCII conversion routines */
+
+static unsigned char __init e2a(unsigned char x)
+{
+        switch (x) {
+        case 0x81 ... 0x89:
+                return x - 0x81 + 'a';
+        case 0x91 ... 0x99:
+                return x - 0x91 + 'j';
+        case 0xA2 ... 0xA9:
+                return x - 0xA2 + 's';
+        case 0xC1 ... 0xC9:
+                return x - 0xC1 + 'A';
+        case 0xD1 ... 0xD9:
+                return x - 0xD1 + 'J';
+        case 0xE2 ... 0xE9:
+                return x - 0xE2 + 'S';
+        case 0xF0 ... 0xF9:
+                return x - 0xF0 + '0';
+        }
+        return ' ';
+}
+
+static unsigned char * __init strne2a(unsigned char *dest,
+                const unsigned char *src, size_t n)
+{
+        int i;
+
+        n = strnlen(src, n);
+
+        for (i = 0; i < n; i++)
+                dest[i] = e2a(src[i]);
+
+        return dest;
+}
+
 static struct iseries_flat_dt * __init dt_init(void)
 {
         struct iseries_flat_dt *dt;
@@ -298,7 +336,8 @@ static void __init dt_vdevices(struct iseries_flat_dt *dt)
         dt_prop_u32(dt, "#address-cells", 1);
         dt_prop_u32(dt, "#size-cells", 0);
 
-        dt_do_vdevice(dt, "vty", reg, -1, device_type_serial, NULL, 1);
+        dt_do_vdevice(dt, "vty", reg, -1, device_type_serial,
+                        "IBM,iSeries-vty", 1);
         reg++;
 
         dt_do_vdevice(dt, "v-scsi", reg, -1, device_type_vscsi,
diff --git a/arch/powerpc/platforms/iseries/hvlpconfig.c b/arch/powerpc/platforms/iseries/hvlpconfig.c
index 663a1affb4bb..f0475f0b1853 100644
--- a/arch/powerpc/platforms/iseries/hvlpconfig.c
+++ b/arch/powerpc/platforms/iseries/hvlpconfig.c
@@ -18,9 +18,22 @@
 
 #include <linux/module.h>
 #include <asm/iseries/hv_lp_config.h>
+#include "it_lp_naca.h"
 
 HvLpIndex HvLpConfig_getLpIndex_outline(void)
 {
         return HvLpConfig_getLpIndex();
 }
 EXPORT_SYMBOL(HvLpConfig_getLpIndex_outline);
+
+HvLpIndex HvLpConfig_getLpIndex(void)
+{
+        return itLpNaca.xLpIndex;
+}
+EXPORT_SYMBOL(HvLpConfig_getLpIndex);
+
+HvLpIndex HvLpConfig_getPrimaryLpIndex(void)
+{
+        return itLpNaca.xPrimaryLpIndex;
+}
+EXPORT_SYMBOL_GPL(HvLpConfig_getPrimaryLpIndex);
diff --git a/arch/powerpc/platforms/iseries/iommu.c b/arch/powerpc/platforms/iseries/iommu.c
index e3bd2015f2c9..f4cbbcf8773a 100644
--- a/arch/powerpc/platforms/iseries/iommu.c
+++ b/arch/powerpc/platforms/iseries/iommu.c
@@ -88,6 +88,23 @@ static void tce_free_iSeries(struct iommu_table *tbl, long index, long npages)
 }
 
 /*
+ * Structure passed to HvCallXm_getTceTableParms
+ */
+struct iommu_table_cb {
+        unsigned long   itc_busno;      /* Bus number for this tce table */
+        unsigned long   itc_start;      /* Will be NULL for secondary */
+        unsigned long   itc_totalsize;  /* Size (in pages) of whole table */
+        unsigned long   itc_offset;     /* Index into real tce table of the
+                                           start of our section */
+        unsigned long   itc_size;       /* Size (in pages) of our section */
+        unsigned long   itc_index;      /* Index of this tce table */
+        unsigned short  itc_maxtables;  /* Max num of tables for partition */
+        unsigned char   itc_virtbus;    /* Flag to indicate virtual bus */
+        unsigned char   itc_slotno;     /* IOA Tce Slot Index */
+        unsigned char   itc_rsvd[4];
+};
+
+/*
  * Call Hv with the architected data structure to get TCE table info.
  * info. Put the returned data into the Linux representation of the
  * TCE table data.
@@ -162,7 +179,7 @@ void iommu_devnode_init_iSeries(struct device_node *dn)
 {
         struct iommu_table *tbl;
         struct pci_dn *pdn = PCI_DN(dn);
-        u32 *lsn = (u32 *)get_property(dn, "linux,logical-slot-number", NULL);
+        const u32 *lsn = get_property(dn, "linux,logical-slot-number", NULL);
 
         BUG_ON(lsn == NULL);
 
diff --git a/arch/powerpc/platforms/iseries/it_exp_vpd_panel.h b/arch/powerpc/platforms/iseries/it_exp_vpd_panel.h
new file mode 100644
index 000000000000..6de9097b7f57
--- /dev/null
+++ b/arch/powerpc/platforms/iseries/it_exp_vpd_panel.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2002  Dave Boutcher IBM Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+#ifndef _PLATFORMS_ISERIES_IT_EXT_VPD_PANEL_H
+#define _PLATFORMS_ISERIES_IT_EXT_VPD_PANEL_H
+
+/*
+ *      This struct maps the panel information
+ *
+ * Warning:
+ *      This data must match the architecture for the panel information
+ */
+
+#include <asm/types.h>
+
+struct ItExtVpdPanel {
+        /* Definition of the Extended Vpd On Panel Data Area */
+        char    systemSerial[8];
+        char    mfgID[4];
+        char    reserved1[24];
+        char    machineType[4];
+        char    systemID[6];
+        char    somUniqueCnt[4];
+        char    serialNumberCount;
+        char    reserved2[7];
+        u16     bbu3;
+        u16     bbu2;
+        u16     bbu1;
+        char    xLocationLabel[8];
+        u8      xRsvd1[6];
+        u16     xFrameId;
+        u8      xRsvd2[48];
+};
+
+extern struct ItExtVpdPanel     xItExtVpdPanel;
+
+#endif /* _PLATFORMS_ISERIES_IT_EXT_VPD_PANEL_H */
diff --git a/arch/powerpc/platforms/iseries/it_lp_naca.h b/arch/powerpc/platforms/iseries/it_lp_naca.h
new file mode 100644
index 000000000000..9bbf58986819
--- /dev/null
+++ b/arch/powerpc/platforms/iseries/it_lp_naca.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2001  Mike Corrigan IBM Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+#ifndef _PLATFORMS_ISERIES_IT_LP_NACA_H
+#define _PLATFORMS_ISERIES_IT_LP_NACA_H
+
+#include <linux/types.h>
+
+/*
+ *      This control block contains the data that is shared between the
+ *      hypervisor (PLIC) and the OS.
+ */
+
+struct ItLpNaca {
+// CACHE_LINE_1 0x0000 - 0x007F Contains read-only data
+        u32     xDesc;                  // Eye catcher                  x00-x03
+        u16     xSize;                  // Size of this class           x04-x05
+        u16     xIntHdlrOffset;         // Offset to IntHdlr array      x06-x07
+        u8      xMaxIntHdlrEntries;     // Number of entries in array   x08-x08
+        u8      xPrimaryLpIndex;        // LP Index of Primary          x09-x09
+        u8      xServiceLpIndex;        // LP Ind of Service Focal Pointx0A-x0A
+        u8      xLpIndex;               // LP Index                     x0B-x0B
+        u16     xMaxLpQueues;           // Number of allocated queues   x0C-x0D
+        u16     xLpQueueOffset;         // Offset to start of LP queues x0E-x0F
+        u8      xPirEnvironMode;        // Piranha or hardware          x10-x10
+        u8      xPirConsoleMode;        // Piranha console indicator    x11-x11
+        u8      xPirDasdMode;           // Piranha dasd indicator       x12-x12
+        u8      xRsvd1_0[5];            // Reserved for Piranha related x13-x17
+        u8      flags;                  // flags, see below             x18-x1F
+        u8      xSpVpdFormat;           // VPD areas are in CSP format  ...
+        u8      xIntProcRatio;          // Ratio of int procs to procs  ...
+        u8      xRsvd1_2[5];            // Reserved                     ...
+        u16     xRsvd1_3;               // Reserved                     x20-x21
+        u16     xPlicVrmIndex;          // VRM index of PLIC            x22-x23
+        u16     xMinSupportedSlicVrmInd;// Min supported OS VRM index   x24-x25
+        u16     xMinCompatableSlicVrmInd;// Min compatible OS VRM index x26-x27
+        u64     xLoadAreaAddr;          // ER address of load area      x28-x2F
+        u32     xLoadAreaChunks;        // Chunks for the load area     x30-x33
+        u32     xPaseSysCallCRMask;     // Mask used to test CR before  x34-x37
+                                        // doing an ASR switch on PASE
+                                        // system call.
+        u64     xSlicSegmentTablePtr;   // Pointer to Slic seg table.   x38-x3f
+        u8      xRsvd1_4[64];           //                              x40-x7F
+
+// CACHE_LINE_2 0x0080 - 0x00FF Contains local read-write data
+        u8      xRsvd2_0[128];          // Reserved                     x00-x7F
+
+// CACHE_LINE_3-6 0x0100 - 0x02FF Contains LP Queue indicators
+// NB: Padding required to keep xInterrruptHdlr at x300 which is required
+// for v4r4 PLIC.
+        u8      xOldLpQueue[128];       // LP Queue needed for v4r4     100-17F
+        u8      xRsvd3_0[384];          // Reserved                     180-2FF
+
+// CACHE_LINE_7-8 0x0300 - 0x03FF Contains the address of the OS interrupt
+//  handlers
+        u64     xInterruptHdlr[32];     // Interrupt handlers           300-x3FF
+};
+
+extern struct ItLpNaca          itLpNaca;
+
+#define ITLPNACA_LPAR           0x80    /* Is LPAR installed on the system */
+#define ITLPNACA_PARTITIONED    0x40    /* Is the system partitioned */
+#define ITLPNACA_HWSYNCEDTBS    0x20    /* Hardware synced TBs */
+#define ITLPNACA_HMTINT         0x10    /* Utilize MHT for interrupts */
+
+#endif /* _PLATFORMS_ISERIES_IT_LP_NACA_H */
diff --git a/arch/powerpc/platforms/iseries/lpardata.c b/arch/powerpc/platforms/iseries/lpardata.c
index a7769445d6c7..8162049bb04d 100644
--- a/arch/powerpc/platforms/iseries/lpardata.c
+++ b/arch/powerpc/platforms/iseries/lpardata.c
@@ -13,12 +13,10 @@
 #include <asm/processor.h>
 #include <asm/ptrace.h>
 #include <asm/abs_addr.h>
-#include <asm/iseries/it_lp_naca.h>
 #include <asm/lppaca.h>
 #include <asm/iseries/it_lp_reg_save.h>
 #include <asm/paca.h>
 #include <asm/iseries/lpar_map.h>
-#include <asm/iseries/it_exp_vpd_panel.h>
 #include <asm/iseries/it_lp_queue.h>
 
 #include "naca.h"
@@ -27,6 +25,8 @@
 #include "ipl_parms.h"
 #include "processor_vpd.h"
 #include "release_data.h"
+#include "it_exp_vpd_panel.h"
+#include "it_lp_naca.h"
 
 /* The HvReleaseData is the root of the information shared between
  * the hypervisor and Linux.
@@ -127,14 +127,12 @@ struct ItLpNaca itLpNaca = {
                 (u64)instruction_access_slb_iSeries /* 0x480 I-SLB */
         }
 };
-EXPORT_SYMBOL(itLpNaca);
 
 /* May be filled in by the hypervisor so cannot end up in the BSS */
 struct ItIplParmsReal xItIplParmsReal __attribute__((__section__(".data")));
 
 /* May be filled in by the hypervisor so cannot end up in the BSS */
 struct ItExtVpdPanel xItExtVpdPanel __attribute__((__section__(".data")));
-EXPORT_SYMBOL(xItExtVpdPanel);
 
 #define maxPhysicalProcessors 32
 
diff --git a/arch/powerpc/platforms/iseries/lpevents.c b/arch/powerpc/platforms/iseries/lpevents.c
index 2a9f81ea27d6..98c1c2440aad 100644
--- a/arch/powerpc/platforms/iseries/lpevents.c
+++ b/arch/powerpc/platforms/iseries/lpevents.c
@@ -20,7 +20,7 @@
 #include <asm/iseries/it_lp_queue.h>
 #include <asm/iseries/hv_lp_event.h>
 #include <asm/iseries/hv_call_event.h>
-#include <asm/iseries/it_lp_naca.h>
+#include "it_lp_naca.h"
 
 /*
  * The LpQueue is used to pass event data from the hypervisor to
diff --git a/arch/powerpc/platforms/iseries/main_store.h b/arch/powerpc/platforms/iseries/main_store.h
index 74f6889f834f..1a7a3f50e40b 100644
--- a/arch/powerpc/platforms/iseries/main_store.h
+++ b/arch/powerpc/platforms/iseries/main_store.h
@@ -61,9 +61,9 @@ struct IoHriMainStoreSegment4 {
 };
 
 /* Main Store VPD for Power4 */
-struct IoHriMainStoreChipInfo1 {
-        u32     chipMfgID       __attribute((packed));
-        char    chipECLevel[4]  __attribute((packed));
+struct __attribute((packed)) IoHriMainStoreChipInfo1 {
+        u32     chipMfgID;
+        char    chipECLevel[4];
 };
 
 struct IoHriMainStoreVpdIdData {
@@ -73,72 +73,72 @@ struct IoHriMainStoreVpdIdData {
         char    serialNumber[12];
 };
 
-struct IoHriMainStoreVpdFruData {
-        char    fruLabel[8]     __attribute((packed));
-        u8      numberOfSlots   __attribute((packed));
-        u8      pluggingType    __attribute((packed));
-        u16     slotMapIndex    __attribute((packed));
+struct  __attribute((packed)) IoHriMainStoreVpdFruData {
+        char    fruLabel[8];
+        u8      numberOfSlots;
+        u8      pluggingType;
+        u16     slotMapIndex;
 };
 
-struct IoHriMainStoreAdrRangeBlock {
-        void    *blockStart      __attribute((packed));
-        void    *blockEnd        __attribute((packed));
-        u32     blockProcChipId __attribute((packed));
+struct  __attribute((packed)) IoHriMainStoreAdrRangeBlock {
+        void    *blockStart;
+        void    *blockEnd;
+        u32     blockProcChipId;
 };
 
 #define MaxAreaAdrRangeBlocks 4
 
-struct IoHriMainStoreArea4 {
-        u32     msVpdFormat                     __attribute((packed));
-        u8      containedVpdType                __attribute((packed));
-        u8      reserved1                       __attribute((packed));
-        u16     reserved2                       __attribute((packed));
-
-        u64     msExists                        __attribute((packed));
-        u64     msFunctional                    __attribute((packed));
-
-        u32     memorySize                      __attribute((packed));
-        u32     procNodeId                      __attribute((packed));
-
-        u32     numAdrRangeBlocks               __attribute((packed));
-        struct IoHriMainStoreAdrRangeBlock xAdrRangeBlock[MaxAreaAdrRangeBlocks]        __attribute((packed));
-
-        struct IoHriMainStoreChipInfo1  chipInfo0       __attribute((packed));
-        struct IoHriMainStoreChipInfo1  chipInfo1       __attribute((packed));
-        struct IoHriMainStoreChipInfo1  chipInfo2       __attribute((packed));
-        struct IoHriMainStoreChipInfo1  chipInfo3       __attribute((packed));
-        struct IoHriMainStoreChipInfo1  chipInfo4       __attribute((packed));
-        struct IoHriMainStoreChipInfo1  chipInfo5       __attribute((packed));
-        struct IoHriMainStoreChipInfo1  chipInfo6       __attribute((packed));
-        struct IoHriMainStoreChipInfo1  chipInfo7       __attribute((packed));
-
-        void    *msRamAreaArray                 __attribute((packed));
-        u32     msRamAreaArrayNumEntries        __attribute((packed));
-        u32     msRamAreaArrayEntrySize         __attribute((packed));
-
-        u32     numaDimmExists                  __attribute((packed));
-        u32     numaDimmFunctional              __attribute((packed));
-        void    *numaDimmArray                  __attribute((packed));
-        u32     numaDimmArrayNumEntries         __attribute((packed));
-        u32     numaDimmArrayEntrySize          __attribute((packed));
-
-        struct IoHriMainStoreVpdIdData idData   __attribute((packed));
-
-        u64     powerData                       __attribute((packed));
-        u64     cardAssemblyPartNum             __attribute((packed));
-        u64     chipSerialNum                   __attribute((packed));
-
-        u64     reserved3                       __attribute((packed));
-        char    reserved4[16]                   __attribute((packed));
-
-        struct IoHriMainStoreVpdFruData fruData __attribute((packed));
-
-        u8      vpdPortNum                      __attribute((packed));
-        u8      reserved5                       __attribute((packed));
-        u8      frameId                         __attribute((packed));
-        u8      rackUnit                        __attribute((packed));
-        char    asciiKeywordVpd[256]            __attribute((packed));
-        u32     reserved6                       __attribute((packed));
+struct __attribute((packed)) IoHriMainStoreArea4 {
+        u32     msVpdFormat;
+        u8      containedVpdType;
+        u8      reserved1;
+        u16     reserved2;
+
+        u64     msExists;
+        u64     msFunctional;
+
+        u32     memorySize;
+        u32     procNodeId;
+
+        u32     numAdrRangeBlocks;
+        struct IoHriMainStoreAdrRangeBlock xAdrRangeBlock[MaxAreaAdrRangeBlocks];
+
+        struct IoHriMainStoreChipInfo1  chipInfo0;
+        struct IoHriMainStoreChipInfo1  chipInfo1;
+        struct IoHriMainStoreChipInfo1  chipInfo2;
+        struct IoHriMainStoreChipInfo1  chipInfo3;
+        struct IoHriMainStoreChipInfo1  chipInfo4;
+        struct IoHriMainStoreChipInfo1  chipInfo5;
+        struct IoHriMainStoreChipInfo1  chipInfo6;
+        struct IoHriMainStoreChipInfo1  chipInfo7;
+
+        void    *msRamAreaArray;
+        u32     msRamAreaArrayNumEntries;
+        u32     msRamAreaArrayEntrySize;
+
+        u32     numaDimmExists;
+        u32     numaDimmFunctional;
+        void    *numaDimmArray;
+        u32     numaDimmArrayNumEntries;
+        u32     numaDimmArrayEntrySize;
+
+        struct IoHriMainStoreVpdIdData idData;
+
+        u64     powerData;
+        u64     cardAssemblyPartNum;
+        u64     chipSerialNum;
+
+        u64     reserved3;
+        char    reserved4[16];
+
+        struct IoHriMainStoreVpdFruData fruData;
+
+        u8      vpdPortNum;
+        u8      reserved5;
+        u8      frameId;
+        u8      rackUnit;
+        char    asciiKeywordVpd[256];
+        u32     reserved6;
 };
 
 
diff --git a/arch/powerpc/platforms/iseries/pci.c b/arch/powerpc/platforms/iseries/pci.c
index 35bcc98111f5..3eb12065df23 100644
--- a/arch/powerpc/platforms/iseries/pci.c
+++ b/arch/powerpc/platforms/iseries/pci.c
@@ -34,6 +34,7 @@
 #include <asm/pci-bridge.h>
 #include <asm/iommu.h>
 #include <asm/abs_addr.h>
+#include <asm/firmware.h>
 
 #include <asm/iseries/hv_call_xm.h>
 #include <asm/iseries/mf.h>
@@ -176,12 +177,12 @@ void iSeries_pcibios_init(void)
         }
         while ((node = of_get_next_child(root, node)) != NULL) {
                 HvBusNumber bus;
-                u32 *busp;
+                const u32 *busp;
 
                 if ((node->type == NULL) || (strcmp(node->type, "pci") != 0))
                         continue;
 
-                busp = (u32 *)get_property(node, "bus-range", NULL);
+                busp = get_property(node, "bus-range", NULL);
                 if (busp == NULL)
                         continue;
                 bus = *busp;
@@ -221,10 +222,9 @@ void __init iSeries_pci_final_fixup(void)
 
                 if (node != NULL) {
                         struct pci_dn *pdn = PCI_DN(node);
-                        u32 *agent;
+                        const u32 *agent;
 
-                        agent = (u32 *)get_property(node, "linux,agent-id",
-                                        NULL);
+                        agent = get_property(node, "linux,agent-id", NULL);
                         if ((pdn != NULL) && (agent != NULL)) {
                                 u8 irq = iSeries_allocate_IRQ(pdn->busno, 0,
                                                 pdn->bussubno);
@@ -271,46 +271,6 @@ void pcibios_fixup_resources(struct pci_dev *pdev)
 }
 
 /*
- * I/0 Memory copy MUST use mmio commands on iSeries
- * To do; For performance, include the hv call directly
- */
-void iSeries_memset_io(volatile void __iomem *dest, char c, size_t Count)
-{
-        u8 ByteValue = c;
-        long NumberOfBytes = Count;
-
-        while (NumberOfBytes > 0) {
-                iSeries_Write_Byte(ByteValue, dest++);
-                -- NumberOfBytes;
-        }
-}
-EXPORT_SYMBOL(iSeries_memset_io);
-
-void iSeries_memcpy_toio(volatile void __iomem *dest, void *source, size_t count)
-{
-        char *src = source;
-        long NumberOfBytes = count;
-
-        while (NumberOfBytes > 0) {
-                iSeries_Write_Byte(*src++, dest++);
-                -- NumberOfBytes;
-        }
-}
-EXPORT_SYMBOL(iSeries_memcpy_toio);
-
-void iSeries_memcpy_fromio(void *dest, const volatile void __iomem *src, size_t count)
-{
-        char *dst = dest;
-        long NumberOfBytes = count;
-
-        while (NumberOfBytes > 0) {
-                *dst++ = iSeries_Read_Byte(src++);
-                -- NumberOfBytes;
-        }
-}
-EXPORT_SYMBOL(iSeries_memcpy_fromio);
-
-/*
  * Look down the chain to find the matching Device Device
  */
 static struct device_node *find_Device_Node(int bus, int devfn)
@@ -492,7 +452,7 @@ static inline struct device_node *xlate_iomm_address(
  * iSeries_Read_Word = Read Word  (16 bit)
  * iSeries_Read_Long = Read Long  (32 bit)
  */
-u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
+static u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
@@ -519,9 +479,8 @@ u8 iSeries_Read_Byte(const volatile void __iomem *IoAddress)
 
         return (u8)ret.value;
 }
-EXPORT_SYMBOL(iSeries_Read_Byte);
 
-u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
+static u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
@@ -549,9 +508,8 @@ u16 iSeries_Read_Word(const volatile void __iomem *IoAddress)
 
         return swab16((u16)ret.value);
 }
-EXPORT_SYMBOL(iSeries_Read_Word);
 
-u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
+static u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
@@ -579,7 +537,6 @@ u32 iSeries_Read_Long(const volatile void __iomem *IoAddress)
 
         return swab32((u32)ret.value);
 }
-EXPORT_SYMBOL(iSeries_Read_Long);
 
 /*
  * Write MM I/O Instructions for the iSeries
@@ -588,7 +545,7 @@ EXPORT_SYMBOL(iSeries_Read_Long);
  * iSeries_Write_Word = Write Word(16 bit)
  * iSeries_Write_Long = Write Long(32 bit)
  */
-void iSeries_Write_Byte(u8 data, volatile void __iomem *IoAddress)
+static void iSeries_Write_Byte(u8 data, volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
@@ -613,9 +570,8 @@ void iSeries_Write_Byte(u8 data, volatile void __iomem *IoAddress)
                 rc = HvCall4(HvCallPciBarStore8, dsa, BarOffset, data, 0);
         } while (CheckReturnCode("WWB", DevNode, &retry, rc) != 0);
 }
-EXPORT_SYMBOL(iSeries_Write_Byte);
 
-void iSeries_Write_Word(u16 data, volatile void __iomem *IoAddress)
+static void iSeries_Write_Word(u16 data, volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
@@ -640,9 +596,8 @@ void iSeries_Write_Word(u16 data, volatile void __iomem *IoAddress)
                 rc = HvCall4(HvCallPciBarStore16, dsa, BarOffset, swab16(data), 0);
         } while (CheckReturnCode("WWW", DevNode, &retry, rc) != 0);
 }
-EXPORT_SYMBOL(iSeries_Write_Word);
 
-void iSeries_Write_Long(u32 data, volatile void __iomem *IoAddress)
+static void iSeries_Write_Long(u32 data, volatile void __iomem *IoAddress)
 {
         u64 BarOffset;
         u64 dsa;
@@ -667,4 +622,224 @@ void iSeries_Write_Long(u32 data, volatile void __iomem *IoAddress)
                 rc = HvCall4(HvCallPciBarStore32, dsa, BarOffset, swab32(data), 0);
         } while (CheckReturnCode("WWL", DevNode, &retry, rc) != 0);
 }
-EXPORT_SYMBOL(iSeries_Write_Long);
+
+extern unsigned char __raw_readb(const volatile void __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        return *(volatile unsigned char __force *)addr;
+}
+EXPORT_SYMBOL(__raw_readb);
+
+extern unsigned short __raw_readw(const volatile void __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        return *(volatile unsigned short __force *)addr;
+}
+EXPORT_SYMBOL(__raw_readw);
+
+extern unsigned int __raw_readl(const volatile void __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        return *(volatile unsigned int __force *)addr;
+}
+EXPORT_SYMBOL(__raw_readl);
+
+extern unsigned long __raw_readq(const volatile void __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        return *(volatile unsigned long __force *)addr;
+}
+EXPORT_SYMBOL(__raw_readq);
+
+extern void __raw_writeb(unsigned char v, volatile void __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        *(volatile unsigned char __force *)addr = v;
+}
+EXPORT_SYMBOL(__raw_writeb);
+
+extern void __raw_writew(unsigned short v, volatile void __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        *(volatile unsigned short __force *)addr = v;
+}
+EXPORT_SYMBOL(__raw_writew);
+
+extern void __raw_writel(unsigned int v, volatile void __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        *(volatile unsigned int __force *)addr = v;
+}
+EXPORT_SYMBOL(__raw_writel);
+
+extern void __raw_writeq(unsigned long v, volatile void __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        *(volatile unsigned long __force *)addr = v;
+}
+EXPORT_SYMBOL(__raw_writeq);
+
+int in_8(const volatile unsigned char __iomem *addr)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                return iSeries_Read_Byte(addr);
+        return __in_8(addr);
+}
+EXPORT_SYMBOL(in_8);
+
+void out_8(volatile unsigned char __iomem *addr, int val)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                iSeries_Write_Byte(val, addr);
+        else
+                __out_8(addr, val);
+}
+EXPORT_SYMBOL(out_8);
+
+int in_le16(const volatile unsigned short __iomem *addr)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                return iSeries_Read_Word(addr);
+        return __in_le16(addr);
+}
+EXPORT_SYMBOL(in_le16);
+
+int in_be16(const volatile unsigned short __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        return __in_be16(addr);
+}
+EXPORT_SYMBOL(in_be16);
+
+void out_le16(volatile unsigned short __iomem *addr, int val)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                iSeries_Write_Word(val, addr);
+        else
+                __out_le16(addr, val);
+}
+EXPORT_SYMBOL(out_le16);
+
+void out_be16(volatile unsigned short __iomem *addr, int val)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        __out_be16(addr, val);
+}
+EXPORT_SYMBOL(out_be16);
+
+unsigned in_le32(const volatile unsigned __iomem *addr)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                return iSeries_Read_Long(addr);
+        return __in_le32(addr);
+}
+EXPORT_SYMBOL(in_le32);
+
+unsigned in_be32(const volatile unsigned __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        return __in_be32(addr);
+}
+EXPORT_SYMBOL(in_be32);
+
+void out_le32(volatile unsigned __iomem *addr, int val)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                iSeries_Write_Long(val, addr);
+        else
+                __out_le32(addr, val);
+}
+EXPORT_SYMBOL(out_le32);
+
+void out_be32(volatile unsigned __iomem *addr, int val)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        __out_be32(addr, val);
+}
+EXPORT_SYMBOL(out_be32);
+
+unsigned long in_le64(const volatile unsigned long __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        return __in_le64(addr);
+}
+EXPORT_SYMBOL(in_le64);
+
+unsigned long in_be64(const volatile unsigned long __iomem *addr)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        return __in_be64(addr);
+}
+EXPORT_SYMBOL(in_be64);
+
+void out_le64(volatile unsigned long __iomem *addr, unsigned long val)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        __out_le64(addr, val);
+}
+EXPORT_SYMBOL(out_le64);
+
+void out_be64(volatile unsigned long __iomem *addr, unsigned long val)
+{
+        BUG_ON(firmware_has_feature(FW_FEATURE_ISERIES));
+
+        __out_be64(addr, val);
+}
+EXPORT_SYMBOL(out_be64);
+
+void memset_io(volatile void __iomem *addr, int c, unsigned long n)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                volatile char __iomem *d = addr;
+
+                while (n-- > 0) {
+                        iSeries_Write_Byte(c, d++);
+                }
+        } else
+                eeh_memset_io(addr, c, n);
+}
+EXPORT_SYMBOL(memset_io);
+
+void memcpy_fromio(void *dest, const volatile void __iomem *src,
+                                 unsigned long n)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                char *d = dest;
+                const volatile char __iomem *s = src;
+
+                while (n-- > 0) {
+                        *d++ = iSeries_Read_Byte(s++);
+                }
+        } else
+                eeh_memcpy_fromio(dest, src, n);
+}
+EXPORT_SYMBOL(memcpy_fromio);
+
+void memcpy_toio(volatile void __iomem *dest, const void *src, unsigned long n)
+{
+        if (firmware_has_feature(FW_FEATURE_ISERIES)) {
+                const char *s = src;
+                volatile char __iomem *d = dest;
+
+                while (n-- > 0) {
+                        iSeries_Write_Byte(*s++, d++);
+                }
+        } else
+                eeh_memcpy_toio(dest, src, n);
+}
+EXPORT_SYMBOL(memcpy_toio);
diff --git a/arch/powerpc/platforms/iseries/setup.c b/arch/powerpc/platforms/iseries/setup.c
index c9605d773a77..7f1953066ff8 100644
--- a/arch/powerpc/platforms/iseries/setup.c
+++ b/arch/powerpc/platforms/iseries/setup.c
@@ -59,6 +59,7 @@
 #include "irq.h"
 #include "vpd_areas.h"
 #include "processor_vpd.h"
+#include "it_lp_naca.h"
 #include "main_store.h"
 #include "call_sm.h"
 #include "call_hpt.h"
diff --git a/arch/powerpc/platforms/iseries/viopath.c b/arch/powerpc/platforms/iseries/viopath.c
index 622a30149b48..9baa4ee82592 100644
--- a/arch/powerpc/platforms/iseries/viopath.c
+++ b/arch/powerpc/platforms/iseries/viopath.c
@@ -41,8 +41,8 @@
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
+#include <asm/prom.h>
 #include <asm/iseries/hv_types.h>
-#include <asm/iseries/it_exp_vpd_panel.h>
 #include <asm/iseries/hv_lp_event.h>
 #include <asm/iseries/hv_lp_config.h>
 #include <asm/iseries/mf.h>
@@ -116,6 +116,8 @@ static int proc_viopath_show(struct seq_file *m, void *v)
         dma_addr_t handle;
         HvLpEvent_Rc hvrc;
         DECLARE_MUTEX_LOCKED(Semaphore);
+        struct device_node *node;
+        const char *sysid;
 
         buf = kmalloc(HW_PAGE_SIZE, GFP_KERNEL);
         if (!buf)
@@ -143,20 +145,26 @@ static int proc_viopath_show(struct seq_file *m, void *v)
 
         buf[HW_PAGE_SIZE-1] = '\0';
         seq_printf(m, "%s", buf);
-        seq_printf(m, "AVAILABLE_VETH=%x\n", vlanMap);
-        seq_printf(m, "SRLNBR=%c%c%c%c%c%c%c\n",
-                   e2a(xItExtVpdPanel.mfgID[2]),
-                   e2a(xItExtVpdPanel.mfgID[3]),
-                   e2a(xItExtVpdPanel.systemSerial[1]),
-                   e2a(xItExtVpdPanel.systemSerial[2]),
-                   e2a(xItExtVpdPanel.systemSerial[3]),
-                   e2a(xItExtVpdPanel.systemSerial[4]),
-                   e2a(xItExtVpdPanel.systemSerial[5]));
 
         dma_unmap_single(iSeries_vio_dev, handle, HW_PAGE_SIZE,
                          DMA_FROM_DEVICE);
         kfree(buf);
 
+        seq_printf(m, "AVAILABLE_VETH=%x\n", vlanMap);
+
+        node = of_find_node_by_path("/");
+        sysid = NULL;
+        if (node != NULL)
+                sysid = get_property(node, "system-id", NULL);
+
+        if (sysid == NULL)
+                seq_printf(m, "SRLNBR=<UNKNOWN>\n");
+        else
+                /* Skip "IBM," on front of serial number, see dt.c */
+                seq_printf(m, "SRLNBR=%s\n", sysid + 4);
+
+        of_node_put(node);
+
         return 0;
 }
 
diff --git a/arch/powerpc/platforms/iseries/vpdinfo.c b/arch/powerpc/platforms/iseries/vpdinfo.c
index 23a6d1e5b429..9f83878a0c2e 100644
--- a/arch/powerpc/platforms/iseries/vpdinfo.c
+++ b/arch/powerpc/platforms/iseries/vpdinfo.c
@@ -188,7 +188,7 @@ static void __init iSeries_Parse_Vpd(u8 *VpdData, int VpdDataLen,
 {
         u8 *TagPtr = VpdData;
         int DataLen = VpdDataLen - 3;
-        u8 PhbId;
+        u8 PhbId = 0xff;
 
         while ((*TagPtr != VpdEndOfAreaTag) && (DataLen > 0)) {
                 int AreaLen = *(TagPtr + 1) + (*(TagPtr + 2) * 256);
@@ -205,15 +205,16 @@ static void __init iSeries_Parse_Vpd(u8 *VpdData, int VpdDataLen,
         }
 }
 
-static void __init iSeries_Get_Location_Code(u16 bus, HvAgentId agent,
+static int __init iSeries_Get_Location_Code(u16 bus, HvAgentId agent,
                 u8 *frame, char card[4])
 {
+        int status = 0;
         int BusVpdLen = 0;
         u8 *BusVpdPtr = kmalloc(BUS_VPDSIZE, GFP_KERNEL);
 
         if (BusVpdPtr == NULL) {
                 printk("PCI: Bus VPD Buffer allocation failure.\n");
-                return;
+                return 0;
         }
         BusVpdLen = HvCallPci_getBusVpd(bus, iseries_hv_addr(BusVpdPtr),
                                         BUS_VPDSIZE);
@@ -228,8 +229,10 @@ static void __init iSeries_Get_Location_Code(u16 bus, HvAgentId agent,
                 goto out_free;
         }
         iSeries_Parse_Vpd(BusVpdPtr, BusVpdLen, agent, frame, card);
+        status = 1;
 out_free:
         kfree(BusVpdPtr);
+        return status;
 }
 
 /*
@@ -246,7 +249,7 @@ void __init iSeries_Device_Information(struct pci_dev *PciDev, int count)
         struct device_node *DevNode = PciDev->sysdata;
         struct pci_dn *pdn;
         u16 bus;
-        u8 frame;
+        u8 frame = 0;
         char card[4];
         HvSubBusNumber subbus;
         HvAgentId agent;
@@ -262,10 +265,11 @@ void __init iSeries_Device_Information(struct pci_dev *PciDev, int count)
         subbus = pdn->bussubno;
         agent = ISERIES_PCI_AGENTID(ISERIES_GET_DEVICE_FROM_SUBBUS(subbus),
                         ISERIES_GET_FUNCTION_FROM_SUBBUS(subbus));
-        iSeries_Get_Location_Code(bus, agent, &frame, card);
 
-        printk("%d. PCI: Bus%3d, Device%3d, Vendor %04X Frame%3d, Card %4s  ",
-                        count, bus, PCI_SLOT(PciDev->devfn), PciDev->vendor,
-                        frame, card);
-        printk("0x%04X\n", (int)(PciDev->class >> 8));
+        if (iSeries_Get_Location_Code(bus, agent, &frame, card)) {
+                printk("%d. PCI: Bus%3d, Device%3d, Vendor %04X Frame%3d, "
+                        "Card %4s  0x%04X\n", count, bus,
+                        PCI_SLOT(PciDev->devfn), PciDev->vendor, frame,
+                        card, (int)(PciDev->class >> 8));
+        }
 }
diff --git a/arch/powerpc/platforms/maple/pci.c b/arch/powerpc/platforms/maple/pci.c
index 63a1670d3bfd..c3aa46b8e2b9 100644
--- a/arch/powerpc/platforms/maple/pci.c
+++ b/arch/powerpc/platforms/maple/pci.c
@@ -38,16 +38,16 @@ static struct pci_controller *u3_agp, *u3_ht;
 static int __init fixup_one_level_bus_range(struct device_node *node, int higher)
 {
         for (; node != 0;node = node->sibling) {
-                int * bus_range;
-                unsigned int *class_code;
+                const int *bus_range;
+                const unsigned int *class_code;
                 int len;
 
                 /* For PCI<->PCI bridges or CardBus bridges, we go down */
-                class_code = (unsigned int *) get_property(node, "class-code", NULL);
+                class_code = get_property(node, "class-code", NULL);
                 if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
                         (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
                         continue;
-                bus_range = (int *) get_property(node, "bus-range", &len);
+                bus_range = get_property(node, "bus-range", &len);
                 if (bus_range != NULL && len > 2 * sizeof(int)) {
                         if (bus_range[1] > higher)
                                 higher = bus_range[1];
@@ -65,30 +65,36 @@ static int __init fixup_one_level_bus_range(struct device_node *node, int higher
  */
 static void __init fixup_bus_range(struct device_node *bridge)
 {
-        int * bus_range;
+        int *bus_range;
+        struct property *prop;
         int len;
 
         /* Lookup the "bus-range" property for the hose */
-        bus_range = (int *) get_property(bridge, "bus-range", &len);
-        if (bus_range == NULL || len < 2 * sizeof(int)) {
+        prop = of_find_property(bridge, "bus-range", &len);
+        if (prop == NULL  || prop->value == NULL || len < 2 * sizeof(int)) {
                 printk(KERN_WARNING "Can't get bus-range for %s\n",
                                bridge->full_name);
                 return;
         }
+        bus_range = (int *)prop->value;
         bus_range[1] = fixup_one_level_bus_range(bridge->child, bus_range[1]);
 }
 
 
-#define U3_AGP_CFA0(devfn, off) \
-        ((1 << (unsigned long)PCI_SLOT(dev_fn)) \
-        | (((unsigned long)PCI_FUNC(dev_fn)) << 8) \
-        | (((unsigned long)(off)) & 0xFCUL))
+static unsigned long u3_agp_cfa0(u8 devfn, u8 off)
+{
+        return (1 << (unsigned long)PCI_SLOT(devfn)) |
+                ((unsigned long)PCI_FUNC(devfn) << 8) |
+                ((unsigned long)off & 0xFCUL);
+}
 
-#define U3_AGP_CFA1(bus, devfn, off)    \
-        ((((unsigned long)(bus)) << 16) \
-        |(((unsigned long)(devfn)) << 8) \
-        |(((unsigned long)(off)) & 0xFCUL) \
-        |1UL)
+static unsigned long u3_agp_cfa1(u8 bus, u8 devfn, u8 off)
+{
+        return ((unsigned long)bus << 16) |
+                ((unsigned long)devfn << 8) |
+                ((unsigned long)off & 0xFCUL) |
+                1UL;
+}
 
 static unsigned long u3_agp_cfg_access(struct pci_controller* hose,
                                        u8 bus, u8 dev_fn, u8 offset)
@@ -98,9 +104,9 @@ static unsigned long u3_agp_cfg_access(struct pci_controller* hose,
         if (bus == hose->first_busno) {
                 if (dev_fn < (11 << 3))
                         return 0;
-                caddr = U3_AGP_CFA0(dev_fn, offset);
+                caddr = u3_agp_cfa0(dev_fn, offset);
         } else
-                caddr = U3_AGP_CFA1(bus, dev_fn, offset);
+                caddr = u3_agp_cfa1(bus, dev_fn, offset);
 
         /* Uninorth will return garbage if we don't read back the value ! */
         do {
@@ -182,13 +188,15 @@ static struct pci_ops u3_agp_pci_ops =
         u3_agp_write_config
 };
 
+static unsigned long u3_ht_cfa0(u8 devfn, u8 off)
+{
+        return (devfn << 8) | off;
+}
 
-#define U3_HT_CFA0(devfn, off)          \
-                ((((unsigned long)devfn) << 8) | offset)
-#define U3_HT_CFA1(bus, devfn, off)     \
-                (U3_HT_CFA0(devfn, off) \
-                + (((unsigned long)bus) << 16) \
-                + 0x01000000UL)
+static unsigned long u3_ht_cfa1(u8 bus, u8 devfn, u8 off)
+{
+        return u3_ht_cfa0(devfn, off) + (bus << 16) + 0x01000000UL;
+}
 
 static unsigned long u3_ht_cfg_access(struct pci_controller* hose,
                                       u8 bus, u8 devfn, u8 offset)
@@ -196,9 +204,9 @@ static unsigned long u3_ht_cfg_access(struct pci_controller* hose,
         if (bus == hose->first_busno) {
                 if (PCI_SLOT(devfn) == 0)
                         return 0;
-                return ((unsigned long)hose->cfg_data) + U3_HT_CFA0(devfn, offset);
+                return ((unsigned long)hose->cfg_data) + u3_ht_cfa0(devfn, offset);
         } else
-                return ((unsigned long)hose->cfg_data) + U3_HT_CFA1(bus, devfn, offset);
+                return ((unsigned long)hose->cfg_data) + u3_ht_cfa1(bus, devfn, offset);
 }
 
 static int u3_ht_read_config(struct pci_bus *bus, unsigned int devfn,
@@ -211,6 +219,9 @@ static int u3_ht_read_config(struct pci_bus *bus, unsigned int devfn,
         if (hose == NULL)
                 return PCIBIOS_DEVICE_NOT_FOUND;
 
+        if (offset > 0xff)
+                return PCIBIOS_BAD_REGISTER_NUMBER;
+
         addr = u3_ht_cfg_access(hose, bus->number, devfn, offset);
         if (!addr)
                 return PCIBIOS_DEVICE_NOT_FOUND;
@@ -243,6 +254,9 @@ static int u3_ht_write_config(struct pci_bus *bus, unsigned int devfn,
         if (hose == NULL)
                 return PCIBIOS_DEVICE_NOT_FOUND;
 
+        if (offset > 0xff)
+                return PCIBIOS_BAD_REGISTER_NUMBER;
+
         addr = u3_ht_cfg_access(hose, bus->number, devfn, offset);
         if (!addr)
                 return PCIBIOS_DEVICE_NOT_FOUND;
@@ -314,12 +328,12 @@ static int __init add_bridge(struct device_node *dev)
         int len;
         struct pci_controller *hose;
         char* disp_name;
-        int *bus_range;
+        const int *bus_range;
         int primary = 1;
 
         DBG("Adding PCI host bridge %s\n", dev->full_name);
 
-        bus_range = (int *) get_property(dev, "bus-range", &len);
+        bus_range = get_property(dev, "bus-range", &len);
         if (bus_range == NULL || len < 2 * sizeof(int)) {
                 printk(KERN_WARNING "Can't get bus-range for %s, assume bus 0\n",
                 dev->full_name);
diff --git a/arch/powerpc/platforms/maple/setup.c b/arch/powerpc/platforms/maple/setup.c
index 57567dfb9819..fe6b9bff61b9 100644
--- a/arch/powerpc/platforms/maple/setup.c
+++ b/arch/powerpc/platforms/maple/setup.c
@@ -99,8 +99,7 @@ static unsigned long maple_find_nvram_base(void)
 static void maple_restart(char *cmd)
 {
         unsigned int maple_nvram_base;
-        unsigned int maple_nvram_offset;
-        unsigned int maple_nvram_command;
+        const unsigned int *maple_nvram_offset, *maple_nvram_command;
         struct device_node *sp;
 
         maple_nvram_base = maple_find_nvram_base();
@@ -113,14 +112,12 @@ static void maple_restart(char *cmd)
                 printk(KERN_EMERG "Maple: Unable to find Service Processor\n");
                 goto fail;
         }
-        maple_nvram_offset = *(unsigned int*) get_property(sp,
-                        "restart-addr", NULL);
-        maple_nvram_command = *(unsigned int*) get_property(sp,
-                        "restart-value", NULL);
+        maple_nvram_offset = get_property(sp, "restart-addr", NULL);
+        maple_nvram_command = get_property(sp, "restart-value", NULL);
         of_node_put(sp);
 
         /* send command */
-        outb_p(maple_nvram_command, maple_nvram_base + maple_nvram_offset);
+        outb_p(*maple_nvram_command, maple_nvram_base + *maple_nvram_offset);
         for (;;) ;
  fail:
         printk(KERN_EMERG "Maple: Manual Restart Required\n");
@@ -129,8 +126,7 @@ static void maple_restart(char *cmd)
 static void maple_power_off(void)
 {
         unsigned int maple_nvram_base;
-        unsigned int maple_nvram_offset;
-        unsigned int maple_nvram_command;
+        const unsigned int *maple_nvram_offset, *maple_nvram_command;
         struct device_node *sp;
 
         maple_nvram_base = maple_find_nvram_base();
@@ -143,14 +139,12 @@ static void maple_power_off(void)
                 printk(KERN_EMERG "Maple: Unable to find Service Processor\n");
                 goto fail;
         }
-        maple_nvram_offset = *(unsigned int*) get_property(sp,
-                        "power-off-addr", NULL);
-        maple_nvram_command = *(unsigned int*) get_property(sp,
-                        "power-off-value", NULL);
+        maple_nvram_offset = get_property(sp, "power-off-addr", NULL);
+        maple_nvram_command = get_property(sp, "power-off-value", NULL);
         of_node_put(sp);
 
         /* send command */
-        outb_p(maple_nvram_command, maple_nvram_base + maple_nvram_offset);
+        outb_p(*maple_nvram_command, maple_nvram_base + *maple_nvram_offset);
         for (;;) ;
  fail:
         printk(KERN_EMERG "Maple: Manual Power-Down Required\n");
@@ -211,7 +205,7 @@ static void __init maple_init_early(void)
 static void __init maple_init_IRQ(void)
 {
         struct device_node *root, *np, *mpic_node = NULL;
-        unsigned int *opprop;
+        const unsigned int *opprop;
         unsigned long openpic_addr = 0;
         int naddr, n, i, opplen, has_isus = 0;
         struct mpic *mpic;
@@ -241,8 +235,7 @@ static void __init maple_init_IRQ(void)
         /* Find address list in /platform-open-pic */
         root = of_find_node_by_path("/");
         naddr = prom_n_addr_cells(root);
-        opprop = (unsigned int *) get_property(root, "platform-open-pic",
-                                               &opplen);
+        opprop = get_property(root, "platform-open-pic", &opplen);
         if (opprop != 0) {
                 openpic_addr = of_read_number(opprop, naddr);
                 has_isus = (opplen > naddr);
diff --git a/arch/powerpc/platforms/pasemi/Makefile b/arch/powerpc/platforms/pasemi/Makefile
new file mode 100644
index 000000000000..1be1a993c5f5
--- /dev/null
+++ b/arch/powerpc/platforms/pasemi/Makefile
@@ -0,0 +1 @@
+obj-y   += setup.o pci.o time.o
diff --git a/arch/powerpc/platforms/pasemi/pasemi.h b/arch/powerpc/platforms/pasemi/pasemi.h
new file mode 100644
index 000000000000..fd71d72736b2
--- /dev/null
+++ b/arch/powerpc/platforms/pasemi/pasemi.h
@@ -0,0 +1,8 @@
+#ifndef _PASEMI_PASEMI_H
+#define _PASEMI_PASEMI_H
+
+extern unsigned long pas_get_boot_time(void);
+extern void pas_pci_init(void);
+extern void pas_pcibios_fixup(void);
+
+#endif /* _PASEMI_PASEMI_H */
diff --git a/arch/powerpc/platforms/pasemi/pci.c b/arch/powerpc/platforms/pasemi/pci.c
new file mode 100644
index 000000000000..4679c5230413
--- /dev/null
+++ b/arch/powerpc/platforms/pasemi/pci.c
@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) 2006 PA Semi, Inc
+ *
+ * Authors: Kip Walker, PA Semi
+ *          Olof Johansson, PA Semi
+ *
+ * Maintained by: Olof Johansson <olof@lixom.net>
+ *
+ * Based on arch/powerpc/platforms/maple/pci.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+
+#include <asm/pci-bridge.h>
+#include <asm/machdep.h>
+
+#include <asm/ppc-pci.h>
+
+#define PA_PXP_CFA(bus, devfn, off) (((bus) << 20) | ((devfn) << 12) | (off))
+
+#define CONFIG_OFFSET_VALID(off) ((off) < 4096)
+
+static unsigned long pa_pxp_cfg_addr(struct pci_controller *hose,
+                                       u8 bus, u8 devfn, int offset)
+{
+        return ((unsigned long)hose->cfg_data) + PA_PXP_CFA(bus, devfn, offset);
+}
+
+static int pa_pxp_read_config(struct pci_bus *bus, unsigned int devfn,
+                              int offset, int len, u32 *val)
+{
+        struct pci_controller *hose;
+        unsigned long addr;
+
+        hose = pci_bus_to_host(bus);
+        if (!hose)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
+        if (!CONFIG_OFFSET_VALID(offset))
+                return PCIBIOS_BAD_REGISTER_NUMBER;
+
+        addr = pa_pxp_cfg_addr(hose, bus->number, devfn, offset);
+
+        /*
+         * Note: the caller has already checked that offset is
+         * suitably aligned and that len is 1, 2 or 4.
+         */
+        switch (len) {
+        case 1:
+                *val = in_8((u8 *)addr);
+                break;
+        case 2:
+                *val = in_le16((u16 *)addr);
+                break;
+        default:
+                *val = in_le32((u32 *)addr);
+                break;
+        }
+
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static int pa_pxp_write_config(struct pci_bus *bus, unsigned int devfn,
+                               int offset, int len, u32 val)
+{
+        struct pci_controller *hose;
+        unsigned long addr;
+
+        hose = pci_bus_to_host(bus);
+        if (!hose)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
+        if (!CONFIG_OFFSET_VALID(offset))
+                return PCIBIOS_BAD_REGISTER_NUMBER;
+
+        addr = pa_pxp_cfg_addr(hose, bus->number, devfn, offset);
+
+        /*
+         * Note: the caller has already checked that offset is
+         * suitably aligned and that len is 1, 2 or 4.
+         */
+        switch (len) {
+        case 1:
+                out_8((u8 *)addr, val);
+                (void) in_8((u8 *)addr);
+                break;
+        case 2:
+                out_le16((u16 *)addr, val);
+                (void) in_le16((u16 *)addr);
+                break;
+        default:
+                out_le32((u32 *)addr, val);
+                (void) in_le32((u32 *)addr);
+                break;
+        }
+        return PCIBIOS_SUCCESSFUL;
+}
+
+static struct pci_ops pa_pxp_ops = {
+        pa_pxp_read_config,
+        pa_pxp_write_config,
+};
+
+static void __init setup_pa_pxp(struct pci_controller *hose)
+{
+        hose->ops = &pa_pxp_ops;
+        hose->cfg_data = ioremap(0xe0000000, 0x10000000);
+}
+
+static int __init add_bridge(struct device_node *dev)
+{
+        struct pci_controller *hose;
+
+        pr_debug("Adding PCI host bridge %s\n", dev->full_name);
+
+        hose = pcibios_alloc_controller(dev);
+        if (!hose)
+                return -ENOMEM;
+
+        hose->first_busno = 0;
+        hose->last_busno = 0xff;
+
+        setup_pa_pxp(hose);
+
+        printk(KERN_INFO "Found PA-PXP PCI host bridge.\n");
+
+        /* Interpret the "ranges" property */
+        /* This also maps the I/O region and sets isa_io/mem_base */
+        pci_process_bridge_OF_ranges(hose, dev, 1);
+        pci_setup_phb_io(hose, 1);
+
+        return 0;
+}
+
+
+void __init pas_pcibios_fixup(void)
+{
+        struct pci_dev *dev = NULL;
+
+        for_each_pci_dev(dev)
+                pci_read_irq_line(dev);
+}
+
+static void __init pas_fixup_phb_resources(void)
+{
+        struct pci_controller *hose, *tmp;
+
+        list_for_each_entry_safe(hose, tmp, &hose_list, list_node) {
+                unsigned long offset = (unsigned long)hose->io_base_virt - pci_io_base;
+                hose->io_resource.start += offset;
+                hose->io_resource.end += offset;
+                printk(KERN_INFO "PCI Host %d, io start: %lx; io end: %lx\n",
+                       hose->global_number,
+                       hose->io_resource.start, hose->io_resource.end);
+        }
+}
+
+
+void __init pas_pci_init(void)
+{
+        struct device_node *np, *root;
+
+        root = of_find_node_by_path("/");
+        if (!root) {
+                printk(KERN_CRIT "pas_pci_init: can't find root "
+                        "of device tree\n");
+                return;
+        }
+
+        for (np = NULL; (np = of_get_next_child(root, np)) != NULL;)
+                if (np->name && !strcmp(np->name, "pxp") && !add_bridge(np))
+                        of_node_get(np);
+
+        of_node_put(root);
+
+        pas_fixup_phb_resources();
+
+        /* Setup the linkage between OF nodes and PHBs */
+        pci_devs_phb_init();
+
+        /* Use the common resource allocation mechanism */
+        pci_probe_only = 1;
+}
diff --git a/arch/powerpc/platforms/pasemi/setup.c b/arch/powerpc/platforms/pasemi/setup.c
new file mode 100644
index 000000000000..628482671c15
--- /dev/null
+++ b/arch/powerpc/platforms/pasemi/setup.c
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2006 PA Semi, Inc
+ *
+ * Authors: Kip Walker, PA Semi
+ *          Olof Johansson, PA Semi
+ *
+ * Maintained by: Olof Johansson <olof@lixom.net>
+ *
+ * Based on arch/powerpc/platforms/maple/setup.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <linux/config.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/console.h>
+
+#include <asm/prom.h>
+#include <asm/system.h>
+#include <asm/iommu.h>
+#include <asm/machdep.h>
+#include <asm/mpic.h>
+#include <asm/smp.h>
+#include <asm/time.h>
+
+#include "pasemi.h"
+
+static void pas_restart(char *cmd)
+{
+        printk("restart unimplemented, looping...\n");
+        for (;;) ;
+}
+
+static void pas_power_off(void)
+{
+        printk("power off unimplemented, looping...\n");
+        for (;;) ;
+}
+
+static void pas_halt(void)
+{
+        pas_power_off();
+}
+
+#ifdef CONFIG_SMP
+struct smp_ops_t pas_smp_ops = {
+        .probe          = smp_mpic_probe,
+        .message_pass   = smp_mpic_message_pass,
+        .kick_cpu       = smp_generic_kick_cpu,
+        .setup_cpu      = smp_mpic_setup_cpu,
+        .give_timebase  = smp_generic_give_timebase,
+        .take_timebase  = smp_generic_take_timebase,
+};
+#endif /* CONFIG_SMP */
+
+void __init pas_setup_arch(void)
+{
+#ifdef CONFIG_SMP
+        /* Setup SMP callback */
+        smp_ops = &pas_smp_ops;
+#endif
+        /* Lookup PCI hosts */
+        pas_pci_init();
+
+#ifdef CONFIG_DUMMY_CONSOLE
+        conswitchp = &dummy_con;
+#endif
+
+        printk(KERN_DEBUG "Using default idle loop\n");
+}
+
+static void iommu_dev_setup_null(struct pci_dev *dev) { }
+static void iommu_bus_setup_null(struct pci_bus *bus) { }
+
+static void __init pas_init_early(void)
+{
+        /* No iommu code yet */
+        ppc_md.iommu_dev_setup = iommu_dev_setup_null;
+        ppc_md.iommu_bus_setup = iommu_bus_setup_null;
+        pci_direct_iommu_init();
+}
+
+/* No legacy IO on our parts */
+static int pas_check_legacy_ioport(unsigned int baseport)
+{
+        return -ENODEV;
+}
+
+static __init void pas_init_IRQ(void)
+{
+        struct device_node *np;
+        struct device_node *root, *mpic_node;
+        unsigned long openpic_addr;
+        const unsigned int *opprop;
+        int naddr, opplen;
+        struct mpic *mpic;
+
+        mpic_node = NULL;
+
+        for_each_node_by_type(np, "interrupt-controller")
+                if (device_is_compatible(np, "open-pic")) {
+                        mpic_node = np;
+                        break;
+                }
+        if (!mpic_node)
+                for_each_node_by_type(np, "open-pic") {
+                        mpic_node = np;
+                        break;
+                }
+        if (!mpic_node) {
+                printk(KERN_ERR
+                        "Failed to locate the MPIC interrupt controller\n");
+                return;
+        }
+
+        /* Find address list in /platform-open-pic */
+        root = of_find_node_by_path("/");
+        naddr = prom_n_addr_cells(root);
+        opprop = get_property(root, "platform-open-pic", &opplen);
+        if (!opprop) {
+                printk(KERN_ERR "No platform-open-pic property.\n");
+                of_node_put(root);
+                return;
+        }
+        openpic_addr = of_read_number(opprop, naddr);
+        printk(KERN_DEBUG "OpenPIC addr: %lx\n", openpic_addr);
+        of_node_put(root);
+
+        mpic = mpic_alloc(mpic_node, openpic_addr, MPIC_PRIMARY, 0, 0,
+                          " PAS-OPIC  ");
+        BUG_ON(!mpic);
+
+        mpic_assign_isu(mpic, 0, openpic_addr + 0x10000);
+        mpic_init(mpic);
+        of_node_put(mpic_node);
+        of_node_put(root);
+}
+
+static void __init pas_progress(char *s, unsigned short hex)
+{
+        printk("[%04x] : %s\n", hex, s ? s : "");
+}
+
+
+/*
+ * Called very early, MMU is off, device-tree isn't unflattened
+ */
+static int __init pas_probe(void)
+{
+        unsigned long root = of_get_flat_dt_root();
+
+        if (!of_flat_dt_is_compatible(root, "PA6T-1682M"))
+                return 0;
+
+        hpte_init_native();
+
+        return 1;
+}
+
+define_machine(pas) {
+        .name                   = "PA Semi PA6T-1682M",
+        .probe                  = pas_probe,
+        .setup_arch             = pas_setup_arch,
+        .init_early             = pas_init_early,
+        .init_IRQ               = pas_init_IRQ,
+        .get_irq                = mpic_get_irq,
+        .pcibios_fixup          = pas_pcibios_fixup,
+        .restart                = pas_restart,
+        .power_off              = pas_power_off,
+        .halt                   = pas_halt,
+        .get_boot_time          = pas_get_boot_time,
+        .calibrate_decr         = generic_calibrate_decr,
+        .check_legacy_ioport    = pas_check_legacy_ioport,
+        .progress               = pas_progress,
+};
diff --git a/arch/powerpc/platforms/pasemi/time.c b/arch/powerpc/platforms/pasemi/time.c
new file mode 100644
index 000000000000..9bd410b8fec6
--- /dev/null
+++ b/arch/powerpc/platforms/pasemi/time.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2006 PA Semi, Inc
+ *
+ * Maintained by: Olof Johansson <olof@lixom.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <linux/config.h>
+#include <linux/time.h>
+
+#include <asm/time.h>
+
+unsigned long __init pas_get_boot_time(void)
+{
+        /* Let's just return a fake date right now */
+        return mktime(2006, 1, 1, 12, 0, 0);
+}
diff --git a/arch/powerpc/platforms/powermac/backlight.c b/arch/powerpc/platforms/powermac/backlight.c
index d66415491055..afa593a8544a 100644
--- a/arch/powerpc/platforms/powermac/backlight.c
+++ b/arch/powerpc/platforms/powermac/backlight.c
@@ -60,7 +60,8 @@ int pmac_has_backlight_type(const char *type)
         struct device_node* bk_node = find_devices("backlight");
 
         if (bk_node) {
-                char *prop = get_property(bk_node, "backlight-control", NULL);
+                const char *prop = get_property(bk_node,
+                                "backlight-control", NULL);
                 if (prop && strncmp(prop, type, strlen(type)) == 0)
                         return 1;
         }
diff --git a/arch/powerpc/platforms/powermac/cpufreq_32.c b/arch/powerpc/platforms/powermac/cpufreq_32.c
index 62926248bdb8..c2b6b4134f68 100644
--- a/arch/powerpc/platforms/powermac/cpufreq_32.c
+++ b/arch/powerpc/platforms/powermac/cpufreq_32.c
@@ -421,7 +421,7 @@ static int pmac_cpufreq_cpu_init(struct cpufreq_policy *policy)
 
 static u32 read_gpio(struct device_node *np)
 {
-        u32 *reg = (u32 *)get_property(np, "reg", NULL);
+        const u32 *reg = get_property(np, "reg", NULL);
         u32 offset;
 
         if (reg == NULL)
@@ -497,7 +497,7 @@ static int pmac_cpufreq_init_MacRISC3(struct device_node *cpunode)
                                                                 "frequency-gpio");
         struct device_node *slew_done_gpio_np = of_find_node_by_name(NULL,
                                                                      "slewing-done");
-        u32 *value;
+        const u32 *value;
 
         /*
          * Check to see if it's GPIO driven or PMU only
@@ -519,15 +519,15 @@ static int pmac_cpufreq_init_MacRISC3(struct device_node *cpunode)
          */
         if (frequency_gpio && slew_done_gpio) {
                 int lenp, rc;
-                u32 *freqs, *ratio;
+                const u32 *freqs, *ratio;
 
-                freqs = (u32 *)get_property(cpunode, "bus-frequencies", &lenp);
+                freqs = get_property(cpunode, "bus-frequencies", &lenp);
                 lenp /= sizeof(u32);
                 if (freqs == NULL || lenp != 2) {
                         printk(KERN_ERR "cpufreq: bus-frequencies incorrect or missing\n");
                         return 1;
                 }
-                ratio = (u32 *)get_property(cpunode, "processor-to-bus-ratio*2", NULL);
+                ratio = get_property(cpunode, "processor-to-bus-ratio*2", NULL);
                 if (ratio == NULL) {
                         printk(KERN_ERR "cpufreq: processor-to-bus-ratio*2 missing\n");
                         return 1;
@@ -562,7 +562,7 @@ static int pmac_cpufreq_init_MacRISC3(struct device_node *cpunode)
         /* If we use the PMU, look for the min & max frequencies in the
          * device-tree
          */
-        value = (u32 *)get_property(cpunode, "min-clock-frequency", NULL);
+        value = get_property(cpunode, "min-clock-frequency", NULL);
         if (!value)
                 return 1;
         low_freq = (*value) / 1000;
@@ -571,7 +571,7 @@ static int pmac_cpufreq_init_MacRISC3(struct device_node *cpunode)
         if (low_freq < 100000)
                 low_freq *= 10;
 
-        value = (u32 *)get_property(cpunode, "max-clock-frequency", NULL);
+        value = get_property(cpunode, "max-clock-frequency", NULL);
         if (!value)
                 return 1;
         hi_freq = (*value) / 1000;
@@ -611,13 +611,14 @@ static int pmac_cpufreq_init_7447A(struct device_node *cpunode)
 static int pmac_cpufreq_init_750FX(struct device_node *cpunode)
 {
         struct device_node *volt_gpio_np;
-        u32 pvr, *value;
+        u32 pvr;
+        const u32 *value;
 
         if (get_property(cpunode, "dynamic-power-step", NULL) == NULL)
                 return 1;
 
         hi_freq = cur_freq;
-        value = (u32 *)get_property(cpunode, "reduced-clock-frequency", NULL);
+        value = get_property(cpunode, "reduced-clock-frequency", NULL);
         if (!value)
                 return 1;
         low_freq = (*value) / 1000;
@@ -650,7 +651,7 @@ static int pmac_cpufreq_init_750FX(struct device_node *cpunode)
 static int __init pmac_cpufreq_setup(void)
 {
         struct device_node      *cpunode;
-        u32                     *value;
+        const u32               *value;
 
         if (strstr(cmd_line, "nocpufreq"))
                 return 0;
@@ -661,7 +662,7 @@ static int __init pmac_cpufreq_setup(void)
                 goto out;
 
         /* Get current cpu clock freq */
-        value = (u32 *)get_property(cpunode, "clock-frequency", NULL);
+        value = get_property(cpunode, "clock-frequency", NULL);
         if (!value)
                 goto out;
         cur_freq = (*value) / 1000;
diff --git a/arch/powerpc/platforms/powermac/cpufreq_64.c b/arch/powerpc/platforms/powermac/cpufreq_64.c
index 7b1156ea5341..d30466d74194 100644
--- a/arch/powerpc/platforms/powermac/cpufreq_64.c
+++ b/arch/powerpc/platforms/powermac/cpufreq_64.c
@@ -89,7 +89,7 @@ static DEFINE_MUTEX(g5_switch_mutex);
 
 #ifdef CONFIG_PMAC_SMU
 
-static u32 *g5_pmode_data;
+static const u32 *g5_pmode_data;
 static int g5_pmode_max;
 
 static struct smu_sdbp_fvt *g5_fvt_table;       /* table of op. points */
@@ -391,7 +391,8 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
         unsigned int psize, ssize;
         unsigned long max_freq;
         char *freq_method, *volt_method;
-        u32 *valp, pvr_hi;
+        const u32 *valp;
+        u32 pvr_hi;
         int use_volts_vdnap = 0;
         int use_volts_smu = 0;
         int rc = -ENODEV;
@@ -409,8 +410,7 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
         /* Get first CPU node */
         for (cpunode = NULL;
              (cpunode = of_get_next_child(cpus, cpunode)) != NULL;) {
-                u32 *reg =
-                        (u32 *)get_property(cpunode, "reg", NULL);
+                const u32 *reg = get_property(cpunode, "reg", NULL);
                 if (reg == NULL || (*reg) != 0)
                         continue;
                 if (!strcmp(cpunode->type, "cpu"))
@@ -422,7 +422,7 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
         }
 
         /* Check 970FX for now */
-        valp = (u32 *)get_property(cpunode, "cpu-version", NULL);
+        valp = get_property(cpunode, "cpu-version", NULL);
         if (!valp) {
                 DBG("No cpu-version property !\n");
                 goto bail_noprops;
@@ -434,7 +434,7 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
         }
 
         /* Look for the powertune data in the device-tree */
-        g5_pmode_data = (u32 *)get_property(cpunode, "power-mode-data",&psize);
+        g5_pmode_data = get_property(cpunode, "power-mode-data",&psize);
         if (!g5_pmode_data) {
                 DBG("No power-mode-data !\n");
                 goto bail_noprops;
@@ -442,7 +442,7 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
         g5_pmode_max = psize / sizeof(u32) - 1;
 
         if (use_volts_smu) {
-                struct smu_sdbp_header *shdr;
+                const struct smu_sdbp_header *shdr;
 
                 /* Look for the FVT table */
                 shdr = smu_get_sdb_partition(SMU_SDB_FVT_ID, NULL);
@@ -493,7 +493,7 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
          * half freq in this version. So far, I haven't yet seen a machine
          * supporting anything else.
          */
-        valp = (u32 *)get_property(cpunode, "clock-frequency", NULL);
+        valp = get_property(cpunode, "clock-frequency", NULL);
         if (!valp)
                 return -ENODEV;
         max_freq = (*valp)/1000;
@@ -541,8 +541,8 @@ static int __init g5_neo2_cpufreq_init(struct device_node *cpus)
 static int __init g5_pm72_cpufreq_init(struct device_node *cpus)
 {
         struct device_node *cpuid = NULL, *hwclock = NULL, *cpunode = NULL;
-        u8 *eeprom = NULL;
-        u32 *valp;
+        const u8 *eeprom = NULL;
+        const u32 *valp;
         u64 max_freq, min_freq, ih, il;
         int has_volt = 1, rc = 0;
 
@@ -563,7 +563,7 @@ static int __init g5_pm72_cpufreq_init(struct device_node *cpus)
         /* Lookup the cpuid eeprom node */
         cpuid = of_find_node_by_path("/u3@0,f8000000/i2c@f8001000/cpuid@a0");
         if (cpuid != NULL)
-                eeprom = (u8 *)get_property(cpuid, "cpuid", NULL);
+                eeprom = get_property(cpuid, "cpuid", NULL);
         if (eeprom == NULL) {
                 printk(KERN_ERR "cpufreq: Can't find cpuid EEPROM !\n");
                 rc = -ENODEV;
@@ -573,7 +573,8 @@ static int __init g5_pm72_cpufreq_init(struct device_node *cpus)
         /* Lookup the i2c hwclock */
         for (hwclock = NULL;
              (hwclock = of_find_node_by_name(hwclock, "i2c-hwclock")) != NULL;){
-                char *loc = get_property(hwclock, "hwctrl-location", NULL);
+                const char *loc = get_property(hwclock,
+                                "hwctrl-location", NULL);
                 if (loc == NULL)
                         continue;
                 if (strcmp(loc, "CPU CLOCK"))
@@ -637,7 +638,7 @@ static int __init g5_pm72_cpufreq_init(struct device_node *cpus)
          */
 
         /* Get max frequency from device-tree */
-        valp = (u32 *)get_property(cpunode, "clock-frequency", NULL);
+        valp = get_property(cpunode, "clock-frequency", NULL);
         if (!valp) {
                 printk(KERN_ERR "cpufreq: Can't find CPU frequency !\n");
                 rc = -ENODEV;
diff --git a/arch/powerpc/platforms/powermac/feature.c b/arch/powerpc/platforms/powermac/feature.c
index f8313bf9a9f7..e49621be6640 100644
--- a/arch/powerpc/platforms/powermac/feature.c
+++ b/arch/powerpc/platforms/powermac/feature.c
@@ -1058,8 +1058,8 @@ core99_reset_cpu(struct device_node *node, long param, long value)
         if (np == NULL)
                 return -ENODEV;
         for (np = np->child; np != NULL; np = np->sibling) {
-                u32 *num = (u32 *)get_property(np, "reg", NULL);
-                u32 *rst = (u32 *)get_property(np, "soft-reset", NULL);
+                const u32 *num = get_property(np, "reg", NULL);
+                const u32 *rst = get_property(np, "soft-reset", NULL);
                 if (num == NULL || rst == NULL)
                         continue;
                 if (param == *num) {
@@ -1087,7 +1087,7 @@ core99_usb_enable(struct device_node *node, long param, long value)
 {
         struct macio_chip *macio;
         unsigned long flags;
-        char *prop;
+        const char *prop;
         int number;
         u32 reg;
 
@@ -1096,7 +1096,7 @@ core99_usb_enable(struct device_node *node, long param, long value)
             macio->type != macio_intrepid)
                 return -ENODEV;
 
-        prop = (char *)get_property(node, "AAPL,clock-id", NULL);
+        prop = get_property(node, "AAPL,clock-id", NULL);
         if (!prop)
                 return -ENODEV;
         if (strncmp(prop, "usb0u048", 8) == 0)
@@ -1507,8 +1507,8 @@ static long g5_reset_cpu(struct device_node *node, long param, long value)
         if (np == NULL)
                 return -ENODEV;
         for (np = np->child; np != NULL; np = np->sibling) {
-                u32 *num = (u32 *)get_property(np, "reg", NULL);
-                u32 *rst = (u32 *)get_property(np, "soft-reset", NULL);
+                const u32 *num = get_property(np, "reg", NULL);
+                const u32 *rst = get_property(np, "soft-reset", NULL);
                 if (num == NULL || rst == NULL)
                         continue;
                 if (param == *num) {
@@ -2408,7 +2408,7 @@ static int __init probe_motherboard(void)
          */
         dt = find_devices("device-tree");
         if (dt != NULL)
-                model = (const char *) get_property(dt, "model", NULL);
+                model = get_property(dt, "model", NULL);
         for(i=0; model && i<(sizeof(pmac_mb_defs)/sizeof(struct pmac_mb_def)); i++) {
             if (strcmp(model, pmac_mb_defs[i].model_string) == 0) {
                 pmac_mb = pmac_mb_defs[i];
@@ -2536,7 +2536,7 @@ found:
  */
 static void __init probe_uninorth(void)
 {
-        u32 *addrp;
+        const u32 *addrp;
         phys_addr_t address;
         unsigned long actrl;
 
@@ -2555,7 +2555,7 @@ static void __init probe_uninorth(void)
         if (uninorth_node == NULL)
                 return;
 
-        addrp = (u32 *)get_property(uninorth_node, "reg", NULL);
+        addrp = get_property(uninorth_node, "reg", NULL);
         if (addrp == NULL)
                 return;
         address = of_translate_address(uninorth_node, addrp);
@@ -2596,7 +2596,7 @@ static void __init probe_one_macio(const char *name, const char *compat, int typ
         struct device_node*     node;
         int                     i;
         volatile u32 __iomem    *base;
-        u32                     *addrp, *revp;
+        const u32               *addrp, *revp;
         phys_addr_t             addr;
         u64                     size;
 
@@ -2639,7 +2639,7 @@ static void __init probe_one_macio(const char *name, const char *compat, int typ
                 return;
         }
         if (type == macio_keylargo || type == macio_keylargo2) {
-                u32 *did = (u32 *)get_property(node, "device-id", NULL);
+                const u32 *did = get_property(node, "device-id", NULL);
                 if (*did == 0x00000025)
                         type = macio_pangea;
                 if (*did == 0x0000003e)
@@ -2652,7 +2652,7 @@ static void __init probe_one_macio(const char *name, const char *compat, int typ
         macio_chips[i].base     = base;
         macio_chips[i].flags    = MACIO_FLAG_SCCB_ON | MACIO_FLAG_SCCB_ON;
         macio_chips[i].name     = macio_names[type];
-        revp = (u32 *)get_property(node, "revision-id", NULL);
+        revp = get_property(node, "revision-id", NULL);
         if (revp)
                 macio_chips[i].rev = *revp;
         printk(KERN_INFO "Found a %s mac-io controller, rev: %d, mapped at 0x%p\n",
@@ -2695,15 +2695,15 @@ static void __init
 initial_serial_shutdown(struct device_node *np)
 {
         int len;
-        struct slot_names_prop {
+        const struct slot_names_prop {
                 int     count;
                 char    name[1];
         } *slots;
-        char *conn;
+        const char *conn;
         int port_type = PMAC_SCC_ASYNC;
         int modem = 0;
 
-        slots = (struct slot_names_prop *)get_property(np, "slot-names", &len);
+        slots = get_property(np, "slot-names", &len);
         conn = get_property(np, "AAPL,connector", &len);
         if (conn && (strcmp(conn, "infrared") == 0))
                 port_type = PMAC_SCC_IRDA;
diff --git a/arch/powerpc/platforms/powermac/low_i2c.c b/arch/powerpc/platforms/powermac/low_i2c.c
index 8677f50c2586..c2c7cf75dd5f 100644
--- a/arch/powerpc/platforms/powermac/low_i2c.c
+++ b/arch/powerpc/platforms/powermac/low_i2c.c
@@ -477,7 +477,8 @@ static int kw_i2c_xfer(struct pmac_i2c_bus *bus, u8 addrdir, int subsize,
 static struct pmac_i2c_host_kw *__init kw_i2c_host_init(struct device_node *np)
 {
         struct pmac_i2c_host_kw *host;
-        u32                     *psteps, *prate, *addrp, steps;
+        const u32               *psteps, *prate, *addrp;
+        u32                     steps;
 
         host = kzalloc(sizeof(struct pmac_i2c_host_kw), GFP_KERNEL);
         if (host == NULL) {
@@ -490,7 +491,7 @@ static struct pmac_i2c_host_kw *__init kw_i2c_host_init(struct device_node *np)
          * on all i2c keywest nodes so far ... we would have to fallback
          * to macio parsing if that wasn't the case
          */
-        addrp = (u32 *)get_property(np, "AAPL,address", NULL);
+        addrp = get_property(np, "AAPL,address", NULL);
         if (addrp == NULL) {
                 printk(KERN_ERR "low_i2c: Can't find address for %s\n",
                        np->full_name);
@@ -504,13 +505,13 @@ static struct pmac_i2c_host_kw *__init kw_i2c_host_init(struct device_node *np)
         host->timeout_timer.function = kw_i2c_timeout;
         host->timeout_timer.data = (unsigned long)host;
 
-        psteps = (u32 *)get_property(np, "AAPL,address-step", NULL);
+        psteps = get_property(np, "AAPL,address-step", NULL);
         steps = psteps ? (*psteps) : 0x10;
         for (host->bsteps = 0; (steps & 0x01) == 0; host->bsteps++)
                 steps >>= 1;
         /* Select interface rate */
         host->speed = KW_I2C_MODE_25KHZ;
-        prate = (u32 *)get_property(np, "AAPL,i2c-rate", NULL);
+        prate = get_property(np, "AAPL,i2c-rate", NULL);
         if (prate) switch(*prate) {
         case 100:
                 host->speed = KW_I2C_MODE_100KHZ;
@@ -618,8 +619,8 @@ static void __init kw_i2c_probe(void)
                 } else {
                         for (child = NULL;
                              (child = of_get_next_child(np, child)) != NULL;) {
-                                u32 *reg =
-                                        (u32 *)get_property(child, "reg", NULL);
+                                const u32 *reg = get_property(child,
+                                                "reg", NULL);
                                 if (reg == NULL)
                                         continue;
                                 kw_i2c_add(host, np, child, *reg);
@@ -881,7 +882,7 @@ static void __init smu_i2c_probe(void)
 {
         struct device_node *controller, *busnode;
         struct pmac_i2c_bus *bus;
-        u32 *reg;
+        const u32 *reg;
         int sz;
 
         if (!smu_present())
@@ -904,7 +905,7 @@ static void __init smu_i2c_probe(void)
                 if (strcmp(busnode->type, "i2c") &&
                     strcmp(busnode->type, "i2c-bus"))
                         continue;
-                reg = (u32 *)get_property(busnode, "reg", NULL);
+                reg = get_property(busnode, "reg", NULL);
                 if (reg == NULL)
                         continue;
 
@@ -948,9 +949,8 @@ struct pmac_i2c_bus *pmac_i2c_find_bus(struct device_node *node)
                 list_for_each_entry(bus, &pmac_i2c_busses, link) {
                         if (p == bus->busnode) {
                                 if (prev && bus->flags & pmac_i2c_multibus) {
-                                        u32 *reg;
-                                        reg = (u32 *)get_property(prev, "reg",
-                                                                  NULL);
+                                        const u32 *reg;
+                                        reg = get_property(prev, "reg", NULL);
                                         if (!reg)
                                                 continue;
                                         if (((*reg) >> 8) != bus->channel)
@@ -971,7 +971,7 @@ EXPORT_SYMBOL_GPL(pmac_i2c_find_bus);
 
 u8 pmac_i2c_get_dev_addr(struct device_node *device)
 {
-        u32 *reg = (u32 *)get_property(device, "reg", NULL);
+        const u32 *reg = get_property(device, "reg", NULL);
 
         if (reg == NULL)
                 return 0;
diff --git a/arch/powerpc/platforms/powermac/pci.c b/arch/powerpc/platforms/powermac/pci.c
index 205d04471161..9923adc5248e 100644
--- a/arch/powerpc/platforms/powermac/pci.c
+++ b/arch/powerpc/platforms/powermac/pci.c
@@ -66,16 +66,16 @@ struct device_node *k2_skiplist[2];
 static int __init fixup_one_level_bus_range(struct device_node *node, int higher)
 {
         for (; node != 0;node = node->sibling) {
-                int * bus_range;
-                unsigned int *class_code;
+                const int * bus_range;
+                const unsigned int *class_code;
                 int len;
 
                 /* For PCI<->PCI bridges or CardBus bridges, we go down */
-                class_code = (unsigned int *) get_property(node, "class-code", NULL);
+                class_code = get_property(node, "class-code", NULL);
                 if (!class_code || ((*class_code >> 8) != PCI_CLASS_BRIDGE_PCI &&
                         (*class_code >> 8) != PCI_CLASS_BRIDGE_CARDBUS))
                         continue;
-                bus_range = (int *) get_property(node, "bus-range", &len);
+                bus_range = get_property(node, "bus-range", &len);
                 if (bus_range != NULL && len > 2 * sizeof(int)) {
                         if (bus_range[1] > higher)
                                 higher = bus_range[1];
@@ -93,13 +93,15 @@ static int __init fixup_one_level_bus_range(struct device_node *node, int higher
  */
 static void __init fixup_bus_range(struct device_node *bridge)
 {
-        int * bus_range;
-        int len;
+        int *bus_range, len;
+        struct property *prop;
 
         /* Lookup the "bus-range" property for the hose */
-        bus_range = (int *) get_property(bridge, "bus-range", &len);
-        if (bus_range == NULL || len < 2 * sizeof(int))
+        prop = of_find_property(bridge, "bus-range", &len);
+        if (prop == NULL || prop->length < 2 * sizeof(int))
                 return;
+
+        bus_range = (int *)prop->value;
         bus_range[1] = fixup_one_level_bus_range(bridge->child, bus_range[1]);
 }
 
@@ -237,7 +239,7 @@ static struct pci_ops macrisc_pci_ops =
 static int chaos_validate_dev(struct pci_bus *bus, int devfn, int offset)
 {
         struct device_node *np;
-        u32 *vendor, *device;
+        const u32 *vendor, *device;
 
         if (offset >= 0x100)
                 return  PCIBIOS_BAD_REGISTER_NUMBER;
@@ -245,8 +247,8 @@ static int chaos_validate_dev(struct pci_bus *bus, int devfn, int offset)
         if (np == NULL)
                 return PCIBIOS_DEVICE_NOT_FOUND;
 
-        vendor = (u32 *)get_property(np, "vendor-id", NULL);
-        device = (u32 *)get_property(np, "device-id", NULL);
+        vendor = get_property(np, "vendor-id", NULL);
+        device = get_property(np, "device-id", NULL);
         if (vendor == NULL || device == NULL)
                 return PCIBIOS_DEVICE_NOT_FOUND;
 
@@ -686,20 +688,21 @@ static void __init fixup_nec_usb2(void)
 
         for (nec = NULL; (nec = of_find_node_by_name(nec, "usb")) != NULL;) {
                 struct pci_controller *hose;
-                u32 data, *prop;
+                u32 data;
+                const u32 *prop;
                 u8 bus, devfn;
 
-                prop = (u32 *)get_property(nec, "vendor-id", NULL);
+                prop = get_property(nec, "vendor-id", NULL);
                 if (prop == NULL)
                         continue;
                 if (0x1033 != *prop)
                         continue;
-                prop = (u32 *)get_property(nec, "device-id", NULL);
+                prop = get_property(nec, "device-id", NULL);
                 if (prop == NULL)
                         continue;
                 if (0x0035 != *prop)
                         continue;
-                prop = (u32 *)get_property(nec, "reg", NULL);
+                prop = get_property(nec, "reg", NULL);
                 if (prop == NULL)
                         continue;
                 devfn = (prop[0] >> 8) & 0xff;
@@ -898,7 +901,7 @@ static int __init add_bridge(struct device_node *dev)
         struct pci_controller *hose;
         struct resource rsrc;
         char *disp_name;
-        int *bus_range;
+        const int *bus_range;
         int primary = 1, has_address = 0;
 
         DBG("Adding PCI host bridge %s\n", dev->full_name);
@@ -907,7 +910,7 @@ static int __init add_bridge(struct device_node *dev)
         has_address = (of_address_to_resource(dev, 0, &rsrc) == 0);
 
         /* Get bus range if any */
-        bus_range = (int *) get_property(dev, "bus-range", &len);
+        bus_range = get_property(dev, "bus-range", &len);
         if (bus_range == NULL || len < 2 * sizeof(int)) {
                 printk(KERN_WARNING "Can't get bus-range for %s, assume"
                        " bus 0\n", dev->full_name);
diff --git a/arch/powerpc/platforms/powermac/pfunc_base.c b/arch/powerpc/platforms/powermac/pfunc_base.c
index aacfa59595d1..ee3b223ab17a 100644
--- a/arch/powerpc/platforms/powermac/pfunc_base.c
+++ b/arch/powerpc/platforms/powermac/pfunc_base.c
@@ -114,7 +114,7 @@ static void macio_gpio_init_one(struct macio_chip *macio)
          * we just create them all
          */
         for (gp = NULL; (gp = of_get_next_child(gparent, gp)) != NULL;) {
-                u32 *reg = (u32 *)get_property(gp, "reg", NULL);
+                const u32 *reg = get_property(gp, "reg", NULL);
                 unsigned long offset;
                 if (reg == NULL)
                         continue;
diff --git a/arch/powerpc/platforms/powermac/pfunc_core.c b/arch/powerpc/platforms/powermac/pfunc_core.c
index b117adbf9571..7651f278615a 100644
--- a/arch/powerpc/platforms/powermac/pfunc_core.c
+++ b/arch/powerpc/platforms/powermac/pfunc_core.c
@@ -813,14 +813,15 @@ struct pmf_function *__pmf_find_function(struct device_node *target,
         struct pmf_device *dev;
         struct pmf_function *func, *result = NULL;
         char fname[64];
-        u32 *prop, ph;
+        const u32 *prop;
+        u32 ph;
 
         /*
          * Look for a "platform-*" function reference. If we can't find
          * one, then we fallback to a direct call attempt
          */
         snprintf(fname, 63, "platform-%s", name);
-        prop = (u32 *)get_property(target, fname, NULL);
+        prop = get_property(target, fname, NULL);
         if (prop == NULL)
                 goto find_it;
         ph = *prop;
diff --git a/arch/powerpc/platforms/powermac/setup.c b/arch/powerpc/platforms/powermac/setup.c
index 31a9da769fa2..824a618396ab 100644
--- a/arch/powerpc/platforms/powermac/setup.c
+++ b/arch/powerpc/platforms/powermac/setup.c
@@ -116,7 +116,7 @@ extern struct smp_ops_t core99_smp_ops;
 static void pmac_show_cpuinfo(struct seq_file *m)
 {
         struct device_node *np;
-        char *pp;
+        const char *pp;
         int plen;
         int mbmodel;
         unsigned int mbflags;
@@ -134,12 +134,12 @@ static void pmac_show_cpuinfo(struct seq_file *m)
         seq_printf(m, "machine\t\t: ");
         np = of_find_node_by_path("/");
         if (np != NULL) {
-                pp = (char *) get_property(np, "model", NULL);
+                pp = get_property(np, "model", NULL);
                 if (pp != NULL)
                         seq_printf(m, "%s\n", pp);
                 else
                         seq_printf(m, "PowerMac\n");
-                pp = (char *) get_property(np, "compatible", &plen);
+                pp = get_property(np, "compatible", &plen);
                 if (pp != NULL) {
                         seq_printf(m, "motherboard\t:");
                         while (plen > 0) {
@@ -163,10 +163,8 @@ static void pmac_show_cpuinfo(struct seq_file *m)
         if (np == NULL)
                 np = of_find_node_by_type(NULL, "cache");
         if (np != NULL) {
-                unsigned int *ic = (unsigned int *)
-                        get_property(np, "i-cache-size", NULL);
-                unsigned int *dc = (unsigned int *)
-                        get_property(np, "d-cache-size", NULL);
+                const unsigned int *ic = get_property(np, "i-cache-size", NULL);
+                const unsigned int *dc = get_property(np, "d-cache-size", NULL);
                 seq_printf(m, "L2 cache\t:");
                 has_l2cache = 1;
                 if (get_property(np, "cache-unified", NULL) != 0 && dc) {
@@ -254,7 +252,7 @@ static void __init l2cr_init(void)
                 if (np == 0)
                         np = find_type_devices("cpu");
                 if (np != 0) {
-                        unsigned int *l2cr = (unsigned int *)
+                        const unsigned int *l2cr =
                                 get_property(np, "l2cr-value", NULL);
                         if (l2cr != 0) {
                                 ppc_override_l2cr = 1;
@@ -277,7 +275,7 @@ static void __init l2cr_init(void)
 static void __init pmac_setup_arch(void)
 {
         struct device_node *cpu, *ic;
-        int *fp;
+        const int *fp;
         unsigned long pvr;
 
         pvr = PVR_VER(mfspr(SPRN_PVR));
@@ -287,7 +285,7 @@ static void __init pmac_setup_arch(void)
         loops_per_jiffy = 50000000 / HZ;
         cpu = of_find_node_by_type(NULL, "cpu");
         if (cpu != NULL) {
-                fp = (int *) get_property(cpu, "clock-frequency", NULL);
+                fp = get_property(cpu, "clock-frequency", NULL);
                 if (fp != NULL) {
                         if (pvr >= 0x30 && pvr < 0x80)
                                 /* PPC970 etc. */
diff --git a/arch/powerpc/platforms/powermac/smp.c b/arch/powerpc/platforms/powermac/smp.c
index 827b7121ffb8..1949b657b092 100644
--- a/arch/powerpc/platforms/powermac/smp.c
+++ b/arch/powerpc/platforms/powermac/smp.c
@@ -548,7 +548,7 @@ static void __init smp_core99_setup_i2c_hwsync(int ncpus)
         struct device_node *cc = NULL;  
         struct device_node *p;
         const char *name = NULL;
-        u32 *reg;
+        const u32 *reg;
         int ok;
 
         /* Look for the clock chip */
@@ -562,7 +562,7 @@ static void __init smp_core99_setup_i2c_hwsync(int ncpus)
                 pmac_tb_clock_chip_host = pmac_i2c_find_bus(cc);
                 if (pmac_tb_clock_chip_host == NULL)
                         continue;
-                reg = (u32 *)get_property(cc, "reg", NULL);
+                reg = get_property(cc, "reg", NULL);
                 if (reg == NULL)
                         continue;
                 switch (*reg) {
@@ -702,13 +702,12 @@ static void __init smp_core99_setup(int ncpus)
         /* GPIO based HW sync on ppc32 Core99 */
         if (pmac_tb_freeze == NULL && !machine_is_compatible("MacRISC4")) {
                 struct device_node *cpu;
-                u32 *tbprop = NULL;
+                const u32 *tbprop = NULL;
 
                 core99_tb_gpio = KL_GPIO_TB_ENABLE;     /* default value */
                 cpu = of_find_node_by_type(NULL, "cpu");
                 if (cpu != NULL) {
-                        tbprop = (u32 *)get_property(cpu, "timebase-enable",
-                                                     NULL);
+                        tbprop = get_property(cpu, "timebase-enable", NULL);
                         if (tbprop)
                                 core99_tb_gpio = *tbprop;
                         of_node_put(cpu);
diff --git a/arch/powerpc/platforms/powermac/udbg_scc.c b/arch/powerpc/platforms/powermac/udbg_scc.c
index 37e5b1eff911..ce1a235855f7 100644
--- a/arch/powerpc/platforms/powermac/udbg_scc.c
+++ b/arch/powerpc/platforms/powermac/udbg_scc.c
@@ -68,11 +68,11 @@ static unsigned char scc_inittab[] = {
 
 void udbg_scc_init(int force_scc)
 {
-        u32 *reg;
+        const u32 *reg;
         unsigned long addr;
         struct device_node *stdout = NULL, *escc = NULL, *macio = NULL;
         struct device_node *ch, *ch_def = NULL, *ch_a = NULL;
-        char *path;
+        const char *path;
         int i, x;
 
         escc = of_find_node_by_name(NULL, "escc");
@@ -81,7 +81,7 @@ void udbg_scc_init(int force_scc)
         macio = of_get_parent(escc);
         if (macio == NULL)
                 goto bail;
-        path = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
+        path = get_property(of_chosen, "linux,stdout-path", NULL);
         if (path != NULL)
                 stdout = of_find_node_by_path(path);
         for (ch = NULL; (ch = of_get_next_child(escc, ch)) != NULL;) {
@@ -96,13 +96,13 @@ void udbg_scc_init(int force_scc)
         ch = ch_def ? ch_def : ch_a;
 
         /* Get address within mac-io ASIC */
-        reg = (u32 *)get_property(escc, "reg", NULL);
+        reg = get_property(escc, "reg", NULL);
         if (reg == NULL)
                 goto bail;
         addr = reg[0];
 
         /* Get address of mac-io PCI itself */
-        reg = (u32 *)get_property(macio, "assigned-addresses", NULL);
+        reg = get_property(macio, "assigned-addresses", NULL);
         if (reg == NULL)
                 goto bail;
         addr += reg[2];
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index e5e0ff466904..997243a91be8 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -12,3 +12,4 @@ obj-$(CONFIG_EEH)	+= eeh.o eeh_cache.o eeh_driver.o eeh_event.o
 
 obj-$(CONFIG_HVC_CONSOLE)       += hvconsole.o
 obj-$(CONFIG_HVCS)              += hvcserver.o
+obj-$(CONFIG_HCALL_STATS)       += hvCall_inst.o
diff --git a/arch/powerpc/platforms/pseries/eeh.c b/arch/powerpc/platforms/pseries/eeh.c
index 32eaddfa5470..84bc8f7e17ef 100644
--- a/arch/powerpc/platforms/pseries/eeh.c
+++ b/arch/powerpc/platforms/pseries/eeh.c
@@ -449,7 +449,11 @@ EXPORT_SYMBOL(eeh_check_failure);
 /* ------------------------------------------------------------- */
 /* The code below deals with error recovery */
 
-/** Return negative value if a permanent error, else return
+/**
+ * eeh_slot_availability - returns error status of slot
+ * @pdn pci device node
+ *
+ * Return negative value if a permanent error, else return
  * a number of milliseconds to wait until the PCI slot is
  * ready to be used.
  */
@@ -474,11 +478,42 @@ eeh_slot_availability(struct pci_dn *pdn)
 
         printk (KERN_ERR "EEH: Slot unavailable: rc=%d, rets=%d %d %d\n",
                 rc, rets[0], rets[1], rets[2]);
-        return -1;
+        return -2;
+}
+
+/**
+ * rtas_pci_enable - enable MMIO or DMA transfers for this slot
+ * @pdn pci device node
+ */
+
+int
+rtas_pci_enable(struct pci_dn *pdn, int function)
+{
+        int config_addr;
+        int rc;
+
+        /* Use PE configuration address, if present */
+        config_addr = pdn->eeh_config_addr;
+        if (pdn->eeh_pe_config_addr)
+                config_addr = pdn->eeh_pe_config_addr;
+
+        rc = rtas_call(ibm_set_eeh_option, 4, 1, NULL,
+                       config_addr,
+                       BUID_HI(pdn->phb->buid),
+                       BUID_LO(pdn->phb->buid),
+                            function);
+
+        if (rc)
+                printk(KERN_WARNING "EEH: Cannot enable function %d, err=%d dn=%s\n",
+                        function, rc, pdn->node->full_name);
+
+        return rc;
 }
 
-/** rtas_pci_slot_reset raises/lowers the pci #RST line
- *  state: 1/0 to raise/lower the #RST
+/**
+ * rtas_pci_slot_reset - raises/lowers the pci #RST line
+ * @pdn pci device node
+ * @state: 1/0 to raise/lower the #RST
  *
  * Clear the EEH-frozen condition on a slot.  This routine
  * asserts the PCI #RST line if the 'state' argument is '1',
@@ -511,24 +546,21 @@ rtas_pci_slot_reset(struct pci_dn *pdn, int state)
                        BUID_HI(pdn->phb->buid),
                        BUID_LO(pdn->phb->buid),
                        state);
-        if (rc) {
-                printk (KERN_WARNING "EEH: Unable to reset the failed slot, (%d) #RST=%d dn=%s\n", 
+        if (rc)
+                printk (KERN_WARNING "EEH: Unable to reset the failed slot,"
+                        " (%d) #RST=%d dn=%s\n",
                         rc, state, pdn->node->full_name);
-                return;
-        }
 }
 
-/** rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
- *  dn -- device node to be reset.
+/**
+ * rtas_set_slot_reset -- assert the pci #RST line for 1/4 second
+ * @pdn: pci device node to be reset.
  *
  *  Return 0 if success, else a non-zero value.
  */
 
-int
-rtas_set_slot_reset(struct pci_dn *pdn)
+static void __rtas_set_slot_reset(struct pci_dn *pdn)
 {
-        int i, rc;
-
         rtas_pci_slot_reset (pdn, 1);
 
         /* The PCI bus requires that the reset be held high for at least
@@ -549,17 +581,33 @@ rtas_set_slot_reset(struct pci_dn *pdn)
          * up traffic. */
 #define PCI_BUS_SETTLE_TIME_MSEC 1800
         msleep (PCI_BUS_SETTLE_TIME_MSEC);
+}
+
+int rtas_set_slot_reset(struct pci_dn *pdn)
+{
+        int i, rc;
+
+        __rtas_set_slot_reset(pdn);
 
         /* Now double check with the firmware to make sure the device is
          * ready to be used; if not, wait for recovery. */
         for (i=0; i<10; i++) {
                 rc = eeh_slot_availability (pdn);
-                if (rc < 0)
-                        printk (KERN_ERR "EEH: failed (%d) to reset slot %s\n", rc, pdn->node->full_name);
                 if (rc == 0)
                         return 0;
-                if (rc < 0)
+
+                if (rc == -2) {
+                        printk (KERN_ERR "EEH: failed (%d) to reset slot %s\n",
+                                i, pdn->node->full_name);
+                        __rtas_set_slot_reset(pdn);
+                        continue;
+                }
+
+                if (rc < 0) {
+                        printk (KERN_ERR "EEH: unrecoverable slot failure %s\n",
+                                pdn->node->full_name);
                         return -1;
+                }
 
                 msleep (rc+100);
         }
@@ -582,6 +630,8 @@ rtas_set_slot_reset(struct pci_dn *pdn)
 
 /**
  * __restore_bars - Restore the Base Address Registers
+ * @pdn: pci device node
+ *
  * Loads the PCI configuration space base address registers,
  * the expansion ROM base address, the latency timer, and etc.
  * from the saved values in the device node.
@@ -691,11 +741,11 @@ static void *early_enable_eeh(struct device_node *dn, void *data)
 {
         struct eeh_early_enable_info *info = data;
         int ret;
-        char *status = get_property(dn, "status", NULL);
-        u32 *class_code = (u32 *)get_property(dn, "class-code", NULL);
-        u32 *vendor_id = (u32 *)get_property(dn, "vendor-id", NULL);
-        u32 *device_id = (u32 *)get_property(dn, "device-id", NULL);
-        u32 *regs;
+        const char *status = get_property(dn, "status", NULL);
+        const u32 *class_code = get_property(dn, "class-code", NULL);
+        const u32 *vendor_id = get_property(dn, "vendor-id", NULL);
+        const u32 *device_id = get_property(dn, "device-id", NULL);
+        const u32 *regs;
         int enable;
         struct pci_dn *pdn = PCI_DN(dn);
 
@@ -737,7 +787,7 @@ static void *early_enable_eeh(struct device_node *dn, void *data)
 
         /* Ok... see if this device supports EEH.  Some do, some don't,
          * and the only way to find out is to check each and every one. */
-        regs = (u32 *)get_property(dn, "reg", NULL);
+        regs = get_property(dn, "reg", NULL);
         if (regs) {
                 /* First register entry is addr (00BBSS00)  */
                 /* Try to enable eeh */
diff --git a/arch/powerpc/platforms/pseries/eeh_cache.c b/arch/powerpc/platforms/pseries/eeh_cache.c
index c37a8497c60f..b6b462d3c604 100644
--- a/arch/powerpc/platforms/pseries/eeh_cache.c
+++ b/arch/powerpc/platforms/pseries/eeh_cache.c
@@ -157,6 +157,7 @@ pci_addr_cache_insert(struct pci_dev *dev, unsigned long alo,
         if (!piar)
                 return NULL;
 
+        pci_dev_get(dev);
         piar->addr_lo = alo;
         piar->addr_hi = ahi;
         piar->pcidev = dev;
@@ -178,7 +179,6 @@ static void __pci_addr_cache_insert_device(struct pci_dev *dev)
         struct device_node *dn;
         struct pci_dn *pdn;
         int i;
-        int inserted = 0;
 
         dn = pci_device_to_OF_node(dev);
         if (!dn) {
@@ -197,9 +197,6 @@ static void __pci_addr_cache_insert_device(struct pci_dev *dev)
                 return;
         }
 
-        /* The cache holds a reference to the device... */
-        pci_dev_get(dev);
-
         /* Walk resources on this device, poke them into the tree */
         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
                 unsigned long start = pci_resource_start(dev,i);
@@ -212,12 +209,7 @@ static void __pci_addr_cache_insert_device(struct pci_dev *dev)
                 if (start == 0 || ~start == 0 || end == 0 || ~end == 0)
                          continue;
                 pci_addr_cache_insert(dev, start, end, flags);
-                inserted = 1;
         }
-
-        /* If there was nothing to add, the cache has no reference... */
-        if (!inserted)
-                pci_dev_put(dev);
 }
 
 /**
@@ -240,7 +232,6 @@ void pci_addr_cache_insert_device(struct pci_dev *dev)
 static inline void __pci_addr_cache_remove_device(struct pci_dev *dev)
 {
         struct rb_node *n;
-        int removed = 0;
 
 restart:
         n = rb_first(&pci_io_addr_cache_root.rb_root);
@@ -250,16 +241,12 @@ restart:
 
                 if (piar->pcidev == dev) {
                         rb_erase(n, &pci_io_addr_cache_root.rb_root);
-                        removed = 1;
+                        pci_dev_put(piar->pcidev);
                         kfree(piar);
                         goto restart;
                 }
                 n = rb_next(n);
         }
-
-        /* The cache no longer holds its reference to this device... */
-        if (removed)
-                pci_dev_put(dev);
 }
 
 /**
diff --git a/arch/powerpc/platforms/pseries/eeh_driver.c b/arch/powerpc/platforms/pseries/eeh_driver.c
index aaad2c0afcbf..c2bc9904f1cb 100644
--- a/arch/powerpc/platforms/pseries/eeh_driver.c
+++ b/arch/powerpc/platforms/pseries/eeh_driver.c
@@ -77,8 +77,12 @@ static int irq_in_use(unsigned int irq)
 }
 
 /* ------------------------------------------------------- */
-/** eeh_report_error - report an EEH error to each device,
- *  collect up and merge the device responses.
+/**
+ * eeh_report_error - report pci error to each device driver
+ * 
+ * Report an EEH error to each device driver, collect up and 
+ * merge the device driver responses. Cumulative response 
+ * passed back in "userdata".
  */
 
 static void eeh_report_error(struct pci_dev *dev, void *userdata)
@@ -96,24 +100,49 @@ static void eeh_report_error(struct pci_dev *dev, void *userdata)
                 PCI_DN(dn)->eeh_mode |= EEH_MODE_IRQ_DISABLED;
                 disable_irq_nosync(dev->irq);
         }
-        if (!driver->err_handler)
-                return;
-        if (!driver->err_handler->error_detected)
+        if (!driver->err_handler ||
+            !driver->err_handler->error_detected)
                 return;
 
         rc = driver->err_handler->error_detected (dev, pci_channel_io_frozen);
         if (*res == PCI_ERS_RESULT_NONE) *res = rc;
-        if (*res == PCI_ERS_RESULT_NEED_RESET) return;
         if (*res == PCI_ERS_RESULT_DISCONNECT &&
              rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
 }
 
-/** eeh_report_reset -- tell this device that the pci slot
- *  has been reset.
+/**
+ * eeh_report_mmio_enabled - tell drivers that MMIO has been enabled
+ *
+ * Report an EEH error to each device driver, collect up and
+ * merge the device driver responses. Cumulative response
+ * passed back in "userdata".
+ */
+
+static void eeh_report_mmio_enabled(struct pci_dev *dev, void *userdata)
+{
+        enum pci_ers_result rc, *res = userdata;
+        struct pci_driver *driver = dev->driver;
+
+        // dev->error_state = pci_channel_mmio_enabled;
+
+        if (!driver ||
+            !driver->err_handler ||
+            !driver->err_handler->mmio_enabled)
+                return;
+
+        rc = driver->err_handler->mmio_enabled (dev);
+        if (*res == PCI_ERS_RESULT_NONE) *res = rc;
+        if (*res == PCI_ERS_RESULT_DISCONNECT &&
+             rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
+}
+
+/**
+ * eeh_report_reset - tell device that slot has been reset
  */
 
 static void eeh_report_reset(struct pci_dev *dev, void *userdata)
 {
+        enum pci_ers_result rc, *res = userdata;
         struct pci_driver *driver = dev->driver;
         struct device_node *dn = pci_device_to_OF_node(dev);
 
@@ -124,14 +153,20 @@ static void eeh_report_reset(struct pci_dev *dev, void *userdata)
                 PCI_DN(dn)->eeh_mode &= ~EEH_MODE_IRQ_DISABLED;
                 enable_irq(dev->irq);
         }
-        if (!driver->err_handler)
-                return;
-        if (!driver->err_handler->slot_reset)
+        if (!driver->err_handler ||
+            !driver->err_handler->slot_reset)
                 return;
 
-        driver->err_handler->slot_reset(dev);
+        rc = driver->err_handler->slot_reset(dev);
+        if (*res == PCI_ERS_RESULT_NONE) *res = rc;
+        if (*res == PCI_ERS_RESULT_DISCONNECT &&
+             rc == PCI_ERS_RESULT_NEED_RESET) *res = rc;
 }
 
+/**
+ * eeh_report_resume - tell device to resume normal operations
+ */
+
 static void eeh_report_resume(struct pci_dev *dev, void *userdata)
 {
         struct pci_driver *driver = dev->driver;
@@ -148,6 +183,13 @@ static void eeh_report_resume(struct pci_dev *dev, void *userdata)
         driver->err_handler->resume(dev);
 }
 
+/**
+ * eeh_report_failure - tell device driver that device is dead.
+ *
+ * This informs the device driver that the device is permanently
+ * dead, and that no further recovery attempts will be made on it.
+ */
+
 static void eeh_report_failure(struct pci_dev *dev, void *userdata)
 {
         struct pci_driver *driver = dev->driver;
@@ -190,11 +232,11 @@ static void eeh_report_failure(struct pci_dev *dev, void *userdata)
 
 /**
  * eeh_reset_device() -- perform actual reset of a pci slot
- * Args: bus: pointer to the pci bus structure corresponding
+ * @bus: pointer to the pci bus structure corresponding
  *            to the isolated slot. A non-null value will
  *            cause all devices under the bus to be removed
  *            and then re-added.
- *     pe_dn: pointer to a "Partionable Endpoint" device node.
+ * @pe_dn: pointer to a "Partionable Endpoint" device node.
  *            This is the top-level structure on which pci
  *            bus resets can be performed.
  */
@@ -268,14 +310,14 @@ struct pci_dn * handle_eeh_events (struct eeh_event *event)
 
         if (!frozen_dn) {
 
-                location = (char *) get_property(event->dn, "ibm,loc-code", NULL);
+                location = get_property(event->dn, "ibm,loc-code", NULL);
                 location = location ? location : "unknown";
                 printk(KERN_ERR "EEH: Error: Cannot find partition endpoint "
                                 "for location=%s pci addr=%s\n",
                         location, pci_name(event->dev));
                 return NULL;
         }
-        location = (char *) get_property(frozen_dn, "ibm,loc-code", NULL);
+        location = get_property(frozen_dn, "ibm,loc-code", NULL);
         location = location ? location : "unknown";
 
         /* There are two different styles for coming up with the PE.
@@ -347,23 +389,43 @@ struct pci_dn * handle_eeh_events (struct eeh_event *event)
                         goto hard_fail;
         }
 
-        /* If any device called out for a reset, then reset the slot */
-        if (result == PCI_ERS_RESULT_NEED_RESET) {
-                rc = eeh_reset_device(frozen_pdn, NULL);
-                if (rc)
-                        goto hard_fail;
-                pci_walk_bus(frozen_bus, eeh_report_reset, NULL);
+        /* If all devices reported they can proceed, then re-enable MMIO */
+        if (result == PCI_ERS_RESULT_CAN_RECOVER) {
+                rc = rtas_pci_enable(frozen_pdn, EEH_THAW_MMIO);
+
+                if (rc) {
+                        result = PCI_ERS_RESULT_NEED_RESET;
+                } else {
+                        result = PCI_ERS_RESULT_NONE;
+                        pci_walk_bus(frozen_bus, eeh_report_mmio_enabled, &result);
+                }
         }
 
-        /* If all devices reported they can proceed, the re-enable PIO */
+        /* If all devices reported they can proceed, then re-enable DMA */
         if (result == PCI_ERS_RESULT_CAN_RECOVER) {
-                /* XXX Not supported; we brute-force reset the device */
+                rc = rtas_pci_enable(frozen_pdn, EEH_THAW_DMA);
+
+                if (rc)
+                        result = PCI_ERS_RESULT_NEED_RESET;
+        }
+
+        /* If any device has a hard failure, then shut off everything. */
+        if (result == PCI_ERS_RESULT_DISCONNECT)
+                goto hard_fail;
+
+        /* If any device called out for a reset, then reset the slot */
+        if (result == PCI_ERS_RESULT_NEED_RESET) {
                 rc = eeh_reset_device(frozen_pdn, NULL);
                 if (rc)
                         goto hard_fail;
-                pci_walk_bus(frozen_bus, eeh_report_reset, NULL);
+                result = PCI_ERS_RESULT_NONE;
+                pci_walk_bus(frozen_bus, eeh_report_reset, &result);
         }
 
+        /* All devices should claim they have recovered by now. */
+        if (result != PCI_ERS_RESULT_RECOVERED)
+                goto hard_fail;
+
         /* Tell all device drivers that they can resume operations */
         pci_walk_bus(frozen_bus, eeh_report_resume, NULL);
 
diff --git a/arch/powerpc/platforms/pseries/eeh_event.c b/arch/powerpc/platforms/pseries/eeh_event.c
index 45ccc687e57c..137077451316 100644
--- a/arch/powerpc/platforms/pseries/eeh_event.c
+++ b/arch/powerpc/platforms/pseries/eeh_event.c
@@ -124,11 +124,11 @@ int eeh_send_failure_event (struct device_node *dn,
 {
         unsigned long flags;
         struct eeh_event *event;
-        char *location;
+        const char *location;
 
         if (!mem_init_done) {
                 printk(KERN_ERR "EEH: event during early boot not handled\n");
-                location = (char *) get_property(dn, "ibm,loc-code", NULL);
+                location = get_property(dn, "ibm,loc-code", NULL);
                 printk(KERN_ERR "EEH: device node = %s\n", dn->full_name);
                 printk(KERN_ERR "EEH: PCI location = %s\n", location);
                 return 1;
diff --git a/arch/powerpc/platforms/pseries/firmware.c b/arch/powerpc/platforms/pseries/firmware.c
index c01d8f0cbe6d..1c7b2baa5f73 100644
--- a/arch/powerpc/platforms/pseries/firmware.c
+++ b/arch/powerpc/platforms/pseries/firmware.c
@@ -68,7 +68,7 @@ firmware_features_table[FIRMWARE_MAX_FEATURES] = {
 void __init fw_feature_init(void)
 {
         struct device_node *dn;
-        char *hypertas, *s;
+        const char *hypertas, *s;
         int len, i;
 
         DBG(" -> fw_feature_init()\n");
diff --git a/arch/powerpc/platforms/pseries/hvCall.S b/arch/powerpc/platforms/pseries/hvCall.S
index c9ff547f9d25..c00cfed7af2c 100644
--- a/arch/powerpc/platforms/pseries/hvCall.S
+++ b/arch/powerpc/platforms/pseries/hvCall.S
@@ -1,7 +1,6 @@
 /*
  * This file contains the generic code to perform a call to the
  * pSeries LPAR hypervisor.
- * NOTE: this file will go away when we move to inline this work.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -11,217 +10,153 @@
 #include <asm/hvcall.h>
 #include <asm/processor.h>
 #include <asm/ppc_asm.h>
+#include <asm/asm-offsets.h>
         
 #define STK_PARM(i)     (48 + ((i)-3)*8)
 
-        .text
-
-/* long plpar_hcall(unsigned long opcode,               R3
-                        unsigned long arg1,             R4
-                        unsigned long arg2,             R5
-                        unsigned long arg3,             R6
-                        unsigned long arg4,             R7
-                        unsigned long *out1,            R8
-                        unsigned long *out2,            R9
-                        unsigned long *out3);           R10
+#ifdef CONFIG_HCALL_STATS
+/*
+ * precall must preserve all registers.  use unused STK_PARM()
+ * areas to save snapshots and opcode.
  */
-_GLOBAL(plpar_hcall)
-        HMT_MEDIUM
-
-        mfcr    r0
-
-        std     r8,STK_PARM(r8)(r1)     /* Save out ptrs */
-        std     r9,STK_PARM(r9)(r1)
-        std     r10,STK_PARM(r10)(r1)
-
-        stw     r0,8(r1)
-
-        HVSC                            /* invoke the hypervisor */
-
-        lwz     r0,8(r1)
-
-        ld      r8,STK_PARM(r8)(r1)     /* Fetch r4-r6 ret args */
-        ld      r9,STK_PARM(r9)(r1)
-        ld      r10,STK_PARM(r10)(r1)
-        std     r4,0(r8)
-        std     r5,0(r9)
-        std     r6,0(r10)
-
-        mtcrf   0xff,r0
-        blr                             /* return r3 = status */
+#define HCALL_INST_PRECALL                                      \
+        std     r3,STK_PARM(r3)(r1);    /* save opcode */       \
+        mftb    r0;                     /* get timebase and */  \
+        std     r0,STK_PARM(r5)(r1);    /* save for later */    \
+BEGIN_FTR_SECTION;                                              \
+        mfspr   r0,SPRN_PURR;           /* get PURR and */      \
+        std     r0,STK_PARM(r6)(r1);    /* save for later */    \
+END_FTR_SECTION_IFCLR(CPU_FTR_PURR);
+        
+/*
+ * postcall is performed immediately before function return which
+ * allows liberal use of volatile registers.
+ */
+#define HCALL_INST_POSTCALL                                     \
+        ld      r4,STK_PARM(r3)(r1);    /* validate opcode */   \
+        cmpldi  cr7,r4,MAX_HCALL_OPCODE;                        \
+        bgt-    cr7,1f;                                         \
+                                                                \
+        /* get time and PURR snapshots after hcall */           \
+        mftb    r7;                     /* timebase after */    \
+BEGIN_FTR_SECTION;                                              \
+        mfspr   r8,SPRN_PURR;           /* PURR after */        \
+        ld      r6,STK_PARM(r6)(r1);    /* PURR before */       \
+        subf    r6,r6,r8;               /* delta */             \
+END_FTR_SECTION_IFCLR(CPU_FTR_PURR);                            \
+        ld      r5,STK_PARM(r5)(r1);    /* timebase before */   \
+        subf    r5,r5,r7;               /* time delta */        \
+                                                                \
+        /* calculate address of stat structure r4 = opcode */   \
+        srdi    r4,r4,2;                /* index into array */  \
+        mulli   r4,r4,HCALL_STAT_SIZE;                          \
+        LOAD_REG_ADDR(r7, per_cpu__hcall_stats);                \
+        add     r4,r4,r7;                                       \
+        ld      r7,PACA_DATA_OFFSET(r13); /* per cpu offset */  \
+        add     r4,r4,r7;                                       \
+                                                                \
+        /* update stats */                                      \
+        ld      r7,HCALL_STAT_CALLS(r4); /* count */            \
+        addi    r7,r7,1;                                        \
+        std     r7,HCALL_STAT_CALLS(r4);                        \
+        ld      r7,HCALL_STAT_TB(r4);   /* timebase */          \
+        add     r7,r7,r5;                                       \
+        std     r7,HCALL_STAT_TB(r4);                           \
+BEGIN_FTR_SECTION;                                              \
+        ld      r7,HCALL_STAT_PURR(r4); /* PURR */              \
+        add     r7,r7,r6;                                       \
+        std     r7,HCALL_STAT_PURR(r4);                         \
+END_FTR_SECTION_IFCLR(CPU_FTR_PURR);                            \
+1:
+#else
+#define HCALL_INST_PRECALL
+#define HCALL_INST_POSTCALL
+#endif
 
+        .text
 
-/* Simple interface with no output values (other than status) */
 _GLOBAL(plpar_hcall_norets)
         HMT_MEDIUM
 
         mfcr    r0
         stw     r0,8(r1)
 
-        HVSC                            /* invoke the hypervisor */
-
-        lwz     r0,8(r1)
-        mtcrf   0xff,r0
-        blr                             /* return r3 = status */
-
-
-/* long plpar_hcall_8arg_2ret(unsigned long opcode,     R3
-                        unsigned long arg1,             R4
-                        unsigned long arg2,             R5
-                        unsigned long arg3,             R6
-                        unsigned long arg4,             R7
-                        unsigned long arg5,             R8
-                        unsigned long arg6,             R9
-                        unsigned long arg7,             R10
-                        unsigned long arg8,             112(R1)
-                        unsigned long *out1);           120(R1)
- */
-_GLOBAL(plpar_hcall_8arg_2ret)
-        HMT_MEDIUM
-
-        mfcr    r0
-        ld      r11,STK_PARM(r11)(r1)   /* put arg8 in R11 */
-        stw     r0,8(r1)
+        HCALL_INST_PRECALL
 
         HVSC                            /* invoke the hypervisor */
 
+        HCALL_INST_POSTCALL
+
         lwz     r0,8(r1)
-        ld      r10,STK_PARM(r12)(r1)   /* Fetch r4 ret arg */
-        std     r4,0(r10)
         mtcrf   0xff,r0
         blr                             /* return r3 = status */
 
-
-/* long plpar_hcall_4out(unsigned long opcode,          R3
-                        unsigned long arg1,             R4
-                        unsigned long arg2,             R5
-                        unsigned long arg3,             R6
-                        unsigned long arg4,             R7
-                        unsigned long *out1,            R8
-                        unsigned long *out2,            R9
-                        unsigned long *out3,            R10
-                        unsigned long *out4);           112(R1)
- */
-_GLOBAL(plpar_hcall_4out)
+_GLOBAL(plpar_hcall)
         HMT_MEDIUM
 
         mfcr    r0
         stw     r0,8(r1)
 
-        std     r8,STK_PARM(r8)(r1)     /* Save out ptrs */
-        std     r9,STK_PARM(r9)(r1)
-        std     r10,STK_PARM(r10)(r1)
-
-        HVSC                            /* invoke the hypervisor */
-
-        lwz     r0,8(r1)
+        HCALL_INST_PRECALL
 
-        ld      r8,STK_PARM(r8)(r1)     /* Fetch r4-r7 ret args */
-        ld      r9,STK_PARM(r9)(r1)
-        ld      r10,STK_PARM(r10)(r1)
-        ld      r11,STK_PARM(r11)(r1)
-        std     r4,0(r8)
-        std     r5,0(r9)
-        std     r6,0(r10)
-        std     r7,0(r11)
+        std     r4,STK_PARM(r4)(r1)     /* Save ret buffer */
 
-        mtcrf   0xff,r0
-        blr                             /* return r3 = status */
-
-/* plpar_hcall_7arg_7ret(unsigned long opcode,          R3
-                         unsigned long arg1,            R4
-                         unsigned long arg2,            R5
-                         unsigned long arg3,            R6
-                         unsigned long arg4,            R7
-                         unsigned long arg5,            R8
-                         unsigned long arg6,            R9
-                         unsigned long arg7,            R10
-                         unsigned long *out1,           112(R1)
-                         unsigned long *out2,           110(R1)
-                         unsigned long *out3,           108(R1)
-                         unsigned long *out4,           106(R1)
-                         unsigned long *out5,           104(R1)
-                         unsigned long *out6,           102(R1)
-                         unsigned long *out7);          100(R1)
-*/
-_GLOBAL(plpar_hcall_7arg_7ret)
-        HMT_MEDIUM
-
-        mfcr    r0
-        stw     r0,8(r1)
+        mr      r4,r5
+        mr      r5,r6
+        mr      r6,r7
+        mr      r7,r8
+        mr      r8,r9
+        mr      r9,r10
 
         HVSC                            /* invoke the hypervisor */
 
-        lwz     r0,8(r1)
+        ld      r12,STK_PARM(r4)(r1)
+        std     r4,  0(r12)
+        std     r5,  8(r12)
+        std     r6, 16(r12)
+        std     r7, 24(r12)
 
-        ld      r11,STK_PARM(r11)(r1)   /* Fetch r4 ret arg */
-        std     r4,0(r11)
-        ld      r11,STK_PARM(r12)(r1)   /* Fetch r5 ret arg */
-        std     r5,0(r11)
-        ld      r11,STK_PARM(r13)(r1)   /* Fetch r6 ret arg */
-        std     r6,0(r11)
-        ld      r11,STK_PARM(r14)(r1)   /* Fetch r7 ret arg */
-        std     r7,0(r11)
-        ld      r11,STK_PARM(r15)(r1)   /* Fetch r8 ret arg */
-        std     r8,0(r11)
-        ld      r11,STK_PARM(r16)(r1)   /* Fetch r9 ret arg */
-        std     r9,0(r11)
-        ld      r11,STK_PARM(r17)(r1)   /* Fetch r10 ret arg */
-        std     r10,0(r11)
+        HCALL_INST_POSTCALL
 
+        lwz     r0,8(r1)
         mtcrf   0xff,r0
 
         blr                             /* return r3 = status */
 
-/* plpar_hcall_9arg_9ret(unsigned long opcode,          R3
-                         unsigned long arg1,            R4
-                         unsigned long arg2,            R5
-                         unsigned long arg3,            R6
-                         unsigned long arg4,            R7
-                         unsigned long arg5,            R8
-                         unsigned long arg6,            R9
-                         unsigned long arg7,            R10
-                         unsigned long arg8,            112(R1)
-                         unsigned long arg9,            110(R1)
-                         unsigned long *out1,           108(R1)
-                         unsigned long *out2,           106(R1)
-                         unsigned long *out3,           104(R1)
-                         unsigned long *out4,           102(R1)
-                         unsigned long *out5,           100(R1)
-                         unsigned long *out6,            98(R1)
-                         unsigned long *out7);           96(R1)
-                         unsigned long *out8,            94(R1)
-                         unsigned long *out9,            92(R1)
-*/
-_GLOBAL(plpar_hcall_9arg_9ret)
+_GLOBAL(plpar_hcall9)
         HMT_MEDIUM
 
         mfcr    r0
         stw     r0,8(r1)
 
-        ld      r11,STK_PARM(r11)(r1)    /* put arg8 in R11 */
-        ld      r12,STK_PARM(r12)(r1)    /* put arg9 in R12 */
+        HCALL_INST_PRECALL
+
+        std     r4,STK_PARM(r4)(r1)     /* Save ret buffer */
+
+        mr      r4,r5
+        mr      r5,r6
+        mr      r6,r7
+        mr      r7,r8
+        mr      r8,r9
+        mr      r9,r10
+        ld      r10,STK_PARM(r11)(r1)    /* put arg7 in R10 */
+        ld      r11,STK_PARM(r12)(r1)    /* put arg8 in R11 */
+        ld      r12,STK_PARM(r13)(r1)    /* put arg9 in R12 */
 
         HVSC                            /* invoke the hypervisor */
 
-        ld      r0,STK_PARM(r13)(r1)    /* Fetch r4 ret arg */
-        stdx    r4,r0,r0
-        ld      r0,STK_PARM(r14)(r1)    /* Fetch r5 ret arg */
-        stdx    r5,r0,r0
-        ld      r0,STK_PARM(r15)(r1)    /* Fetch r6 ret arg */
-        stdx    r6,r0,r0
-        ld      r0,STK_PARM(r16)(r1)    /* Fetch r7 ret arg */
-        stdx    r7,r0,r0
-        ld      r0,STK_PARM(r17)(r1)    /* Fetch r8 ret arg */
-        stdx    r8,r0,r0
-        ld      r0,STK_PARM(r18)(r1)    /* Fetch r9 ret arg */
-        stdx    r9,r0,r0
-        ld      r0,STK_PARM(r19)(r1)    /* Fetch r10 ret arg */
-        stdx    r10,r0,r0
-        ld      r0,STK_PARM(r20)(r1)    /* Fetch r11 ret arg */
-        stdx    r11,r0,r0
-        ld      r0,STK_PARM(r21)(r1)    /* Fetch r12 ret arg */
-        stdx    r12,r0,r0
+        ld      r12,STK_PARM(r4)(r1)
+        std     r4,  0(r12)
+        std     r5,  8(r12)
+        std     r6, 16(r12)
+        std     r7, 24(r12)
+        std     r8, 32(r12)
+        std     r9, 40(r12)
+        std     r10,48(r12)
+        std     r11,56(r12)
+        std     r12,64(r12)
+
+        HCALL_INST_POSTCALL
 
         lwz     r0,8(r1)
         mtcrf   0xff,r0
diff --git a/arch/powerpc/platforms/pseries/hvCall_inst.c b/arch/powerpc/platforms/pseries/hvCall_inst.c
new file mode 100644
index 000000000000..641e6511cf06
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/hvCall_inst.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2006 Mike Kravetz IBM Corporation
+ *
+ * Hypervisor Call Instrumentation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/percpu.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/cpumask.h>
+#include <asm/hvcall.h>
+#include <asm/firmware.h>
+#include <asm/cputable.h>
+
+DEFINE_PER_CPU(struct hcall_stats[HCALL_STAT_ARRAY_SIZE], hcall_stats);
+
+/*
+ * Routines for displaying the statistics in debugfs
+ */
+static void *hc_start(struct seq_file *m, loff_t *pos)
+{
+        if ((int)*pos < HCALL_STAT_ARRAY_SIZE)
+                return (void *)(unsigned long)(*pos + 1);
+
+        return NULL;
+}
+
+static void *hc_next(struct seq_file *m, void *p, loff_t * pos)
+{
+        ++*pos;
+
+        return hc_start(m, pos);
+}
+
+static void hc_stop(struct seq_file *m, void *p)
+{
+}
+
+static int hc_show(struct seq_file *m, void *p)
+{
+        unsigned long h_num = (unsigned long)p;
+        struct hcall_stats *hs = (struct hcall_stats *)m->private;
+
+        if (hs[h_num].num_calls) {
+                if (!cpu_has_feature(CPU_FTR_PURR))
+                        seq_printf(m, "%lu %lu %lu %lu\n", h_num<<2,
+                                   hs[h_num].num_calls,
+                                   hs[h_num].tb_total,
+                                   hs[h_num].purr_total);
+                else
+                        seq_printf(m, "%lu %lu %lu\n", h_num<<2,
+                                   hs[h_num].num_calls,
+                                   hs[h_num].tb_total);
+        }
+
+        return 0;
+}
+
+static struct seq_operations hcall_inst_seq_ops = {
+        .start = hc_start,
+        .next  = hc_next,
+        .stop  = hc_stop,
+        .show  = hc_show
+};
+
+static int hcall_inst_seq_open(struct inode *inode, struct file *file)
+{
+        int rc;
+        struct seq_file *seq;
+
+        rc = seq_open(file, &hcall_inst_seq_ops);
+        seq = file->private_data;
+        seq->private = file->f_dentry->d_inode->u.generic_ip;
+
+        return rc;
+}
+
+static struct file_operations hcall_inst_seq_fops = {
+        .open = hcall_inst_seq_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = seq_release,
+};
+
+#define HCALL_ROOT_DIR          "hcall_inst"
+#define CPU_NAME_BUF_SIZE       32
+
+static int __init hcall_inst_init(void)
+{
+        struct dentry *hcall_root;
+        struct dentry *hcall_file;
+        char cpu_name_buf[CPU_NAME_BUF_SIZE];
+        int cpu;
+
+        if (!firmware_has_feature(FW_FEATURE_LPAR))
+                return 0;
+
+        hcall_root = debugfs_create_dir(HCALL_ROOT_DIR, NULL);
+        if (!hcall_root)
+                return -ENOMEM;
+
+        for_each_possible_cpu(cpu) {
+                snprintf(cpu_name_buf, CPU_NAME_BUF_SIZE, "cpu%d", cpu);
+                hcall_file = debugfs_create_file(cpu_name_buf, S_IRUGO,
+                                                 hcall_root,
+                                                 per_cpu(hcall_stats, cpu),
+                                                 &hcall_inst_seq_fops);
+                if (!hcall_file)
+                        return -ENOMEM;
+        }
+
+        return 0;
+}
+__initcall(hcall_inst_init);
diff --git a/arch/powerpc/platforms/pseries/hvconsole.c b/arch/powerpc/platforms/pseries/hvconsole.c
index a72a987f1d4d..3f6a89b09816 100644
--- a/arch/powerpc/platforms/pseries/hvconsole.c
+++ b/arch/powerpc/platforms/pseries/hvconsole.c
@@ -27,6 +27,7 @@
 #include <linux/module.h>
 #include <asm/hvcall.h>
 #include <asm/hvconsole.h>
+#include "plpar_wrappers.h"
 
 /**
  * hvc_get_chars - retrieve characters from firmware for denoted vterm adatper
@@ -40,9 +41,9 @@ int hvc_get_chars(uint32_t vtermno, char *buf, int count)
 {
         unsigned long got;
 
-        if (plpar_hcall(H_GET_TERM_CHAR, vtermno, 0, 0, 0, &got,
-                (unsigned long *)buf, (unsigned long *)buf+1) == H_SUCCESS)
+        if (plpar_get_term_char(vtermno, &got, buf) == H_SUCCESS)
                 return got;
+
         return 0;
 }
 
diff --git a/arch/powerpc/platforms/pseries/iommu.c b/arch/powerpc/platforms/pseries/iommu.c
index d67af2c65754..bbf2e34dc358 100644
--- a/arch/powerpc/platforms/pseries/iommu.c
+++ b/arch/powerpc/platforms/pseries/iommu.c
@@ -267,13 +267,12 @@ static void iommu_table_setparms(struct pci_controller *phb,
                                  struct iommu_table *tbl)
 {
         struct device_node *node;
-        unsigned long *basep;
-        unsigned int *sizep;
+        const unsigned long *basep, *sizep;
 
         node = (struct device_node *)phb->arch_data;
 
-        basep = (unsigned long *)get_property(node, "linux,tce-base", NULL);
-        sizep = (unsigned int *)get_property(node, "linux,tce-size", NULL);
+        basep = get_property(node, "linux,tce-base", NULL);
+        sizep = get_property(node, "linux,tce-size", NULL);
         if (basep == NULL || sizep == NULL) {
                 printk(KERN_ERR "PCI_DMA: iommu_table_setparms: %s has "
                                 "missing tce entries !\n", dn->full_name);
@@ -315,7 +314,7 @@ static void iommu_table_setparms(struct pci_controller *phb,
 static void iommu_table_setparms_lpar(struct pci_controller *phb,
                                       struct device_node *dn,
                                       struct iommu_table *tbl,
-                                      unsigned char *dma_window)
+                                      const void *dma_window)
 {
         unsigned long offset, size;
 
@@ -415,7 +414,7 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
         struct iommu_table *tbl;
         struct device_node *dn, *pdn;
         struct pci_dn *ppci;
-        unsigned char *dma_window = NULL;
+        const void *dma_window = NULL;
 
         DBG("iommu_bus_setup_pSeriesLP, bus %p, bus->self %p\n", bus, bus->self);
 
@@ -519,7 +518,7 @@ static void iommu_dev_setup_pSeriesLP(struct pci_dev *dev)
 {
         struct device_node *pdn, *dn;
         struct iommu_table *tbl;
-        unsigned char *dma_window = NULL;
+        const void *dma_window = NULL;
         struct pci_dn *pci;
 
         DBG("iommu_dev_setup_pSeriesLP, dev %p (%s)\n", dev, pci_name(dev));
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index 3aeb40699042..1820a0b0a8c6 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -48,13 +48,11 @@
 #define DBG_LOW(fmt...) do { } while(0)
 #endif
 
-/* in pSeries_hvCall.S */
+/* in hvCall.S */
 EXPORT_SYMBOL(plpar_hcall);
-EXPORT_SYMBOL(plpar_hcall_4out);
+EXPORT_SYMBOL(plpar_hcall9);
 EXPORT_SYMBOL(plpar_hcall_norets);
-EXPORT_SYMBOL(plpar_hcall_8arg_2ret);
-EXPORT_SYMBOL(plpar_hcall_7arg_7ret);
-EXPORT_SYMBOL(plpar_hcall_9arg_9ret);
+
 extern void pSeries_find_serial_port(void);
 
 
@@ -204,20 +202,20 @@ void __init udbg_init_debug_lpar(void)
 void __init find_udbg_vterm(void)
 {
         struct device_node *stdout_node;
-        u32 *termno;
-        char *name;
+        const u32 *termno;
+        const char *name;
         int add_console;
 
         /* find the boot console from /chosen/stdout */
         if (!of_chosen)
                 return;
-        name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
+        name = get_property(of_chosen, "linux,stdout-path", NULL);
         if (name == NULL)
                 return;
         stdout_node = of_find_node_by_path(name);
         if (!stdout_node)
                 return;
-        name = (char *)get_property(stdout_node, "name", NULL);
+        name = get_property(stdout_node, "name", NULL);
         if (!name) {
                 printk(KERN_WARNING "stdout node missing 'name' property!\n");
                 goto out;
@@ -228,7 +226,7 @@ void __init find_udbg_vterm(void)
         /* Check if it's a virtual terminal */
         if (strncmp(name, "vty", 3) != 0)
                 goto out;
-        termno = (u32 *)get_property(stdout_node, "reg", NULL);
+        termno = get_property(stdout_node, "reg", NULL);
         if (termno == NULL)
                 goto out;
         vtermno = termno[0];
@@ -254,18 +252,34 @@ out:
 void vpa_init(int cpu)
 {
         int hwcpu = get_hard_smp_processor_id(cpu);
-        unsigned long vpa = __pa(&lppaca[cpu]);
+        unsigned long addr;
         long ret;
 
         if (cpu_has_feature(CPU_FTR_ALTIVEC))
                 lppaca[cpu].vmxregs_in_use = 1;
 
-        ret = register_vpa(hwcpu, vpa);
+        addr = __pa(&lppaca[cpu]);
+        ret = register_vpa(hwcpu, addr);
 
-        if (ret)
+        if (ret) {
                 printk(KERN_ERR "WARNING: vpa_init: VPA registration for "
                                 "cpu %d (hw %d) of area %lx returns %ld\n",
-                                cpu, hwcpu, vpa, ret);
+                                cpu, hwcpu, addr, ret);
+                return;
+        }
+        /*
+         * PAPR says this feature is SLB-Buffer but firmware never
+         * reports that.  All SPLPAR support SLB shadow buffer.
+         */
+        addr = __pa(&slb_shadow[cpu]);
+        if (firmware_has_feature(FW_FEATURE_SPLPAR)) {
+                ret = register_slb_shadow(hwcpu, addr);
+                if (ret)
+                        printk(KERN_ERR
+                               "WARNING: vpa_init: SLB shadow buffer "
+                               "registration for cpu %d (hw %d) of area %lx "
+                               "returns %ld\n", cpu, hwcpu, addr, ret);
+        }
 }
 
 long pSeries_lpar_hpte_insert(unsigned long hpte_group,
@@ -277,7 +291,6 @@ long pSeries_lpar_hpte_insert(unsigned long hpte_group,
         unsigned long flags;
         unsigned long slot;
         unsigned long hpte_v, hpte_r;
-        unsigned long dummy0, dummy1;
 
         if (!(vflags & HPTE_V_BOLTED))
                 DBG_LOW("hpte_insert(group=%lx, va=%016lx, pa=%016lx, "
@@ -302,8 +315,7 @@ long pSeries_lpar_hpte_insert(unsigned long hpte_group,
         if (rflags & (_PAGE_GUARDED|_PAGE_NO_CACHE))
                 hpte_r &= ~_PAGE_COHERENT;
 
-        lpar_rc = plpar_hcall(H_ENTER, flags, hpte_group, hpte_v,
-                              hpte_r, &slot, &dummy0, &dummy1);
+        lpar_rc = plpar_pte_enter(flags, hpte_group, hpte_v, hpte_r, &slot);
         if (unlikely(lpar_rc == H_PTEG_FULL)) {
                 if (!(vflags & HPTE_V_BOLTED))
                         DBG_LOW(" full\n");
diff --git a/arch/powerpc/platforms/pseries/nvram.c b/arch/powerpc/platforms/pseries/nvram.c
index 18abfb1f4e24..64163cecdf93 100644
--- a/arch/powerpc/platforms/pseries/nvram.c
+++ b/arch/powerpc/platforms/pseries/nvram.c
@@ -123,13 +123,14 @@ static ssize_t pSeries_nvram_get_size(void)
 int __init pSeries_nvram_init(void)
 {
         struct device_node *nvram;
-        unsigned int *nbytes_p, proplen;
+        const unsigned int *nbytes_p;
+        unsigned int proplen;
 
         nvram = of_find_node_by_type(NULL, "nvram");
         if (nvram == NULL)
                 return -ENODEV;
 
-        nbytes_p = (unsigned int *)get_property(nvram, "#bytes", &proplen);
+        nbytes_p = get_property(nvram, "#bytes", &proplen);
         if (nbytes_p == NULL || proplen != sizeof(unsigned int))
                 return -EIO;
 
diff --git a/arch/powerpc/platforms/pseries/pci.c b/arch/powerpc/platforms/pseries/pci.c
index e97e67f5e079..410a6bcc4ca0 100644
--- a/arch/powerpc/platforms/pseries/pci.c
+++ b/arch/powerpc/platforms/pseries/pci.c
@@ -60,7 +60,7 @@ DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pcibios_name_device);
 static void __devinit check_s7a(void)
 {
         struct device_node *root;
-        char *model;
+        const char *model;
 
         s7a_workaround = 0;
         root = of_find_node_by_path("/");
diff --git a/arch/powerpc/platforms/pseries/plpar_wrappers.h b/arch/powerpc/platforms/pseries/plpar_wrappers.h
index 3bd1b3e06003..3eb7b294d92f 100644
--- a/arch/powerpc/platforms/pseries/plpar_wrappers.h
+++ b/arch/powerpc/platforms/pseries/plpar_wrappers.h
@@ -5,20 +5,17 @@
 
 static inline long poll_pending(void)
 {
-        unsigned long dummy;
-        return plpar_hcall(H_POLL_PENDING, 0, 0, 0, 0, &dummy, &dummy, &dummy);
+        return plpar_hcall_norets(H_POLL_PENDING);
 }
 
 static inline long prod_processor(void)
 {
-        plpar_hcall_norets(H_PROD);
-        return 0;
+        return plpar_hcall_norets(H_PROD);
 }
 
 static inline long cede_processor(void)
 {
-        plpar_hcall_norets(H_CEDE);
-        return 0;
+        return plpar_hcall_norets(H_CEDE);
 }
 
 static inline long vpa_call(unsigned long flags, unsigned long cpu,
@@ -40,23 +37,59 @@ static inline long register_vpa(unsigned long cpu, unsigned long vpa)
         return vpa_call(0x1, cpu, vpa);
 }
 
+static inline long unregister_slb_shadow(unsigned long cpu, unsigned long vpa)
+{
+        return vpa_call(0x7, cpu, vpa);
+}
+
+static inline long register_slb_shadow(unsigned long cpu, unsigned long vpa)
+{
+        return vpa_call(0x3, cpu, vpa);
+}
+
 extern void vpa_init(int cpu);
 
+static inline long plpar_pte_enter(unsigned long flags,
+                unsigned long hpte_group, unsigned long hpte_v,
+                unsigned long hpte_r, unsigned long *slot)
+{
+        long rc;
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
+
+        rc = plpar_hcall(H_ENTER, retbuf, flags, hpte_group, hpte_v, hpte_r);
+
+        *slot = retbuf[0];
+
+        return rc;
+}
+
 static inline long plpar_pte_remove(unsigned long flags, unsigned long ptex,
                 unsigned long avpn, unsigned long *old_pteh_ret,
                 unsigned long *old_ptel_ret)
 {
-        unsigned long dummy;
-        return plpar_hcall(H_REMOVE, flags, ptex, avpn, 0, old_pteh_ret,
-                        old_ptel_ret, &dummy);
+        long rc;
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
+
+        rc = plpar_hcall(H_REMOVE, retbuf, flags, ptex, avpn);
+
+        *old_pteh_ret = retbuf[0];
+        *old_ptel_ret = retbuf[1];
+
+        return rc;
 }
 
 static inline long plpar_pte_read(unsigned long flags, unsigned long ptex,
                 unsigned long *old_pteh_ret, unsigned long *old_ptel_ret)
 {
-        unsigned long dummy;
-        return plpar_hcall(H_READ, flags, ptex, 0, 0, old_pteh_ret,
-                        old_ptel_ret, &dummy);
+        long rc;
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
+
+        rc = plpar_hcall(H_READ, retbuf, flags, ptex);
+
+        *old_pteh_ret = retbuf[0];
+        *old_ptel_ret = retbuf[1];
+
+        return rc;
 }
 
 static inline long plpar_pte_protect(unsigned long flags, unsigned long ptex,
@@ -68,9 +101,14 @@ static inline long plpar_pte_protect(unsigned long flags, unsigned long ptex,
 static inline long plpar_tce_get(unsigned long liobn, unsigned long ioba,
                 unsigned long *tce_ret)
 {
-        unsigned long dummy;
-        return plpar_hcall(H_GET_TCE, liobn, ioba, 0, 0, tce_ret, &dummy,
-                        &dummy);
+        long rc;
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
+
+        rc = plpar_hcall(H_GET_TCE, retbuf, liobn, ioba);
+
+        *tce_ret = retbuf[0];
+
+        return rc;
 }
 
 static inline long plpar_tce_put(unsigned long liobn, unsigned long ioba,
@@ -94,9 +132,17 @@ static inline long plpar_tce_stuff(unsigned long liobn, unsigned long ioba,
 static inline long plpar_get_term_char(unsigned long termno,
                 unsigned long *len_ret, char *buf_ret)
 {
+        long rc;
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
         unsigned long *lbuf = (unsigned long *)buf_ret; /* TODO: alignment? */
-        return plpar_hcall(H_GET_TERM_CHAR, termno, 0, 0, 0, len_ret,
-                        lbuf + 0, lbuf + 1);
+
+        rc = plpar_hcall(H_GET_TERM_CHAR, retbuf, termno);
+
+        *len_ret = retbuf[0];
+        lbuf[0] = retbuf[1];
+        lbuf[1] = retbuf[2];
+
+        return rc;
 }
 
 static inline long plpar_put_term_char(unsigned long termno, unsigned long len,
@@ -107,4 +153,31 @@ static inline long plpar_put_term_char(unsigned long termno, unsigned long len,
                         lbuf[1]);
 }
 
+static inline long plpar_eoi(unsigned long xirr)
+{
+        return plpar_hcall_norets(H_EOI, xirr);
+}
+
+static inline long plpar_cppr(unsigned long cppr)
+{
+        return plpar_hcall_norets(H_CPPR, cppr);
+}
+
+static inline long plpar_ipi(unsigned long servernum, unsigned long mfrr)
+{
+        return plpar_hcall_norets(H_IPI, servernum, mfrr);
+}
+
+static inline long plpar_xirr(unsigned long *xirr_ret)
+{
+        long rc;
+        unsigned long retbuf[PLPAR_HCALL_BUFSIZE];
+
+        rc = plpar_hcall(H_XIRR, retbuf);
+
+        *xirr_ret = retbuf[0];
+
+        return rc;
+}
+
 #endif /* _PSERIES_PLPAR_WRAPPERS_H */
diff --git a/arch/powerpc/platforms/pseries/ras.c b/arch/powerpc/platforms/pseries/ras.c
index c7ffde1a614e..903115d67fdc 100644
--- a/arch/powerpc/platforms/pseries/ras.c
+++ b/arch/powerpc/platforms/pseries/ras.c
@@ -79,7 +79,7 @@ static void request_ras_irqs(struct device_node *np,
 {
         int i, index, count = 0;
         struct of_irq oirq;
-        u32 *opicprop;
+        const u32 *opicprop;
         unsigned int opicplen;
         unsigned int virqs[16];
 
@@ -87,7 +87,7 @@ static void request_ras_irqs(struct device_node *np,
          * map those interrupts using the default interrupt host and default
          * trigger
          */
-        opicprop = (u32 *)get_property(np, "open-pic-interrupt", &opicplen);
+        opicprop = get_property(np, "open-pic-interrupt", &opicplen);
         if (opicprop) {
                 opicplen /= sizeof(u32);
                 for (i = 0; i < opicplen; i++) {
diff --git a/arch/powerpc/platforms/pseries/rtasd.c b/arch/powerpc/platforms/pseries/rtasd.c
index 2e4e04042d85..8ca2612221d6 100644
--- a/arch/powerpc/platforms/pseries/rtasd.c
+++ b/arch/powerpc/platforms/pseries/rtasd.c
@@ -359,11 +359,11 @@ static int enable_surveillance(int timeout)
 static int get_eventscan_parms(void)
 {
         struct device_node *node;
-        int *ip;
+        const int *ip;
 
         node = of_find_node_by_path("/rtas");
 
-        ip = (int *)get_property(node, "rtas-event-scan-rate", NULL);
+        ip = get_property(node, "rtas-event-scan-rate", NULL);
         if (ip == NULL) {
                 printk(KERN_ERR "rtasd: no rtas-event-scan-rate\n");
                 of_node_put(node);
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index 31867a701fcb..a6398fbe530d 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -133,9 +133,9 @@ void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc,
 static void __init pseries_mpic_init_IRQ(void)
 {
         struct device_node *np, *old, *cascade = NULL;
-        unsigned int *addrp;
+        const unsigned int *addrp;
         unsigned long intack = 0;
-        unsigned int *opprop;
+        const unsigned int *opprop;
         unsigned long openpic_addr = 0;
         unsigned int cascade_irq;
         int naddr, n, i, opplen;
@@ -143,7 +143,7 @@ static void __init pseries_mpic_init_IRQ(void)
 
         np = of_find_node_by_path("/");
         naddr = prom_n_addr_cells(np);
-        opprop = (unsigned int *) get_property(np, "platform-open-pic", &opplen);
+        opprop = get_property(np, "platform-open-pic", &opplen);
         if (opprop != 0) {
                 openpic_addr = of_read_number(opprop, naddr);
                 printk(KERN_DEBUG "OpenPIC addr: %lx\n", openpic_addr);
@@ -192,7 +192,7 @@ static void __init pseries_mpic_init_IRQ(void)
                         break;
                 if (strcmp(np->name, "pci") != 0)
                         continue;
-                addrp = (u32 *)get_property(np, "8259-interrupt-acknowledge",
+                addrp = get_property(np, "8259-interrupt-acknowledge",
                                             NULL);
                 if (addrp == NULL)
                         continue;
@@ -223,23 +223,37 @@ static void pseries_lpar_enable_pmcs(void)
 }
 
 #ifdef CONFIG_KEXEC
-static void pseries_kexec_cpu_down_mpic(int crash_shutdown, int secondary)
-{
-        mpic_teardown_this_cpu(secondary);
-}
-
-static void pseries_kexec_cpu_down_xics(int crash_shutdown, int secondary)
+static void pseries_kexec_cpu_down(int crash_shutdown, int secondary)
 {
         /* Don't risk a hypervisor call if we're crashing */
         if (firmware_has_feature(FW_FEATURE_SPLPAR) && !crash_shutdown) {
-                unsigned long vpa = __pa(get_lppaca());
+                unsigned long addr;
 
-                if (unregister_vpa(hard_smp_processor_id(), vpa)) {
+                addr = __pa(get_slb_shadow());
+                if (unregister_slb_shadow(hard_smp_processor_id(), addr))
+                        printk("SLB shadow buffer deregistration of "
+                               "cpu %u (hw_cpu_id %d) failed\n",
+                               smp_processor_id(),
+                               hard_smp_processor_id());
+
+                addr = __pa(get_lppaca());
+                if (unregister_vpa(hard_smp_processor_id(), addr)) {
                         printk("VPA deregistration of cpu %u (hw_cpu_id %d) "
                                         "failed\n", smp_processor_id(),
                                         hard_smp_processor_id());
                 }
         }
+}
+
+static void pseries_kexec_cpu_down_mpic(int crash_shutdown, int secondary)
+{
+        pseries_kexec_cpu_down(crash_shutdown, secondary);
+        mpic_teardown_this_cpu(secondary);
+}
+
+static void pseries_kexec_cpu_down_xics(int crash_shutdown, int secondary)
+{
+        pseries_kexec_cpu_down(crash_shutdown, secondary);
         xics_teardown_cpu(secondary);
 }
 #endif /* CONFIG_KEXEC */
@@ -247,11 +261,11 @@ static void pseries_kexec_cpu_down_xics(int crash_shutdown, int secondary)
 static void __init pseries_discover_pic(void)
 {
         struct device_node *np;
-        char *typep;
+        const char *typep;
 
         for (np = NULL; (np = of_find_node_by_name(np,
                                                    "interrupt-controller"));) {
-                typep = (char *)get_property(np, "compatible", NULL);
+                typep = get_property(np, "compatible", NULL);
                 if (strstr(typep, "open-pic")) {
                         pSeries_mpic_node = of_node_get(np);
                         ppc_md.init_IRQ       = pseries_mpic_init_IRQ;
diff --git a/arch/powerpc/platforms/pseries/smp.c b/arch/powerpc/platforms/pseries/smp.c
index ac61098ff401..c6624b8a0e77 100644
--- a/arch/powerpc/platforms/pseries/smp.c
+++ b/arch/powerpc/platforms/pseries/smp.c
@@ -62,7 +62,7 @@
  */
 static cpumask_t of_spin_map;
 
-extern void pSeries_secondary_smp_init(unsigned long);
+extern void generic_secondary_smp_init(unsigned long);
 
 #ifdef CONFIG_HOTPLUG_CPU
 
@@ -145,9 +145,9 @@ static int pSeries_add_processor(struct device_node *np)
         unsigned int cpu;
         cpumask_t candidate_map, tmp = CPU_MASK_NONE;
         int err = -ENOSPC, len, nthreads, i;
-        u32 *intserv;
+        const u32 *intserv;
 
-        intserv = (u32 *)get_property(np, "ibm,ppc-interrupt-server#s", &len);
+        intserv = get_property(np, "ibm,ppc-interrupt-server#s", &len);
         if (!intserv)
                 return 0;
 
@@ -205,9 +205,9 @@ static void pSeries_remove_processor(struct device_node *np)
 {
         unsigned int cpu;
         int len, nthreads, i;
-        u32 *intserv;
+        const u32 *intserv;
 
-        intserv = (u32 *)get_property(np, "ibm,ppc-interrupt-server#s", &len);
+        intserv = get_property(np, "ibm,ppc-interrupt-server#s", &len);
         if (!intserv)
                 return;
 
@@ -270,7 +270,7 @@ static inline int __devinit smp_startup_cpu(unsigned int lcpu)
 {
         int status;
         unsigned long start_here = __pa((u32)*((unsigned long *)
-                                               pSeries_secondary_smp_init));
+                                               generic_secondary_smp_init));
         unsigned int pcpu;
         int start_cpu;
 
diff --git a/arch/powerpc/platforms/pseries/xics.c b/arch/powerpc/platforms/pseries/xics.c
index e98863025721..253972e5479f 100644
--- a/arch/powerpc/platforms/pseries/xics.c
+++ b/arch/powerpc/platforms/pseries/xics.c
@@ -34,6 +34,7 @@
 #include <asm/i8259.h>
 
 #include "xics.h"
+#include "plpar_wrappers.h"
 
 #define XICS_IPI                2
 #define XICS_IRQ_SPURIOUS       0
@@ -110,27 +111,6 @@ static inline void direct_qirr_info(int n_cpu, u8 value)
 /* LPAR low level accessors */
 
 
-static inline long plpar_eoi(unsigned long xirr)
-{
-        return plpar_hcall_norets(H_EOI, xirr);
-}
-
-static inline long plpar_cppr(unsigned long cppr)
-{
-        return plpar_hcall_norets(H_CPPR, cppr);
-}
-
-static inline long plpar_ipi(unsigned long servernum, unsigned long mfrr)
-{
-        return plpar_hcall_norets(H_IPI, servernum, mfrr);
-}
-
-static inline long plpar_xirr(unsigned long *xirr_ret)
-{
-        unsigned long dummy;
-        return plpar_hcall(H_XIRR, 0, 0, 0, 0, xirr_ret, &dummy, &dummy);
-}
-
 static inline unsigned int lpar_xirr_info_get(int n_cpu)
 {
         unsigned long lpar_rc;
@@ -590,14 +570,14 @@ static void __init xics_init_one_node(struct device_node *np,
                                       unsigned int *indx)
 {
         unsigned int ilen;
-        u32 *ireg;
+        const u32 *ireg;
 
         /* This code does the theorically broken assumption that the interrupt
          * server numbers are the same as the hard CPU numbers.
          * This happens to be the case so far but we are playing with fire...
          * should be fixed one of these days. -BenH.
          */
-        ireg = (u32 *)get_property(np, "ibm,interrupt-server-ranges", NULL);
+        ireg = get_property(np, "ibm,interrupt-server-ranges", NULL);
 
         /* Do that ever happen ? we'll know soon enough... but even good'old
          * f80 does have that property ..
@@ -609,7 +589,7 @@ static void __init xics_init_one_node(struct device_node *np,
                  */
                 *indx = *ireg;
         }
-        ireg = (u32 *)get_property(np, "reg", &ilen);
+        ireg = get_property(np, "reg", &ilen);
         if (!ireg)
                 panic("xics_init_IRQ: can't find interrupt reg property");
 
@@ -635,7 +615,7 @@ static void __init xics_setup_8259_cascade(void)
 {
         struct device_node *np, *old, *found = NULL;
         int cascade, naddr;
-        u32 *addrp;
+        const u32 *addrp;
         unsigned long intack = 0;
 
         for_each_node_by_type(np, "interrupt-controller")
@@ -661,7 +641,7 @@ static void __init xics_setup_8259_cascade(void)
                         break;
                 if (strcmp(np->name, "pci") != 0)
                         continue;
-                addrp = (u32 *)get_property(np, "8259-interrupt-acknowledge", NULL);
+                addrp = get_property(np, "8259-interrupt-acknowledge", NULL);
                 if (addrp == NULL)
                         continue;
                 naddr = prom_n_addr_cells(np);
@@ -680,7 +660,8 @@ void __init xics_init_IRQ(void)
 {
         int i;
         struct device_node *np;
-        u32 *ireg, ilen, indx = 0;
+        u32 ilen, indx = 0;
+        const u32 *ireg;
         int found = 0;
 
         ppc64_boot_msg(0x20, "XICS Init");
@@ -705,18 +686,17 @@ void __init xics_init_IRQ(void)
         for (np = of_find_node_by_type(NULL, "cpu");
              np;
              np = of_find_node_by_type(np, "cpu")) {
-                ireg = (u32 *)get_property(np, "reg", &ilen);
+                ireg = get_property(np, "reg", &ilen);
                 if (ireg && ireg[0] == get_hard_smp_processor_id(boot_cpuid)) {
-                        ireg = (u32 *)get_property(np,
-                                                  "ibm,ppc-interrupt-gserver#s",
-                                                   &ilen);
+                        ireg = get_property(np,
+                                        "ibm,ppc-interrupt-gserver#s", &ilen);
                         i = ilen / sizeof(int);
                         if (ireg && i > 0) {
                                 default_server = ireg[0];
                                 /* take last element */
                                 default_distrib_server = ireg[i-1];
                         }
-                        ireg = (u32 *)get_property(np,
+                        ireg = get_property(np,
                                         "ibm,interrupt-server#-size", NULL);
                         if (ireg)
                                 interrupt_server_size = *ireg;
diff --git a/arch/powerpc/sysdev/fsl_soc.c b/arch/powerpc/sysdev/fsl_soc.c
index ef10bcf2d943..92ba378b7990 100644
--- a/arch/powerpc/sysdev/fsl_soc.c
+++ b/arch/powerpc/sysdev/fsl_soc.c
@@ -41,7 +41,7 @@ phys_addr_t get_immrbase(void)
         soc = of_find_node_by_type(NULL, "soc");
         if (soc) {
                 unsigned int size;
-                void *prop = get_property(soc, "reg", &size);
+                const void *prop = get_property(soc, "reg", &size);
                 immrbase = of_translate_address(soc, prop);
                 of_node_put(soc);
         };
@@ -85,7 +85,7 @@ static int __init gfar_mdio_of_init(void)
                         mdio_data.irq[k] = -1;
 
                 while ((child = of_get_next_child(np, child)) != NULL) {
-                        u32 *id = get_property(child, "reg", NULL);
+                        const u32 *id = get_property(child, "reg", NULL);
                         mdio_data.irq[*id] = irq_of_parse_and_map(child, 0);
                 }
 
@@ -124,10 +124,10 @@ static int __init gfar_of_init(void)
                 struct resource r[4];
                 struct device_node *phy, *mdio;
                 struct gianfar_platform_data gfar_data;
-                unsigned int *id;
-                char *model;
-                void *mac_addr;
-                phandle *ph;
+                const unsigned int *id;
+                const char *model;
+                const void *mac_addr;
+                const phandle *ph;
                 int n_res = 1;
 
                 memset(r, 0, sizeof(r));
@@ -193,7 +193,7 @@ static int __init gfar_of_init(void)
                             FSL_GIANFAR_DEV_HAS_VLAN |
                             FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;
 
-                ph = (phandle *) get_property(np, "phy-handle", NULL);
+                ph = get_property(np, "phy-handle", NULL);
                 phy = of_find_node_by_phandle(*ph);
 
                 if (phy == NULL) {
@@ -203,7 +203,7 @@ static int __init gfar_of_init(void)
 
                 mdio = of_get_parent(phy);
 
-                id = (u32 *) get_property(phy, "reg", NULL);
+                id = get_property(phy, "reg", NULL);
                 ret = of_address_to_resource(mdio, 0, &res);
                 if (ret) {
                         of_node_put(phy);
@@ -247,7 +247,7 @@ static int __init fsl_i2c_of_init(void)
              i++) {
                 struct resource r[2];
                 struct fsl_i2c_platform_data i2c_data;
-                unsigned char *flags = NULL;
+                const unsigned char *flags = NULL;
 
                 memset(&r, 0, sizeof(r));
                 memset(&i2c_data, 0, sizeof(i2c_data));
@@ -298,7 +298,7 @@ static int __init mpc83xx_wdt_init(void)
         struct resource r;
         struct device_node *soc, *np;
         struct platform_device *dev;
-        unsigned int *freq;
+        const unsigned int *freq;
         int ret;
 
         np = of_find_compatible_node(NULL, "watchdog", "mpc83xx_wdt");
@@ -315,7 +315,7 @@ static int __init mpc83xx_wdt_init(void)
                 goto nosoc;
         }
 
-        freq = (unsigned int *)get_property(soc, "bus-frequency", NULL);
+        freq = get_property(soc, "bus-frequency", NULL);
         if (!freq) {
                 ret = -ENODEV;
                 goto err;
@@ -355,7 +355,7 @@ nodev:
 arch_initcall(mpc83xx_wdt_init);
 #endif
 
-static enum fsl_usb2_phy_modes determine_usb_phy(char * phy_type)
+static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type)
 {
         if (!phy_type)
                 return FSL_USB2_PHY_NONE;
@@ -383,7 +383,7 @@ static int __init fsl_usb_of_init(void)
              i++) {
                 struct resource r[2];
                 struct fsl_usb2_platform_data usb_data;
-                unsigned char *prop = NULL;
+                const unsigned char *prop = NULL;
 
                 memset(&r, 0, sizeof(r));
                 memset(&usb_data, 0, sizeof(usb_data));
@@ -431,7 +431,7 @@ static int __init fsl_usb_of_init(void)
              i++) {
                 struct resource r[2];
                 struct fsl_usb2_platform_data usb_data;
-                unsigned char *prop = NULL;
+                const unsigned char *prop = NULL;
 
                 memset(&r, 0, sizeof(r));
                 memset(&usb_data, 0, sizeof(usb_data));
diff --git a/arch/powerpc/sysdev/fsl_soc.h b/arch/powerpc/sysdev/fsl_soc.h
index c433d3f39edd..5a3dd480d2fd 100644
--- a/arch/powerpc/sysdev/fsl_soc.h
+++ b/arch/powerpc/sysdev/fsl_soc.h
@@ -2,6 +2,8 @@
 #define __PPC_FSL_SOC_H
 #ifdef __KERNEL__
 
+#include <asm/mmu.h>
+
 extern phys_addr_t get_immrbase(void);
 
 #endif
diff --git a/arch/powerpc/sysdev/i8259.c b/arch/powerpc/sysdev/i8259.c
index 9855820b9548..26a6a3becd66 100644
--- a/arch/powerpc/sysdev/i8259.c
+++ b/arch/powerpc/sysdev/i8259.c
@@ -224,7 +224,7 @@ static struct irq_host_ops i8259_host_ops = {
         .xlate = i8259_host_xlate,
 };
 
-/****
+/**
  * i8259_init - Initialize the legacy controller
  * @node: device node of the legacy PIC (can be NULL, but then, it will match
  *        all interrupts, so beware)
diff --git a/arch/powerpc/sysdev/ipic.c b/arch/powerpc/sysdev/ipic.c
index 70e707785d49..0251b7c68d0e 100644
--- a/arch/powerpc/sysdev/ipic.c
+++ b/arch/powerpc/sysdev/ipic.c
@@ -210,7 +210,7 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 4,
         },
         [64] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = IPIC_SMPRR_A,
                 .force  = IPIC_SIFCR_L,
@@ -218,7 +218,7 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 0,
         },
         [65] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = IPIC_SMPRR_A,
                 .force  = IPIC_SIFCR_L,
@@ -226,7 +226,7 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 1,
         },
         [66] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = IPIC_SMPRR_A,
                 .force  = IPIC_SIFCR_L,
@@ -234,7 +234,7 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 2,
         },
         [67] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = IPIC_SMPRR_A,
                 .force  = IPIC_SIFCR_L,
@@ -242,7 +242,7 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 3,
         },
         [68] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = IPIC_SMPRR_B,
                 .force  = IPIC_SIFCR_L,
@@ -250,7 +250,7 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 0,
         },
         [69] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = IPIC_SMPRR_B,
                 .force  = IPIC_SIFCR_L,
@@ -258,7 +258,7 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 1,
         },
         [70] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = IPIC_SMPRR_B,
                 .force  = IPIC_SIFCR_L,
@@ -266,7 +266,7 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 2,
         },
         [71] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = IPIC_SMPRR_B,
                 .force  = IPIC_SIFCR_L,
@@ -274,91 +274,91 @@ static struct ipic_info ipic_info[] = {
                 .prio_mask = 3,
         },
         [72] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 8,
         },
         [73] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 9,
         },
         [74] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 10,
         },
         [75] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 11,
         },
         [76] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 12,
         },
         [77] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 13,
         },
         [78] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 14,
         },
         [79] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 15,
         },
         [80] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 16,
         },
         [84] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 20,
         },
         [85] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 21,
         },
         [90] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
                 .bit    = 26,
         },
         [91] = {
-                .pend   = IPIC_SIPNR_H,
+                .pend   = IPIC_SIPNR_L,
                 .mask   = IPIC_SIMSR_L,
                 .prio   = 0,
                 .force  = IPIC_SIFCR_L,
diff --git a/arch/powerpc/sysdev/mmio_nvram.c b/arch/powerpc/sysdev/mmio_nvram.c
index 615350d46b52..ff23f5a4d4b9 100644
--- a/arch/powerpc/sysdev/mmio_nvram.c
+++ b/arch/powerpc/sysdev/mmio_nvram.c
@@ -80,7 +80,7 @@ static ssize_t mmio_nvram_get_size(void)
 int __init mmio_nvram_init(void)
 {
         struct device_node *nvram_node;
-        unsigned long *buffer;
+        const unsigned long *buffer;
         int proplen;
         unsigned long nvram_addr;
         int ret;
@@ -91,7 +91,7 @@ int __init mmio_nvram_init(void)
                 goto out;
 
         ret = -EIO;
-        buffer = (unsigned long *)get_property(nvram_node, "reg", &proplen);
+        buffer = get_property(nvram_node, "reg", &proplen);
         if (proplen != 2*sizeof(unsigned long))
                 goto out;
 
diff --git a/arch/powerpc/sysdev/tsi108_pci.c b/arch/powerpc/sysdev/tsi108_pci.c
index 2ab06ed3ae73..c28f69bef8e2 100644
--- a/arch/powerpc/sysdev/tsi108_pci.c
+++ b/arch/powerpc/sysdev/tsi108_pci.c
@@ -194,7 +194,7 @@ int __init tsi108_setup_pci(struct device_node *dev)
         int len;
         struct pci_controller *hose;
         struct resource rsrc;
-        int *bus_range;
+        const int *bus_range;
         int primary = 0, has_address = 0;
 
         /* PCI Config mapping */
@@ -207,7 +207,7 @@ int __init tsi108_setup_pci(struct device_node *dev)
         has_address = (of_address_to_resource(dev, 0, &rsrc) == 0);
 
         /* Get bus range if any */
-        bus_range = (int *)get_property(dev, "bus-range", &len);
+        bus_range = get_property(dev, "bus-range", &len);
         if (bus_range == NULL || len < 2 * sizeof(int)) {
                 printk(KERN_WARNING "Can't get bus-range for %s, assume"
                        " bus 0\n", dev->full_name);
diff --git a/arch/powerpc/xmon/xmon.c b/arch/powerpc/xmon/xmon.c
index 179b10ced8c7..8adad1444a51 100644
--- a/arch/powerpc/xmon/xmon.c
+++ b/arch/powerpc/xmon/xmon.c
@@ -137,10 +137,14 @@ static void bootcmds(void);
 static void proccall(void);
 void dump_segments(void);
 static void symbol_lookup(void);
+static void xmon_show_stack(unsigned long sp, unsigned long lr,
+                            unsigned long pc);
 static void xmon_print_symbol(unsigned long address, const char *mid,
                               const char *after);
 static const char *getvecname(unsigned long vec);
 
+int xmon_no_auto_backtrace;
+
 extern int print_insn_powerpc(unsigned long, unsigned long, int);
 
 extern void xmon_enter(void);
@@ -736,6 +740,12 @@ cmds(struct pt_regs *excp)
 
         last_cmd = NULL;
         xmon_regs = excp;
+
+        if (!xmon_no_auto_backtrace) {
+                xmon_no_auto_backtrace = 1;
+                xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
+        }
+
         for(;;) {
 #ifdef CONFIG_SMP
                 printf("%x:", smp_processor_id());
diff --git a/arch/ppc/Kconfig b/arch/ppc/Kconfig
index a04cdf01596b..8fa10cf661a8 100644
--- a/arch/ppc/Kconfig
+++ b/arch/ppc/Kconfig
@@ -1204,7 +1204,7 @@ config PCI_DOMAINS
         default PCI
 
 config MPC83xx_PCI2
-        bool "  Supprt for 2nd PCI host controller"
+        bool "Support for 2nd PCI host controller"
         depends on PCI && MPC834x
         default y if MPC834x_SYS
 
@@ -1223,12 +1223,12 @@ config PCI_8260
         default y
 
 config 8260_PCI9
-        bool "  Enable workaround for MPC826x erratum PCI 9"
+        bool "Enable workaround for MPC826x erratum PCI 9"
         depends on PCI_8260 && !ADS8272
         default y
 
 choice
-        prompt "  IDMA channel for PCI 9 workaround"
+        prompt "IDMA channel for PCI 9 workaround"
         depends on 8260_PCI9
 
 config 8260_PCI9_IDMA1
diff --git a/arch/ppc/kernel/misc.S b/arch/ppc/kernel/misc.S
index 2fa0075f2b5f..50b4bbd06804 100644
--- a/arch/ppc/kernel/misc.S
+++ b/arch/ppc/kernel/misc.S
@@ -768,91 +768,6 @@ _GLOBAL(_outsb)
         bdnz    00b
         blr
 
-_GLOBAL(_insw)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,2
-        blelr-
-00:     lhbrx   r5,0,r3
-01:     eieio
-02:     sthu    r5,2(r4)
-        ISYNC_8xx
-        .section .fixup,"ax"
-03:     blr
-        .text
-        .section __ex_table, "a"
-                .align 2
-                .long 00b, 03b
-                .long 01b, 03b
-                .long 02b, 03b
-        .text
-        bdnz    00b
-        blr
-
-_GLOBAL(_outsw)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,2
-        blelr-
-00:     lhzu    r5,2(r4)
-01:     eieio
-02:     sthbrx  r5,0,r3
-        ISYNC_8xx
-        .section .fixup,"ax"
-03:     blr
-        .text
-        .section __ex_table, "a"
-                .align 2
-                .long 00b, 03b
-                .long 01b, 03b
-                .long 02b, 03b
-        .text
-        bdnz    00b
-        blr
-
-_GLOBAL(_insl)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,4
-        blelr-
-00:     lwbrx   r5,0,r3
-01:     eieio
-02:     stwu    r5,4(r4)
-        ISYNC_8xx
-        .section .fixup,"ax"
-03:     blr
-        .text
-        .section __ex_table, "a"
-                .align 2
-                .long 00b, 03b
-                .long 01b, 03b
-                .long 02b, 03b
-        .text
-        bdnz    00b
-        blr
-
-_GLOBAL(_outsl)
-        cmpwi   0,r5,0
-        mtctr   r5
-        subi    r4,r4,4
-        blelr-
-00:     lwzu    r5,4(r4)
-01:     stwbrx  r5,0,r3
-02:     eieio
-        ISYNC_8xx
-        .section .fixup,"ax"
-03:     blr
-        .text
-        .section __ex_table, "a"
-                .align 2
-                .long 00b, 03b
-                .long 01b, 03b
-                .long 02b, 03b
-        .text
-        bdnz    00b
-        blr
-
-_GLOBAL(__ide_mm_insw)
 _GLOBAL(_insw_ns)
         cmpwi   0,r5,0
         mtctr   r5
@@ -874,7 +789,6 @@ _GLOBAL(_insw_ns)
         bdnz    00b
         blr
 
-_GLOBAL(__ide_mm_outsw)
 _GLOBAL(_outsw_ns)
         cmpwi   0,r5,0
         mtctr   r5
@@ -896,7 +810,6 @@ _GLOBAL(_outsw_ns)
         bdnz    00b
         blr
 
-_GLOBAL(__ide_mm_insl)
 _GLOBAL(_insl_ns)
         cmpwi   0,r5,0
         mtctr   r5
@@ -918,7 +831,6 @@ _GLOBAL(_insl_ns)
         bdnz    00b
         blr
 
-_GLOBAL(__ide_mm_outsl)
 _GLOBAL(_outsl_ns)
         cmpwi   0,r5,0
         mtctr   r5
diff --git a/arch/ppc/kernel/ppc_ksyms.c b/arch/ppc/kernel/ppc_ksyms.c
index d1735401384c..c8b65ca8a350 100644
--- a/arch/ppc/kernel/ppc_ksyms.c
+++ b/arch/ppc/kernel/ppc_ksyms.c
@@ -115,17 +115,8 @@ EXPORT_SYMBOL(outw);
 EXPORT_SYMBOL(outl);
 EXPORT_SYMBOL(outsl);*/
 
-EXPORT_SYMBOL(__ide_mm_insl);
-EXPORT_SYMBOL(__ide_mm_outsw);
-EXPORT_SYMBOL(__ide_mm_insw);
-EXPORT_SYMBOL(__ide_mm_outsl);
-
 EXPORT_SYMBOL(_insb);
 EXPORT_SYMBOL(_outsb);
-EXPORT_SYMBOL(_insw);
-EXPORT_SYMBOL(_outsw);
-EXPORT_SYMBOL(_insl);
-EXPORT_SYMBOL(_outsl);
 EXPORT_SYMBOL(_insw_ns);
 EXPORT_SYMBOL(_outsw_ns);
 EXPORT_SYMBOL(_insl_ns);
diff --git a/arch/ppc/kernel/setup.c b/arch/ppc/kernel/setup.c
index a74f46d9826f..5458ac5da7c3 100644
--- a/arch/ppc/kernel/setup.c
+++ b/arch/ppc/kernel/setup.c
@@ -127,11 +127,8 @@ void machine_restart(char *cmd)
         ppc_md.restart(cmd);
 }
 
-void machine_power_off(void)
+static void ppc_generic_power_off(void)
 {
-#ifdef CONFIG_NVRAM
-        nvram_sync();
-#endif
         ppc_md.power_off();
 }
 
@@ -143,7 +140,17 @@ void machine_halt(void)
         ppc_md.halt();
 }
 
-void (*pm_power_off)(void) = machine_power_off;
+void (*pm_power_off)(void) = ppc_generic_power_off;
+
+void machine_power_off(void)
+{
+#ifdef CONFIG_NVRAM
+        nvram_sync();
+#endif
+        if (pm_power_off)
+                pm_power_off();
+        ppc_generic_power_off();
+}
 
 #ifdef CONFIG_TAU
 extern u32 cpu_temp(unsigned long cpu);
diff --git a/arch/ppc/platforms/85xx/sbc8560.h b/arch/ppc/platforms/85xx/sbc8560.h
index c7d61cf3a449..e5e156f60100 100644
--- a/arch/ppc/platforms/85xx/sbc8560.h
+++ b/arch/ppc/platforms/85xx/sbc8560.h
@@ -14,6 +14,7 @@
 #define __MACH_SBC8560_H__
  
 #include <platforms/85xx/sbc85xx.h>
+#include <asm/irq.h>
 
 #define CPM_MAP_ADDR    (CCSRBAR + MPC85xx_CPM_OFFSET)
  
diff --git a/arch/ppc/platforms/85xx/sbc85xx.h b/arch/ppc/platforms/85xx/sbc85xx.h
index 21ea7a55639b..51df4dc04e22 100644
--- a/arch/ppc/platforms/85xx/sbc85xx.h
+++ b/arch/ppc/platforms/85xx/sbc85xx.h
@@ -49,4 +49,22 @@ extern void sbc8560_init_IRQ(void) __init;
 
 #define MPC85XX_PCI1_IO_SIZE    0x01000000
 
+/* FCC1 Clock Source Configuration.  These can be
+ * redefined in the board specific file.
+ *    Can only choose from CLK9-12 */
+#define F1_RXCLK       12
+#define F1_TXCLK       11
+
+/* FCC2 Clock Source Configuration.  These can be
+ * redefined in the board specific file.
+ *    Can only choose from CLK13-16 */
+#define F2_RXCLK       13
+#define F2_TXCLK       14
+
+/* FCC3 Clock Source Configuration.  These can be
+ * redefined in the board specific file.
+ *    Can only choose from CLK13-16 */
+#define F3_RXCLK       15
+#define F3_TXCLK       16
+
 #endif /* __PLATFORMS_85XX_SBC85XX_H__ */
diff --git a/arch/ppc/syslib/m8260_pci_erratum9.c b/arch/ppc/syslib/m8260_pci_erratum9.c
index 974581ea4849..5475709ce07b 100644
--- a/arch/ppc/syslib/m8260_pci_erratum9.c
+++ b/arch/ppc/syslib/m8260_pci_erratum9.c
@@ -339,20 +339,6 @@ void insl(unsigned port, void *buf, int nl)
         idma_pci9_read((u8 *)buf, (u8 *)addr, nl*sizeof(u32), sizeof(u32), 0);
 }
 
-void insw_ns(unsigned port, void *buf, int ns)
-{
-        u8 *addr = (u8 *)(port + _IO_BASE);
-
-        idma_pci9_read((u8 *)buf, (u8 *)addr, ns*sizeof(u16), sizeof(u16), 0);
-}
-
-void insl_ns(unsigned port, void *buf, int nl)
-{
-        u8 *addr = (u8 *)(port + _IO_BASE);
-
-        idma_pci9_read((u8 *)buf, (u8 *)addr, nl*sizeof(u32), sizeof(u32), 0);
-}
-
 void *memcpy_fromio(void *dest, unsigned long src, size_t count)
 {
         unsigned long pa = iopa((unsigned long) src);
@@ -373,8 +359,6 @@ EXPORT_SYMBOL(inl);
 EXPORT_SYMBOL(insb);
 EXPORT_SYMBOL(insw);
 EXPORT_SYMBOL(insl);
-EXPORT_SYMBOL(insw_ns);
-EXPORT_SYMBOL(insl_ns);
 EXPORT_SYMBOL(memcpy_fromio);
 
 #endif  /* ifdef CONFIG_8260_PCI9 */
diff --git a/arch/ppc/xmon/start.c b/arch/ppc/xmon/start.c
index f7e92986952a..d74a883e5bde 100644
--- a/arch/ppc/xmon/start.c
+++ b/arch/ppc/xmon/start.c
@@ -15,6 +15,7 @@
 #include <asm/processor.h>
 #include <asm/delay.h>
 #include <asm/btext.h>
+#include <asm/ibm4xx.h>
 
 static volatile unsigned char *sccc, *sccd;
 unsigned int TXRDY, RXRDY, DLAB;
@@ -57,23 +58,30 @@ static struct sysrq_key_op sysrq_xmon_op =
 void
 xmon_map_scc(void)
 {
-#ifdef CONFIG_PPC_PREP
-        volatile unsigned char *base;
-
-#elif defined(CONFIG_GEMINI)
+#if defined(CONFIG_GEMINI)
         /* should already be mapped by the kernel boot */
-        sccc = (volatile unsigned char *) 0xffeffb0d;
         sccd = (volatile unsigned char *) 0xffeffb08;
-        TXRDY = 0x20;
-        RXRDY = 1;
-        DLAB = 0x80;
 #elif defined(CONFIG_405GP)
-        sccc = (volatile unsigned char *)0xef600305;
         sccd = (volatile unsigned char *)0xef600300;
+#elif defined(CONFIG_440EP)
+        sccd = (volatile unsigned char *) ioremap(PPC440EP_UART0_ADDR, 8);
+#elif defined(CONFIG_440SP)
+        sccd = (volatile unsigned char *) ioremap64(PPC440SP_UART0_ADDR, 8);
+#elif defined(CONFIG_440SPE)
+        sccd = (volatile unsigned char *) ioremap64(PPC440SPE_UART0_ADDR, 8);
+#elif defined(CONFIG_44x)
+        /* This is the default for 44x platforms.  Any boards that have a
+           different UART address need to be put in cases before this or the
+           port will be mapped incorrectly */
+        sccd = (volatile unsigned char *) ioremap64(PPC440GP_UART0_ADDR, 8);
+#endif /* platform */
+
+#ifndef CONFIG_PPC_PREP
+        sccc = sccd + 5;
         TXRDY = 0x20;
         RXRDY = 1;
         DLAB = 0x80;
-#endif /* platform */
+#endif
 
         register_sysrq_key('x', &sysrq_xmon_op);
 }
diff --git a/arch/ppc/xmon/xmon.c b/arch/ppc/xmon/xmon.c
index 37d234f93394..b1a91744fd2d 100644
--- a/arch/ppc/xmon/xmon.c
+++ b/arch/ppc/xmon/xmon.c
@@ -153,6 +153,12 @@ static int xmon_trace[NR_CPUS];
 #define SSTEP   1               /* stepping because of 's' command */
 #define BRSTEP  2               /* stepping over breakpoint */
 
+#ifdef CONFIG_4xx
+#define MSR_SSTEP_ENABLE 0x200
+#else
+#define MSR_SSTEP_ENABLE 0x400
+#endif
+
 static struct pt_regs *xmon_regs[NR_CPUS];
 
 extern inline void sync(void)
@@ -211,6 +217,14 @@ static void get_tb(unsigned *p)
         p[1] = lo;
 }
 
+static inline void xmon_enable_sstep(struct pt_regs *regs)
+{
+        regs->msr |= MSR_SSTEP_ENABLE;
+#ifdef CONFIG_4xx
+        mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
+#endif
+}
+
 int xmon(struct pt_regs *excp)
 {
         struct pt_regs regs;
@@ -254,10 +268,10 @@ int xmon(struct pt_regs *excp)
         cmd = cmds(excp);
         if (cmd == 's') {
                 xmon_trace[smp_processor_id()] = SSTEP;
-                excp->msr |= 0x400;
+                xmon_enable_sstep(excp);
         } else if (at_breakpoint(excp->nip)) {
                 xmon_trace[smp_processor_id()] = BRSTEP;
-                excp->msr |= 0x400;
+                xmon_enable_sstep(excp);
         } else {
                 xmon_trace[smp_processor_id()] = 0;
                 insert_bpts();
@@ -298,7 +312,7 @@ xmon_bpt(struct pt_regs *regs)
                 remove_bpts();
                 excprint(regs);
                 xmon_trace[smp_processor_id()] = BRSTEP;
-                regs->msr |= 0x400;
+                xmon_enable_sstep(regs);
         } else {
                 xmon(regs);
         }
@@ -385,7 +399,7 @@ insert_bpts(void)
                 }
                 store_inst((void *) bp->address);
         }
-#if !defined(CONFIG_8xx)
+#if ! (defined(CONFIG_8xx) || defined(CONFIG_4xx))
         if (dabr.enabled)
                 set_dabr(dabr.address);
         if (iabr.enabled)
@@ -400,7 +414,7 @@ remove_bpts(void)
         struct bpt *bp;
         unsigned instr;
 
-#if !defined(CONFIG_8xx)
+#if ! (defined(CONFIG_8xx) || defined(CONFIG_4xx))
         set_dabr(0);
         set_iabr(0);
 #endif
@@ -677,7 +691,7 @@ bpt_cmds(void)
 
         cmd = inchar();
         switch (cmd) {
-#if !defined(CONFIG_8xx)
+#if ! (defined(CONFIG_8xx) || defined(CONFIG_4xx))
         case 'd':
                 mode = 7;
                 cmd = inchar();
@@ -792,7 +806,7 @@ backtrace(struct pt_regs *excp)
         for (; sp != 0; sp = stack[0]) {
                 if (mread(sp, stack, sizeof(stack)) != sizeof(stack))
                         break;
-                printf("[%.8lx] ", stack);
+                printf("[%.8lx] ", stack[0]);
                 xmon_print_symbol(stack[1], " ", "\n");
                 if (stack[1] == (unsigned) &ret_from_except
                     || stack[1] == (unsigned) &ret_from_except_full
diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 2f4f70c4dbb2..b216ca659cdf 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -460,8 +460,7 @@ config S390_HYPFS_FS
           information in an s390 hypervisor environment.
 
 config KEXEC
-        bool "kexec system call (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        bool "kexec system call"
         help
           kexec is a system call that implements the ability to shutdown your
           current kernel, and to start another kernel.  It is like a reboot
@@ -487,8 +486,22 @@ source "drivers/net/Kconfig"
 
 source "fs/Kconfig"
 
+menu "Instrumentation Support"
+
 source "arch/s390/oprofile/Kconfig"
 
+config KPROBES
+        bool "Kprobes (EXPERIMENTAL)"
+        depends on EXPERIMENTAL && MODULES
+        help
+          Kprobes allows you to trap at almost any kernel address and
+          execute a callback function.  register_kprobe() establishes
+          a probepoint and specifies the callback.  Kprobes is useful
+          for kernel debugging, non-intrusive instrumentation and testing.
+          If in doubt, say "N".
+
+endmenu
+
 source "arch/s390/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/s390/appldata/appldata.h b/arch/s390/appldata/appldata.h
index 71d65eb30650..0429481dea63 100644
--- a/arch/s390/appldata/appldata.h
+++ b/arch/s390/appldata/appldata.h
@@ -29,22 +29,6 @@
 #define CTL_APPLDATA_NET_SUM    2125
 #define CTL_APPLDATA_PROC       2126
 
-#ifndef CONFIG_64BIT
-
-#define APPLDATA_START_INTERVAL_REC 0x00        /* Function codes for */
-#define APPLDATA_STOP_REC           0x01        /* DIAG 0xDC      */
-#define APPLDATA_GEN_EVENT_RECORD   0x02
-#define APPLDATA_START_CONFIG_REC   0x03
-
-#else
-
-#define APPLDATA_START_INTERVAL_REC 0x80
-#define APPLDATA_STOP_REC           0x81
-#define APPLDATA_GEN_EVENT_RECORD   0x82
-#define APPLDATA_START_CONFIG_REC   0x83
-
-#endif /* CONFIG_64BIT */
-
 #define P_INFO(x...)    printk(KERN_INFO MY_PRINT_NAME " info: " x)
 #define P_ERROR(x...)   printk(KERN_ERR MY_PRINT_NAME " error: " x)
 #define P_WARNING(x...) printk(KERN_WARNING MY_PRINT_NAME " status: " x)
diff --git a/arch/s390/appldata/appldata_base.c b/arch/s390/appldata/appldata_base.c
index a0a94e0ef8d1..b69ed742f981 100644
--- a/arch/s390/appldata/appldata_base.c
+++ b/arch/s390/appldata/appldata_base.c
@@ -14,20 +14,20 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/smp.h>
 #include <linux/interrupt.h>
 #include <linux/proc_fs.h>
 #include <linux/page-flags.h>
 #include <linux/swap.h>
 #include <linux/pagemap.h>
 #include <linux/sysctl.h>
-#include <asm/timer.h>
-//#include <linux/kernel_stat.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/workqueue.h>
+#include <asm/appldata.h>
+#include <asm/timer.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
+#include <asm/smp.h>
 
 #include "appldata.h"
 
@@ -39,34 +39,6 @@
 
 #define TOD_MICRO       0x01000                 /* nr. of TOD clock units
                                                    for 1 microsecond */
-
-/*
- * Parameter list for DIAGNOSE X'DC'
- */
-#ifndef CONFIG_64BIT
-struct appldata_parameter_list {
-        u16 diag;               /* The DIAGNOSE code X'00DC'          */
-        u8  function;           /* The function code for the DIAGNOSE */
-        u8  parlist_length;     /* Length of the parameter list       */
-        u32 product_id_addr;    /* Address of the 16-byte product ID  */
-        u16 reserved;
-        u16 buffer_length;      /* Length of the application data buffer  */
-        u32 buffer_addr;        /* Address of the application data buffer */
-};
-#else
-struct appldata_parameter_list {
-        u16 diag;
-        u8  function;
-        u8  parlist_length;
-        u32 unused01;
-        u16 reserved;
-        u16 buffer_length;
-        u32 unused02;
-        u64 product_id_addr;
-        u64 buffer_addr;
-};
-#endif /* CONFIG_64BIT */
-
 /*
  * /proc entries (sysctl)
  */
@@ -181,46 +153,17 @@ static void appldata_work_fn(void *data)
 int appldata_diag(char record_nr, u16 function, unsigned long buffer,
                         u16 length, char *mod_lvl)
 {
-        unsigned long ry;
-        struct appldata_product_id {
-                char prod_nr[7];                        /* product nr. */
-                char prod_fn[2];                        /* product function */
-                char record_nr;                         /* record nr. */
-                char version_nr[2];                     /* version */
-                char release_nr[2];                     /* release */
-                char mod_lvl[2];                        /* modification lvl. */
-        } appldata_product_id = {
-        /* all strings are EBCDIC, record_nr is byte */
+        struct appldata_product_id id = {
                 .prod_nr    = {0xD3, 0xC9, 0xD5, 0xE4,
-                                0xE7, 0xD2, 0xD9},      /* "LINUXKR" */
-                .prod_fn    = {0xD5, 0xD3},             /* "NL" */
+                               0xE7, 0xD2, 0xD9},       /* "LINUXKR" */
+                .prod_fn    = 0xD5D3,                   /* "NL" */
                 .record_nr  = record_nr,
-                .version_nr = {0xF2, 0xF6},             /* "26" */
-                .release_nr = {0xF0, 0xF1},             /* "01" */
-                .mod_lvl    = {mod_lvl[0], mod_lvl[1]},
-        };
-        struct appldata_parameter_list appldata_parameter_list = {
-                                .diag = 0xDC,
-                                .function = function,
-                                .parlist_length =
-                                        sizeof(appldata_parameter_list),
-                                .buffer_length = length,
-                                .product_id_addr =
-                                        (unsigned long) &appldata_product_id,
-                                .buffer_addr = virt_to_phys((void *) buffer)
+                .version_nr = 0xF2F6,                   /* "26" */
+                .release_nr = 0xF0F1,                   /* "01" */
+                .mod_lvl    = (mod_lvl[0]) << 8 | mod_lvl[1],
         };
 
-        if (!MACHINE_IS_VM)
-                return -ENOSYS;
-        ry = -1;
-        asm volatile(
-                        "diag %1,%0,0xDC\n\t"
-                        : "=d" (ry)
-                        : "d" (&appldata_parameter_list),
-                          "m" (appldata_parameter_list),
-                          "m" (appldata_product_id)
-                        : "cc");
-        return (int) ry;
+        return appldata_asm(&id, function, (void *) buffer, length);
 }
 /************************ timer, work, DIAG <END> ****************************/
 
diff --git a/arch/s390/appldata/appldata_os.c b/arch/s390/appldata/appldata_os.c
index 161acc5c8a1b..76a15523ae9e 100644
--- a/arch/s390/appldata/appldata_os.c
+++ b/arch/s390/appldata/appldata_os.c
@@ -16,6 +16,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/netdevice.h>
 #include <linux/sched.h>
+#include <asm/appldata.h>
 #include <asm/smp.h>
 
 #include "appldata.h"
diff --git a/arch/s390/crypto/aes_s390.c b/arch/s390/crypto/aes_s390.c
index 5713c7e5bd16..15c9eec02928 100644
--- a/arch/s390/crypto/aes_s390.c
+++ b/arch/s390/crypto/aes_s390.c
@@ -16,9 +16,9 @@
  *
  */
 
+#include <crypto/algapi.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/crypto.h>
 #include "crypt_s390.h"
 
 #define AES_MIN_KEY_SIZE        16
@@ -34,13 +34,16 @@ int has_aes_256 = 0;
 struct s390_aes_ctx {
         u8 iv[AES_BLOCK_SIZE];
         u8 key[AES_MAX_KEY_SIZE];
+        long enc;
+        long dec;
         int key_len;
 };
 
 static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
-                       unsigned int key_len, u32 *flags)
+                       unsigned int key_len)
 {
         struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
+        u32 *flags = &tfm->crt_flags;
 
         switch (key_len) {
         case 16:
@@ -110,133 +113,206 @@ static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
         }
 }
 
-static unsigned int aes_encrypt_ecb(const struct cipher_desc *desc, u8 *out,
-                                    const u8 *in, unsigned int nbytes)
-{
-        struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
 
-        /* only use complete blocks */
-        nbytes &= ~(AES_BLOCK_SIZE - 1);
+static struct crypto_alg aes_alg = {
+        .cra_name               =       "aes",
+        .cra_driver_name        =       "aes-s390",
+        .cra_priority           =       CRYPT_S390_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       AES_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       AES_MIN_KEY_SIZE,
+                        .cia_max_keysize        =       AES_MAX_KEY_SIZE,
+                        .cia_setkey             =       aes_set_key,
+                        .cia_encrypt            =       aes_encrypt,
+                        .cia_decrypt            =       aes_decrypt,
+                }
+        }
+};
+
+static int ecb_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
+                           unsigned int key_len)
+{
+        struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
 
-        switch (sctx->key_len) {
+        switch (key_len) {
         case 16:
-                ret = crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
+                sctx->enc = KM_AES_128_ENCRYPT;
+                sctx->dec = KM_AES_128_DECRYPT;
                 break;
         case 24:
-                ret = crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
+                sctx->enc = KM_AES_192_ENCRYPT;
+                sctx->dec = KM_AES_192_DECRYPT;
                 break;
         case 32:
-                ret = crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
+                sctx->enc = KM_AES_256_ENCRYPT;
+                sctx->dec = KM_AES_256_DECRYPT;
                 break;
         }
-        return nbytes;
+
+        return aes_set_key(tfm, in_key, key_len);
 }
 
-static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out,
-                                    const u8 *in, unsigned int nbytes)
+static int ecb_aes_crypt(struct blkcipher_desc *desc, long func, void *param,
+                         struct blkcipher_walk *walk)
 {
-        struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        int ret = blkcipher_walk_virt(desc, walk);
+        unsigned int nbytes;
 
-        /* only use complete blocks */
-        nbytes &= ~(AES_BLOCK_SIZE - 1);
+        while ((nbytes = walk->nbytes)) {
+                /* only use complete blocks */
+                unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
+                u8 *out = walk->dst.virt.addr;
+                u8 *in = walk->src.virt.addr;
 
-        switch (sctx->key_len) {
-        case 16:
-                ret = crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
-                break;
-        case 24:
-                ret = crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
-                break;
-        case 32:
-                ret = crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
-                break;
+                ret = crypt_s390_km(func, param, out, in, n);
+                BUG_ON((ret < 0) || (ret != n));
+
+                nbytes &= AES_BLOCK_SIZE - 1;
+                ret = blkcipher_walk_done(desc, walk, nbytes);
         }
-        return nbytes;
+
+        return ret;
 }
 
-static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out,
-                                    const u8 *in, unsigned int nbytes)
+static int ecb_aes_encrypt(struct blkcipher_desc *desc,
+                           struct scatterlist *dst, struct scatterlist *src,
+                           unsigned int nbytes)
 {
-        struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        /* only use complete blocks */
-        nbytes &= ~(AES_BLOCK_SIZE - 1);
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return ecb_aes_crypt(desc, sctx->enc, sctx->key, &walk);
+}
 
-        memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);
-        switch (sctx->key_len) {
+static int ecb_aes_decrypt(struct blkcipher_desc *desc,
+                           struct scatterlist *dst, struct scatterlist *src,
+                           unsigned int nbytes)
+{
+        struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
+
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return ecb_aes_crypt(desc, sctx->dec, sctx->key, &walk);
+}
+
+static struct crypto_alg ecb_aes_alg = {
+        .cra_name               =       "ecb(aes)",
+        .cra_driver_name        =       "ecb-aes-s390",
+        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
+        .cra_blocksize          =       AES_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
+        .cra_type               =       &crypto_blkcipher_type,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(ecb_aes_alg.cra_list),
+        .cra_u                  =       {
+                .blkcipher = {
+                        .min_keysize            =       AES_MIN_KEY_SIZE,
+                        .max_keysize            =       AES_MAX_KEY_SIZE,
+                        .setkey                 =       ecb_aes_set_key,
+                        .encrypt                =       ecb_aes_encrypt,
+                        .decrypt                =       ecb_aes_decrypt,
+                }
+        }
+};
+
+static int cbc_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
+                           unsigned int key_len)
+{
+        struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm);
+
+        switch (key_len) {
         case 16:
-                ret = crypt_s390_kmc(KMC_AES_128_ENCRYPT, &sctx->iv, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
+                sctx->enc = KMC_AES_128_ENCRYPT;
+                sctx->dec = KMC_AES_128_DECRYPT;
                 break;
         case 24:
-                ret = crypt_s390_kmc(KMC_AES_192_ENCRYPT, &sctx->iv, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
+                sctx->enc = KMC_AES_192_ENCRYPT;
+                sctx->dec = KMC_AES_192_DECRYPT;
                 break;
         case 32:
-                ret = crypt_s390_kmc(KMC_AES_256_ENCRYPT, &sctx->iv, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
+                sctx->enc = KMC_AES_256_ENCRYPT;
+                sctx->dec = KMC_AES_256_DECRYPT;
                 break;
         }
-        memcpy(desc->info, &sctx->iv, AES_BLOCK_SIZE);
 
-        return nbytes;
+        return aes_set_key(tfm, in_key, key_len);
 }
 
-static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out,
-                                    const u8 *in, unsigned int nbytes)
+static int cbc_aes_crypt(struct blkcipher_desc *desc, long func, void *param,
+                         struct blkcipher_walk *walk)
 {
-        struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        int ret = blkcipher_walk_virt(desc, walk);
+        unsigned int nbytes = walk->nbytes;
 
-        /* only use complete blocks */
-        nbytes &= ~(AES_BLOCK_SIZE - 1);
+        if (!nbytes)
+                goto out;
 
-        memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);
-        switch (sctx->key_len) {
-        case 16:
-                ret = crypt_s390_kmc(KMC_AES_128_DECRYPT, &sctx->iv, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
-                break;
-        case 24:
-                ret = crypt_s390_kmc(KMC_AES_192_DECRYPT, &sctx->iv, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
-                break;
-        case 32:
-                ret = crypt_s390_kmc(KMC_AES_256_DECRYPT, &sctx->iv, out, in, nbytes);
-                BUG_ON((ret < 0) || (ret != nbytes));
-                break;
-        }
-        return nbytes;
+        memcpy(param, walk->iv, AES_BLOCK_SIZE);
+        do {
+                /* only use complete blocks */
+                unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
+                u8 *out = walk->dst.virt.addr;
+                u8 *in = walk->src.virt.addr;
+
+                ret = crypt_s390_kmc(func, param, out, in, n);
+                BUG_ON((ret < 0) || (ret != n));
+
+                nbytes &= AES_BLOCK_SIZE - 1;
+                ret = blkcipher_walk_done(desc, walk, nbytes);
+        } while ((nbytes = walk->nbytes));
+        memcpy(walk->iv, param, AES_BLOCK_SIZE);
+
+out:
+        return ret;
 }
 
+static int cbc_aes_encrypt(struct blkcipher_desc *desc,
+                           struct scatterlist *dst, struct scatterlist *src,
+                           unsigned int nbytes)
+{
+        struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-static struct crypto_alg aes_alg = {
-        .cra_name               =       "aes",
-        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return cbc_aes_crypt(desc, sctx->enc, sctx->iv, &walk);
+}
+
+static int cbc_aes_decrypt(struct blkcipher_desc *desc,
+                           struct scatterlist *dst, struct scatterlist *src,
+                           unsigned int nbytes)
+{
+        struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
+
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return cbc_aes_crypt(desc, sctx->dec, sctx->iv, &walk);
+}
+
+static struct crypto_alg cbc_aes_alg = {
+        .cra_name               =       "cbc(aes)",
+        .cra_driver_name        =       "cbc-aes-s390",
+        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
         .cra_blocksize          =       AES_BLOCK_SIZE,
         .cra_ctxsize            =       sizeof(struct s390_aes_ctx),
+        .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
-        .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
+        .cra_list               =       LIST_HEAD_INIT(cbc_aes_alg.cra_list),
         .cra_u                  =       {
-                .cipher = {
-                        .cia_min_keysize        =       AES_MIN_KEY_SIZE,
-                        .cia_max_keysize        =       AES_MAX_KEY_SIZE,
-                        .cia_setkey             =       aes_set_key,
-                        .cia_encrypt            =       aes_encrypt,
-                        .cia_decrypt            =       aes_decrypt,
-                        .cia_encrypt_ecb        =       aes_encrypt_ecb,
-                        .cia_decrypt_ecb        =       aes_decrypt_ecb,
-                        .cia_encrypt_cbc        =       aes_encrypt_cbc,
-                        .cia_decrypt_cbc        =       aes_decrypt_cbc,
+                .blkcipher = {
+                        .min_keysize            =       AES_MIN_KEY_SIZE,
+                        .max_keysize            =       AES_MAX_KEY_SIZE,
+                        .ivsize                 =       AES_BLOCK_SIZE,
+                        .setkey                 =       cbc_aes_set_key,
+                        .encrypt                =       cbc_aes_encrypt,
+                        .decrypt                =       cbc_aes_decrypt,
                 }
         }
 };
@@ -256,13 +332,40 @@ static int __init aes_init(void)
                 return -ENOSYS;
 
         ret = crypto_register_alg(&aes_alg);
-        if (ret != 0)
-                printk(KERN_INFO "crypt_s390: aes_s390 couldn't be loaded.\n");
+        if (ret != 0) {
+                printk(KERN_INFO "crypt_s390: aes-s390 couldn't be loaded.\n");
+                goto aes_err;
+        }
+
+        ret = crypto_register_alg(&ecb_aes_alg);
+        if (ret != 0) {
+                printk(KERN_INFO
+                       "crypt_s390: ecb-aes-s390 couldn't be loaded.\n");
+                goto ecb_aes_err;
+        }
+
+        ret = crypto_register_alg(&cbc_aes_alg);
+        if (ret != 0) {
+                printk(KERN_INFO
+                       "crypt_s390: cbc-aes-s390 couldn't be loaded.\n");
+                goto cbc_aes_err;
+        }
+
+out:
         return ret;
+
+cbc_aes_err:
+        crypto_unregister_alg(&ecb_aes_alg);
+ecb_aes_err:
+        crypto_unregister_alg(&aes_alg);
+aes_err:
+        goto out;
 }
 
 static void __exit aes_fini(void)
 {
+        crypto_unregister_alg(&cbc_aes_alg);
+        crypto_unregister_alg(&ecb_aes_alg);
         crypto_unregister_alg(&aes_alg);
 }
 
diff --git a/arch/s390/crypto/crypt_s390.h b/arch/s390/crypto/crypt_s390.h
index d1c259a7fe33..efd836c2e4a6 100644
--- a/arch/s390/crypto/crypt_s390.h
+++ b/arch/s390/crypto/crypt_s390.h
@@ -20,6 +20,9 @@
 #define CRYPT_S390_OP_MASK 0xFF00
 #define CRYPT_S390_FUNC_MASK 0x00FF
 
+#define CRYPT_S390_PRIORITY 300
+#define CRYPT_S390_COMPOSITE_PRIORITY 400
+
 /* s930 cryptographic operations */
 enum crypt_s390_operations {
         CRYPT_S390_KM   = 0x0100,
diff --git a/arch/s390/crypto/des_s390.c b/arch/s390/crypto/des_s390.c
index b3f7496a79b4..2aba04852fe3 100644
--- a/arch/s390/crypto/des_s390.c
+++ b/arch/s390/crypto/des_s390.c
@@ -13,9 +13,10 @@
  * (at your option) any later version.
  *
  */
+
+#include <crypto/algapi.h>
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/crypto.h>
 
 #include "crypt_s390.h"
 #include "crypto_des.h"
@@ -45,9 +46,10 @@ struct crypt_s390_des3_192_ctx {
 };
 
 static int des_setkey(struct crypto_tfm *tfm, const u8 *key,
-                      unsigned int keylen, u32 *flags)
+                      unsigned int keylen)
 {
         struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm);
+        u32 *flags = &tfm->crt_flags;
         int ret;
 
         /* test if key is valid (not a weak key) */
@@ -71,85 +73,159 @@ static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
         crypt_s390_km(KM_DEA_DECRYPT, dctx->key, out, in, DES_BLOCK_SIZE);
 }
 
-static unsigned int des_encrypt_ecb(const struct cipher_desc *desc, u8 *out,
-                                    const u8 *in, unsigned int nbytes)
+static struct crypto_alg des_alg = {
+        .cra_name               =       "des",
+        .cra_driver_name        =       "des-s390",
+        .cra_priority           =       CRYPT_S390_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       DES_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct crypt_s390_des_ctx),
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(des_alg.cra_list),
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       DES_KEY_SIZE,
+                        .cia_max_keysize        =       DES_KEY_SIZE,
+                        .cia_setkey             =       des_setkey,
+                        .cia_encrypt            =       des_encrypt,
+                        .cia_decrypt            =       des_decrypt,
+                }
+        }
+};
+
+static int ecb_desall_crypt(struct blkcipher_desc *desc, long func,
+                            void *param, struct blkcipher_walk *walk)
 {
-        struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        int ret = blkcipher_walk_virt(desc, walk);
+        unsigned int nbytes;
+
+        while ((nbytes = walk->nbytes)) {
+                /* only use complete blocks */
+                unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
+                u8 *out = walk->dst.virt.addr;
+                u8 *in = walk->src.virt.addr;
 
-        /* only use complete blocks */
-        nbytes &= ~(DES_BLOCK_SIZE - 1);
-        ret = crypt_s390_km(KM_DEA_ENCRYPT, sctx->key, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+                ret = crypt_s390_km(func, param, out, in, n);
+                BUG_ON((ret < 0) || (ret != n));
 
-        return nbytes;
+                nbytes &= DES_BLOCK_SIZE - 1;
+                ret = blkcipher_walk_done(desc, walk, nbytes);
+        }
+
+        return ret;
 }
 
-static unsigned int des_decrypt_ecb(const struct cipher_desc *desc, u8 *out,
-                                    const u8 *in, unsigned int nbytes)
+static int cbc_desall_crypt(struct blkcipher_desc *desc, long func,
+                            void *param, struct blkcipher_walk *walk)
 {
-        struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        int ret = blkcipher_walk_virt(desc, walk);
+        unsigned int nbytes = walk->nbytes;
+
+        if (!nbytes)
+                goto out;
+
+        memcpy(param, walk->iv, DES_BLOCK_SIZE);
+        do {
+                /* only use complete blocks */
+                unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
+                u8 *out = walk->dst.virt.addr;
+                u8 *in = walk->src.virt.addr;
 
-        /* only use complete blocks */
-        nbytes &= ~(DES_BLOCK_SIZE - 1);
-        ret = crypt_s390_km(KM_DEA_DECRYPT, sctx->key, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+                ret = crypt_s390_kmc(func, param, out, in, n);
+                BUG_ON((ret < 0) || (ret != n));
 
-        return nbytes;
+                nbytes &= DES_BLOCK_SIZE - 1;
+                ret = blkcipher_walk_done(desc, walk, nbytes);
+        } while ((nbytes = walk->nbytes));
+        memcpy(walk->iv, param, DES_BLOCK_SIZE);
+
+out:
+        return ret;
 }
 
-static unsigned int des_encrypt_cbc(const struct cipher_desc *desc, u8 *out,
-                                    const u8 *in, unsigned int nbytes)
+static int ecb_des_encrypt(struct blkcipher_desc *desc,
+                           struct scatterlist *dst, struct scatterlist *src,
+                           unsigned int nbytes)
 {
-        struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        /* only use complete blocks */
-        nbytes &= ~(DES_BLOCK_SIZE - 1);
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return ecb_desall_crypt(desc, KM_DEA_ENCRYPT, sctx->key, &walk);
+}
 
-        memcpy(sctx->iv, desc->info, DES_BLOCK_SIZE);
-        ret = crypt_s390_kmc(KMC_DEA_ENCRYPT, &sctx->iv, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+static int ecb_des_decrypt(struct blkcipher_desc *desc,
+                           struct scatterlist *dst, struct scatterlist *src,
+                           unsigned int nbytes)
+{
+        struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        memcpy(desc->info, sctx->iv, DES_BLOCK_SIZE);
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return ecb_desall_crypt(desc, KM_DEA_DECRYPT, sctx->key, &walk);
 }
 
-static unsigned int des_decrypt_cbc(const struct cipher_desc *desc, u8 *out,
-                                    const u8 *in, unsigned int nbytes)
+static struct crypto_alg ecb_des_alg = {
+        .cra_name               =       "ecb(des)",
+        .cra_driver_name        =       "ecb-des-s390",
+        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
+        .cra_blocksize          =       DES_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct crypt_s390_des_ctx),
+        .cra_type               =       &crypto_blkcipher_type,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(ecb_des_alg.cra_list),
+        .cra_u                  =       {
+                .blkcipher = {
+                        .min_keysize            =       DES_KEY_SIZE,
+                        .max_keysize            =       DES_KEY_SIZE,
+                        .setkey                 =       des_setkey,
+                        .encrypt                =       ecb_des_encrypt,
+                        .decrypt                =       ecb_des_decrypt,
+                }
+        }
+};
+
+static int cbc_des_encrypt(struct blkcipher_desc *desc,
+                           struct scatterlist *dst, struct scatterlist *src,
+                           unsigned int nbytes)
 {
-        struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        /* only use complete blocks */
-        nbytes &= ~(DES_BLOCK_SIZE - 1);
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return cbc_desall_crypt(desc, KMC_DEA_ENCRYPT, sctx->iv, &walk);
+}
 
-        memcpy(&sctx->iv, desc->info, DES_BLOCK_SIZE);
-        ret = crypt_s390_kmc(KMC_DEA_DECRYPT, &sctx->iv, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+static int cbc_des_decrypt(struct blkcipher_desc *desc,
+                           struct scatterlist *dst, struct scatterlist *src,
+                           unsigned int nbytes)
+{
+        struct crypt_s390_des_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return cbc_desall_crypt(desc, KMC_DEA_DECRYPT, sctx->iv, &walk);
 }
 
-static struct crypto_alg des_alg = {
-        .cra_name               =       "des",
-        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+static struct crypto_alg cbc_des_alg = {
+        .cra_name               =       "cbc(des)",
+        .cra_driver_name        =       "cbc-des-s390",
+        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
         .cra_blocksize          =       DES_BLOCK_SIZE,
         .cra_ctxsize            =       sizeof(struct crypt_s390_des_ctx),
+        .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
-        .cra_list               =       LIST_HEAD_INIT(des_alg.cra_list),
+        .cra_list               =       LIST_HEAD_INIT(cbc_des_alg.cra_list),
         .cra_u                  =       {
-                .cipher = {
-                        .cia_min_keysize        =       DES_KEY_SIZE,
-                        .cia_max_keysize        =       DES_KEY_SIZE,
-                        .cia_setkey             =       des_setkey,
-                        .cia_encrypt            =       des_encrypt,
-                        .cia_decrypt            =       des_decrypt,
-                        .cia_encrypt_ecb        =       des_encrypt_ecb,
-                        .cia_decrypt_ecb        =       des_decrypt_ecb,
-                        .cia_encrypt_cbc        =       des_encrypt_cbc,
-                        .cia_decrypt_cbc        =       des_decrypt_cbc,
+                .blkcipher = {
+                        .min_keysize            =       DES_KEY_SIZE,
+                        .max_keysize            =       DES_KEY_SIZE,
+                        .ivsize                 =       DES_BLOCK_SIZE,
+                        .setkey                 =       des_setkey,
+                        .encrypt                =       cbc_des_encrypt,
+                        .decrypt                =       cbc_des_decrypt,
                 }
         }
 };
@@ -167,11 +243,12 @@ static struct crypto_alg des_alg = {
  *
  */
 static int des3_128_setkey(struct crypto_tfm *tfm, const u8 *key,
-                           unsigned int keylen, u32 *flags)
+                           unsigned int keylen)
 {
         int i, ret;
         struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm);
-        const u8* temp_key = key;
+        const u8 *temp_key = key;
+        u32 *flags = &tfm->crt_flags;
 
         if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE))) {
                 *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
@@ -202,89 +279,111 @@ static void des3_128_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
                       DES3_128_BLOCK_SIZE);
 }
 
-static unsigned int des3_128_encrypt_ecb(const struct cipher_desc *desc,
-                                         u8 *out, const u8 *in,
-                                         unsigned int nbytes)
-{
-        struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+static struct crypto_alg des3_128_alg = {
+        .cra_name               =       "des3_ede128",
+        .cra_driver_name        =       "des3_ede128-s390",
+        .cra_priority           =       CRYPT_S390_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       DES3_128_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(des3_128_alg.cra_list),
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       DES3_128_KEY_SIZE,
+                        .cia_max_keysize        =       DES3_128_KEY_SIZE,
+                        .cia_setkey             =       des3_128_setkey,
+                        .cia_encrypt            =       des3_128_encrypt,
+                        .cia_decrypt            =       des3_128_decrypt,
+                }
+        }
+};
 
-        /* only use complete blocks */
-        nbytes &= ~(DES3_128_BLOCK_SIZE - 1);
-        ret = crypt_s390_km(KM_TDEA_128_ENCRYPT, sctx->key, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+static int ecb_des3_128_encrypt(struct blkcipher_desc *desc,
+                                struct scatterlist *dst,
+                                struct scatterlist *src, unsigned int nbytes)
+{
+        struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return ecb_desall_crypt(desc, KM_TDEA_128_ENCRYPT, sctx->key, &walk);
 }
 
-static unsigned int des3_128_decrypt_ecb(const struct cipher_desc *desc,
-                                         u8 *out, const u8 *in,
-                                         unsigned int nbytes)
+static int ecb_des3_128_decrypt(struct blkcipher_desc *desc,
+                                struct scatterlist *dst,
+                                struct scatterlist *src, unsigned int nbytes)
 {
-        struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        /* only use complete blocks */
-        nbytes &= ~(DES3_128_BLOCK_SIZE - 1);
-        ret = crypt_s390_km(KM_TDEA_128_DECRYPT, sctx->key, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
-
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return ecb_desall_crypt(desc, KM_TDEA_128_DECRYPT, sctx->key, &walk);
 }
 
-static unsigned int des3_128_encrypt_cbc(const struct cipher_desc *desc,
-                                         u8 *out, const u8 *in,
-                                         unsigned int nbytes)
-{
-        struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
-
-        /* only use complete blocks */
-        nbytes &= ~(DES3_128_BLOCK_SIZE - 1);
+static struct crypto_alg ecb_des3_128_alg = {
+        .cra_name               =       "ecb(des3_ede128)",
+        .cra_driver_name        =       "ecb-des3_ede128-s390",
+        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
+        .cra_blocksize          =       DES3_128_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
+        .cra_type               =       &crypto_blkcipher_type,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(
+                                                ecb_des3_128_alg.cra_list),
+        .cra_u                  =       {
+                .blkcipher = {
+                        .min_keysize            =       DES3_128_KEY_SIZE,
+                        .max_keysize            =       DES3_128_KEY_SIZE,
+                        .setkey                 =       des3_128_setkey,
+                        .encrypt                =       ecb_des3_128_encrypt,
+                        .decrypt                =       ecb_des3_128_decrypt,
+                }
+        }
+};
 
-        memcpy(sctx->iv, desc->info, DES3_128_BLOCK_SIZE);
-        ret = crypt_s390_kmc(KMC_TDEA_128_ENCRYPT, &sctx->iv, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+static int cbc_des3_128_encrypt(struct blkcipher_desc *desc,
+                                struct scatterlist *dst,
+                                struct scatterlist *src, unsigned int nbytes)
+{
+        struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        memcpy(desc->info, sctx->iv, DES3_128_BLOCK_SIZE);
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return cbc_desall_crypt(desc, KMC_TDEA_128_ENCRYPT, sctx->iv, &walk);
 }
 
-static unsigned int des3_128_decrypt_cbc(const struct cipher_desc *desc,
-                                         u8 *out, const u8 *in,
-                                         unsigned int nbytes)
+static int cbc_des3_128_decrypt(struct blkcipher_desc *desc,
+                                struct scatterlist *dst,
+                                struct scatterlist *src, unsigned int nbytes)
 {
-        struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
-
-        /* only use complete blocks */
-        nbytes &= ~(DES3_128_BLOCK_SIZE - 1);
-
-        memcpy(&sctx->iv, desc->info, DES3_128_BLOCK_SIZE);
-        ret = crypt_s390_kmc(KMC_TDEA_128_DECRYPT, &sctx->iv, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+        struct crypt_s390_des3_128_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return cbc_desall_crypt(desc, KMC_TDEA_128_DECRYPT, sctx->iv, &walk);
 }
 
-static struct crypto_alg des3_128_alg = {
-        .cra_name               =       "des3_ede128",
-        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+static struct crypto_alg cbc_des3_128_alg = {
+        .cra_name               =       "cbc(des3_ede128)",
+        .cra_driver_name        =       "cbc-des3_ede128-s390",
+        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
         .cra_blocksize          =       DES3_128_BLOCK_SIZE,
         .cra_ctxsize            =       sizeof(struct crypt_s390_des3_128_ctx),
+        .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
-        .cra_list               =       LIST_HEAD_INIT(des3_128_alg.cra_list),
+        .cra_list               =       LIST_HEAD_INIT(
+                                                cbc_des3_128_alg.cra_list),
         .cra_u                  =       {
-                .cipher = {
-                        .cia_min_keysize        =       DES3_128_KEY_SIZE,
-                        .cia_max_keysize        =       DES3_128_KEY_SIZE,
-                        .cia_setkey             =       des3_128_setkey,
-                        .cia_encrypt            =       des3_128_encrypt,
-                        .cia_decrypt            =       des3_128_decrypt,
-                        .cia_encrypt_ecb        =       des3_128_encrypt_ecb,
-                        .cia_decrypt_ecb        =       des3_128_decrypt_ecb,
-                        .cia_encrypt_cbc        =       des3_128_encrypt_cbc,
-                        .cia_decrypt_cbc        =       des3_128_decrypt_cbc,
+                .blkcipher = {
+                        .min_keysize            =       DES3_128_KEY_SIZE,
+                        .max_keysize            =       DES3_128_KEY_SIZE,
+                        .ivsize                 =       DES3_128_BLOCK_SIZE,
+                        .setkey                 =       des3_128_setkey,
+                        .encrypt                =       cbc_des3_128_encrypt,
+                        .decrypt                =       cbc_des3_128_decrypt,
                 }
         }
 };
@@ -303,11 +402,12 @@ static struct crypto_alg des3_128_alg = {
  *
  */
 static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key,
-                           unsigned int keylen, u32 *flags)
+                           unsigned int keylen)
 {
         int i, ret;
         struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm);
-        const u8* temp_key = key;
+        const u8 *temp_key = key;
+        u32 *flags = &tfm->crt_flags;
 
         if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
             memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2],
@@ -341,89 +441,111 @@ static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
                       DES3_192_BLOCK_SIZE);
 }
 
-static unsigned int des3_192_encrypt_ecb(const struct cipher_desc *desc,
-                                         u8 *out, const u8 *in,
-                                         unsigned int nbytes)
-{
-        struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+static struct crypto_alg des3_192_alg = {
+        .cra_name               =       "des3_ede",
+        .cra_driver_name        =       "des3_ede-s390",
+        .cra_priority           =       CRYPT_S390_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       DES3_192_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(des3_192_alg.cra_list),
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       DES3_192_KEY_SIZE,
+                        .cia_max_keysize        =       DES3_192_KEY_SIZE,
+                        .cia_setkey             =       des3_192_setkey,
+                        .cia_encrypt            =       des3_192_encrypt,
+                        .cia_decrypt            =       des3_192_decrypt,
+                }
+        }
+};
 
-        /* only use complete blocks */
-        nbytes &= ~(DES3_192_BLOCK_SIZE - 1);
-        ret = crypt_s390_km(KM_TDEA_192_ENCRYPT, sctx->key, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+static int ecb_des3_192_encrypt(struct blkcipher_desc *desc,
+                                struct scatterlist *dst,
+                                struct scatterlist *src, unsigned int nbytes)
+{
+        struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return ecb_desall_crypt(desc, KM_TDEA_192_ENCRYPT, sctx->key, &walk);
 }
 
-static unsigned int des3_192_decrypt_ecb(const struct cipher_desc *desc,
-                                         u8 *out, const u8 *in,
-                                         unsigned int nbytes)
+static int ecb_des3_192_decrypt(struct blkcipher_desc *desc,
+                                struct scatterlist *dst,
+                                struct scatterlist *src, unsigned int nbytes)
 {
-        struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
-
-        /* only use complete blocks */
-        nbytes &= ~(DES3_192_BLOCK_SIZE - 1);
-        ret = crypt_s390_km(KM_TDEA_192_DECRYPT, sctx->key, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+        struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return ecb_desall_crypt(desc, KM_TDEA_192_DECRYPT, sctx->key, &walk);
 }
 
-static unsigned int des3_192_encrypt_cbc(const struct cipher_desc *desc,
-                                         u8 *out, const u8 *in,
-                                         unsigned int nbytes)
-{
-        struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
-
-        /* only use complete blocks */
-        nbytes &= ~(DES3_192_BLOCK_SIZE - 1);
+static struct crypto_alg ecb_des3_192_alg = {
+        .cra_name               =       "ecb(des3_ede)",
+        .cra_driver_name        =       "ecb-des3_ede-s390",
+        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
+        .cra_blocksize          =       DES3_192_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
+        .cra_type               =       &crypto_blkcipher_type,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(
+                                                ecb_des3_192_alg.cra_list),
+        .cra_u                  =       {
+                .blkcipher = {
+                        .min_keysize            =       DES3_192_KEY_SIZE,
+                        .max_keysize            =       DES3_192_KEY_SIZE,
+                        .setkey                 =       des3_192_setkey,
+                        .encrypt                =       ecb_des3_192_encrypt,
+                        .decrypt                =       ecb_des3_192_decrypt,
+                }
+        }
+};
 
-        memcpy(sctx->iv, desc->info, DES3_192_BLOCK_SIZE);
-        ret = crypt_s390_kmc(KMC_TDEA_192_ENCRYPT, &sctx->iv, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
+static int cbc_des3_192_encrypt(struct blkcipher_desc *desc,
+                                struct scatterlist *dst,
+                                struct scatterlist *src, unsigned int nbytes)
+{
+        struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        memcpy(desc->info, sctx->iv, DES3_192_BLOCK_SIZE);
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return cbc_desall_crypt(desc, KMC_TDEA_192_ENCRYPT, sctx->iv, &walk);
 }
 
-static unsigned int des3_192_decrypt_cbc(const struct cipher_desc *desc,
-                                         u8 *out, const u8 *in,
-                                         unsigned int nbytes)
+static int cbc_des3_192_decrypt(struct blkcipher_desc *desc,
+                                struct scatterlist *dst,
+                                struct scatterlist *src, unsigned int nbytes)
 {
-        struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);
-        int ret;
+        struct crypt_s390_des3_192_ctx *sctx = crypto_blkcipher_ctx(desc->tfm);
+        struct blkcipher_walk walk;
 
-        /* only use complete blocks */
-        nbytes &= ~(DES3_192_BLOCK_SIZE - 1);
-
-        memcpy(&sctx->iv, desc->info, DES3_192_BLOCK_SIZE);
-        ret = crypt_s390_kmc(KMC_TDEA_192_DECRYPT, &sctx->iv, out, in, nbytes);
-        BUG_ON((ret < 0) || (ret != nbytes));
-
-        return nbytes;
+        blkcipher_walk_init(&walk, dst, src, nbytes);
+        return cbc_desall_crypt(desc, KMC_TDEA_192_DECRYPT, sctx->iv, &walk);
 }
 
-static struct crypto_alg des3_192_alg = {
-        .cra_name               =       "des3_ede",
-        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+static struct crypto_alg cbc_des3_192_alg = {
+        .cra_name               =       "cbc(des3_ede)",
+        .cra_driver_name        =       "cbc-des3_ede-s390",
+        .cra_priority           =       CRYPT_S390_COMPOSITE_PRIORITY,
+        .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
         .cra_blocksize          =       DES3_192_BLOCK_SIZE,
         .cra_ctxsize            =       sizeof(struct crypt_s390_des3_192_ctx),
+        .cra_type               =       &crypto_blkcipher_type,
         .cra_module             =       THIS_MODULE,
-        .cra_list               =       LIST_HEAD_INIT(des3_192_alg.cra_list),
+        .cra_list               =       LIST_HEAD_INIT(
+                                                cbc_des3_192_alg.cra_list),
         .cra_u                  =       {
-                .cipher = {
-                        .cia_min_keysize        =       DES3_192_KEY_SIZE,
-                        .cia_max_keysize        =       DES3_192_KEY_SIZE,
-                        .cia_setkey             =       des3_192_setkey,
-                        .cia_encrypt            =       des3_192_encrypt,
-                        .cia_decrypt            =       des3_192_decrypt,
-                        .cia_encrypt_ecb        =       des3_192_encrypt_ecb,
-                        .cia_decrypt_ecb        =       des3_192_decrypt_ecb,
-                        .cia_encrypt_cbc        =       des3_192_encrypt_cbc,
-                        .cia_decrypt_cbc        =       des3_192_decrypt_cbc,
+                .blkcipher = {
+                        .min_keysize            =       DES3_192_KEY_SIZE,
+                        .max_keysize            =       DES3_192_KEY_SIZE,
+                        .ivsize                 =       DES3_192_BLOCK_SIZE,
+                        .setkey                 =       des3_192_setkey,
+                        .encrypt                =       cbc_des3_192_encrypt,
+                        .decrypt                =       cbc_des3_192_decrypt,
                 }
         }
 };
@@ -437,22 +559,69 @@ static int init(void)
             !crypt_s390_func_available(KM_TDEA_192_ENCRYPT))
                 return -ENOSYS;
 
-        ret |= (crypto_register_alg(&des_alg) == 0) ? 0:1;
-        ret |= (crypto_register_alg(&des3_128_alg) == 0) ? 0:2;
-        ret |= (crypto_register_alg(&des3_192_alg) == 0) ? 0:4;
-        if (ret) {
-                crypto_unregister_alg(&des3_192_alg);
-                crypto_unregister_alg(&des3_128_alg);
-                crypto_unregister_alg(&des_alg);
-                return -EEXIST;
-        }
-        return 0;
+        ret = crypto_register_alg(&des_alg);
+        if (ret)
+                goto des_err;
+        ret = crypto_register_alg(&ecb_des_alg);
+        if (ret)
+                goto ecb_des_err;
+        ret = crypto_register_alg(&cbc_des_alg);
+        if (ret)
+                goto cbc_des_err;
+
+        ret = crypto_register_alg(&des3_128_alg);
+        if (ret)
+                goto des3_128_err;
+        ret = crypto_register_alg(&ecb_des3_128_alg);
+        if (ret)
+                goto ecb_des3_128_err;
+        ret = crypto_register_alg(&cbc_des3_128_alg);
+        if (ret)
+                goto cbc_des3_128_err;
+
+        ret = crypto_register_alg(&des3_192_alg);
+        if (ret)
+                goto des3_192_err;
+        ret = crypto_register_alg(&ecb_des3_192_alg);
+        if (ret)
+                goto ecb_des3_192_err;
+        ret = crypto_register_alg(&cbc_des3_192_alg);
+        if (ret)
+                goto cbc_des3_192_err;
+
+out:
+        return ret;
+
+cbc_des3_192_err:
+        crypto_unregister_alg(&ecb_des3_192_alg);
+ecb_des3_192_err:
+        crypto_unregister_alg(&des3_192_alg);
+des3_192_err:
+        crypto_unregister_alg(&cbc_des3_128_alg);
+cbc_des3_128_err:
+        crypto_unregister_alg(&ecb_des3_128_alg);
+ecb_des3_128_err:
+        crypto_unregister_alg(&des3_128_alg);
+des3_128_err:
+        crypto_unregister_alg(&cbc_des_alg);
+cbc_des_err:
+        crypto_unregister_alg(&ecb_des_alg);
+ecb_des_err:
+        crypto_unregister_alg(&des_alg);
+des_err:
+        goto out;
 }
 
 static void __exit fini(void)
 {
+        crypto_unregister_alg(&cbc_des3_192_alg);
+        crypto_unregister_alg(&ecb_des3_192_alg);
         crypto_unregister_alg(&des3_192_alg);
+        crypto_unregister_alg(&cbc_des3_128_alg);
+        crypto_unregister_alg(&ecb_des3_128_alg);
         crypto_unregister_alg(&des3_128_alg);
+        crypto_unregister_alg(&cbc_des_alg);
+        crypto_unregister_alg(&ecb_des_alg);
         crypto_unregister_alg(&des_alg);
 }
 
diff --git a/arch/s390/crypto/sha1_s390.c b/arch/s390/crypto/sha1_s390.c
index 9d34a35b1aa5..49ca8690ee39 100644
--- a/arch/s390/crypto/sha1_s390.c
+++ b/arch/s390/crypto/sha1_s390.c
@@ -126,6 +126,8 @@ static void sha1_final(struct crypto_tfm *tfm, u8 *out)
 
 static struct crypto_alg alg = {
         .cra_name       =       "sha1",
+        .cra_driver_name =      "sha1-s390",
+        .cra_priority   =       CRYPT_S390_PRIORITY,
         .cra_flags      =       CRYPTO_ALG_TYPE_DIGEST,
         .cra_blocksize  =       SHA1_BLOCK_SIZE,
         .cra_ctxsize    =       sizeof(struct crypt_s390_sha1_ctx),
diff --git a/arch/s390/crypto/sha256_s390.c b/arch/s390/crypto/sha256_s390.c
index f573df30f31d..8e4e67503fe7 100644
--- a/arch/s390/crypto/sha256_s390.c
+++ b/arch/s390/crypto/sha256_s390.c
@@ -127,6 +127,8 @@ static void sha256_final(struct crypto_tfm *tfm, u8 *out)
 
 static struct crypto_alg alg = {
         .cra_name       =       "sha256",
+        .cra_driver_name =      "sha256-s390",
+        .cra_priority   =       CRYPT_S390_PRIORITY,
         .cra_flags      =       CRYPTO_ALG_TYPE_DIGEST,
         .cra_blocksize  =       SHA256_BLOCK_SIZE,
         .cra_ctxsize    =       sizeof(struct s390_sha256_ctx),
diff --git a/arch/s390/defconfig b/arch/s390/defconfig
index f1d4591eddbb..35da53986b1b 100644
--- a/arch/s390/defconfig
+++ b/arch/s390/defconfig
@@ -428,6 +428,7 @@ CONFIG_S390_TAPE_34XX=m
 # CONFIG_VMLOGRDR is not set
 # CONFIG_VMCP is not set
 # CONFIG_MONREADER is not set
+CONFIG_MONWRITER=m
 
 #
 # Cryptographic devices
diff --git a/arch/s390/hypfs/hypfs.h b/arch/s390/hypfs/hypfs.h
index ea5567be00fc..f3dbd91965c6 100644
--- a/arch/s390/hypfs/hypfs.h
+++ b/arch/s390/hypfs/hypfs.h
@@ -1,5 +1,5 @@
 /*
- *  fs/hypfs/hypfs.h
+ *  arch/s390/hypfs/hypfs.h
  *    Hypervisor filesystem for Linux on s390.
  *
  *    Copyright (C) IBM Corp. 2006
diff --git a/arch/s390/hypfs/hypfs_diag.c b/arch/s390/hypfs/hypfs_diag.c
index 1785bce2b919..75144efbb92b 100644
--- a/arch/s390/hypfs/hypfs_diag.c
+++ b/arch/s390/hypfs/hypfs_diag.c
@@ -1,5 +1,5 @@
 /*
- *  fs/hypfs/hypfs_diag.c
+ *  arch/s390/hypfs/hypfs_diag.c
  *    Hypervisor filesystem for Linux on s390. Diag 204 and 224
  *    implementation.
  *
@@ -432,12 +432,14 @@ static int diag204_probe(void)
 
         buf = diag204_get_buffer(INFO_EXT, &pages);
         if (!IS_ERR(buf)) {
-                if (diag204(SUBC_STIB7 | INFO_EXT, pages, buf) >= 0) {
+                if (diag204((unsigned long)SUBC_STIB7 |
+                            (unsigned long)INFO_EXT, pages, buf) >= 0) {
                         diag204_store_sc = SUBC_STIB7;
                         diag204_info_type = INFO_EXT;
                         goto out;
                 }
-                if (diag204(SUBC_STIB6 | INFO_EXT, pages, buf) >= 0) {
+                if (diag204((unsigned long)SUBC_STIB6 |
+                            (unsigned long)INFO_EXT, pages, buf) >= 0) {
                         diag204_store_sc = SUBC_STIB7;
                         diag204_info_type = INFO_EXT;
                         goto out;
@@ -452,7 +454,8 @@ static int diag204_probe(void)
                 rc = PTR_ERR(buf);
                 goto fail_alloc;
         }
-        if (diag204(SUBC_STIB4 | INFO_SIMPLE, pages, buf) >= 0) {
+        if (diag204((unsigned long)SUBC_STIB4 |
+                    (unsigned long)INFO_SIMPLE, pages, buf) >= 0) {
                 diag204_store_sc = SUBC_STIB4;
                 diag204_info_type = INFO_SIMPLE;
                 goto out;
@@ -476,7 +479,8 @@ static void *diag204_store(void)
         buf = diag204_get_buffer(diag204_info_type, &pages);
         if (IS_ERR(buf))
                 goto out;
-        if (diag204(diag204_store_sc | diag204_info_type, pages, buf) < 0)
+        if (diag204((unsigned long)diag204_store_sc |
+                    (unsigned long)diag204_info_type, pages, buf) < 0)
                 return ERR_PTR(-ENOSYS);
 out:
         return buf;
@@ -531,7 +535,7 @@ __init int hypfs_diag_init(void)
         return rc;
 }
 
-__exit void hypfs_diag_exit(void)
+void hypfs_diag_exit(void)
 {
         diag224_delete_name_table();
         diag204_free_buffer();
diff --git a/arch/s390/hypfs/hypfs_diag.h b/arch/s390/hypfs/hypfs_diag.h
index 793dea6b9bb6..256b384aebe1 100644
--- a/arch/s390/hypfs/hypfs_diag.h
+++ b/arch/s390/hypfs/hypfs_diag.h
@@ -1,5 +1,5 @@
 /*
- *  fs/hypfs/hypfs_diag.h
+ *  arch/s390/hypfs_diag.h
  *    Hypervisor filesystem for Linux on s390.
  *
  *    Copyright (C) IBM Corp. 2006
diff --git a/arch/s390/hypfs/inode.c b/arch/s390/hypfs/inode.c
index 18c091925ea5..bdade5f2e325 100644
--- a/arch/s390/hypfs/inode.c
+++ b/arch/s390/hypfs/inode.c
@@ -1,5 +1,5 @@
 /*
- *  fs/hypfs/inode.c
+ *  arch/s390/hypfs/inode.c
  *    Hypervisor filesystem for Linux on s390.
  *
  *    Copyright (C) IBM Corp. 2006
@@ -312,10 +312,12 @@ static void hypfs_kill_super(struct super_block *sb)
 {
         struct hypfs_sb_info *sb_info = sb->s_fs_info;
 
-        hypfs_delete_tree(sb->s_root);
-        hypfs_remove(sb_info->update_file);
-        kfree(sb->s_fs_info);
-        sb->s_fs_info = NULL;
+        if (sb->s_root) {
+                hypfs_delete_tree(sb->s_root);
+                hypfs_remove(sb_info->update_file);
+                kfree(sb->s_fs_info);
+                sb->s_fs_info = NULL;
+        }
         kill_litter_super(sb);
 }
 
diff --git a/arch/s390/kernel/Makefile b/arch/s390/kernel/Makefile
index 9a33ed6ca696..aa978978d3d1 100644
--- a/arch/s390/kernel/Makefile
+++ b/arch/s390/kernel/Makefile
@@ -6,7 +6,7 @@ EXTRA_AFLAGS	:= -traditional
 
 obj-y   :=  bitmap.o traps.o time.o process.o \
             setup.o sys_s390.o ptrace.o signal.o cpcmd.o ebcdic.o \
-            semaphore.o s390_ext.o debug.o profile.o irq.o reipl_diag.o
+            semaphore.o s390_ext.o debug.o profile.o irq.o ipl.o
 
 obj-y   += $(if $(CONFIG_64BIT),entry64.o,entry.o)
 obj-y   += $(if $(CONFIG_64BIT),reipl64.o,reipl.o)
@@ -24,6 +24,7 @@ obj-$(CONFIG_COMPAT)		+= compat_linux.o compat_signal.o \
 
 obj-$(CONFIG_VIRT_TIMER)        += vtime.o
 obj-$(CONFIG_STACKTRACE)        += stacktrace.o
+obj-$(CONFIG_KPROBES)           += kprobes.o
 
 # Kexec part
 S390_KEXEC_OBJS := machine_kexec.o crash.o
diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S
index 5b5799ac8f83..0c712b78a7e8 100644
--- a/arch/s390/kernel/entry.S
+++ b/arch/s390/kernel/entry.S
@@ -505,6 +505,8 @@ pgm_no_vtime2:
         mvc     __THREAD_per+__PER_address(4,%r1),__LC_PER_ADDRESS
         mvc     __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID
         oi      __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP
+        tm      SP_PSW+1(%r15),0x01     # kernel per event ?
+        bz      BASED(kernel_per)
         l       %r3,__LC_PGM_ILC         # load program interruption code
         la      %r8,0x7f
         nr      %r8,%r3                  # clear per-event-bit and ilc
@@ -536,6 +538,16 @@ pgm_no_vtime3:
         stosm   __SF_EMPTY(%r15),0x03   # reenable interrupts
         b       BASED(sysc_do_svc)
 
+#
+# per was called from kernel, must be kprobes
+#
+kernel_per:
+        mvi     SP_TRAP+1(%r15),0x28    # set trap indication to pgm check
+        la      %r2,SP_PTREGS(%r15)     # address of register-save area
+        l       %r1,BASED(.Lhandle_per) # load adr. of per handler
+        la      %r14,BASED(sysc_leave)  # load adr. of system return
+        br      %r1                     # branch to do_single_step
+
 /*
  * IO interrupt handler routine
  */
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S
index 56f5f613b868..29bbfbab7332 100644
--- a/arch/s390/kernel/entry64.S
+++ b/arch/s390/kernel/entry64.S
@@ -518,6 +518,8 @@ pgm_no_vtime2:
 #endif
         lg      %r9,__LC_THREAD_INFO    # load pointer to thread_info struct
         lg      %r1,__TI_task(%r9)
+        tm      SP_PSW+1(%r15),0x01     # kernel per event ?
+        jz      kernel_per
         mvc     __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID
         mvc     __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS
         mvc     __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID
@@ -553,6 +555,16 @@ pgm_no_vtime3:
         stosm   __SF_EMPTY(%r15),0x03   # reenable interrupts
         j       sysc_do_svc
 
+#
+# per was called from kernel, must be kprobes
+#
+kernel_per:
+        lhi     %r0,__LC_PGM_OLD_PSW
+        sth     %r0,SP_TRAP(%r15)       # set trap indication to pgm check
+        la      %r2,SP_PTREGS(%r15)     # address of register-save area
+        larl    %r14,sysc_leave         # load adr. of system ret, no work
+        jg      do_single_step          # branch to do_single_step
+
 /*
  * IO interrupt handler routine
  */
@@ -815,7 +827,7 @@ restart_go:
  */
 stack_overflow:
         lg      %r15,__LC_PANIC_STACK   # change to panic stack
-        aghi    %r1,-SP_SIZE
+        aghi    %r15,-SP_SIZE
         mvc     SP_PSW(16,%r15),0(%r12) # move user PSW to stack
         stmg    %r0,%r11,SP_R0(%r15)    # store gprs %r0-%r11 to kernel stack
         la      %r1,__LC_SAVE_AREA
@@ -823,7 +835,7 @@ stack_overflow:
         je      0f
         chi     %r12,__LC_PGM_OLD_PSW
         je      0f
-        la      %r1,__LC_SAVE_AREA+16
+        la      %r1,__LC_SAVE_AREA+32
 0:      mvc     SP_R12(32,%r15),0(%r1)  # move %r12-%r15 to stack
         xc      __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15) # clear back chain
         la      %r2,SP_PTREGS(%r15)     # load pt_regs
diff --git a/arch/s390/kernel/head.S b/arch/s390/kernel/head.S
index adad8863ee2f..0f1db268a8a9 100644
--- a/arch/s390/kernel/head.S
+++ b/arch/s390/kernel/head.S
@@ -272,7 +272,7 @@ iplstart:
 # load parameter file from ipl device
 #
 .Lagain1:
-        l     %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12) # ramdisk loc. is temp
+        l     %r2,.Linitrd                     # ramdisk loc. is temp
         bas   %r14,.Lloader                    # load parameter file
         ltr   %r2,%r2                          # got anything ?
         bz    .Lnopf
@@ -280,7 +280,7 @@ iplstart:
         bnh   .Lnotrunc
         la    %r2,895
 .Lnotrunc:
-        l     %r4,INITRD_START+ARCH_OFFSET-PARMAREA(%r12)
+        l     %r4,.Linitrd
         clc   0(3,%r4),.L_hdr                  # if it is HDRx
         bz    .Lagain1                         # skip dataset header
         clc   0(3,%r4),.L_eof                  # if it is EOFx
@@ -323,14 +323,15 @@ iplstart:
 # load ramdisk from ipl device
 #       
 .Lagain2:
-        l     %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12) # addr of ramdisk
+        l     %r2,.Linitrd                     # addr of ramdisk
+        st    %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12)
         bas   %r14,.Lloader                    # load ramdisk
         st    %r2,INITRD_SIZE+ARCH_OFFSET-PARMAREA(%r12) # store size of ramdisk
         ltr   %r2,%r2
         bnz   .Lrdcont
         st    %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12) # no ramdisk found
 .Lrdcont:
-        l     %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12)
+        l     %r2,.Linitrd
 
         clc   0(3,%r2),.L_hdr                  # skip HDRx and EOFx 
         bz    .Lagain2
@@ -379,6 +380,7 @@ iplstart:
         l     %r1,.Lstartup
         br    %r1
 
+.Linitrd:.long _end + 0x400000                 # default address of initrd
 .Lparm: .long  PARMAREA
 .Lstartup: .long startup
 .Lcvtab:.long  _ebcasc                         # ebcdic to ascii table
@@ -479,65 +481,6 @@ start:
         .byte 0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7 
         .byte 0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff
 
-.macro GET_IPL_DEVICE
-.Lget_ipl_device:
-        l     %r1,0xb8                  # get sid
-        sll   %r1,15                    # test if subchannel is enabled
-        srl   %r1,31
-        ltr   %r1,%r1
-        bz    2f-.LPG1(%r13)            # subchannel disabled
-        l     %r1,0xb8
-        la    %r5,.Lipl_schib-.LPG1(%r13)
-        stsch 0(%r5)                    # get schib of subchannel
-        bnz   2f-.LPG1(%r13)            # schib not available
-        tm    5(%r5),0x01               # devno valid?
-        bno   2f-.LPG1(%r13)
-        la    %r6,ipl_parameter_flags-.LPG1(%r13)
-        oi    3(%r6),0x01               # set flag
-        la    %r2,ipl_devno-.LPG1(%r13)
-        mvc   0(2,%r2),6(%r5)           # store devno
-        tm    4(%r5),0x80               # qdio capable device?
-        bno   2f-.LPG1(%r13)
-        oi    3(%r6),0x02               # set flag
-
-        # copy ipl parameters
-
-        lhi   %r0,4096
-        l     %r2,20(%r0)               # get address of parameter list
-        lhi   %r3,IPL_PARMBLOCK_ORIGIN
-        st    %r3,20(%r0)
-        lhi   %r4,1
-        cr    %r2,%r3                   # start parameters < destination ?
-        jl    0f
-        lhi   %r1,1                     # copy direction is upwards
-        j     1f
-0:      lhi   %r1,-1                    # copy direction is downwards
-        ar    %r2,%r0
-        ar    %r3,%r0
-        ar    %r2,%r1
-        ar    %r3,%r1
-1:      mvc   0(1,%r3),0(%r2)           # finally copy ipl parameters
-        ar    %r3,%r1
-        ar    %r2,%r1
-        sr    %r0,%r4
-        jne   1b
-        b     2f-.LPG1(%r13)
-
-        .align 4
-.Lipl_schib:
-        .rept 13
-        .long 0
-        .endr
-
-        .globl ipl_parameter_flags
-ipl_parameter_flags:
-        .long 0
-        .globl ipl_devno
-ipl_devno:
-        .word 0
-2:
-.endm
-
 #ifdef CONFIG_64BIT
 #include "head64.S"
 #else
diff --git a/arch/s390/kernel/head31.S b/arch/s390/kernel/head31.S
index a4dc61f3285e..1fa9fa1ca740 100644
--- a/arch/s390/kernel/head31.S
+++ b/arch/s390/kernel/head31.S
@@ -26,8 +26,8 @@ startup:basr	%r13,0			# get base
 #
         .org    PARMAREA
         .long   0,0                     # IPL_DEVICE
-        .long   0,RAMDISK_ORIGIN        # INITRD_START
-        .long   0,RAMDISK_SIZE          # INITRD_SIZE
+        .long   0,0                     # INITRD_START
+        .long   0,0                     # INITRD_SIZE
 
         .org    COMMAND_LINE
         .byte   "root=/dev/ram0 ro"
@@ -37,12 +37,23 @@ startup:basr	%r13,0			# get base
 
 startup_continue:
         basr    %r13,0                  # get base
-.LPG1:  GET_IPL_DEVICE
+.LPG1:  mvi     __LC_AR_MODE_ID,0       # set ESA flag (mode 0)
         lctl    %c0,%c15,.Lctl-.LPG1(%r13) # load control registers
         l       %r12,.Lparmaddr-.LPG1(%r13) # pointer to parameter area
                                         # move IPL device to lowcore
         mvc     __LC_IPLDEV(4),IPL_DEVICE-PARMAREA(%r12)
+#
+# Setup stack
+#
+        l       %r15,.Linittu-.LPG1(%r13)
+        mvc     __LC_CURRENT(4),__TI_task(%r15)
+        ahi     %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union+THREAD_SIZE
+        st      %r15,__LC_KERNEL_STACK  # set end of kernel stack
+        ahi     %r15,-96
+        xc      __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
 
+        l       %r14,.Lipl_save_parameters-.LPG1(%r13)
+        basr    %r14,%r14
 #
 # clear bss memory
 #
@@ -114,6 +125,10 @@ startup_continue:
         b       .Lfchunk-.LPG1(%r13)
 
         .align 4
+.Lipl_save_parameters:
+        .long   ipl_save_parameters
+.Linittu:
+        .long   init_thread_union
 .Lpmask:
         .byte   0
 .align 8
@@ -273,7 +288,23 @@ startup_continue:
 .Lbss_end:  .long _end
 .Lparmaddr: .long PARMAREA
 .Lsccbaddr: .long .Lsccb
+
+        .globl ipl_schib
+ipl_schib:
+        .rept 13
+        .long 0
+        .endr
+
+        .globl ipl_flags
+ipl_flags:
+        .long 0
+        .globl ipl_devno
+ipl_devno:
+        .word 0
+
         .org    0x12000
+.globl s390_readinfo_sccb
+s390_readinfo_sccb:
 .Lsccb:
         .hword  0x1000                  # length, one page
         .byte   0x00,0x00,0x00
@@ -302,16 +333,6 @@ startup_continue:
         .globl  _stext
 _stext: basr    %r13,0                  # get base
 .LPG3:
-#
-# Setup stack
-#
-        l       %r15,.Linittu-.LPG3(%r13)
-        mvc     __LC_CURRENT(4),__TI_task(%r15)
-        ahi     %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union+THREAD_SIZE
-        st      %r15,__LC_KERNEL_STACK  # set end of kernel stack
-        ahi     %r15,-96
-        xc      __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
-
 # check control registers
         stctl   %c0,%c15,0(%r15)
         oi      2(%r15),0x40            # enable sigp emergency signal
@@ -330,6 +351,5 @@ _stext:	basr	%r13,0			# get base
 #
         .align  8
 .Ldw:   .long   0x000a0000,0x00000000
-.Linittu:.long  init_thread_union
 .Lstart:.long   start_kernel
 .Laregs:.long   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
diff --git a/arch/s390/kernel/head64.S b/arch/s390/kernel/head64.S
index 9d80c5b1ef95..a8bdd96494c7 100644
--- a/arch/s390/kernel/head64.S
+++ b/arch/s390/kernel/head64.S
@@ -26,8 +26,8 @@ startup:basr  %r13,0			 # get base
 #
         .org   PARMAREA
         .quad  0                        # IPL_DEVICE
-        .quad  RAMDISK_ORIGIN           # INITRD_START
-        .quad  RAMDISK_SIZE             # INITRD_SIZE
+        .quad  0                        # INITRD_START
+        .quad  0                        # INITRD_SIZE
 
         .org   COMMAND_LINE
         .byte  "root=/dev/ram0 ro"
@@ -39,8 +39,8 @@ startup_continue:
         basr  %r13,0                     # get base
 .LPG1:  sll   %r13,1                     # remove high order bit
         srl   %r13,1
-        GET_IPL_DEVICE
         lhi   %r1,1                      # mode 1 = esame
+        mvi   __LC_AR_MODE_ID,1          # set esame flag
         slr   %r0,%r0                    # set cpuid to zero
         sigp  %r1,%r0,0x12               # switch to esame mode
         sam64                            # switch to 64 bit mode
@@ -48,7 +48,18 @@ startup_continue:
         lg    %r12,.Lparmaddr-.LPG1(%r13)# pointer to parameter area
                                          # move IPL device to lowcore
         mvc   __LC_IPLDEV(4),IPL_DEVICE+4-PARMAREA(%r12)
+#
+# Setup stack
+#
+        larl  %r15,init_thread_union
+        lg    %r14,__TI_task(%r15)      # cache current in lowcore
+        stg   %r14,__LC_CURRENT
+        aghi  %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union + THREAD_SIZE
+        stg   %r15,__LC_KERNEL_STACK    # set end of kernel stack
+        aghi  %r15,-160
+        xc    __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
 
+        brasl %r14,ipl_save_parameters
 #
 # clear bss memory
 #
@@ -239,6 +250,19 @@ startup_continue:
         oi      7(%r12),0x80            # set IDTE flag
 0:
 
+#
+# find out if we have the MVCOS instruction
+#
+        la      %r1,0f-.LPG1(%r13)      # set program check address
+        stg     %r1,__LC_PGM_NEW_PSW+8
+        .short  0xc800                  # mvcos 0(%r0),0(%r0),%r0
+        .short  0x0000
+        .short  0x0000
+0:      tm      0x8f,0x13               # special-operation exception?
+        bno     1f-.LPG1(%r13)          # if yes, MVCOS is present
+        oi      6(%r12),2               # set MVCOS flag
+1:
+
         lpswe .Lentry-.LPG1(13)         # jump to _stext in primary-space,
                                         # virtual and never return ...
         .align 16
@@ -268,7 +292,22 @@ startup_continue:
 .Lparmaddr:
         .quad   PARMAREA
 
+        .globl ipl_schib
+ipl_schib:
+        .rept 13
+        .long 0
+        .endr
+
+        .globl ipl_flags
+ipl_flags:
+        .long 0
+        .globl ipl_devno
+ipl_devno:
+        .word 0
+
         .org    0x12000
+.globl s390_readinfo_sccb
+s390_readinfo_sccb:
 .Lsccb:
         .hword 0x1000                   # length, one page
         .byte 0x00,0x00,0x00
@@ -297,24 +336,12 @@ startup_continue:
         .globl _stext
 _stext: basr  %r13,0                    # get base
 .LPG3:
-#
-# Setup stack
-#
-        larl  %r15,init_thread_union
-        lg    %r14,__TI_task(%r15)      # cache current in lowcore
-        stg   %r14,__LC_CURRENT
-        aghi  %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union + THREAD_SIZE
-        stg   %r15,__LC_KERNEL_STACK    # set end of kernel stack
-        aghi  %r15,-160
-        xc    __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
-
 # check control registers
         stctg  %c0,%c15,0(%r15)
         oi     6(%r15),0x40             # enable sigp emergency signal
         oi     4(%r15),0x10             # switch on low address proctection
         lctlg  %c0,%c15,0(%r15)
 
-#
         lam    0,15,.Laregs-.LPG3(%r13) # load access regs needed by uaccess
         brasl  %r14,start_kernel        # go to C code
 #
@@ -322,7 +349,7 @@ _stext:	basr  %r13,0                    # get base
 #
         basr  %r13,0
         lpswe .Ldw-.(%r13)           # load disabled wait psw
-#
+
             .align 8
 .Ldw:       .quad  0x0002000180000000,0x0000000000000000
 .Laregs:    .long  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
diff --git a/arch/s390/kernel/ipl.c b/arch/s390/kernel/ipl.c
new file mode 100644
index 000000000000..6555cc48e28f
--- /dev/null
+++ b/arch/s390/kernel/ipl.c
@@ -0,0 +1,942 @@
+/*
+ *  arch/s390/kernel/ipl.c
+ *    ipl/reipl/dump support for Linux on s390.
+ *
+ *    Copyright (C) IBM Corp. 2005,2006
+ *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
+ *               Heiko Carstens <heiko.carstens@de.ibm.com>
+ *               Volker Sameske <sameske@de.ibm.com>
+ */
+
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/delay.h>
+#include <linux/reboot.h>
+#include <asm/smp.h>
+#include <asm/setup.h>
+#include <asm/cpcmd.h>
+#include <asm/cio.h>
+
+#define IPL_PARM_BLOCK_VERSION 0
+
+enum ipl_type {
+        IPL_TYPE_NONE    = 1,
+        IPL_TYPE_UNKNOWN = 2,
+        IPL_TYPE_CCW     = 4,
+        IPL_TYPE_FCP     = 8,
+};
+
+#define IPL_NONE_STR     "none"
+#define IPL_UNKNOWN_STR  "unknown"
+#define IPL_CCW_STR      "ccw"
+#define IPL_FCP_STR      "fcp"
+
+static char *ipl_type_str(enum ipl_type type)
+{
+        switch (type) {
+        case IPL_TYPE_NONE:
+                return IPL_NONE_STR;
+        case IPL_TYPE_CCW:
+                return IPL_CCW_STR;
+        case IPL_TYPE_FCP:
+                return IPL_FCP_STR;
+        case IPL_TYPE_UNKNOWN:
+        default:
+                return IPL_UNKNOWN_STR;
+        }
+}
+
+enum ipl_method {
+        IPL_METHOD_NONE,
+        IPL_METHOD_CCW_CIO,
+        IPL_METHOD_CCW_DIAG,
+        IPL_METHOD_CCW_VM,
+        IPL_METHOD_FCP_RO_DIAG,
+        IPL_METHOD_FCP_RW_DIAG,
+        IPL_METHOD_FCP_RO_VM,
+};
+
+enum shutdown_action {
+        SHUTDOWN_REIPL,
+        SHUTDOWN_DUMP,
+        SHUTDOWN_STOP,
+};
+
+#define SHUTDOWN_REIPL_STR "reipl"
+#define SHUTDOWN_DUMP_STR  "dump"
+#define SHUTDOWN_STOP_STR  "stop"
+
+static char *shutdown_action_str(enum shutdown_action action)
+{
+        switch (action) {
+        case SHUTDOWN_REIPL:
+                return SHUTDOWN_REIPL_STR;
+        case SHUTDOWN_DUMP:
+                return SHUTDOWN_DUMP_STR;
+        case SHUTDOWN_STOP:
+                return SHUTDOWN_STOP_STR;
+        default:
+                BUG();
+        }
+}
+
+enum diag308_subcode  {
+        DIAG308_IPL   = 3,
+        DIAG308_DUMP  = 4,
+        DIAG308_SET   = 5,
+        DIAG308_STORE = 6,
+};
+
+enum diag308_ipl_type {
+        DIAG308_IPL_TYPE_FCP = 0,
+        DIAG308_IPL_TYPE_CCW = 2,
+};
+
+enum diag308_opt {
+        DIAG308_IPL_OPT_IPL  = 0x10,
+        DIAG308_IPL_OPT_DUMP = 0x20,
+};
+
+enum diag308_rc {
+        DIAG308_RC_OK = 1,
+};
+
+static int diag308_set_works = 0;
+
+static int reipl_capabilities = IPL_TYPE_UNKNOWN;
+static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN;
+static enum ipl_method reipl_method = IPL_METHOD_NONE;
+static struct ipl_parameter_block *reipl_block_fcp;
+static struct ipl_parameter_block *reipl_block_ccw;
+
+static int dump_capabilities = IPL_TYPE_NONE;
+static enum ipl_type dump_type = IPL_TYPE_NONE;
+static enum ipl_method dump_method = IPL_METHOD_NONE;
+static struct ipl_parameter_block *dump_block_fcp;
+static struct ipl_parameter_block *dump_block_ccw;
+
+static enum shutdown_action on_panic_action = SHUTDOWN_STOP;
+
+static int diag308(unsigned long subcode, void *addr)
+{
+        register unsigned long _addr asm("0") = (unsigned long)addr;
+        register unsigned long _rc asm("1") = 0;
+
+        asm volatile (
+                "   diag %0,%2,0x308\n"
+                "0: \n"
+                ".section __ex_table,\"a\"\n"
+#ifdef CONFIG_64BIT
+                "   .align 8\n"
+                "   .quad 0b, 0b\n"
+#else
+                "   .align 4\n"
+                "   .long 0b, 0b\n"
+#endif
+                ".previous\n"
+                : "+d" (_addr), "+d" (_rc)
+                : "d" (subcode) : "cc", "memory" );
+
+        return _rc;
+}
+
+/* SYSFS */
+
+#define DEFINE_IPL_ATTR_RO(_prefix, _name, _format, _value)             \
+static ssize_t sys_##_prefix##_##_name##_show(struct subsystem *subsys, \
+                char *page)                                             \
+{                                                                       \
+        return sprintf(page, _format, _value);                          \
+}                                                                       \
+static struct subsys_attribute sys_##_prefix##_##_name##_attr =         \
+        __ATTR(_name, S_IRUGO, sys_##_prefix##_##_name##_show, NULL);
+
+#define DEFINE_IPL_ATTR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)   \
+static ssize_t sys_##_prefix##_##_name##_show(struct subsystem *subsys, \
+                char *page)                                             \
+{                                                                       \
+        return sprintf(page, _fmt_out,                                  \
+                        (unsigned long long) _value);                   \
+}                                                                       \
+static ssize_t sys_##_prefix##_##_name##_store(struct subsystem *subsys,\
+                const char *buf, size_t len)                            \
+{                                                                       \
+        unsigned long long value;                                       \
+        if (sscanf(buf, _fmt_in, &value) != 1)                          \
+                return -EINVAL;                                         \
+        _value = value;                                                 \
+        return len;                                                     \
+}                                                                       \
+static struct subsys_attribute sys_##_prefix##_##_name##_attr =         \
+        __ATTR(_name,(S_IRUGO | S_IWUSR),                               \
+                        sys_##_prefix##_##_name##_show,                 \
+                        sys_##_prefix##_##_name##_store);
+
+static void make_attrs_ro(struct attribute **attrs)
+{
+        while (*attrs) {
+                (*attrs)->mode = S_IRUGO;
+                attrs++;
+        }
+}
+
+/*
+ * ipl section
+ */
+
+static enum ipl_type ipl_get_type(void)
+{
+        struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
+
+        if (!(ipl_flags & IPL_DEVNO_VALID))
+                return IPL_TYPE_UNKNOWN;
+        if (!(ipl_flags & IPL_PARMBLOCK_VALID))
+                return IPL_TYPE_CCW;
+        if (ipl->hdr.version > IPL_MAX_SUPPORTED_VERSION)
+                return IPL_TYPE_UNKNOWN;
+        if (ipl->hdr.pbt != DIAG308_IPL_TYPE_FCP)
+                return IPL_TYPE_UNKNOWN;
+        return IPL_TYPE_FCP;
+}
+
+static ssize_t ipl_type_show(struct subsystem *subsys, char *page)
+{
+        return sprintf(page, "%s\n", ipl_type_str(ipl_get_type()));
+}
+
+static struct subsys_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type);
+
+static ssize_t sys_ipl_device_show(struct subsystem *subsys, char *page)
+{
+        struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
+
+        switch (ipl_get_type()) {
+        case IPL_TYPE_CCW:
+                return sprintf(page, "0.0.%04x\n", ipl_devno);
+        case IPL_TYPE_FCP:
+                return sprintf(page, "0.0.%04x\n", ipl->ipl_info.fcp.devno);
+        default:
+                return 0;
+        }
+}
+
+static struct subsys_attribute sys_ipl_device_attr =
+        __ATTR(device, S_IRUGO, sys_ipl_device_show, NULL);
+
+static ssize_t ipl_parameter_read(struct kobject *kobj, char *buf, loff_t off,
+                                  size_t count)
+{
+        unsigned int size = IPL_PARMBLOCK_SIZE;
+
+        if (off > size)
+                return 0;
+        if (off + count > size)
+                count = size - off;
+        memcpy(buf, (void *)IPL_PARMBLOCK_START + off, count);
+        return count;
+}
+
+static struct bin_attribute ipl_parameter_attr = {
+        .attr = {
+                .name = "binary_parameter",
+                .mode = S_IRUGO,
+                .owner = THIS_MODULE,
+        },
+        .size = PAGE_SIZE,
+        .read = &ipl_parameter_read,
+};
+
+static ssize_t ipl_scp_data_read(struct kobject *kobj, char *buf, loff_t off,
+        size_t count)
+{
+        unsigned int size = IPL_PARMBLOCK_START->ipl_info.fcp.scp_data_len;
+        void *scp_data = &IPL_PARMBLOCK_START->ipl_info.fcp.scp_data;
+
+        if (off > size)
+                return 0;
+        if (off + count > size)
+                count = size - off;
+        memcpy(buf, scp_data + off, count);
+        return count;
+}
+
+static struct bin_attribute ipl_scp_data_attr = {
+        .attr = {
+                .name = "scp_data",
+                .mode = S_IRUGO,
+                .owner = THIS_MODULE,
+        },
+        .size = PAGE_SIZE,
+        .read = &ipl_scp_data_read,
+};
+
+/* FCP ipl device attributes */
+
+DEFINE_IPL_ATTR_RO(ipl_fcp, wwpn, "0x%016llx\n", (unsigned long long)
+                   IPL_PARMBLOCK_START->ipl_info.fcp.wwpn);
+DEFINE_IPL_ATTR_RO(ipl_fcp, lun, "0x%016llx\n", (unsigned long long)
+                   IPL_PARMBLOCK_START->ipl_info.fcp.lun);
+DEFINE_IPL_ATTR_RO(ipl_fcp, bootprog, "%lld\n", (unsigned long long)
+                   IPL_PARMBLOCK_START->ipl_info.fcp.bootprog);
+DEFINE_IPL_ATTR_RO(ipl_fcp, br_lba, "%lld\n", (unsigned long long)
+                   IPL_PARMBLOCK_START->ipl_info.fcp.br_lba);
+
+static struct attribute *ipl_fcp_attrs[] = {
+        &sys_ipl_type_attr.attr,
+        &sys_ipl_device_attr.attr,
+        &sys_ipl_fcp_wwpn_attr.attr,
+        &sys_ipl_fcp_lun_attr.attr,
+        &sys_ipl_fcp_bootprog_attr.attr,
+        &sys_ipl_fcp_br_lba_attr.attr,
+        NULL,
+};
+
+static struct attribute_group ipl_fcp_attr_group = {
+        .attrs = ipl_fcp_attrs,
+};
+
+/* CCW ipl device attributes */
+
+static struct attribute *ipl_ccw_attrs[] = {
+        &sys_ipl_type_attr.attr,
+        &sys_ipl_device_attr.attr,
+        NULL,
+};
+
+static struct attribute_group ipl_ccw_attr_group = {
+        .attrs = ipl_ccw_attrs,
+};
+
+/* UNKNOWN ipl device attributes */
+
+static struct attribute *ipl_unknown_attrs[] = {
+        &sys_ipl_type_attr.attr,
+        NULL,
+};
+
+static struct attribute_group ipl_unknown_attr_group = {
+        .attrs = ipl_unknown_attrs,
+};
+
+static decl_subsys(ipl, NULL, NULL);
+
+/*
+ * reipl section
+ */
+
+/* FCP reipl device attributes */
+
+DEFINE_IPL_ATTR_RW(reipl_fcp, wwpn, "0x%016llx\n", "%016llx\n",
+                   reipl_block_fcp->ipl_info.fcp.wwpn);
+DEFINE_IPL_ATTR_RW(reipl_fcp, lun, "0x%016llx\n", "%016llx\n",
+                   reipl_block_fcp->ipl_info.fcp.lun);
+DEFINE_IPL_ATTR_RW(reipl_fcp, bootprog, "%lld\n", "%lld\n",
+                   reipl_block_fcp->ipl_info.fcp.bootprog);
+DEFINE_IPL_ATTR_RW(reipl_fcp, br_lba, "%lld\n", "%lld\n",
+                   reipl_block_fcp->ipl_info.fcp.br_lba);
+DEFINE_IPL_ATTR_RW(reipl_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
+                   reipl_block_fcp->ipl_info.fcp.devno);
+
+static struct attribute *reipl_fcp_attrs[] = {
+        &sys_reipl_fcp_device_attr.attr,
+        &sys_reipl_fcp_wwpn_attr.attr,
+        &sys_reipl_fcp_lun_attr.attr,
+        &sys_reipl_fcp_bootprog_attr.attr,
+        &sys_reipl_fcp_br_lba_attr.attr,
+        NULL,
+};
+
+static struct attribute_group reipl_fcp_attr_group = {
+        .name  = IPL_FCP_STR,
+        .attrs = reipl_fcp_attrs,
+};
+
+/* CCW reipl device attributes */
+
+DEFINE_IPL_ATTR_RW(reipl_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
+        reipl_block_ccw->ipl_info.ccw.devno);
+
+static struct attribute *reipl_ccw_attrs[] = {
+        &sys_reipl_ccw_device_attr.attr,
+        NULL,
+};
+
+static struct attribute_group reipl_ccw_attr_group = {
+        .name  = IPL_CCW_STR,
+        .attrs = reipl_ccw_attrs,
+};
+
+/* reipl type */
+
+static int reipl_set_type(enum ipl_type type)
+{
+        if (!(reipl_capabilities & type))
+                return -EINVAL;
+
+        switch(type) {
+        case IPL_TYPE_CCW:
+                if (MACHINE_IS_VM)
+                        reipl_method = IPL_METHOD_CCW_VM;
+                else
+                        reipl_method = IPL_METHOD_CCW_CIO;
+                break;
+        case IPL_TYPE_FCP:
+                if (diag308_set_works)
+                        reipl_method = IPL_METHOD_FCP_RW_DIAG;
+                else if (MACHINE_IS_VM)
+                        reipl_method = IPL_METHOD_FCP_RO_VM;
+                else
+                        reipl_method = IPL_METHOD_FCP_RO_DIAG;
+                break;
+        default:
+                reipl_method = IPL_METHOD_NONE;
+        }
+        reipl_type = type;
+        return 0;
+}
+
+static ssize_t reipl_type_show(struct subsystem *subsys, char *page)
+{
+        return sprintf(page, "%s\n", ipl_type_str(reipl_type));
+}
+
+static ssize_t reipl_type_store(struct subsystem *subsys, const char *buf,
+                                size_t len)
+{
+        int rc = -EINVAL;
+
+        if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
+                rc = reipl_set_type(IPL_TYPE_CCW);
+        else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
+                rc = reipl_set_type(IPL_TYPE_FCP);
+        return (rc != 0) ? rc : len;
+}
+
+static struct subsys_attribute reipl_type_attr =
+                __ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store);
+
+static decl_subsys(reipl, NULL, NULL);
+
+/*
+ * dump section
+ */
+
+/* FCP dump device attributes */
+
+DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%016llx\n",
+                   dump_block_fcp->ipl_info.fcp.wwpn);
+DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%016llx\n",
+                   dump_block_fcp->ipl_info.fcp.lun);
+DEFINE_IPL_ATTR_RW(dump_fcp, bootprog, "%lld\n", "%lld\n",
+                   dump_block_fcp->ipl_info.fcp.bootprog);
+DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n",
+                   dump_block_fcp->ipl_info.fcp.br_lba);
+DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
+                   dump_block_fcp->ipl_info.fcp.devno);
+
+static struct attribute *dump_fcp_attrs[] = {
+        &sys_dump_fcp_device_attr.attr,
+        &sys_dump_fcp_wwpn_attr.attr,
+        &sys_dump_fcp_lun_attr.attr,
+        &sys_dump_fcp_bootprog_attr.attr,
+        &sys_dump_fcp_br_lba_attr.attr,
+        NULL,
+};
+
+static struct attribute_group dump_fcp_attr_group = {
+        .name  = IPL_FCP_STR,
+        .attrs = dump_fcp_attrs,
+};
+
+/* CCW dump device attributes */
+
+DEFINE_IPL_ATTR_RW(dump_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
+                   dump_block_ccw->ipl_info.ccw.devno);
+
+static struct attribute *dump_ccw_attrs[] = {
+        &sys_dump_ccw_device_attr.attr,
+        NULL,
+};
+
+static struct attribute_group dump_ccw_attr_group = {
+        .name  = IPL_CCW_STR,
+        .attrs = dump_ccw_attrs,
+};
+
+/* dump type */
+
+static int dump_set_type(enum ipl_type type)
+{
+        if (!(dump_capabilities & type))
+                return -EINVAL;
+        switch(type) {
+        case IPL_TYPE_CCW:
+                if (MACHINE_IS_VM)
+                        dump_method = IPL_METHOD_CCW_VM;
+                else
+                        dump_method = IPL_METHOD_CCW_CIO;
+                break;
+        case IPL_TYPE_FCP:
+                dump_method = IPL_METHOD_FCP_RW_DIAG;
+                break;
+        default:
+                dump_method = IPL_METHOD_NONE;
+        }
+        dump_type = type;
+        return 0;
+}
+
+static ssize_t dump_type_show(struct subsystem *subsys, char *page)
+{
+        return sprintf(page, "%s\n", ipl_type_str(dump_type));
+}
+
+static ssize_t dump_type_store(struct subsystem *subsys, const char *buf,
+                               size_t len)
+{
+        int rc = -EINVAL;
+
+        if (strncmp(buf, IPL_NONE_STR, strlen(IPL_NONE_STR)) == 0)
+                rc = dump_set_type(IPL_TYPE_NONE);
+        else if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
+                rc = dump_set_type(IPL_TYPE_CCW);
+        else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
+                rc = dump_set_type(IPL_TYPE_FCP);
+        return (rc != 0) ? rc : len;
+}
+
+static struct subsys_attribute dump_type_attr =
+                __ATTR(dump_type, 0644, dump_type_show, dump_type_store);
+
+static decl_subsys(dump, NULL, NULL);
+
+#ifdef CONFIG_SMP
+static void dump_smp_stop_all(void)
+{
+        int cpu;
+        preempt_disable();
+        for_each_online_cpu(cpu) {
+                if (cpu == smp_processor_id())
+                        continue;
+                while (signal_processor(cpu, sigp_stop) == sigp_busy)
+                        udelay(10);
+        }
+        preempt_enable();
+}
+#else
+#define dump_smp_stop_all() do { } while (0)
+#endif
+
+/*
+ * Shutdown actions section
+ */
+
+static decl_subsys(shutdown_actions, NULL, NULL);
+
+/* on panic */
+
+static ssize_t on_panic_show(struct subsystem *subsys, char *page)
+{
+        return sprintf(page, "%s\n", shutdown_action_str(on_panic_action));
+}
+
+static ssize_t on_panic_store(struct subsystem *subsys, const char *buf,
+                              size_t len)
+{
+        if (strncmp(buf, SHUTDOWN_REIPL_STR, strlen(SHUTDOWN_REIPL_STR)) == 0)
+                on_panic_action = SHUTDOWN_REIPL;
+        else if (strncmp(buf, SHUTDOWN_DUMP_STR,
+                         strlen(SHUTDOWN_DUMP_STR)) == 0)
+                on_panic_action = SHUTDOWN_DUMP;
+        else if (strncmp(buf, SHUTDOWN_STOP_STR,
+                         strlen(SHUTDOWN_STOP_STR)) == 0)
+                on_panic_action = SHUTDOWN_STOP;
+        else
+                return -EINVAL;
+
+        return len;
+}
+
+static struct subsys_attribute on_panic_attr =
+                __ATTR(on_panic, 0644, on_panic_show, on_panic_store);
+
+static void print_fcp_block(struct ipl_parameter_block *fcp_block)
+{
+        printk(KERN_EMERG "wwpn:      %016llx\n",
+                (unsigned long long)fcp_block->ipl_info.fcp.wwpn);
+        printk(KERN_EMERG "lun:       %016llx\n",
+                (unsigned long long)fcp_block->ipl_info.fcp.lun);
+        printk(KERN_EMERG "bootprog:  %lld\n",
+                (unsigned long long)fcp_block->ipl_info.fcp.bootprog);
+        printk(KERN_EMERG "br_lba:    %lld\n",
+                (unsigned long long)fcp_block->ipl_info.fcp.br_lba);
+        printk(KERN_EMERG "device:    %llx\n",
+                (unsigned long long)fcp_block->ipl_info.fcp.devno);
+        printk(KERN_EMERG "opt:       %x\n", fcp_block->ipl_info.fcp.opt);
+}
+
+void do_reipl(void)
+{
+        struct ccw_dev_id devid;
+        static char buf[100];
+
+        switch (reipl_type) {
+        case IPL_TYPE_CCW:
+                printk(KERN_EMERG "reboot on ccw device: 0.0.%04x\n",
+                        reipl_block_ccw->ipl_info.ccw.devno);
+                break;
+        case IPL_TYPE_FCP:
+                printk(KERN_EMERG "reboot on fcp device:\n");
+                print_fcp_block(reipl_block_fcp);
+                break;
+        default:
+                break;
+        }
+
+        switch (reipl_method) {
+        case IPL_METHOD_CCW_CIO:
+                devid.devno = reipl_block_ccw->ipl_info.ccw.devno;
+                devid.ssid  = 0;
+                reipl_ccw_dev(&devid);
+                break;
+        case IPL_METHOD_CCW_VM:
+                sprintf(buf, "IPL %X", reipl_block_ccw->ipl_info.ccw.devno);
+                cpcmd(buf, NULL, 0, NULL);
+                break;
+        case IPL_METHOD_CCW_DIAG:
+                diag308(DIAG308_SET, reipl_block_ccw);
+                diag308(DIAG308_IPL, NULL);
+                break;
+        case IPL_METHOD_FCP_RW_DIAG:
+                diag308(DIAG308_SET, reipl_block_fcp);
+                diag308(DIAG308_IPL, NULL);
+                break;
+        case IPL_METHOD_FCP_RO_DIAG:
+                diag308(DIAG308_IPL, NULL);
+                break;
+        case IPL_METHOD_FCP_RO_VM:
+                cpcmd("IPL", NULL, 0, NULL);
+                break;
+        case IPL_METHOD_NONE:
+        default:
+                if (MACHINE_IS_VM)
+                        cpcmd("IPL", NULL, 0, NULL);
+                diag308(DIAG308_IPL, NULL);
+                break;
+        }
+        panic("reipl failed!\n");
+}
+
+static void do_dump(void)
+{
+        struct ccw_dev_id devid;
+        static char buf[100];
+
+        switch (dump_type) {
+        case IPL_TYPE_CCW:
+                printk(KERN_EMERG "Automatic dump on ccw device: 0.0.%04x\n",
+                       dump_block_ccw->ipl_info.ccw.devno);
+                break;
+        case IPL_TYPE_FCP:
+                printk(KERN_EMERG "Automatic dump on fcp device:\n");
+                print_fcp_block(dump_block_fcp);
+                break;
+        default:
+                return;
+        }
+
+        switch (dump_method) {
+        case IPL_METHOD_CCW_CIO:
+                dump_smp_stop_all();
+                devid.devno = dump_block_ccw->ipl_info.ccw.devno;
+                devid.ssid  = 0;
+                reipl_ccw_dev(&devid);
+                break;
+        case IPL_METHOD_CCW_VM:
+                dump_smp_stop_all();
+                sprintf(buf, "STORE STATUS");
+                cpcmd(buf, NULL, 0, NULL);
+                sprintf(buf, "IPL %X", dump_block_ccw->ipl_info.ccw.devno);
+                cpcmd(buf, NULL, 0, NULL);
+                break;
+        case IPL_METHOD_CCW_DIAG:
+                diag308(DIAG308_SET, dump_block_ccw);
+                diag308(DIAG308_DUMP, NULL);
+                break;
+        case IPL_METHOD_FCP_RW_DIAG:
+                diag308(DIAG308_SET, dump_block_fcp);
+                diag308(DIAG308_DUMP, NULL);
+                break;
+        case IPL_METHOD_NONE:
+        default:
+                return;
+        }
+        printk(KERN_EMERG "Dump failed!\n");
+}
+
+/* init functions */
+
+static int __init ipl_register_fcp_files(void)
+{
+        int rc;
+
+        rc = sysfs_create_group(&ipl_subsys.kset.kobj,
+                                &ipl_fcp_attr_group);
+        if (rc)
+                goto out;
+        rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
+                                   &ipl_parameter_attr);
+        if (rc)
+                goto out_ipl_parm;
+        rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
+                                   &ipl_scp_data_attr);
+        if (!rc)
+                goto out;
+
+        sysfs_remove_bin_file(&ipl_subsys.kset.kobj, &ipl_parameter_attr);
+
+out_ipl_parm:
+        sysfs_remove_group(&ipl_subsys.kset.kobj, &ipl_fcp_attr_group);
+out:
+        return rc;
+}
+
+static int __init ipl_init(void)
+{
+        int rc;
+
+        rc = firmware_register(&ipl_subsys);
+        if (rc)
+                return rc;
+        switch (ipl_get_type()) {
+        case IPL_TYPE_CCW:
+                rc = sysfs_create_group(&ipl_subsys.kset.kobj,
+                                        &ipl_ccw_attr_group);
+                break;
+        case IPL_TYPE_FCP:
+                rc = ipl_register_fcp_files();
+                break;
+        default:
+                rc = sysfs_create_group(&ipl_subsys.kset.kobj,
+                                        &ipl_unknown_attr_group);
+                break;
+        }
+        if (rc)
+                firmware_unregister(&ipl_subsys);
+        return rc;
+}
+
+static void __init reipl_probe(void)
+{
+        void *buffer;
+
+        buffer = (void *) get_zeroed_page(GFP_KERNEL);
+        if (!buffer)
+                return;
+        if (diag308(DIAG308_STORE, buffer) == DIAG308_RC_OK)
+                diag308_set_works = 1;
+        free_page((unsigned long)buffer);
+}
+
+static int __init reipl_ccw_init(void)
+{
+        int rc;
+
+        reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
+        if (!reipl_block_ccw)
+                return -ENOMEM;
+        rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_ccw_attr_group);
+        if (rc) {
+                free_page((unsigned long)reipl_block_ccw);
+                return rc;
+        }
+        reipl_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
+        reipl_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
+        reipl_block_ccw->hdr.blk0_len = sizeof(reipl_block_ccw->ipl_info.ccw);
+        reipl_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
+        if (ipl_get_type() == IPL_TYPE_CCW)
+                reipl_block_ccw->ipl_info.ccw.devno = ipl_devno;
+        reipl_capabilities |= IPL_TYPE_CCW;
+        return 0;
+}
+
+static int __init reipl_fcp_init(void)
+{
+        int rc;
+
+        if ((!diag308_set_works) && (ipl_get_type() != IPL_TYPE_FCP))
+                return 0;
+        if ((!diag308_set_works) && (ipl_get_type() == IPL_TYPE_FCP))
+                make_attrs_ro(reipl_fcp_attrs);
+
+        reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
+        if (!reipl_block_fcp)
+                return -ENOMEM;
+        rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_fcp_attr_group);
+        if (rc) {
+                free_page((unsigned long)reipl_block_fcp);
+                return rc;
+        }
+        if (ipl_get_type() == IPL_TYPE_FCP) {
+                memcpy(reipl_block_fcp, IPL_PARMBLOCK_START, PAGE_SIZE);
+        } else {
+                reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
+                reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
+                reipl_block_fcp->hdr.blk0_len =
+                        sizeof(reipl_block_fcp->ipl_info.fcp);
+                reipl_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
+                reipl_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_IPL;
+        }
+        reipl_capabilities |= IPL_TYPE_FCP;
+        return 0;
+}
+
+static int __init reipl_init(void)
+{
+        int rc;
+
+        rc = firmware_register(&reipl_subsys);
+        if (rc)
+                return rc;
+        rc = subsys_create_file(&reipl_subsys, &reipl_type_attr);
+        if (rc) {
+                firmware_unregister(&reipl_subsys);
+                return rc;
+        }
+        rc = reipl_ccw_init();
+        if (rc)
+                return rc;
+        rc = reipl_fcp_init();
+        if (rc)
+                return rc;
+        rc = reipl_set_type(ipl_get_type());
+        if (rc)
+                return rc;
+        return 0;
+}
+
+static int __init dump_ccw_init(void)
+{
+        int rc;
+
+        dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
+        if (!dump_block_ccw)
+                return -ENOMEM;
+        rc = sysfs_create_group(&dump_subsys.kset.kobj, &dump_ccw_attr_group);
+        if (rc) {
+                free_page((unsigned long)dump_block_ccw);
+                return rc;
+        }
+        dump_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
+        dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
+        dump_block_ccw->hdr.blk0_len = sizeof(reipl_block_ccw->ipl_info.ccw);
+        dump_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
+        dump_capabilities |= IPL_TYPE_CCW;
+        return 0;
+}
+
+extern char s390_readinfo_sccb[];
+
+static int __init dump_fcp_init(void)
+{
+        int rc;
+
+        if(!(s390_readinfo_sccb[91] & 0x2))
+                return 0; /* LDIPL DUMP is not installed */
+        if (!diag308_set_works)
+                return 0;
+        dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
+        if (!dump_block_fcp)
+                return -ENOMEM;
+        rc = sysfs_create_group(&dump_subsys.kset.kobj, &dump_fcp_attr_group);
+        if (rc) {
+                free_page((unsigned long)dump_block_fcp);
+                return rc;
+        }
+        dump_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
+        dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
+        dump_block_fcp->hdr.blk0_len = sizeof(dump_block_fcp->ipl_info.fcp);
+        dump_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
+        dump_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_DUMP;
+        dump_capabilities |= IPL_TYPE_FCP;
+        return 0;
+}
+
+#define SHUTDOWN_ON_PANIC_PRIO 0
+
+static int shutdown_on_panic_notify(struct notifier_block *self,
+                                    unsigned long event, void *data)
+{
+        if (on_panic_action == SHUTDOWN_DUMP)
+                do_dump();
+        else if (on_panic_action == SHUTDOWN_REIPL)
+                do_reipl();
+        return NOTIFY_OK;
+}
+
+static struct notifier_block shutdown_on_panic_nb = {
+        .notifier_call = shutdown_on_panic_notify,
+        .priority = SHUTDOWN_ON_PANIC_PRIO
+};
+
+static int __init dump_init(void)
+{
+        int rc;
+
+        rc = firmware_register(&dump_subsys);
+        if (rc)
+                return rc;
+        rc = subsys_create_file(&dump_subsys, &dump_type_attr);
+        if (rc) {
+                firmware_unregister(&dump_subsys);
+                return rc;
+        }
+        rc = dump_ccw_init();
+        if (rc)
+                return rc;
+        rc = dump_fcp_init();
+        if (rc)
+                return rc;
+        dump_set_type(IPL_TYPE_NONE);
+        return 0;
+}
+
+static int __init shutdown_actions_init(void)
+{
+        int rc;
+
+        rc = firmware_register(&shutdown_actions_subsys);
+        if (rc)
+                return rc;
+        rc = subsys_create_file(&shutdown_actions_subsys, &on_panic_attr);
+        if (rc) {
+                firmware_unregister(&shutdown_actions_subsys);
+                return rc;
+        }
+        atomic_notifier_chain_register(&panic_notifier_list,
+                                       &shutdown_on_panic_nb);
+        return 0;
+}
+
+static int __init s390_ipl_init(void)
+{
+        int rc;
+
+        reipl_probe();
+        rc = ipl_init();
+        if (rc)
+                return rc;
+        rc = reipl_init();
+        if (rc)
+                return rc;
+        rc = dump_init();
+        if (rc)
+                return rc;
+        rc = shutdown_actions_init();
+        if (rc)
+                return rc;
+        return 0;
+}
+
+__initcall(s390_ipl_init);
diff --git a/arch/s390/kernel/kprobes.c b/arch/s390/kernel/kprobes.c
new file mode 100644
index 000000000000..ca28fb0b3790
--- /dev/null
+++ b/arch/s390/kernel/kprobes.c
@@ -0,0 +1,657 @@
+/*
+ *  Kernel Probes (KProbes)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright (C) IBM Corporation, 2002, 2006
+ *
+ * s390 port, used ppc64 as template. Mike Grundy <grundym@us.ibm.com>
+ */
+
+#include <linux/config.h>
+#include <linux/kprobes.h>
+#include <linux/ptrace.h>
+#include <linux/preempt.h>
+#include <linux/stop_machine.h>
+#include <asm/cacheflush.h>
+#include <asm/kdebug.h>
+#include <asm/sections.h>
+#include <asm/uaccess.h>
+#include <linux/module.h>
+
+DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
+DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
+
+int __kprobes arch_prepare_kprobe(struct kprobe *p)
+{
+        /* Make sure the probe isn't going on a difficult instruction */
+        if (is_prohibited_opcode((kprobe_opcode_t *) p->addr))
+                return -EINVAL;
+
+        if ((unsigned long)p->addr & 0x01) {
+                printk("Attempt to register kprobe at an unaligned address\n");
+                return -EINVAL;
+                }
+
+        /* Use the get_insn_slot() facility for correctness */
+        if (!(p->ainsn.insn = get_insn_slot()))
+                return -ENOMEM;
+
+        memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE * sizeof(kprobe_opcode_t));
+
+        get_instruction_type(&p->ainsn);
+        p->opcode = *p->addr;
+        return 0;
+}
+
+int __kprobes is_prohibited_opcode(kprobe_opcode_t *instruction)
+{
+        switch (*(__u8 *) instruction) {
+        case 0x0c:      /* bassm */
+        case 0x0b:      /* bsm   */
+        case 0x83:      /* diag  */
+        case 0x44:      /* ex    */
+                return -EINVAL;
+        }
+        switch (*(__u16 *) instruction) {
+        case 0x0101:    /* pr    */
+        case 0xb25a:    /* bsa   */
+        case 0xb240:    /* bakr  */
+        case 0xb258:    /* bsg   */
+        case 0xb218:    /* pc    */
+        case 0xb228:    /* pt    */
+                return -EINVAL;
+        }
+        return 0;
+}
+
+void __kprobes get_instruction_type(struct arch_specific_insn *ainsn)
+{
+        /* default fixup method */
+        ainsn->fixup = FIXUP_PSW_NORMAL;
+
+        /* save r1 operand */
+        ainsn->reg = (*ainsn->insn & 0xf0) >> 4;
+
+        /* save the instruction length (pop 5-5) in bytes */
+        switch (*(__u8 *) (ainsn->insn) >> 4) {
+        case 0:
+                ainsn->ilen = 2;
+                break;
+        case 1:
+        case 2:
+                ainsn->ilen = 4;
+                break;
+        case 3:
+                ainsn->ilen = 6;
+                break;
+        }
+
+        switch (*(__u8 *) ainsn->insn) {
+        case 0x05:      /* balr */
+        case 0x0d:      /* basr */
+                ainsn->fixup = FIXUP_RETURN_REGISTER;
+                /* if r2 = 0, no branch will be taken */
+                if ((*ainsn->insn & 0x0f) == 0)
+                        ainsn->fixup |= FIXUP_BRANCH_NOT_TAKEN;
+                break;
+        case 0x06:      /* bctr */
+        case 0x07:      /* bcr  */
+                ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN;
+                break;
+        case 0x45:      /* bal  */
+        case 0x4d:      /* bas  */
+                ainsn->fixup = FIXUP_RETURN_REGISTER;
+                break;
+        case 0x47:      /* bc   */
+        case 0x46:      /* bct  */
+        case 0x86:      /* bxh  */
+        case 0x87:      /* bxle */
+                ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN;
+                break;
+        case 0x82:      /* lpsw */
+                ainsn->fixup = FIXUP_NOT_REQUIRED;
+                break;
+        case 0xb2:      /* lpswe */
+                if (*(((__u8 *) ainsn->insn) + 1) == 0xb2) {
+                        ainsn->fixup = FIXUP_NOT_REQUIRED;
+                }
+                break;
+        case 0xa7:      /* bras */
+                if ((*ainsn->insn & 0x0f) == 0x05) {
+                        ainsn->fixup |= FIXUP_RETURN_REGISTER;
+                }
+                break;
+        case 0xc0:
+                if ((*ainsn->insn & 0x0f) == 0x00  /* larl  */
+                        || (*ainsn->insn & 0x0f) == 0x05) /* brasl */
+                ainsn->fixup |= FIXUP_RETURN_REGISTER;
+                break;
+        case 0xeb:
+                if (*(((__u8 *) ainsn->insn) + 5 ) == 0x44 ||   /* bxhg  */
+                        *(((__u8 *) ainsn->insn) + 5) == 0x45) {/* bxleg */
+                        ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN;
+                }
+                break;
+        case 0xe3:      /* bctg */
+                if (*(((__u8 *) ainsn->insn) + 5) == 0x46) {
+                        ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN;
+                }
+                break;
+        }
+}
+
+static int __kprobes swap_instruction(void *aref)
+{
+        struct ins_replace_args *args = aref;
+        int err = -EFAULT;
+
+        asm volatile(
+                "0: mvc  0(2,%2),0(%3)\n"
+                "1: la   %0,0\n"
+                "2:\n"
+                EX_TABLE(0b,2b)
+                : "+d" (err), "=m" (*args->ptr)
+                : "a" (args->ptr), "a" (&args->new), "m" (args->new));
+        return err;
+}
+
+void __kprobes arch_arm_kprobe(struct kprobe *p)
+{
+        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+        unsigned long status = kcb->kprobe_status;
+        struct ins_replace_args args;
+
+        args.ptr = p->addr;
+        args.old = p->opcode;
+        args.new = BREAKPOINT_INSTRUCTION;
+
+        kcb->kprobe_status = KPROBE_SWAP_INST;
+        stop_machine_run(swap_instruction, &args, NR_CPUS);
+        kcb->kprobe_status = status;
+}
+
+void __kprobes arch_disarm_kprobe(struct kprobe *p)
+{
+        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+        unsigned long status = kcb->kprobe_status;
+        struct ins_replace_args args;
+
+        args.ptr = p->addr;
+        args.old = BREAKPOINT_INSTRUCTION;
+        args.new = p->opcode;
+
+        kcb->kprobe_status = KPROBE_SWAP_INST;
+        stop_machine_run(swap_instruction, &args, NR_CPUS);
+        kcb->kprobe_status = status;
+}
+
+void __kprobes arch_remove_kprobe(struct kprobe *p)
+{
+        mutex_lock(&kprobe_mutex);
+        free_insn_slot(p->ainsn.insn);
+        mutex_unlock(&kprobe_mutex);
+}
+
+static void __kprobes prepare_singlestep(struct kprobe *p, struct pt_regs *regs)
+{
+        per_cr_bits kprobe_per_regs[1];
+
+        memset(kprobe_per_regs, 0, sizeof(per_cr_bits));
+        regs->psw.addr = (unsigned long)p->ainsn.insn | PSW_ADDR_AMODE;
+
+        /* Set up the per control reg info, will pass to lctl */
+        kprobe_per_regs[0].em_instruction_fetch = 1;
+        kprobe_per_regs[0].starting_addr = (unsigned long)p->ainsn.insn;
+        kprobe_per_regs[0].ending_addr = (unsigned long)p->ainsn.insn + 1;
+
+        /* Set the PER control regs, turns on single step for this address */
+        __ctl_load(kprobe_per_regs, 9, 11);
+        regs->psw.mask |= PSW_MASK_PER;
+        regs->psw.mask &= ~(PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK);
+}
+
+static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb)
+{
+        kcb->prev_kprobe.kp = kprobe_running();
+        kcb->prev_kprobe.status = kcb->kprobe_status;
+        kcb->prev_kprobe.kprobe_saved_imask = kcb->kprobe_saved_imask;
+        memcpy(kcb->prev_kprobe.kprobe_saved_ctl, kcb->kprobe_saved_ctl,
+                                        sizeof(kcb->kprobe_saved_ctl));
+}
+
+static void __kprobes restore_previous_kprobe(struct kprobe_ctlblk *kcb)
+{
+        __get_cpu_var(current_kprobe) = kcb->prev_kprobe.kp;
+        kcb->kprobe_status = kcb->prev_kprobe.status;
+        kcb->kprobe_saved_imask = kcb->prev_kprobe.kprobe_saved_imask;
+        memcpy(kcb->kprobe_saved_ctl, kcb->prev_kprobe.kprobe_saved_ctl,
+                                        sizeof(kcb->kprobe_saved_ctl));
+}
+
+static void __kprobes set_current_kprobe(struct kprobe *p, struct pt_regs *regs,
+                                                struct kprobe_ctlblk *kcb)
+{
+        __get_cpu_var(current_kprobe) = p;
+        /* Save the interrupt and per flags */
+        kcb->kprobe_saved_imask = regs->psw.mask &
+            (PSW_MASK_PER | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK);
+        /* Save the control regs that govern PER */
+        __ctl_store(kcb->kprobe_saved_ctl, 9, 11);
+}
+
+/* Called with kretprobe_lock held */
+void __kprobes arch_prepare_kretprobe(struct kretprobe *rp,
+                                        struct pt_regs *regs)
+{
+        struct kretprobe_instance *ri;
+
+        if ((ri = get_free_rp_inst(rp)) != NULL) {
+                ri->rp = rp;
+                ri->task = current;
+                ri->ret_addr = (kprobe_opcode_t *) regs->gprs[14];
+
+                /* Replace the return addr with trampoline addr */
+                regs->gprs[14] = (unsigned long)&kretprobe_trampoline;
+
+                add_rp_inst(ri);
+        } else {
+                rp->nmissed++;
+        }
+}
+
+static int __kprobes kprobe_handler(struct pt_regs *regs)
+{
+        struct kprobe *p;
+        int ret = 0;
+        unsigned long *addr = (unsigned long *)
+                ((regs->psw.addr & PSW_ADDR_INSN) - 2);
+        struct kprobe_ctlblk *kcb;
+
+        /*
+         * We don't want to be preempted for the entire
+         * duration of kprobe processing
+         */
+        preempt_disable();
+        kcb = get_kprobe_ctlblk();
+
+        /* Check we're not actually recursing */
+        if (kprobe_running()) {
+                p = get_kprobe(addr);
+                if (p) {
+                        if (kcb->kprobe_status == KPROBE_HIT_SS &&
+                            *p->ainsn.insn == BREAKPOINT_INSTRUCTION) {
+                                regs->psw.mask &= ~PSW_MASK_PER;
+                                regs->psw.mask |= kcb->kprobe_saved_imask;
+                                goto no_kprobe;
+                        }
+                        /* We have reentered the kprobe_handler(), since
+                         * another probe was hit while within the handler.
+                         * We here save the original kprobes variables and
+                         * just single step on the instruction of the new probe
+                         * without calling any user handlers.
+                         */
+                        save_previous_kprobe(kcb);
+                        set_current_kprobe(p, regs, kcb);
+                        kprobes_inc_nmissed_count(p);
+                        prepare_singlestep(p, regs);
+                        kcb->kprobe_status = KPROBE_REENTER;
+                        return 1;
+                } else {
+                        p = __get_cpu_var(current_kprobe);
+                        if (p->break_handler && p->break_handler(p, regs)) {
+                                goto ss_probe;
+                        }
+                }
+                goto no_kprobe;
+        }
+
+        p = get_kprobe(addr);
+        if (!p) {
+                if (*addr != BREAKPOINT_INSTRUCTION) {
+                        /*
+                         * The breakpoint instruction was removed right
+                         * after we hit it.  Another cpu has removed
+                         * either a probepoint or a debugger breakpoint
+                         * at this address.  In either case, no further
+                         * handling of this interrupt is appropriate.
+                         *
+                         */
+                        ret = 1;
+                }
+                /* Not one of ours: let kernel handle it */
+                goto no_kprobe;
+        }
+
+        kcb->kprobe_status = KPROBE_HIT_ACTIVE;
+        set_current_kprobe(p, regs, kcb);
+        if (p->pre_handler && p->pre_handler(p, regs))
+                /* handler has already set things up, so skip ss setup */
+                return 1;
+
+ss_probe:
+        prepare_singlestep(p, regs);
+        kcb->kprobe_status = KPROBE_HIT_SS;
+        return 1;
+
+no_kprobe:
+        preempt_enable_no_resched();
+        return ret;
+}
+
+/*
+ * Function return probe trampoline:
+ *      - init_kprobes() establishes a probepoint here
+ *      - When the probed function returns, this probe
+ *              causes the handlers to fire
+ */
+void __kprobes kretprobe_trampoline_holder(void)
+{
+        asm volatile(".global kretprobe_trampoline\n"
+                     "kretprobe_trampoline: bcr 0,0\n");
+}
+
+/*
+ * Called when the probe at kretprobe trampoline is hit
+ */
+int __kprobes trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
+{
+        struct kretprobe_instance *ri = NULL;
+        struct hlist_head *head;
+        struct hlist_node *node, *tmp;
+        unsigned long flags, orig_ret_address = 0;
+        unsigned long trampoline_address = (unsigned long)&kretprobe_trampoline;
+
+        spin_lock_irqsave(&kretprobe_lock, flags);
+        head = kretprobe_inst_table_head(current);
+
+        /*
+         * It is possible to have multiple instances associated with a given
+         * task either because an multiple functions in the call path
+         * have a return probe installed on them, and/or more then one return
+         * return probe was registered for a target function.
+         *
+         * We can handle this because:
+         *     - instances are always inserted at the head of the list
+         *     - when multiple return probes are registered for the same
+         *       function, the first instance's ret_addr will point to the
+         *       real return address, and all the rest will point to
+         *       kretprobe_trampoline
+         */
+        hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
+                if (ri->task != current)
+                        /* another task is sharing our hash bucket */
+                        continue;
+
+                if (ri->rp && ri->rp->handler)
+                        ri->rp->handler(ri, regs);
+
+                orig_ret_address = (unsigned long)ri->ret_addr;
+                recycle_rp_inst(ri);
+
+                if (orig_ret_address != trampoline_address) {
+                        /*
+                         * This is the real return address. Any other
+                         * instances associated with this task are for
+                         * other calls deeper on the call stack
+                         */
+                        break;
+                }
+        }
+        BUG_ON(!orig_ret_address || (orig_ret_address == trampoline_address));
+        regs->psw.addr = orig_ret_address | PSW_ADDR_AMODE;
+
+        reset_current_kprobe();
+        spin_unlock_irqrestore(&kretprobe_lock, flags);
+        preempt_enable_no_resched();
+
+        /*
+         * By returning a non-zero value, we are telling
+         * kprobe_handler() that we don't want the post_handler
+         * to run (and have re-enabled preemption)
+         */
+        return 1;
+}
+
+/*
+ * Called after single-stepping.  p->addr is the address of the
+ * instruction whose first byte has been replaced by the "breakpoint"
+ * instruction.  To avoid the SMP problems that can occur when we
+ * temporarily put back the original opcode to single-step, we
+ * single-stepped a copy of the instruction.  The address of this
+ * copy is p->ainsn.insn.
+ */
+static void __kprobes resume_execution(struct kprobe *p, struct pt_regs *regs)
+{
+        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+
+        regs->psw.addr &= PSW_ADDR_INSN;
+
+        if (p->ainsn.fixup & FIXUP_PSW_NORMAL)
+                regs->psw.addr = (unsigned long)p->addr +
+                                ((unsigned long)regs->psw.addr -
+                                 (unsigned long)p->ainsn.insn);
+
+        if (p->ainsn.fixup & FIXUP_BRANCH_NOT_TAKEN)
+                if ((unsigned long)regs->psw.addr -
+                    (unsigned long)p->ainsn.insn == p->ainsn.ilen)
+                        regs->psw.addr = (unsigned long)p->addr + p->ainsn.ilen;
+
+        if (p->ainsn.fixup & FIXUP_RETURN_REGISTER)
+                regs->gprs[p->ainsn.reg] = ((unsigned long)p->addr +
+                                                (regs->gprs[p->ainsn.reg] -
+                                                (unsigned long)p->ainsn.insn))
+                                                | PSW_ADDR_AMODE;
+
+        regs->psw.addr |= PSW_ADDR_AMODE;
+        /* turn off PER mode */
+        regs->psw.mask &= ~PSW_MASK_PER;
+        /* Restore the original per control regs */
+        __ctl_load(kcb->kprobe_saved_ctl, 9, 11);
+        regs->psw.mask |= kcb->kprobe_saved_imask;
+}
+
+static int __kprobes post_kprobe_handler(struct pt_regs *regs)
+{
+        struct kprobe *cur = kprobe_running();
+        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+
+        if (!cur)
+                return 0;
+
+        if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
+                kcb->kprobe_status = KPROBE_HIT_SSDONE;
+                cur->post_handler(cur, regs, 0);
+        }
+
+        resume_execution(cur, regs);
+
+        /*Restore back the original saved kprobes variables and continue. */
+        if (kcb->kprobe_status == KPROBE_REENTER) {
+                restore_previous_kprobe(kcb);
+                goto out;
+        }
+        reset_current_kprobe();
+out:
+        preempt_enable_no_resched();
+
+        /*
+         * if somebody else is singlestepping across a probe point, psw mask
+         * will have PER set, in which case, continue the remaining processing
+         * of do_single_step, as if this is not a probe hit.
+         */
+        if (regs->psw.mask & PSW_MASK_PER) {
+                return 0;
+        }
+
+        return 1;
+}
+
+static int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr)
+{
+        struct kprobe *cur = kprobe_running();
+        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+        const struct exception_table_entry *entry;
+
+        switch(kcb->kprobe_status) {
+        case KPROBE_SWAP_INST:
+                /* We are here because the instruction replacement failed */
+                return 0;
+        case KPROBE_HIT_SS:
+        case KPROBE_REENTER:
+                /*
+                 * We are here because the instruction being single
+                 * stepped caused a page fault. We reset the current
+                 * kprobe and the nip points back to the probe address
+                 * and allow the page fault handler to continue as a
+                 * normal page fault.
+                 */
+                regs->psw.addr = (unsigned long)cur->addr | PSW_ADDR_AMODE;
+                regs->psw.mask &= ~PSW_MASK_PER;
+                regs->psw.mask |= kcb->kprobe_saved_imask;
+                if (kcb->kprobe_status == KPROBE_REENTER)
+                        restore_previous_kprobe(kcb);
+                else
+                        reset_current_kprobe();
+                preempt_enable_no_resched();
+                break;
+        case KPROBE_HIT_ACTIVE:
+        case KPROBE_HIT_SSDONE:
+                /*
+                 * We increment the nmissed count for accounting,
+                 * we can also use npre/npostfault count for accouting
+                 * these specific fault cases.
+                 */
+                kprobes_inc_nmissed_count(cur);
+
+                /*
+                 * We come here because instructions in the pre/post
+                 * handler caused the page_fault, this could happen
+                 * if handler tries to access user space by
+                 * copy_from_user(), get_user() etc. Let the
+                 * user-specified handler try to fix it first.
+                 */
+                if (cur->fault_handler && cur->fault_handler(cur, regs, trapnr))
+                        return 1;
+
+                /*
+                 * In case the user-specified fault handler returned
+                 * zero, try to fix up.
+                 */
+                entry = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN);
+                if (entry) {
+                        regs->psw.addr = entry->fixup | PSW_ADDR_AMODE;
+                        return 1;
+                }
+
+                /*
+                 * fixup_exception() could not handle it,
+                 * Let do_page_fault() fix it.
+                 */
+                break;
+        default:
+                break;
+        }
+        return 0;
+}
+
+/*
+ * Wrapper routine to for handling exceptions.
+ */
+int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
+                                       unsigned long val, void *data)
+{
+        struct die_args *args = (struct die_args *)data;
+        int ret = NOTIFY_DONE;
+
+        switch (val) {
+        case DIE_BPT:
+                if (kprobe_handler(args->regs))
+                        ret = NOTIFY_STOP;
+                break;
+        case DIE_SSTEP:
+                if (post_kprobe_handler(args->regs))
+                        ret = NOTIFY_STOP;
+                break;
+        case DIE_TRAP:
+        case DIE_PAGE_FAULT:
+                /* kprobe_running() needs smp_processor_id() */
+                preempt_disable();
+                if (kprobe_running() &&
+                    kprobe_fault_handler(args->regs, args->trapnr))
+                        ret = NOTIFY_STOP;
+                preempt_enable();
+                break;
+        default:
+                break;
+        }
+        return ret;
+}
+
+int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)
+{
+        struct jprobe *jp = container_of(p, struct jprobe, kp);
+        unsigned long addr;
+        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+
+        memcpy(&kcb->jprobe_saved_regs, regs, sizeof(struct pt_regs));
+
+        /* setup return addr to the jprobe handler routine */
+        regs->psw.addr = (unsigned long)(jp->entry) | PSW_ADDR_AMODE;
+
+        /* r14 is the function return address */
+        kcb->jprobe_saved_r14 = (unsigned long)regs->gprs[14];
+        /* r15 is the stack pointer */
+        kcb->jprobe_saved_r15 = (unsigned long)regs->gprs[15];
+        addr = (unsigned long)kcb->jprobe_saved_r15;
+
+        memcpy(kcb->jprobes_stack, (kprobe_opcode_t *) addr,
+               MIN_STACK_SIZE(addr));
+        return 1;
+}
+
+void __kprobes jprobe_return(void)
+{
+        asm volatile(".word 0x0002");
+}
+
+void __kprobes jprobe_return_end(void)
+{
+        asm volatile("bcr 0,0");
+}
+
+int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)
+{
+        struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+        unsigned long stack_addr = (unsigned long)(kcb->jprobe_saved_r15);
+
+        /* Put the regs back */
+        memcpy(regs, &kcb->jprobe_saved_regs, sizeof(struct pt_regs));
+        /* put the stack back */
+        memcpy((kprobe_opcode_t *) stack_addr, kcb->jprobes_stack,
+               MIN_STACK_SIZE(stack_addr));
+        preempt_enable_no_resched();
+        return 1;
+}
+
+static struct kprobe trampoline_p = {
+        .addr = (kprobe_opcode_t *) & kretprobe_trampoline,
+        .pre_handler = trampoline_probe_handler
+};
+
+int __init arch_init_kprobes(void)
+{
+        return register_kprobe(&trampoline_p);
+}
diff --git a/arch/s390/kernel/reipl.S b/arch/s390/kernel/reipl.S
index 658e5ac484f9..4562cdbce8eb 100644
--- a/arch/s390/kernel/reipl.S
+++ b/arch/s390/kernel/reipl.S
@@ -8,13 +8,30 @@
 
 #include <asm/lowcore.h>
 
-                .globl  do_reipl
-do_reipl:       basr    %r13,0
+                .globl  do_reipl_asm
+do_reipl_asm:   basr    %r13,0
 .Lpg0:          lpsw    .Lnewpsw-.Lpg0(%r13)
-.Lpg1:          lctl    %c6,%c6,.Lall-.Lpg0(%r13)
-                stctl   %c0,%c0,.Lctlsave-.Lpg0(%r13)
-                ni      .Lctlsave-.Lpg0(%r13),0xef
-                lctl    %c0,%c0,.Lctlsave-.Lpg0(%r13)
+
+                # switch off lowcore protection
+
+.Lpg1:          stctl   %c0,%c0,.Lctlsave1-.Lpg0(%r13)
+                stctl   %c0,%c0,.Lctlsave2-.Lpg0(%r13)
+                ni      .Lctlsave1-.Lpg0(%r13),0xef
+                lctl    %c0,%c0,.Lctlsave1-.Lpg0(%r13)
+
+                # do store status of all registers
+
+                stm     %r0,%r15,__LC_GPREGS_SAVE_AREA
+                stctl   %c0,%c15,__LC_CREGS_SAVE_AREA
+                mvc     __LC_CREGS_SAVE_AREA(4),.Lctlsave2-.Lpg0(%r13)
+                stam    %a0,%a15,__LC_AREGS_SAVE_AREA
+                stpx    __LC_PREFIX_SAVE_AREA
+                stckc   .Lclkcmp-.Lpg0(%r13)
+                mvc     __LC_CLOCK_COMP_SAVE_AREA(8),.Lclkcmp-.Lpg0(%r13)
+                stpt    __LC_CPU_TIMER_SAVE_AREA
+                st      %r13, __LC_PSW_SAVE_AREA+4
+
+                lctl    %c6,%c6,.Lall-.Lpg0(%r13)
                 lr      %r1,%r2
                 mvc     __LC_PGM_NEW_PSW(8),.Lpcnew-.Lpg0(%r13)
                 stsch   .Lschib-.Lpg0(%r13)                                    
@@ -46,9 +63,11 @@ do_reipl:	basr	%r13,0
 .Ldisab:        st      %r14,.Ldispsw+4-.Lpg0(%r13)
                 lpsw    .Ldispsw-.Lpg0(%r13)
                 .align  8
+.Lclkcmp:       .quad   0x0000000000000000
 .Lall:          .long   0xff000000
 .Lnull:         .long   0x00000000
-.Lctlsave:      .long   0x00000000
+.Lctlsave1:     .long   0x00000000
+.Lctlsave2:     .long   0x00000000
                 .align  8
 .Lnewpsw:       .long   0x00080000,0x80000000+.Lpg1
 .Lpcnew:        .long   0x00080000,0x80000000+.Lecs
diff --git a/arch/s390/kernel/reipl64.S b/arch/s390/kernel/reipl64.S
index 4d090d60f3ef..95bd1e234f63 100644
--- a/arch/s390/kernel/reipl64.S
+++ b/arch/s390/kernel/reipl64.S
@@ -8,13 +8,30 @@
  */
 
 #include <asm/lowcore.h>
-                .globl  do_reipl
-do_reipl:       basr    %r13,0
-.Lpg0:          lpswe   .Lnewpsw-.Lpg0(%r13)
+                .globl  do_reipl_asm
+do_reipl_asm:   basr    %r13,0
+
+                # do store status of all registers
+
+.Lpg0:          stg     %r1,.Lregsave-.Lpg0(%r13)
+                lghi    %r1,0x1000
+                stmg    %r0,%r15,__LC_GPREGS_SAVE_AREA-0x1000(%r1)
+                lg      %r0,.Lregsave-.Lpg0(%r13)
+                stg     %r0,__LC_GPREGS_SAVE_AREA-0x1000+8(%r1)
+                stctg   %c0,%c15,__LC_CREGS_SAVE_AREA-0x1000(%r1)
+                stam    %a0,%a15,__LC_AREGS_SAVE_AREA-0x1000(%r1)
+                stpx    __LC_PREFIX_SAVE_AREA-0x1000(%r1)
+                stfpc   __LC_FP_CREG_SAVE_AREA-0x1000(%r1)
+                stckc   .Lclkcmp-.Lpg0(%r13)
+                mvc     __LC_CLOCK_COMP_SAVE_AREA-0x1000(8,%r1),.Lclkcmp-.Lpg0(%r13)
+                stpt    __LC_CPU_TIMER_SAVE_AREA-0x1000(%r1)
+                stg     %r13, __LC_PSW_SAVE_AREA-0x1000+8(%r1)
+
+                lpswe   .Lnewpsw-.Lpg0(%r13)
 .Lpg1:          lctlg   %c6,%c6,.Lall-.Lpg0(%r13)
-                stctg   %c0,%c0,.Lctlsave-.Lpg0(%r13)
-                ni      .Lctlsave+4-.Lpg0(%r13),0xef
-                lctlg   %c0,%c0,.Lctlsave-.Lpg0(%r13)
+                stctg   %c0,%c0,.Lregsave-.Lpg0(%r13)
+                ni      .Lregsave+4-.Lpg0(%r13),0xef
+                lctlg   %c0,%c0,.Lregsave-.Lpg0(%r13)
                 lgr     %r1,%r2
                 mvc     __LC_PGM_NEW_PSW(16),.Lpcnew-.Lpg0(%r13)
                 stsch   .Lschib-.Lpg0(%r13)                                    
@@ -50,8 +67,9 @@ do_reipl:	basr	%r13,0
                 st     %r14,.Ldispsw+12-.Lpg0(%r13)
                 lpswe   .Ldispsw-.Lpg0(%r13)
                 .align  8
+.Lclkcmp:       .quad   0x0000000000000000
 .Lall:          .quad   0x00000000ff000000
-.Lctlsave:      .quad   0x0000000000000000
+.Lregsave:      .quad   0x0000000000000000
 .Lnull:         .long   0x0000000000000000
                 .align  16
 /*
@@ -92,5 +110,3 @@ do_reipl:	basr	%r13,0
                 .long   0x00000000,0x00000000
                 .long   0x00000000,0x00000000
         
-
-        
diff --git a/arch/s390/kernel/reipl_diag.c b/arch/s390/kernel/reipl_diag.c
deleted file mode 100644
index 1f33951ba439..000000000000
--- a/arch/s390/kernel/reipl_diag.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * This file contains the implementation of the
- * Linux re-IPL support
- *
- * (C) Copyright IBM Corp. 2005
- *
- * Author(s): Volker Sameske (sameske@de.ibm.com)
- *
- */
-
-#include <linux/kernel.h>
-
-static unsigned int reipl_diag_rc1;
-static unsigned int reipl_diag_rc2;
-
-/*
- * re-IPL the system using the last used IPL parameters
- */
-void reipl_diag(void)
-{
-        asm volatile (
-                "   la   %%r4,0\n"
-                "   la   %%r5,0\n"
-                "   diag %%r4,%2,0x308\n"
-                "0:\n"
-                "   st   %%r4,%0\n"
-                "   st   %%r5,%1\n"
-                ".section __ex_table,\"a\"\n"
-#ifdef CONFIG_64BIT
-                "   .align 8\n"
-                "   .quad 0b, 0b\n"
-#else
-                "   .align 4\n"
-                "   .long 0b, 0b\n"
-#endif
-                ".previous\n"
-                : "=m" (reipl_diag_rc1), "=m" (reipl_diag_rc2)
-                : "d" (3) : "cc", "4", "5" );
-}
diff --git a/arch/s390/kernel/s390_ksyms.c b/arch/s390/kernel/s390_ksyms.c
index c73a45467fa4..9f19e833a562 100644
--- a/arch/s390/kernel/s390_ksyms.c
+++ b/arch/s390/kernel/s390_ksyms.c
@@ -25,12 +25,6 @@ EXPORT_SYMBOL(_oi_bitmap);
 EXPORT_SYMBOL(_ni_bitmap);
 EXPORT_SYMBOL(_zb_findmap);
 EXPORT_SYMBOL(_sb_findmap);
-EXPORT_SYMBOL(__copy_from_user_asm);
-EXPORT_SYMBOL(__copy_to_user_asm);
-EXPORT_SYMBOL(__copy_in_user_asm);
-EXPORT_SYMBOL(__clear_user_asm);
-EXPORT_SYMBOL(__strncpy_from_user_asm);
-EXPORT_SYMBOL(__strnlen_user_asm);
 EXPORT_SYMBOL(diag10);
 
 /*
diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c
index c902f059c7aa..e3d9325f6022 100644
--- a/arch/s390/kernel/setup.c
+++ b/arch/s390/kernel/setup.c
@@ -37,6 +37,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/device.h>
 #include <linux/notifier.h>
+#include <linux/pfn.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -50,6 +51,12 @@
 #include <asm/sections.h>
 
 /*
+ * User copy operations.
+ */
+struct uaccess_ops uaccess;
+EXPORT_SYMBOL_GPL(uaccess);
+
+/*
  * Machine setup..
  */
 unsigned int console_mode = 0;
@@ -284,16 +291,9 @@ void (*_machine_power_off)(void) = machine_power_off_smp;
 /*
  * Reboot, halt and power_off routines for non SMP.
  */
-extern void reipl(unsigned long devno);
-extern void reipl_diag(void);
 static void do_machine_restart_nonsmp(char * __unused)
 {
-        reipl_diag();
-
-        if (MACHINE_IS_VM)
-                cpcmd ("IPL", NULL, 0, NULL);
-        else
-                reipl (0x10000 | S390_lowcore.ipl_device);
+        do_reipl();
 }
 
 static void do_machine_halt_nonsmp(void)
@@ -501,13 +501,47 @@ setup_memory(void)
          * partially used pages are not usable - thus
          * we are rounding upwards:
          */
-        start_pfn = (__pa(&_end) + PAGE_SIZE - 1) >> PAGE_SHIFT;
-        end_pfn = max_pfn = memory_end >> PAGE_SHIFT;
+        start_pfn = PFN_UP(__pa(&_end));
+        end_pfn = max_pfn = PFN_DOWN(memory_end);
 
         /* Initialize storage key for kernel pages */
         for (init_pfn = 0 ; init_pfn < start_pfn; init_pfn++)
                 page_set_storage_key(init_pfn << PAGE_SHIFT, PAGE_DEFAULT_KEY);
 
+#ifdef CONFIG_BLK_DEV_INITRD
+        /*
+         * Move the initrd in case the bitmap of the bootmem allocater
+         * would overwrite it.
+         */
+
+        if (INITRD_START && INITRD_SIZE) {
+                unsigned long bmap_size;
+                unsigned long start;
+
+                bmap_size = bootmem_bootmap_pages(end_pfn - start_pfn + 1);
+                bmap_size = PFN_PHYS(bmap_size);
+
+                if (PFN_PHYS(start_pfn) + bmap_size > INITRD_START) {
+                        start = PFN_PHYS(start_pfn) + bmap_size + PAGE_SIZE;
+
+                        if (start + INITRD_SIZE > memory_end) {
+                                printk("initrd extends beyond end of memory "
+                                       "(0x%08lx > 0x%08lx)\n"
+                                       "disabling initrd\n",
+                                       start + INITRD_SIZE, memory_end);
+                                INITRD_START = INITRD_SIZE = 0;
+                        } else {
+                                printk("Moving initrd (0x%08lx -> 0x%08lx, "
+                                       "size: %ld)\n",
+                                       INITRD_START, start, INITRD_SIZE);
+                                memmove((void *) start, (void *) INITRD_START,
+                                        INITRD_SIZE);
+                                INITRD_START = start;
+                        }
+                }
+        }
+#endif
+
         /*
          * Initialize the boot-time allocator (with low memory only):
          */
@@ -559,7 +593,7 @@ setup_memory(void)
         reserve_bootmem(start_pfn << PAGE_SHIFT, bootmap_size);
 
 #ifdef CONFIG_BLK_DEV_INITRD
-        if (INITRD_START) {
+        if (INITRD_START && INITRD_SIZE) {
                 if (INITRD_START + INITRD_SIZE <= memory_end) {
                         reserve_bootmem(INITRD_START, INITRD_SIZE);
                         initrd_start = INITRD_START;
@@ -613,6 +647,11 @@ setup_arch(char **cmdline_p)
 
         memory_end = memory_size;
 
+        if (MACHINE_HAS_MVCOS)
+                memcpy(&uaccess, &uaccess_mvcos, sizeof(uaccess));
+        else
+                memcpy(&uaccess, &uaccess_std, sizeof(uaccess));
+
         parse_early_param();
 
 #ifndef CONFIG_64BIT
@@ -720,214 +759,3 @@ struct seq_operations cpuinfo_op = {
         .show   = show_cpuinfo,
 };
 
-#define DEFINE_IPL_ATTR(_name, _format, _value)                 \
-static ssize_t ipl_##_name##_show(struct subsystem *subsys,     \
-                char *page)                                     \
-{                                                               \
-        return sprintf(page, _format, _value);                  \
-}                                                               \
-static struct subsys_attribute ipl_##_name##_attr =             \
-        __ATTR(_name, S_IRUGO, ipl_##_name##_show, NULL);
-
-DEFINE_IPL_ATTR(wwpn, "0x%016llx\n", (unsigned long long)
-                IPL_PARMBLOCK_START->fcp.wwpn);
-DEFINE_IPL_ATTR(lun, "0x%016llx\n", (unsigned long long)
-                IPL_PARMBLOCK_START->fcp.lun);
-DEFINE_IPL_ATTR(bootprog, "%lld\n", (unsigned long long)
-                IPL_PARMBLOCK_START->fcp.bootprog);
-DEFINE_IPL_ATTR(br_lba, "%lld\n", (unsigned long long)
-                IPL_PARMBLOCK_START->fcp.br_lba);
-
-enum ipl_type_type {
-        ipl_type_unknown,
-        ipl_type_ccw,
-        ipl_type_fcp,
-};
-
-static enum ipl_type_type
-get_ipl_type(void)
-{
-        struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
-
-        if (!IPL_DEVNO_VALID)
-                return ipl_type_unknown;
-        if (!IPL_PARMBLOCK_VALID)
-                return ipl_type_ccw;
-        if (ipl->hdr.header.version > IPL_MAX_SUPPORTED_VERSION)
-                return ipl_type_unknown;
-        if (ipl->fcp.pbt != IPL_TYPE_FCP)
-                return ipl_type_unknown;
-        return ipl_type_fcp;
-}
-
-static ssize_t
-ipl_type_show(struct subsystem *subsys, char *page)
-{
-        switch (get_ipl_type()) {
-        case ipl_type_ccw:
-                return sprintf(page, "ccw\n");
-        case ipl_type_fcp:
-                return sprintf(page, "fcp\n");
-        default:
-                return sprintf(page, "unknown\n");
-        }
-}
-
-static struct subsys_attribute ipl_type_attr = __ATTR_RO(ipl_type);
-
-static ssize_t
-ipl_device_show(struct subsystem *subsys, char *page)
-{
-        struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
-
-        switch (get_ipl_type()) {
-        case ipl_type_ccw:
-                return sprintf(page, "0.0.%04x\n", ipl_devno);
-        case ipl_type_fcp:
-                return sprintf(page, "0.0.%04x\n", ipl->fcp.devno);
-        default:
-                return 0;
-        }
-}
-
-static struct subsys_attribute ipl_device_attr =
-        __ATTR(device, S_IRUGO, ipl_device_show, NULL);
-
-static struct attribute *ipl_fcp_attrs[] = {
-        &ipl_type_attr.attr,
-        &ipl_device_attr.attr,
-        &ipl_wwpn_attr.attr,
-        &ipl_lun_attr.attr,
-        &ipl_bootprog_attr.attr,
-        &ipl_br_lba_attr.attr,
-        NULL,
-};
-
-static struct attribute_group ipl_fcp_attr_group = {
-        .attrs = ipl_fcp_attrs,
-};
-
-static struct attribute *ipl_ccw_attrs[] = {
-        &ipl_type_attr.attr,
-        &ipl_device_attr.attr,
-        NULL,
-};
-
-static struct attribute_group ipl_ccw_attr_group = {
-        .attrs = ipl_ccw_attrs,
-};
-
-static struct attribute *ipl_unknown_attrs[] = {
-        &ipl_type_attr.attr,
-        NULL,
-};
-
-static struct attribute_group ipl_unknown_attr_group = {
-        .attrs = ipl_unknown_attrs,
-};
-
-static ssize_t
-ipl_parameter_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
-{
-        unsigned int size = IPL_PARMBLOCK_SIZE;
-
-        if (off > size)
-                return 0;
-        if (off + count > size)
-                count = size - off;
-
-        memcpy(buf, (void *) IPL_PARMBLOCK_START + off, count);
-        return count;
-}
-
-static struct bin_attribute ipl_parameter_attr = {
-        .attr = {
-                .name = "binary_parameter",
-                .mode = S_IRUGO,
-                .owner = THIS_MODULE,
-        },
-        .size = PAGE_SIZE,
-        .read = &ipl_parameter_read,
-};
-
-static ssize_t
-ipl_scp_data_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
-{
-        unsigned int size =  IPL_PARMBLOCK_START->fcp.scp_data_len;
-        void *scp_data = &IPL_PARMBLOCK_START->fcp.scp_data;
-
-        if (off > size)
-                return 0;
-        if (off + count > size)
-                count = size - off;
-
-        memcpy(buf, scp_data + off, count);
-        return count;
-}
-
-static struct bin_attribute ipl_scp_data_attr = {
-        .attr = {
-                .name = "scp_data",
-                .mode = S_IRUGO,
-                .owner = THIS_MODULE,
-        },
-        .size = PAGE_SIZE,
-        .read = &ipl_scp_data_read,
-};
-
-static decl_subsys(ipl, NULL, NULL);
-
-static int ipl_register_fcp_files(void)
-{
-        int rc;
-
-        rc = sysfs_create_group(&ipl_subsys.kset.kobj,
-                                &ipl_fcp_attr_group);
-        if (rc)
-                goto out;
-        rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
-                                   &ipl_parameter_attr);
-        if (rc)
-                goto out_ipl_parm;
-        rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
-                                   &ipl_scp_data_attr);
-        if (!rc)
-                goto out;
-
-        sysfs_remove_bin_file(&ipl_subsys.kset.kobj, &ipl_parameter_attr);
-
-out_ipl_parm:
-        sysfs_remove_group(&ipl_subsys.kset.kobj, &ipl_fcp_attr_group);
-out:
-        return rc;
-}
-
-static int __init
-ipl_device_sysfs_register(void) {
-        int rc;
-
-        rc = firmware_register(&ipl_subsys);
-        if (rc)
-                goto out;
-
-        switch (get_ipl_type()) {
-        case ipl_type_ccw:
-                rc = sysfs_create_group(&ipl_subsys.kset.kobj,
-                                        &ipl_ccw_attr_group);
-                break;
-        case ipl_type_fcp:
-                rc = ipl_register_fcp_files();
-                break;
-        default:
-                rc = sysfs_create_group(&ipl_subsys.kset.kobj,
-                                        &ipl_unknown_attr_group);
-                break;
-        }
-
-        if (rc)
-                firmware_unregister(&ipl_subsys);
-out:
-        return rc;
-}
-
-__initcall(ipl_device_sysfs_register);
diff --git a/arch/s390/kernel/signal.c b/arch/s390/kernel/signal.c
index a887b686f279..642095ec7c07 100644
--- a/arch/s390/kernel/signal.c
+++ b/arch/s390/kernel/signal.c
@@ -114,29 +114,26 @@ sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
 {
         unsigned long old_mask = regs->psw.mask;
-        int err;
-  
+        _sigregs user_sregs;
+
         save_access_regs(current->thread.acrs);
 
         /* Copy a 'clean' PSW mask to the user to avoid leaking
            information about whether PER is currently on.  */
         regs->psw.mask = PSW_MASK_MERGE(PSW_USER_BITS, regs->psw.mask);
-        err = __copy_to_user(&sregs->regs.psw, &regs->psw,
-                             sizeof(sregs->regs.psw)+sizeof(sregs->regs.gprs));
+        memcpy(&user_sregs.regs.psw, &regs->psw, sizeof(sregs->regs.psw) +
+               sizeof(sregs->regs.gprs));
         regs->psw.mask = old_mask;
-        if (err != 0)
-                return err;
-        err = __copy_to_user(&sregs->regs.acrs, current->thread.acrs,
-                             sizeof(sregs->regs.acrs));
-        if (err != 0)
-                return err;
+        memcpy(&user_sregs.regs.acrs, current->thread.acrs,
+               sizeof(sregs->regs.acrs));
         /* 
          * We have to store the fp registers to current->thread.fp_regs
          * to merge them with the emulated registers.
          */
         save_fp_regs(&current->thread.fp_regs);
-        return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
-                              sizeof(s390_fp_regs));
+        memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
+               sizeof(s390_fp_regs));
+        return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
 }
 
 /* Returns positive number on error */
@@ -144,27 +141,25 @@ static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
 {
         unsigned long old_mask = regs->psw.mask;
         int err;
+        _sigregs user_sregs;
 
         /* Alwys make any pending restarted system call return -EINTR */
         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 
-        err = __copy_from_user(&regs->psw, &sregs->regs.psw,
-                               sizeof(sregs->regs.psw)+sizeof(sregs->regs.gprs));
+        err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
         regs->psw.mask = PSW_MASK_MERGE(old_mask, regs->psw.mask);
         regs->psw.addr |= PSW_ADDR_AMODE;
         if (err)
                 return err;
-        err = __copy_from_user(&current->thread.acrs, &sregs->regs.acrs,
-                               sizeof(sregs->regs.acrs));
-        if (err)
-                return err;
+        memcpy(&regs->psw, &user_sregs.regs.psw, sizeof(sregs->regs.psw) +
+               sizeof(sregs->regs.gprs));
+        memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
+               sizeof(sregs->regs.acrs));
         restore_access_regs(current->thread.acrs);
 
-        err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
-                               sizeof(s390_fp_regs));
+        memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
+               sizeof(s390_fp_regs));
         current->thread.fp_regs.fpc &= FPC_VALID_MASK;
-        if (err)
-                return err;
 
         restore_fp_regs(&current->thread.fp_regs);
         regs->trap = -1;        /* disable syscall checks */
@@ -457,6 +452,7 @@ void do_signal(struct pt_regs *regs)
                 case -ERESTART_RESTARTBLOCK:
                         regs->gprs[2] = -EINTR;
                 }
+                regs->trap = -1;        /* Don't deal with this again. */
         }
 
         /* Get signal to deliver.  When running under ptrace, at this point
diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
index 8e03219eea76..b2e6f4c8d382 100644
--- a/arch/s390/kernel/smp.c
+++ b/arch/s390/kernel/smp.c
@@ -59,9 +59,6 @@ static struct task_struct *current_set[NR_CPUS];
 extern char vmhalt_cmd[];
 extern char vmpoff_cmd[];
 
-extern void reipl(unsigned long devno);
-extern void reipl_diag(void);
-
 static void smp_ext_bitcall(int, ec_bit_sig);
 static void smp_ext_bitcall_others(ec_bit_sig);
 
@@ -279,12 +276,7 @@ static void do_machine_restart(void * __unused)
          * interrupted by an external interrupt and s390irq
          * locks are always held disabled).
          */
-        reipl_diag();
-
-        if (MACHINE_IS_VM)
-                cpcmd ("IPL", NULL, 0, NULL);
-        else
-                reipl (0x10000 | S390_lowcore.ipl_device);
+        do_reipl();
 }
 
 void machine_restart_smp(char * __unused) 
diff --git a/arch/s390/kernel/traps.c b/arch/s390/kernel/traps.c
index bde1d1d59858..c4982c963424 100644
--- a/arch/s390/kernel/traps.c
+++ b/arch/s390/kernel/traps.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/kallsyms.h>
 #include <linux/reboot.h>
+#include <linux/kprobes.h>
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
@@ -39,6 +40,7 @@
 #include <asm/s390_ext.h>
 #include <asm/lowcore.h>
 #include <asm/debug.h>
+#include <asm/kdebug.h>
 
 /* Called from entry.S only */
 extern void handle_per_exception(struct pt_regs *regs);
@@ -74,6 +76,20 @@ static int kstack_depth_to_print = 12;
 static int kstack_depth_to_print = 20;
 #endif /* CONFIG_64BIT */
 
+ATOMIC_NOTIFIER_HEAD(s390die_chain);
+
+int register_die_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_register(&s390die_chain, nb);
+}
+EXPORT_SYMBOL(register_die_notifier);
+
+int unregister_die_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_unregister(&s390die_chain, nb);
+}
+EXPORT_SYMBOL(unregister_die_notifier);
+
 /*
  * For show_trace we have tree different stack to consider:
  *   - the panic stack which is used if the kernel stack has overflown
@@ -305,8 +321,9 @@ report_user_fault(long interruption_code, struct pt_regs *regs)
 #endif
 }
 
-static void inline do_trap(long interruption_code, int signr, char *str,
-                           struct pt_regs *regs, siginfo_t *info)
+static void __kprobes inline do_trap(long interruption_code, int signr,
+                                        char *str, struct pt_regs *regs,
+                                        siginfo_t *info)
 {
         /*
          * We got all needed information from the lowcore and can
@@ -315,6 +332,10 @@ static void inline do_trap(long interruption_code, int signr, char *str,
         if (regs->psw.mask & PSW_MASK_PSTATE)
                 local_irq_enable();
 
+        if (notify_die(DIE_TRAP, str, regs, interruption_code,
+                                interruption_code, signr) == NOTIFY_STOP)
+                return;
+
         if (regs->psw.mask & PSW_MASK_PSTATE) {
                 struct task_struct *tsk = current;
 
@@ -336,8 +357,12 @@ static inline void __user *get_check_address(struct pt_regs *regs)
         return (void __user *)((regs->psw.addr-S390_lowcore.pgm_ilc) & PSW_ADDR_INSN);
 }
 
-void do_single_step(struct pt_regs *regs)
+void __kprobes do_single_step(struct pt_regs *regs)
 {
+        if (notify_die(DIE_SSTEP, "sstep", regs, 0, 0,
+                                        SIGTRAP) == NOTIFY_STOP){
+                return;
+        }
         if ((current->ptrace & PT_PTRACED) != 0)
                 force_sig(SIGTRAP, current);
 }
diff --git a/arch/s390/kernel/vmlinux.lds.S b/arch/s390/kernel/vmlinux.lds.S
index ff5f7bb34f75..af9e69a03011 100644
--- a/arch/s390/kernel/vmlinux.lds.S
+++ b/arch/s390/kernel/vmlinux.lds.S
@@ -24,6 +24,7 @@ SECTIONS
         *(.text)
         SCHED_TEXT
         LOCK_TEXT
+        KPROBES_TEXT
         *(.fixup)
         *(.gnu.warning)
         } = 0x0700
@@ -117,7 +118,7 @@ SECTIONS
 
   /* Sections to be discarded */
   /DISCARD/ : {
-        *(.exitcall.exit)
+        *(.exit.text) *(.exit.data) *(.exitcall.exit)
         }
 
   /* Stabs debugging sections.  */
diff --git a/arch/s390/lib/Makefile b/arch/s390/lib/Makefile
index e05d087a6eae..c42ffedfdb49 100644
--- a/arch/s390/lib/Makefile
+++ b/arch/s390/lib/Makefile
@@ -4,6 +4,6 @@
 
 EXTRA_AFLAGS := -traditional
 
-lib-y += delay.o string.o
-lib-y += $(if $(CONFIG_64BIT),uaccess64.o,uaccess.o)
+lib-y += delay.o string.o uaccess_std.o
+lib-$(CONFIG_64BIT) += uaccess_mvcos.o
 lib-$(CONFIG_SMP) += spinlock.o
diff --git a/arch/s390/lib/uaccess.S b/arch/s390/lib/uaccess.S
deleted file mode 100644
index 837275284d9f..000000000000
--- a/arch/s390/lib/uaccess.S
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- *  arch/s390/lib/uaccess.S
- *    __copy_{from|to}_user functions.
- *
- *  s390
- *    Copyright (C) 2000,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
- *    Authors(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
- *
- *  These functions have standard call interface
- */
-
-#include <linux/errno.h>
-#include <asm/lowcore.h>
-#include <asm/asm-offsets.h>
-
-        .text
-        .align 4
-        .globl __copy_from_user_asm
-        # %r2 = to, %r3 = n, %r4 = from
-__copy_from_user_asm:
-        slr     %r0,%r0
-0:      mvcp    0(%r3,%r2),0(%r4),%r0
-        jnz     1f
-        slr     %r2,%r2
-        br      %r14
-1:      la      %r2,256(%r2)
-        la      %r4,256(%r4)
-        ahi     %r3,-256
-2:      mvcp    0(%r3,%r2),0(%r4),%r0
-        jnz     1b
-3:      slr     %r2,%r2
-        br      %r14
-4:      lhi     %r0,-4096
-        lr      %r5,%r4
-        slr     %r5,%r0
-        nr      %r5,%r0         # %r5 = (%r4 + 4096) & -4096
-        slr     %r5,%r4         # %r5 = #bytes to next user page boundary
-        clr     %r3,%r5         # copy crosses next page boundary ?
-        jnh     6f              # no, the current page faulted
-        # move with the reduced length which is < 256
-5:      mvcp    0(%r5,%r2),0(%r4),%r0
-        slr     %r3,%r5
-6:      lr      %r2,%r3
-        br      %r14
-        .section __ex_table,"a"
-        .long   0b,4b
-        .long   2b,4b
-        .long   5b,6b
-        .previous
-
-        .align 4
-        .text
-        .globl __copy_to_user_asm
-        # %r2 = from, %r3 = n, %r4 = to
-__copy_to_user_asm:
-        slr     %r0,%r0
-0:      mvcs    0(%r3,%r4),0(%r2),%r0
-        jnz     1f
-        slr     %r2,%r2
-        br      %r14
-1:      la      %r2,256(%r2)
-        la      %r4,256(%r4)
-        ahi     %r3,-256
-2:      mvcs    0(%r3,%r4),0(%r2),%r0
-        jnz     1b
-3:      slr     %r2,%r2
-        br      %r14
-4:      lhi     %r0,-4096
-        lr      %r5,%r4
-        slr     %r5,%r0
-        nr      %r5,%r0         # %r5 = (%r4 + 4096) & -4096
-        slr     %r5,%r4         # %r5 = #bytes to next user page boundary
-        clr     %r3,%r5         # copy crosses next page boundary ?
-        jnh     6f              # no, the current page faulted
-        # move with the reduced length which is < 256
-5:      mvcs    0(%r5,%r4),0(%r2),%r0
-        slr     %r3,%r5
-6:      lr      %r2,%r3
-        br      %r14
-        .section __ex_table,"a"
-        .long   0b,4b
-        .long   2b,4b
-        .long   5b,6b
-        .previous
-
-        .align 4
-        .text
-        .globl __copy_in_user_asm
-        # %r2 = from, %r3 = n, %r4 = to
-__copy_in_user_asm:
-        ahi     %r3,-1
-        jo      6f
-        sacf    256
-        bras    %r1,4f
-0:      ahi     %r3,257
-1:      mvc     0(1,%r4),0(%r2)
-        la      %r2,1(%r2)
-        la      %r4,1(%r4)
-        ahi     %r3,-1
-        jnz     1b
-2:      lr      %r2,%r3
-        br      %r14
-3:      mvc     0(256,%r4),0(%r2)
-        la      %r2,256(%r2)
-        la      %r4,256(%r4)
-4:      ahi     %r3,-256
-        jnm     3b
-5:      ex      %r3,4(%r1)
-        sacf    0
-6:      slr     %r2,%r2
-        br      %r14
-        .section __ex_table,"a"
-        .long   1b,2b
-        .long   3b,0b
-        .long   5b,0b
-        .previous
-
-        .align 4
-        .text
-        .globl __clear_user_asm
-        # %r2 = to, %r3 = n
-__clear_user_asm:
-        bras    %r5,0f
-        .long   empty_zero_page
-0:      l       %r5,0(%r5)
-        slr     %r0,%r0
-1:      mvcs    0(%r3,%r2),0(%r5),%r0
-        jnz     2f
-        slr     %r2,%r2
-        br      %r14
-2:      la      %r2,256(%r2)
-        ahi     %r3,-256
-3:      mvcs    0(%r3,%r2),0(%r5),%r0
-        jnz     2b
-4:      slr     %r2,%r2
-        br      %r14
-5:      lhi     %r0,-4096
-        lr      %r4,%r2
-        slr     %r4,%r0
-        nr      %r4,%r0         # %r4 = (%r2 + 4096) & -4096
-        slr     %r4,%r2         # %r4 = #bytes to next user page boundary
-        clr     %r3,%r4         # clear crosses next page boundary ?
-        jnh     7f              # no, the current page faulted
-        # clear with the reduced length which is < 256
-6:      mvcs    0(%r4,%r2),0(%r5),%r0
-        slr     %r3,%r4
-7:      lr      %r2,%r3
-        br      %r14
-        .section __ex_table,"a"
-        .long   1b,5b
-        .long   3b,5b
-        .long   6b,7b
-        .previous
-
-        .align 4
-        .text
-        .globl __strncpy_from_user_asm
-        # %r2 = count, %r3 = dst, %r4 = src
-__strncpy_from_user_asm:
-        lhi     %r0,0
-        lr      %r1,%r4
-        la      %r4,0(%r4)      # clear high order bit from %r4
-        la      %r2,0(%r2,%r4)  # %r2 points to first byte after string
-        sacf    256
-0:      srst    %r2,%r1
-        jo      0b
-        sacf    0
-        lr      %r1,%r2
-        jh      1f              # \0 found in string ?
-        ahi     %r1,1           # include \0 in copy
-1:      slr     %r1,%r4         # %r1 = copy length (without \0)
-        slr     %r2,%r4         # %r2 = return length (including \0)
-2:      mvcp    0(%r1,%r3),0(%r4),%r0
-        jnz     3f
-        br      %r14
-3:      la      %r3,256(%r3)
-        la      %r4,256(%r4)
-        ahi     %r1,-256
-        mvcp    0(%r1,%r3),0(%r4),%r0
-        jnz     3b
-        br      %r14
-4:      sacf    0
-        lhi     %r2,-EFAULT
-        br      %r14
-        .section __ex_table,"a"
-        .long   0b,4b
-        .previous
-
-        .align 4
-        .text
-        .globl __strnlen_user_asm
-        # %r2 = count, %r3 = src
-__strnlen_user_asm:
-        lhi     %r0,0
-        lr      %r1,%r3
-        la      %r3,0(%r3)      # clear high order bit from %r4
-        la      %r2,0(%r2,%r3)  # %r2 points to first byte after string
-        sacf    256
-0:      srst    %r2,%r1
-        jo      0b
-        sacf    0
-        ahi     %r2,1           # strnlen_user result includes the \0
-                                # or return count+1 if \0 not found
-        slr     %r2,%r3
-        br      %r14
-2:      sacf    0
-        slr     %r2,%r2         # return 0 on exception
-        br      %r14
-        .section __ex_table,"a"
-        .long   0b,2b
-        .previous
diff --git a/arch/s390/lib/uaccess64.S b/arch/s390/lib/uaccess64.S
deleted file mode 100644
index 1f755be22f92..000000000000
--- a/arch/s390/lib/uaccess64.S
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
- *  arch/s390x/lib/uaccess.S
- *    __copy_{from|to}_user functions.
- *
- *  s390
- *    Copyright (C) 2000,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
- *    Authors(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
- *
- *  These functions have standard call interface
- */
-
-#include <linux/errno.h>
-#include <asm/lowcore.h>
-#include <asm/asm-offsets.h>
-
-        .text
-        .align 4
-        .globl __copy_from_user_asm
-        # %r2 = to, %r3 = n, %r4 = from
-__copy_from_user_asm:
-        slgr    %r0,%r0
-0:      mvcp    0(%r3,%r2),0(%r4),%r0
-        jnz     1f
-        slgr    %r2,%r2
-        br      %r14
-1:      la      %r2,256(%r2)
-        la      %r4,256(%r4)
-        aghi    %r3,-256
-2:      mvcp    0(%r3,%r2),0(%r4),%r0
-        jnz     1b
-3:      slgr    %r2,%r2
-        br      %r14
-4:      lghi    %r0,-4096
-        lgr     %r5,%r4
-        slgr    %r5,%r0
-        ngr     %r5,%r0         # %r5 = (%r4 + 4096) & -4096
-        slgr    %r5,%r4         # %r5 = #bytes to next user page boundary
-        clgr    %r3,%r5         # copy crosses next page boundary ?
-        jnh     6f              # no, the current page faulted
-        # move with the reduced length which is < 256
-5:      mvcp    0(%r5,%r2),0(%r4),%r0
-        slgr    %r3,%r5
-6:      lgr     %r2,%r3
-        br      %r14
-        .section __ex_table,"a"
-        .quad   0b,4b
-        .quad   2b,4b
-        .quad   5b,6b
-        .previous
-
-        .align 4
-        .text
-        .globl __copy_to_user_asm
-        # %r2 = from, %r3 = n, %r4 = to
-__copy_to_user_asm:
-        slgr    %r0,%r0
-0:      mvcs    0(%r3,%r4),0(%r2),%r0
-        jnz     1f
-        slgr    %r2,%r2
-        br      %r14
-1:      la      %r2,256(%r2)
-        la      %r4,256(%r4)
-        aghi    %r3,-256
-2:      mvcs    0(%r3,%r4),0(%r2),%r0
-        jnz     1b
-3:      slgr    %r2,%r2
-        br      %r14
-4:      lghi    %r0,-4096
-        lgr     %r5,%r4
-        slgr    %r5,%r0
-        ngr     %r5,%r0         # %r5 = (%r4 + 4096) & -4096
-        slgr    %r5,%r4         # %r5 = #bytes to next user page boundary
-        clgr    %r3,%r5         # copy crosses next page boundary ?
-        jnh     6f              # no, the current page faulted
-        # move with the reduced length which is < 256
-5:      mvcs    0(%r5,%r4),0(%r2),%r0
-        slgr    %r3,%r5
-6:      lgr     %r2,%r3
-        br      %r14
-        .section __ex_table,"a"
-        .quad   0b,4b
-        .quad   2b,4b
-        .quad   5b,6b
-        .previous
-
-        .align 4
-        .text
-        .globl __copy_in_user_asm
-        # %r2 = from, %r3 = n, %r4 = to
-__copy_in_user_asm:
-        aghi    %r3,-1
-        jo      6f
-        sacf    256
-        bras    %r1,4f
-0:      aghi    %r3,257
-1:      mvc     0(1,%r4),0(%r2)
-        la      %r2,1(%r2)
-        la      %r4,1(%r4)
-        aghi    %r3,-1
-        jnz     1b
-2:      lgr     %r2,%r3
-        br      %r14
-3:      mvc     0(256,%r4),0(%r2)
-        la      %r2,256(%r2)
-        la      %r4,256(%r4)
-4:      aghi    %r3,-256
-        jnm     3b
-5:      ex      %r3,4(%r1)
-        sacf    0
-6:      slgr    %r2,%r2
-        br      14
-        .section __ex_table,"a"
-        .quad   1b,2b
-        .quad   3b,0b
-        .quad   5b,0b
-        .previous
-
-        .align 4
-        .text
-        .globl __clear_user_asm
-        # %r2 = to, %r3 = n
-__clear_user_asm:
-        slgr    %r0,%r0
-        larl    %r5,empty_zero_page
-1:      mvcs    0(%r3,%r2),0(%r5),%r0
-        jnz     2f
-        slgr    %r2,%r2
-        br      %r14
-2:      la      %r2,256(%r2)
-        aghi    %r3,-256
-3:      mvcs    0(%r3,%r2),0(%r5),%r0
-        jnz     2b
-4:      slgr    %r2,%r2
-        br      %r14
-5:      lghi    %r0,-4096
-        lgr     %r4,%r2
-        slgr    %r4,%r0
-        ngr     %r4,%r0         # %r4 = (%r2 + 4096) & -4096
-        slgr    %r4,%r2         # %r4 = #bytes to next user page boundary
-        clgr    %r3,%r4         # clear crosses next page boundary ?
-        jnh     7f              # no, the current page faulted
-        # clear with the reduced length which is < 256
-6:      mvcs    0(%r4,%r2),0(%r5),%r0
-        slgr    %r3,%r4
-7:      lgr     %r2,%r3
-        br      %r14
-        .section __ex_table,"a"
-        .quad   1b,5b
-        .quad   3b,5b
-        .quad   6b,7b
-        .previous
-
-        .align 4
-        .text
-        .globl __strncpy_from_user_asm
-        # %r2 = count, %r3 = dst, %r4 = src
-__strncpy_from_user_asm:
-        lghi    %r0,0
-        lgr     %r1,%r4
-        la      %r2,0(%r2,%r4)  # %r2 points to first byte after string
-        sacf    256
-0:      srst    %r2,%r1
-        jo      0b
-        sacf    0
-        lgr     %r1,%r2
-        jh      1f              # \0 found in string ?
-        aghi    %r1,1           # include \0 in copy
-1:      slgr    %r1,%r4         # %r1 = copy length (without \0)
-        slgr    %r2,%r4         # %r2 = return length (including \0)
-2:      mvcp    0(%r1,%r3),0(%r4),%r0
-        jnz     3f
-        br      %r14
-3:      la      %r3,256(%r3)
-        la      %r4,256(%r4)
-        aghi    %r1,-256
-        mvcp    0(%r1,%r3),0(%r4),%r0
-        jnz     3b
-        br      %r14
-4:      sacf    0
-        lghi    %r2,-EFAULT
-        br      %r14
-        .section __ex_table,"a"
-        .quad   0b,4b
-        .previous
-
-        .align 4
-        .text
-        .globl __strnlen_user_asm
-        # %r2 = count, %r3 = src
-__strnlen_user_asm:
-        lghi    %r0,0
-        lgr     %r1,%r3
-        la      %r2,0(%r2,%r3)  # %r2 points to first byte after string
-        sacf    256
-0:      srst    %r2,%r1
-        jo      0b
-        sacf    0
-        aghi    %r2,1           # strnlen_user result includes the \0
-                                # or return count+1 if \0 not found
-        slgr    %r2,%r3
-        br      %r14
-2:      sacf    0
-        slgr    %r2,%r2         # return 0 on exception
-        br      %r14
-        .section __ex_table,"a"
-        .quad   0b,2b
-        .previous
diff --git a/arch/s390/lib/uaccess_mvcos.c b/arch/s390/lib/uaccess_mvcos.c
new file mode 100644
index 000000000000..86c96d6c191a
--- /dev/null
+++ b/arch/s390/lib/uaccess_mvcos.c
@@ -0,0 +1,156 @@
+/*
+ *  arch/s390/lib/uaccess_mvcos.c
+ *
+ *  Optimized user space space access functions based on mvcos.
+ *
+ *    Copyright (C) IBM Corp. 2006
+ *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
+ *               Gerald Schaefer (gerald.schaefer@de.ibm.com)
+ */
+
+#include <linux/errno.h>
+#include <linux/mm.h>
+#include <asm/uaccess.h>
+#include <asm/futex.h>
+
+#ifndef __s390x__
+#define AHI     "ahi"
+#define ALR     "alr"
+#define CLR     "clr"
+#define LHI     "lhi"
+#define SLR     "slr"
+#else
+#define AHI     "aghi"
+#define ALR     "algr"
+#define CLR     "clgr"
+#define LHI     "lghi"
+#define SLR     "slgr"
+#endif
+
+size_t copy_from_user_mvcos(size_t size, const void __user *ptr, void *x)
+{
+        register unsigned long reg0 asm("0") = 0x81UL;
+        unsigned long tmp1, tmp2;
+
+        tmp1 = -4096UL;
+        asm volatile(
+                "0: .insn ss,0xc80000000000,0(%0,%2),0(%1),0\n"
+                "   jz    4f\n"
+                "1:"ALR"  %0,%3\n"
+                "  "SLR"  %1,%3\n"
+                "  "SLR"  %2,%3\n"
+                "   j     0b\n"
+                "2: la    %4,4095(%1)\n"/* %4 = ptr + 4095 */
+                "   nr    %4,%3\n"      /* %4 = (ptr + 4095) & -4096 */
+                "  "SLR"  %4,%1\n"
+                "  "CLR"  %0,%4\n"      /* copy crosses next page boundary? */
+                "   jnh   5f\n"
+                "3: .insn ss,0xc80000000000,0(%4,%2),0(%1),0\n"
+                "  "SLR"  %0,%4\n"
+                "   j     5f\n"
+                "4:"SLR"  %0,%0\n"
+                "5: \n"
+                EX_TABLE(0b,2b) EX_TABLE(3b,5b)
+                : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
+                : "d" (reg0) : "cc", "memory");
+        return size;
+}
+
+size_t copy_to_user_mvcos(size_t size, void __user *ptr, const void *x)
+{
+        register unsigned long reg0 asm("0") = 0x810000UL;
+        unsigned long tmp1, tmp2;
+
+        tmp1 = -4096UL;
+        asm volatile(
+                "0: .insn ss,0xc80000000000,0(%0,%1),0(%2),0\n"
+                "   jz    4f\n"
+                "1:"ALR"  %0,%3\n"
+                "  "SLR"  %1,%3\n"
+                "  "SLR"  %2,%3\n"
+                "   j     0b\n"
+                "2: la    %4,4095(%1)\n"/* %4 = ptr + 4095 */
+                "   nr    %4,%3\n"      /* %4 = (ptr + 4095) & -4096 */
+                "  "SLR"  %4,%1\n"
+                "  "CLR"  %0,%4\n"      /* copy crosses next page boundary? */
+                "   jnh   5f\n"
+                "3: .insn ss,0xc80000000000,0(%4,%1),0(%2),0\n"
+                "  "SLR"  %0,%4\n"
+                "   j     5f\n"
+                "4:"SLR"  %0,%0\n"
+                "5: \n"
+                EX_TABLE(0b,2b) EX_TABLE(3b,5b)
+                : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
+                : "d" (reg0) : "cc", "memory");
+        return size;
+}
+
+size_t copy_in_user_mvcos(size_t size, void __user *to, const void __user *from)
+{
+        register unsigned long reg0 asm("0") = 0x810081UL;
+        unsigned long tmp1, tmp2;
+
+        tmp1 = -4096UL;
+        /* FIXME: copy with reduced length. */
+        asm volatile(
+                "0: .insn ss,0xc80000000000,0(%0,%1),0(%2),0\n"
+                "   jz    2f\n"
+                "1:"ALR"  %0,%3\n"
+                "  "SLR"  %1,%3\n"
+                "  "SLR"  %2,%3\n"
+                "   j     0b\n"
+                "2:"SLR"  %0,%0\n"
+                "3: \n"
+                EX_TABLE(0b,3b)
+                : "+a" (size), "+a" (to), "+a" (from), "+a" (tmp1), "=a" (tmp2)
+                : "d" (reg0) : "cc", "memory");
+        return size;
+}
+
+size_t clear_user_mvcos(size_t size, void __user *to)
+{
+        register unsigned long reg0 asm("0") = 0x810000UL;
+        unsigned long tmp1, tmp2;
+
+        tmp1 = -4096UL;
+        asm volatile(
+                "0: .insn ss,0xc80000000000,0(%0,%1),0(%4),0\n"
+                "   jz    4f\n"
+                "1:"ALR"  %0,%2\n"
+                "  "SLR"  %1,%2\n"
+                "   j     0b\n"
+                "2: la    %3,4095(%1)\n"/* %4 = to + 4095 */
+                "   nr    %3,%2\n"      /* %4 = (to + 4095) & -4096 */
+                "  "SLR"  %3,%1\n"
+                "  "CLR"  %0,%3\n"      /* copy crosses next page boundary? */
+                "   jnh   5f\n"
+                "3: .insn ss,0xc80000000000,0(%3,%1),0(%4),0\n"
+                "  "SLR"  %0,%3\n"
+                "   j     5f\n"
+                "4:"SLR"  %0,%0\n"
+                "5: \n"
+                EX_TABLE(0b,2b) EX_TABLE(3b,5b)
+                : "+a" (size), "+a" (to), "+a" (tmp1), "=a" (tmp2)
+                : "a" (empty_zero_page), "d" (reg0) : "cc", "memory");
+        return size;
+}
+
+extern size_t copy_from_user_std_small(size_t, const void __user *, void *);
+extern size_t copy_to_user_std_small(size_t, void __user *, const void *);
+extern size_t strnlen_user_std(size_t, const char __user *);
+extern size_t strncpy_from_user_std(size_t, const char __user *, char *);
+extern int futex_atomic_op(int, int __user *, int, int *);
+extern int futex_atomic_cmpxchg(int __user *, int, int);
+
+struct uaccess_ops uaccess_mvcos = {
+        .copy_from_user = copy_from_user_mvcos,
+        .copy_from_user_small = copy_from_user_std_small,
+        .copy_to_user = copy_to_user_mvcos,
+        .copy_to_user_small = copy_to_user_std_small,
+        .copy_in_user = copy_in_user_mvcos,
+        .clear_user = clear_user_mvcos,
+        .strnlen_user = strnlen_user_std,
+        .strncpy_from_user = strncpy_from_user_std,
+        .futex_atomic_op = futex_atomic_op,
+        .futex_atomic_cmpxchg = futex_atomic_cmpxchg,
+};
diff --git a/arch/s390/lib/uaccess_std.c b/arch/s390/lib/uaccess_std.c
new file mode 100644
index 000000000000..9a4d4a29ea79
--- /dev/null
+++ b/arch/s390/lib/uaccess_std.c
@@ -0,0 +1,340 @@
+/*
+ *  arch/s390/lib/uaccess_std.c
+ *
+ *  Standard user space access functions based on mvcp/mvcs and doing
+ *  interesting things in the secondary space mode.
+ *
+ *    Copyright (C) IBM Corp. 2006
+ *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
+ *               Gerald Schaefer (gerald.schaefer@de.ibm.com)
+ */
+
+#include <linux/errno.h>
+#include <linux/mm.h>
+#include <asm/uaccess.h>
+#include <asm/futex.h>
+
+#ifndef __s390x__
+#define AHI     "ahi"
+#define ALR     "alr"
+#define CLR     "clr"
+#define LHI     "lhi"
+#define SLR     "slr"
+#else
+#define AHI     "aghi"
+#define ALR     "algr"
+#define CLR     "clgr"
+#define LHI     "lghi"
+#define SLR     "slgr"
+#endif
+
+size_t copy_from_user_std(size_t size, const void __user *ptr, void *x)
+{
+        unsigned long tmp1, tmp2;
+
+        tmp1 = -256UL;
+        asm volatile(
+                "0: mvcp  0(%0,%2),0(%1),%3\n"
+                "   jz    5f\n"
+                "1:"ALR"  %0,%3\n"
+                "   la    %1,256(%1)\n"
+                "   la    %2,256(%2)\n"
+                "2: mvcp  0(%0,%2),0(%1),%3\n"
+                "   jnz   1b\n"
+                "   j     5f\n"
+                "3: la    %4,255(%1)\n" /* %4 = ptr + 255 */
+                "  "LHI"  %3,-4096\n"
+                "   nr    %4,%3\n"      /* %4 = (ptr + 255) & -4096 */
+                "  "SLR"  %4,%1\n"
+                "  "CLR"  %0,%4\n"      /* copy crosses next page boundary? */
+                "   jnh   6f\n"
+                "4: mvcp  0(%4,%2),0(%1),%3\n"
+                "  "SLR"  %0,%4\n"
+                "   j     6f\n"
+                "5:"SLR"  %0,%0\n"
+                "6: \n"
+                EX_TABLE(0b,3b) EX_TABLE(2b,3b) EX_TABLE(4b,6b)
+                : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
+                : : "cc", "memory");
+        return size;
+}
+
+size_t copy_from_user_std_small(size_t size, const void __user *ptr, void *x)
+{
+        unsigned long tmp1, tmp2;
+
+        tmp1 = 0UL;
+        asm volatile(
+                "0: mvcp  0(%0,%2),0(%1),%3\n"
+                "  "SLR"  %0,%0\n"
+                "   j     3f\n"
+                "1: la    %4,255(%1)\n" /* %4 = ptr + 255 */
+                "  "LHI"  %3,-4096\n"
+                "   nr    %4,%3\n"      /* %4 = (ptr + 255) & -4096 */
+                "  "SLR"  %4,%1\n"
+                "  "CLR"  %0,%4\n"      /* copy crosses next page boundary? */
+                "   jnh   3f\n"
+                "2: mvcp  0(%4,%2),0(%1),%3\n"
+                "  "SLR"  %0,%4\n"
+                "3:\n"
+                EX_TABLE(0b,1b) EX_TABLE(2b,3b)
+                : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
+                : : "cc", "memory");
+        return size;
+}
+
+size_t copy_to_user_std(size_t size, void __user *ptr, const void *x)
+{
+        unsigned long tmp1, tmp2;
+
+        tmp1 = -256UL;
+        asm volatile(
+                "0: mvcs  0(%0,%1),0(%2),%3\n"
+                "   jz    5f\n"
+                "1:"ALR"  %0,%3\n"
+                "   la    %1,256(%1)\n"
+                "   la    %2,256(%2)\n"
+                "2: mvcs  0(%0,%1),0(%2),%3\n"
+                "   jnz   1b\n"
+                "   j     5f\n"
+                "3: la    %4,255(%1)\n" /* %4 = ptr + 255 */
+                "  "LHI"  %3,-4096\n"
+                "   nr    %4,%3\n"      /* %4 = (ptr + 255) & -4096 */
+                "  "SLR"  %4,%1\n"
+                "  "CLR"  %0,%4\n"      /* copy crosses next page boundary? */
+                "   jnh   6f\n"
+                "4: mvcs  0(%4,%1),0(%2),%3\n"
+                "  "SLR"  %0,%4\n"
+                "   j     6f\n"
+                "5:"SLR"  %0,%0\n"
+                "6: \n"
+                EX_TABLE(0b,3b) EX_TABLE(2b,3b) EX_TABLE(4b,6b)
+                : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
+                : : "cc", "memory");
+        return size;
+}
+
+size_t copy_to_user_std_small(size_t size, void __user *ptr, const void *x)
+{
+        unsigned long tmp1, tmp2;
+
+        tmp1 = 0UL;
+        asm volatile(
+                "0: mvcs  0(%0,%1),0(%2),%3\n"
+                "  "SLR"  %0,%0\n"
+                "   j     3f\n"
+                "1: la    %4,255(%1)\n" /* ptr + 255 */
+                "  "LHI"  %3,-4096\n"
+                "   nr    %4,%3\n"      /* (ptr + 255) & -4096UL */
+                "  "SLR"  %4,%1\n"
+                "  "CLR"  %0,%4\n"      /* copy crosses next page boundary? */
+                "   jnh   3f\n"
+                "2: mvcs  0(%4,%1),0(%2),%3\n"
+                "  "SLR"  %0,%4\n"
+                "3:\n"
+                EX_TABLE(0b,1b) EX_TABLE(2b,3b)
+                : "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
+                : : "cc", "memory");
+        return size;
+}
+
+size_t copy_in_user_std(size_t size, void __user *to, const void __user *from)
+{
+        unsigned long tmp1;
+
+        asm volatile(
+                "  "AHI"  %0,-1\n"
+                "   jo    5f\n"
+                "   sacf  256\n"
+                "   bras  %3,3f\n"
+                "0:"AHI"  %0,257\n"
+                "1: mvc   0(1,%1),0(%2)\n"
+                "   la    %1,1(%1)\n"
+                "   la    %2,1(%2)\n"
+                "  "AHI"  %0,-1\n"
+                "   jnz   1b\n"
+                "   j     5f\n"
+                "2: mvc   0(256,%1),0(%2)\n"
+                "   la    %1,256(%1)\n"
+                "   la    %2,256(%2)\n"
+                "3:"AHI"  %0,-256\n"
+                "   jnm   2b\n"
+                "4: ex    %0,1b-0b(%3)\n"
+                "   sacf  0\n"
+                "5: "SLR"  %0,%0\n"
+                "6:\n"
+                EX_TABLE(1b,6b) EX_TABLE(2b,0b) EX_TABLE(4b,0b)
+                : "+a" (size), "+a" (to), "+a" (from), "=a" (tmp1)
+                : : "cc", "memory");
+        return size;
+}
+
+size_t clear_user_std(size_t size, void __user *to)
+{
+        unsigned long tmp1, tmp2;
+
+        asm volatile(
+                "  "AHI"  %0,-1\n"
+                "   jo    5f\n"
+                "   sacf  256\n"
+                "   bras  %3,3f\n"
+                "   xc    0(1,%1),0(%1)\n"
+                "0:"AHI"  %0,257\n"
+                "   la    %2,255(%1)\n" /* %2 = ptr + 255 */
+                "   srl   %2,12\n"
+                "   sll   %2,12\n"      /* %2 = (ptr + 255) & -4096 */
+                "  "SLR"  %2,%1\n"
+                "  "CLR"  %0,%2\n"      /* clear crosses next page boundary? */
+                "   jnh   5f\n"
+                "  "AHI"  %2,-1\n"
+                "1: ex    %2,0(%3)\n"
+                "  "AHI"  %2,1\n"
+                "  "SLR"  %0,%2\n"
+                "   j     5f\n"
+                "2: xc    0(256,%1),0(%1)\n"
+                "   la    %1,256(%1)\n"
+                "3:"AHI"  %0,-256\n"
+                "   jnm   2b\n"
+                "4: ex    %0,0(%3)\n"
+                "   sacf  0\n"
+                "5: "SLR"  %0,%0\n"
+                "6:\n"
+                EX_TABLE(1b,6b) EX_TABLE(2b,0b) EX_TABLE(4b,0b)
+                : "+a" (size), "+a" (to), "=a" (tmp1), "=a" (tmp2)
+                : : "cc", "memory");
+        return size;
+}
+
+size_t strnlen_user_std(size_t size, const char __user *src)
+{
+        register unsigned long reg0 asm("0") = 0UL;
+        unsigned long tmp1, tmp2;
+
+        asm volatile(
+                "   la    %2,0(%1)\n"
+                "   la    %3,0(%0,%1)\n"
+                "  "SLR"  %0,%0\n"
+                "   sacf  256\n"
+                "0: srst  %3,%2\n"
+                "   jo    0b\n"
+                "   la    %0,1(%3)\n"   /* strnlen_user results includes \0 */
+                "  "SLR"  %0,%1\n"
+                "1: sacf  0\n"
+                EX_TABLE(0b,1b)
+                : "+a" (size), "+a" (src), "=a" (tmp1), "=a" (tmp2)
+                : "d" (reg0) : "cc", "memory");
+        return size;
+}
+
+size_t strncpy_from_user_std(size_t size, const char __user *src, char *dst)
+{
+        register unsigned long reg0 asm("0") = 0UL;
+        unsigned long tmp1, tmp2;
+
+        asm volatile(
+                "   la    %3,0(%1)\n"
+                "   la    %4,0(%0,%1)\n"
+                "   sacf  256\n"
+                "0: srst  %4,%3\n"
+                "   jo    0b\n"
+                "   sacf  0\n"
+                "   la    %0,0(%4)\n"
+                "   jh    1f\n"         /* found \0 in string ? */
+                "  "AHI"  %4,1\n"       /* include \0 in copy */
+                "1:"SLR"  %0,%1\n"      /* %0 = return length (without \0) */
+                "  "SLR"  %4,%1\n"      /* %4 = copy length (including \0) */
+                "2: mvcp  0(%4,%2),0(%1),%5\n"
+                "   jz    9f\n"
+                "3:"AHI"  %4,-256\n"
+                "   la    %1,256(%1)\n"
+                "   la    %2,256(%2)\n"
+                "4: mvcp  0(%4,%2),0(%1),%5\n"
+                "   jnz   3b\n"
+                "   j     9f\n"
+                "7: sacf  0\n"
+                "8:"LHI"  %0,%6\n"
+                "9:\n"
+                EX_TABLE(0b,7b) EX_TABLE(2b,8b) EX_TABLE(4b,8b)
+                : "+a" (size), "+a" (src), "+d" (dst), "=a" (tmp1), "=a" (tmp2)
+                : "d" (reg0), "K" (-EFAULT) : "cc", "memory");
+        return size;
+}
+
+#define __futex_atomic_op(insn, ret, oldval, newval, uaddr, oparg)      \
+        asm volatile(                                                   \
+                "   sacf  256\n"                                        \
+                "0: l     %1,0(%6)\n"                                   \
+                "1:"insn                                                \
+                "2: cs    %1,%2,0(%6)\n"                                \
+                "3: jl    1b\n"                                         \
+                "   lhi   %0,0\n"                                       \
+                "4: sacf  0\n"                                          \
+                EX_TABLE(0b,4b) EX_TABLE(2b,4b) EX_TABLE(3b,4b)         \
+                : "=d" (ret), "=&d" (oldval), "=&d" (newval),           \
+                  "=m" (*uaddr)                                         \
+                : "0" (-EFAULT), "d" (oparg), "a" (uaddr),              \
+                  "m" (*uaddr) : "cc");
+
+int futex_atomic_op(int op, int __user *uaddr, int oparg, int *old)
+{
+        int oldval = 0, newval, ret;
+
+        inc_preempt_count();
+
+        switch (op) {
+        case FUTEX_OP_SET:
+                __futex_atomic_op("lr %2,%5\n",
+                                  ret, oldval, newval, uaddr, oparg);
+                break;
+        case FUTEX_OP_ADD:
+                __futex_atomic_op("lr %2,%1\nar %2,%5\n",
+                                  ret, oldval, newval, uaddr, oparg);
+                break;
+        case FUTEX_OP_OR:
+                __futex_atomic_op("lr %2,%1\nor %2,%5\n",
+                                  ret, oldval, newval, uaddr, oparg);
+                break;
+        case FUTEX_OP_ANDN:
+                __futex_atomic_op("lr %2,%1\nnr %2,%5\n",
+                                  ret, oldval, newval, uaddr, oparg);
+                break;
+        case FUTEX_OP_XOR:
+                __futex_atomic_op("lr %2,%1\nxr %2,%5\n",
+                                  ret, oldval, newval, uaddr, oparg);
+                break;
+        default:
+                ret = -ENOSYS;
+        }
+        dec_preempt_count();
+        *old = oldval;
+        return ret;
+}
+
+int futex_atomic_cmpxchg(int __user *uaddr, int oldval, int newval)
+{
+        int ret;
+
+        asm volatile(
+                "   sacf 256\n"
+                "   cs   %1,%4,0(%5)\n"
+                "0: lr   %0,%1\n"
+                "1: sacf 0\n"
+                EX_TABLE(0b,1b)
+                : "=d" (ret), "+d" (oldval), "=m" (*uaddr)
+                : "0" (-EFAULT), "d" (newval), "a" (uaddr), "m" (*uaddr)
+                : "cc", "memory" );
+        return ret;
+}
+
+struct uaccess_ops uaccess_std = {
+        .copy_from_user = copy_from_user_std,
+        .copy_from_user_small = copy_from_user_std_small,
+        .copy_to_user = copy_to_user_std,
+        .copy_to_user_small = copy_to_user_std_small,
+        .copy_in_user = copy_in_user_std,
+        .clear_user = clear_user_std,
+        .strnlen_user = strnlen_user_std,
+        .strncpy_from_user = strncpy_from_user_std,
+        .futex_atomic_op = futex_atomic_op,
+        .futex_atomic_cmpxchg = futex_atomic_cmpxchg,
+};
diff --git a/arch/s390/mm/cmm.c b/arch/s390/mm/cmm.c
index ceea51cff03b..786a44dba5bf 100644
--- a/arch/s390/mm/cmm.c
+++ b/arch/s390/mm/cmm.c
@@ -53,22 +53,6 @@ static void cmm_timer_fn(unsigned long);
 static void cmm_set_timer(void);
 
 static long
-cmm_strtoul(const char *cp, char **endp)
-{
-        unsigned int base = 10;
-
-        if (*cp == '0') {
-                base = 8;
-                cp++;
-                if ((*cp == 'x' || *cp == 'X') && isxdigit(cp[1])) {
-                        base = 16;
-                        cp++;
-                }
-        }
-        return simple_strtoul(cp, endp, base);
-}
-
-static long
 cmm_alloc_pages(long pages, long *counter, struct cmm_page_array **list)
 {
         struct cmm_page_array *pa;
@@ -276,7 +260,7 @@ cmm_pages_handler(ctl_table *ctl, int write, struct file *filp,
                         return -EFAULT;
                 buf[sizeof(buf) - 1] = '\0';
                 cmm_skip_blanks(buf, &p);
-                pages = cmm_strtoul(p, &p);
+                pages = simple_strtoul(p, &p, 0);
                 if (ctl == &cmm_table[0])
                         cmm_set_pages(pages);
                 else
@@ -317,9 +301,9 @@ cmm_timeout_handler(ctl_table *ctl, int write, struct file *filp,
                         return -EFAULT;
                 buf[sizeof(buf) - 1] = '\0';
                 cmm_skip_blanks(buf, &p);
-                pages = cmm_strtoul(p, &p);
+                pages = simple_strtoul(p, &p, 0);
                 cmm_skip_blanks(p, &p);
-                seconds = cmm_strtoul(p, &p);
+                seconds = simple_strtoul(p, &p, 0);
                 cmm_set_timeout(pages, seconds);
         } else {
                 len = sprintf(buf, "%ld %ld\n",
@@ -382,24 +366,24 @@ cmm_smsg_target(char *from, char *msg)
         if (strncmp(msg, "SHRINK", 6) == 0) {
                 if (!cmm_skip_blanks(msg + 6, &msg))
                         return;
-                pages = cmm_strtoul(msg, &msg);
+                pages = simple_strtoul(msg, &msg, 0);
                 cmm_skip_blanks(msg, &msg);
                 if (*msg == '\0')
                         cmm_set_pages(pages);
         } else if (strncmp(msg, "RELEASE", 7) == 0) {
                 if (!cmm_skip_blanks(msg + 7, &msg))
                         return;
-                pages = cmm_strtoul(msg, &msg);
+                pages = simple_strtoul(msg, &msg, 0);
                 cmm_skip_blanks(msg, &msg);
                 if (*msg == '\0')
                         cmm_add_timed_pages(pages);
         } else if (strncmp(msg, "REUSE", 5) == 0) {
                 if (!cmm_skip_blanks(msg + 5, &msg))
                         return;
-                pages = cmm_strtoul(msg, &msg);
+                pages = simple_strtoul(msg, &msg, 0);
                 if (!cmm_skip_blanks(msg, &msg))
                         return;
-                seconds = cmm_strtoul(msg, &msg);
+                seconds = simple_strtoul(msg, &msg, 0);
                 cmm_skip_blanks(msg, &msg);
                 if (*msg == '\0')
                         cmm_set_timeout(pages, seconds);
diff --git a/arch/s390/mm/fault.c b/arch/s390/mm/fault.c
index 7cd82575813d..44f0cda7e72e 100644
--- a/arch/s390/mm/fault.c
+++ b/arch/s390/mm/fault.c
@@ -25,10 +25,12 @@
 #include <linux/console.h>
 #include <linux/module.h>
 #include <linux/hardirq.h>
+#include <linux/kprobes.h>
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
+#include <asm/kdebug.h>
 
 #ifndef CONFIG_64BIT
 #define __FAIL_ADDR_MASK 0x7ffff000
@@ -48,6 +50,38 @@ extern int sysctl_userprocess_debug;
 
 extern void die(const char *,struct pt_regs *,long);
 
+#ifdef CONFIG_KPROBES
+ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
+int register_page_fault_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_register(&notify_page_fault_chain, nb);
+}
+
+int unregister_page_fault_notifier(struct notifier_block *nb)
+{
+        return atomic_notifier_chain_unregister(&notify_page_fault_chain, nb);
+}
+
+static inline int notify_page_fault(enum die_val val, const char *str,
+                        struct pt_regs *regs, long err, int trap, int sig)
+{
+        struct die_args args = {
+                .regs = regs,
+                .str = str,
+                .err = err,
+                .trapnr = trap,
+                .signr = sig
+        };
+        return atomic_notifier_call_chain(&notify_page_fault_chain, val, &args);
+}
+#else
+static inline int notify_page_fault(enum die_val val, const char *str,
+                        struct pt_regs *regs, long err, int trap, int sig)
+{
+        return NOTIFY_DONE;
+}
+#endif
+
 extern spinlock_t timerlist_lock;
 
 /*
@@ -159,7 +193,7 @@ static void do_sigsegv(struct pt_regs *regs, unsigned long error_code,
  *   11       Page translation     ->  Not present       (nullification)
  *   3b       Region third trans.  ->  Not present       (nullification)
  */
-static inline void
+static inline void __kprobes
 do_exception(struct pt_regs *regs, unsigned long error_code, int is_protection)
 {
         struct task_struct *tsk;
@@ -173,6 +207,10 @@ do_exception(struct pt_regs *regs, unsigned long error_code, int is_protection)
         tsk = current;
         mm = tsk->mm;
         
+        if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14,
+                                        SIGSEGV) == NOTIFY_STOP)
+                return;
+
         /* 
          * Check for low-address protection.  This needs to be treated
          * as a special case because the translation exception code 
diff --git a/arch/s390/mm/init.c b/arch/s390/mm/init.c
index 6e6b6de77770..cfd9b8f7a523 100644
--- a/arch/s390/mm/init.c
+++ b/arch/s390/mm/init.c
@@ -108,16 +108,23 @@ void __init paging_init(void)
         unsigned long pgdir_k = (__pa(swapper_pg_dir) & PAGE_MASK) | _KERNSEG_TABLE;
         static const int ssm_mask = 0x04000000L;
         unsigned long ro_start_pfn, ro_end_pfn;
+        unsigned long zones_size[MAX_NR_ZONES];
 
         ro_start_pfn = PFN_DOWN((unsigned long)&__start_rodata);
         ro_end_pfn = PFN_UP((unsigned long)&__end_rodata);
 
+        memset(zones_size, 0, sizeof(zones_size));
+        zones_size[ZONE_DMA] = max_low_pfn;
+        free_area_init_node(0, &contig_page_data, zones_size,
+                            __pa(PAGE_OFFSET) >> PAGE_SHIFT,
+                            zholes_size);
+
         /* unmap whole virtual address space */
         
         pg_dir = swapper_pg_dir;
 
-        for (i=0;i<KERNEL_PGD_PTRS;i++) 
-                pmd_clear((pmd_t*)pg_dir++);
+        for (i = 0; i < PTRS_PER_PGD; i++)
+                pmd_clear((pmd_t *) pg_dir++);
                 
         /*
          * map whole physical memory to virtual memory (identity mapping) 
@@ -131,10 +138,7 @@ void __init paging_init(void)
                  */
                 pg_table = (pte_t *) alloc_bootmem_pages(PAGE_SIZE);
 
-                pg_dir->pgd0 =  (_PAGE_TABLE | __pa(pg_table));
-                pg_dir->pgd1 =  (_PAGE_TABLE | (__pa(pg_table)+1024));
-                pg_dir->pgd2 =  (_PAGE_TABLE | (__pa(pg_table)+2048));
-                pg_dir->pgd3 =  (_PAGE_TABLE | (__pa(pg_table)+3072));
+                pmd_populate_kernel(&init_mm, (pmd_t *) pg_dir, pg_table);
                 pg_dir++;
 
                 for (tmp = 0 ; tmp < PTRS_PER_PTE ; tmp++,pg_table++) {
@@ -143,8 +147,8 @@ void __init paging_init(void)
                         else
                                 pte = pfn_pte(pfn, PAGE_KERNEL);
                         if (pfn >= max_low_pfn)
-                                pte_clear(&init_mm, 0, &pte);
-                        set_pte(pg_table, pte);
+                                pte_val(pte) = _PAGE_TYPE_EMPTY;
+                        set_pte(pg_table, pte);
                         pfn++;
                 }
         }
@@ -159,16 +163,6 @@ void __init paging_init(void)
                              : : "m" (pgdir_k), "m" (ssm_mask));
 
         local_flush_tlb();
-
-        {
-                unsigned long zones_size[MAX_NR_ZONES];
-
-                memset(zones_size, 0, sizeof(zones_size));
-                zones_size[ZONE_DMA] = max_low_pfn;
-                free_area_init_node(0, &contig_page_data, zones_size,
-                                    __pa(PAGE_OFFSET) >> PAGE_SHIFT,
-                                    zholes_size);
-        }
         return;
 }
 
@@ -236,10 +230,8 @@ void __init paging_init(void)
                                         pte = pfn_pte(pfn, __pgprot(_PAGE_RO));
                                 else
                                         pte = pfn_pte(pfn, PAGE_KERNEL);
-                                if (pfn >= max_low_pfn) {
-                                        pte_clear(&init_mm, 0, &pte); 
-                                        continue;
-                                }
+                                if (pfn >= max_low_pfn)
+                                        pte_val(pte) = _PAGE_TYPE_EMPTY;
                                 set_pte(pt_dir, pte);
                                 pfn++;
                         }
diff --git a/arch/sparc/kernel/ebus.c b/arch/sparc/kernel/ebus.c
index 81c0cbd96ff0..75ac24d229b1 100644
--- a/arch/sparc/kernel/ebus.c
+++ b/arch/sparc/kernel/ebus.c
@@ -277,7 +277,7 @@ void __init ebus_init(void)
         struct pci_dev *pdev;
         struct pcidev_cookie *cookie;
         struct device_node *dp;
-        unsigned long addr, *base;
+        struct resource *p;
         unsigned short pci_command;
         int len, reg, nreg;
         int num_ebus = 0;
@@ -321,13 +321,12 @@ void __init ebus_init(void)
                 }
                 nreg = len / sizeof(struct linux_prom_pci_registers);
 
-                base = &ebus->self->resource[0].start;
+                p = &ebus->self->resource[0];
                 for (reg = 0; reg < nreg; reg++) {
                         if (!(regs[reg].which_io & 0x03000000))
                                 continue;
 
-                        addr = regs[reg].phys_lo;
-                        *base++ = addr;
+                        (p++)->start = regs[reg].phys_lo;
                 }
 
                 ebus->ofdev.node = dp;
diff --git a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
index 8654b446ac9e..d33f8a07ccac 100644
--- a/arch/sparc/kernel/ioport.c
+++ b/arch/sparc/kernel/ioport.c
@@ -508,6 +508,7 @@ void __init sbus_arch_bus_ranges_init(struct device_node *pn, struct sbus_bus *s
 
 void __init sbus_setup_iommu(struct sbus_bus *sbus, struct device_node *dp)
 {
+#ifndef CONFIG_SUN4
         struct device_node *parent = dp->parent;
 
         if (sparc_cpu_model != sun4d &&
@@ -524,6 +525,7 @@ void __init sbus_setup_iommu(struct sbus_bus *sbus, struct device_node *dp)
 
                 iounit_init(dp->node, parent->node, sbus);
         }
+#endif
 }
 
 void __init sbus_setup_arch_props(struct sbus_bus *sbus, struct device_node *dp)
diff --git a/arch/sparc64/defconfig b/arch/sparc64/defconfig
index 43d9229fca07..51cf6027b701 100644
--- a/arch/sparc64/defconfig
+++ b/arch/sparc64/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.18-rc2
-# Fri Jul 21 14:19:24 2006
+# Linux kernel version: 2.6.18
+# Sat Sep 23 18:32:19 2006
 #
 CONFIG_SPARC=y
 CONFIG_SPARC64=y
@@ -9,6 +9,7 @@ CONFIG_64BIT=y
 CONFIG_MMU=y
 CONFIG_TIME_INTERPOLATION=y
 CONFIG_ARCH_MAY_HAVE_PC_FDC=y
+CONFIG_AUDIT_ARCH=y
 CONFIG_SPARC64_PAGE_SIZE_8KB=y
 # CONFIG_SPARC64_PAGE_SIZE_64KB is not set
 # CONFIG_SPARC64_PAGE_SIZE_512KB is not set
@@ -37,14 +38,14 @@ CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
-CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
 # CONFIG_IKCONFIG is not set
 CONFIG_RELAY=y
 CONFIG_INITRAMFS_SOURCE=""
-CONFIG_UID16=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 # CONFIG_EMBEDDED is not set
+CONFIG_UID16=y
+CONFIG_SYSCTL=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
@@ -53,12 +54,12 @@ CONFIG_PRINTK=y
 CONFIG_BUG=y
 CONFIG_ELF_CORE=y
 CONFIG_BASE_FULL=y
-CONFIG_RT_MUTEXES=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
 CONFIG_SHMEM=y
 CONFIG_SLAB=y
 CONFIG_VM_EVENT_COUNTERS=y
+CONFIG_RT_MUTEXES=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
 # CONFIG_SLOB is not set
@@ -169,6 +170,7 @@ CONFIG_PACKET_MMAP=y
 CONFIG_UNIX=y
 CONFIG_XFRM=y
 CONFIG_XFRM_USER=m
+# CONFIG_XFRM_SUB_POLICY is not set
 CONFIG_NET_KEY=m
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
@@ -214,11 +216,15 @@ CONFIG_IPV6_ROUTE_INFO=y
 CONFIG_INET6_AH=m
 CONFIG_INET6_ESP=m
 CONFIG_INET6_IPCOMP=m
+# CONFIG_IPV6_MIP6 is not set
 CONFIG_INET6_XFRM_TUNNEL=m
 CONFIG_INET6_TUNNEL=m
 CONFIG_INET6_XFRM_MODE_TRANSPORT=m
 CONFIG_INET6_XFRM_MODE_TUNNEL=m
+# CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION is not set
 CONFIG_IPV6_TUNNEL=m
+# CONFIG_IPV6_SUBTREES is not set
+# CONFIG_IPV6_MULTIPLE_TABLES is not set
 # CONFIG_NETWORK_SECMARK is not set
 # CONFIG_NETFILTER is not set
 
@@ -233,6 +239,7 @@ CONFIG_IP_DCCP_ACKVEC=y
 # DCCP CCIDs Configuration (EXPERIMENTAL)
 #
 CONFIG_IP_DCCP_CCID2=m
+# CONFIG_IP_DCCP_CCID2_DEBUG is not set
 CONFIG_IP_DCCP_CCID3=m
 CONFIG_IP_DCCP_TFRC_LIB=m
 
@@ -259,7 +266,6 @@ CONFIG_VLAN_8021Q=m
 # CONFIG_ATALK is not set
 # CONFIG_X25 is not set
 # CONFIG_LAPB is not set
-# CONFIG_NET_DIVERT is not set
 # CONFIG_ECONET is not set
 # CONFIG_WAN_ROUTER is not set
 
@@ -1386,6 +1392,10 @@ CONFIG_KEYS=y
 # Cryptographic options
 #
 CONFIG_CRYPTO=y
+CONFIG_CRYPTO_ALGAPI=y
+CONFIG_CRYPTO_BLKCIPHER=y
+CONFIG_CRYPTO_HASH=y
+CONFIG_CRYPTO_MANAGER=m
 CONFIG_CRYPTO_HMAC=y
 CONFIG_CRYPTO_NULL=m
 CONFIG_CRYPTO_MD4=y
@@ -1395,9 +1405,12 @@ CONFIG_CRYPTO_SHA256=m
 CONFIG_CRYPTO_SHA512=m
 CONFIG_CRYPTO_WP512=m
 CONFIG_CRYPTO_TGR192=m
+CONFIG_CRYPTO_ECB=m
+CONFIG_CRYPTO_CBC=y
 CONFIG_CRYPTO_DES=y
 CONFIG_CRYPTO_BLOWFISH=m
 CONFIG_CRYPTO_TWOFISH=m
+CONFIG_CRYPTO_TWOFISH_COMMON=m
 CONFIG_CRYPTO_SERPENT=m
 CONFIG_CRYPTO_AES=m
 CONFIG_CRYPTO_CAST5=m
diff --git a/arch/sparc64/kernel/time.c b/arch/sparc64/kernel/time.c
index 094d3e35be18..b0b4feeec098 100644
--- a/arch/sparc64/kernel/time.c
+++ b/arch/sparc64/kernel/time.c
@@ -983,7 +983,7 @@ static struct time_interpolator sparc64_cpu_interpolator = {
 };
 
 /* The quotient formula is taken from the IA64 port. */
-#define SPARC64_NSEC_PER_CYC_SHIFT      30UL
+#define SPARC64_NSEC_PER_CYC_SHIFT      10UL
 void __init time_init(void)
 {
         unsigned long clock = sparc64_init_timers();
diff --git a/arch/x86_64/crypto/Makefile b/arch/x86_64/crypto/Makefile
index 426d20f4b72e..15b538a8b7f7 100644
--- a/arch/x86_64/crypto/Makefile
+++ b/arch/x86_64/crypto/Makefile
@@ -5,5 +5,8 @@
 # 
 
 obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
+obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
 
 aes-x86_64-y := aes-x86_64-asm.o aes.o
+twofish-x86_64-y := twofish-x86_64-asm.o twofish.o
+
diff --git a/arch/x86_64/crypto/aes.c b/arch/x86_64/crypto/aes.c
index 68866fab37aa..5cdb13ea5cc2 100644
--- a/arch/x86_64/crypto/aes.c
+++ b/arch/x86_64/crypto/aes.c
@@ -228,13 +228,14 @@ static void __init gen_tabs(void)
 }
 
 static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
-                       unsigned int key_len, u32 *flags)
+                       unsigned int key_len)
 {
         struct aes_ctx *ctx = crypto_tfm_ctx(tfm);
         const __le32 *key = (const __le32 *)in_key;
+        u32 *flags = &tfm->crt_flags;
         u32 i, j, t, u, v, w;
 
-        if (key_len != 16 && key_len != 24 && key_len != 32) {
+        if (key_len % 8) {
                 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
                 return -EINVAL;
         }
diff --git a/arch/x86_64/crypto/twofish-x86_64-asm.S b/arch/x86_64/crypto/twofish-x86_64-asm.S
new file mode 100644
index 000000000000..35974a586615
--- /dev/null
+++ b/arch/x86_64/crypto/twofish-x86_64-asm.S
@@ -0,0 +1,324 @@
+/***************************************************************************
+*   Copyright (C) 2006 by Joachim Fritschi, <jfritschi@freenet.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.,                                       *
+*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+***************************************************************************/
+
+.file "twofish-x86_64-asm.S"
+.text
+
+#include <asm/asm-offsets.h>
+
+#define a_offset        0
+#define b_offset        4
+#define c_offset        8
+#define d_offset        12
+
+/* Structure of the crypto context struct*/
+
+#define s0      0       /* S0 Array 256 Words each */
+#define s1      1024    /* S1 Array */
+#define s2      2048    /* S2 Array */
+#define s3      3072    /* S3 Array */
+#define w       4096    /* 8 whitening keys (word) */
+#define k       4128    /* key 1-32 ( word ) */
+
+/* define a few register aliases to allow macro substitution */
+
+#define R0     %rax
+#define R0D    %eax
+#define R0B    %al
+#define R0H    %ah
+
+#define R1     %rbx
+#define R1D    %ebx
+#define R1B    %bl
+#define R1H    %bh
+
+#define R2     %rcx
+#define R2D    %ecx
+#define R2B    %cl
+#define R2H    %ch
+
+#define R3     %rdx
+#define R3D    %edx
+#define R3B    %dl
+#define R3H    %dh
+
+
+/* performs input whitening */
+#define input_whitening(src,context,offset)\
+        xor     w+offset(context),      src;
+
+/* performs input whitening */
+#define output_whitening(src,context,offset)\
+        xor     w+16+offset(context),   src;
+
+
+/*
+ * a input register containing a (rotated 16)
+ * b input register containing b
+ * c input register containing c
+ * d input register containing d (already rol $1)
+ * operations on a and b are interleaved to increase performance
+ */
+#define encrypt_round(a,b,c,d,round)\
+        movzx   b ## B,         %edi;\
+        mov     s1(%r11,%rdi,4),%r8d;\
+        movzx   a ## B,         %edi;\
+        mov     s2(%r11,%rdi,4),%r9d;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     s2(%r11,%rdi,4),%r8d;\
+        movzx   a ## H,         %edi;\
+        ror     $16,            a ## D;\
+        xor     s3(%r11,%rdi,4),%r9d;\
+        movzx   b ## B,         %edi;\
+        xor     s3(%r11,%rdi,4),%r8d;\
+        movzx   a ## B,         %edi;\
+        xor     (%r11,%rdi,4),  %r9d;\
+        movzx   b ## H,         %edi;\
+        ror     $15,            b ## D;\
+        xor     (%r11,%rdi,4),  %r8d;\
+        movzx   a ## H,         %edi;\
+        xor     s1(%r11,%rdi,4),%r9d;\
+        add     %r8d,           %r9d;\
+        add     %r9d,           %r8d;\
+        add     k+round(%r11),  %r9d;\
+        xor     %r9d,           c ## D;\
+        rol     $15,            c ## D;\
+        add     k+4+round(%r11),%r8d;\
+        xor     %r8d,           d ## D;
+
+/*
+ * a input register containing a(rotated 16)
+ * b input register containing b
+ * c input register containing c
+ * d input register containing d (already rol $1)
+ * operations on a and b are interleaved to increase performance
+ * during the round a and b are prepared for the output whitening
+ */
+#define encrypt_last_round(a,b,c,d,round)\
+        mov     b ## D,         %r10d;\
+        shl     $32,            %r10;\
+        movzx   b ## B,         %edi;\
+        mov     s1(%r11,%rdi,4),%r8d;\
+        movzx   a ## B,         %edi;\
+        mov     s2(%r11,%rdi,4),%r9d;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     s2(%r11,%rdi,4),%r8d;\
+        movzx   a ## H,         %edi;\
+        ror     $16,            a ## D;\
+        xor     s3(%r11,%rdi,4),%r9d;\
+        movzx   b ## B,         %edi;\
+        xor     s3(%r11,%rdi,4),%r8d;\
+        movzx   a ## B,         %edi;\
+        xor     (%r11,%rdi,4),  %r9d;\
+        xor     a,              %r10;\
+        movzx   b ## H,         %edi;\
+        xor     (%r11,%rdi,4),  %r8d;\
+        movzx   a ## H,         %edi;\
+        xor     s1(%r11,%rdi,4),%r9d;\
+        add     %r8d,           %r9d;\
+        add     %r9d,           %r8d;\
+        add     k+round(%r11),  %r9d;\
+        xor     %r9d,           c ## D;\
+        ror     $1,             c ## D;\
+        add     k+4+round(%r11),%r8d;\
+        xor     %r8d,           d ## D
+
+/*
+ * a input register containing a
+ * b input register containing b (rotated 16)
+ * c input register containing c (already rol $1)
+ * d input register containing d
+ * operations on a and b are interleaved to increase performance
+ */
+#define decrypt_round(a,b,c,d,round)\
+        movzx   a ## B,         %edi;\
+        mov     (%r11,%rdi,4),  %r9d;\
+        movzx   b ## B,         %edi;\
+        mov     s3(%r11,%rdi,4),%r8d;\
+        movzx   a ## H,         %edi;\
+        ror     $16,            a ## D;\
+        xor     s1(%r11,%rdi,4),%r9d;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     (%r11,%rdi,4),  %r8d;\
+        movzx   a ## B,         %edi;\
+        xor     s2(%r11,%rdi,4),%r9d;\
+        movzx   b ## B,         %edi;\
+        xor     s1(%r11,%rdi,4),%r8d;\
+        movzx   a ## H,         %edi;\
+        ror     $15,            a ## D;\
+        xor     s3(%r11,%rdi,4),%r9d;\
+        movzx   b ## H,         %edi;\
+        xor     s2(%r11,%rdi,4),%r8d;\
+        add     %r8d,           %r9d;\
+        add     %r9d,           %r8d;\
+        add     k+round(%r11),  %r9d;\
+        xor     %r9d,           c ## D;\
+        add     k+4+round(%r11),%r8d;\
+        xor     %r8d,           d ## D;\
+        rol     $15,            d ## D;
+
+/*
+ * a input register containing a
+ * b input register containing b
+ * c input register containing c (already rol $1)
+ * d input register containing d
+ * operations on a and b are interleaved to increase performance
+ * during the round a and b are prepared for the output whitening
+ */
+#define decrypt_last_round(a,b,c,d,round)\
+        movzx   a ## B,         %edi;\
+        mov     (%r11,%rdi,4),  %r9d;\
+        movzx   b ## B,         %edi;\
+        mov     s3(%r11,%rdi,4),%r8d;\
+        movzx   b ## H,         %edi;\
+        ror     $16,            b ## D;\
+        xor     (%r11,%rdi,4),  %r8d;\
+        movzx   a ## H,         %edi;\
+        mov     b ## D,         %r10d;\
+        shl     $32,            %r10;\
+        xor     a,              %r10;\
+        ror     $16,            a ## D;\
+        xor     s1(%r11,%rdi,4),%r9d;\
+        movzx   b ## B,         %edi;\
+        xor     s1(%r11,%rdi,4),%r8d;\
+        movzx   a ## B,         %edi;\
+        xor     s2(%r11,%rdi,4),%r9d;\
+        movzx   b ## H,         %edi;\
+        xor     s2(%r11,%rdi,4),%r8d;\
+        movzx   a ## H,         %edi;\
+        xor     s3(%r11,%rdi,4),%r9d;\
+        add     %r8d,           %r9d;\
+        add     %r9d,           %r8d;\
+        add     k+round(%r11),  %r9d;\
+        xor     %r9d,           c ## D;\
+        add     k+4+round(%r11),%r8d;\
+        xor     %r8d,           d ## D;\
+        ror     $1,             d ## D;
+
+.align 8
+.global twofish_enc_blk
+.global twofish_dec_blk
+
+twofish_enc_blk:
+        pushq    R1
+
+        /* %rdi contains the crypto tfm adress */
+        /* %rsi contains the output adress */
+        /* %rdx contains the input adress */
+        add     $crypto_tfm_ctx_offset, %rdi    /* set ctx adress */
+        /* ctx adress is moved to free one non-rex register
+        as target for the 8bit high operations */
+        mov     %rdi,           %r11
+
+        movq    (R3),   R1
+        movq    8(R3),  R3
+        input_whitening(R1,%r11,a_offset)
+        input_whitening(R3,%r11,c_offset)
+        mov     R1D,    R0D
+        rol     $16,    R0D
+        shr     $32,    R1
+        mov     R3D,    R2D
+        shr     $32,    R3
+        rol     $1,     R3D
+
+        encrypt_round(R0,R1,R2,R3,0);
+        encrypt_round(R2,R3,R0,R1,8);
+        encrypt_round(R0,R1,R2,R3,2*8);
+        encrypt_round(R2,R3,R0,R1,3*8);
+        encrypt_round(R0,R1,R2,R3,4*8);
+        encrypt_round(R2,R3,R0,R1,5*8);
+        encrypt_round(R0,R1,R2,R3,6*8);
+        encrypt_round(R2,R3,R0,R1,7*8);
+        encrypt_round(R0,R1,R2,R3,8*8);
+        encrypt_round(R2,R3,R0,R1,9*8);
+        encrypt_round(R0,R1,R2,R3,10*8);
+        encrypt_round(R2,R3,R0,R1,11*8);
+        encrypt_round(R0,R1,R2,R3,12*8);
+        encrypt_round(R2,R3,R0,R1,13*8);
+        encrypt_round(R0,R1,R2,R3,14*8);
+        encrypt_last_round(R2,R3,R0,R1,15*8);
+
+
+        output_whitening(%r10,%r11,a_offset)
+        movq    %r10,   (%rsi)
+
+        shl     $32,    R1
+        xor     R0,     R1
+
+        output_whitening(R1,%r11,c_offset)
+        movq    R1,     8(%rsi)
+
+        popq    R1
+        movq    $1,%rax
+        ret
+
+twofish_dec_blk:
+        pushq    R1
+
+        /* %rdi contains the crypto tfm adress */
+        /* %rsi contains the output adress */
+        /* %rdx contains the input adress */
+        add     $crypto_tfm_ctx_offset, %rdi    /* set ctx adress */
+        /* ctx adress is moved to free one non-rex register
+        as target for the 8bit high operations */
+        mov     %rdi,           %r11
+
+        movq    (R3),   R1
+        movq    8(R3),  R3
+        output_whitening(R1,%r11,a_offset)
+        output_whitening(R3,%r11,c_offset)
+        mov     R1D,    R0D
+        shr     $32,    R1
+        rol     $16,    R1D
+        mov     R3D,    R2D
+        shr     $32,    R3
+        rol     $1,     R2D
+
+        decrypt_round(R0,R1,R2,R3,15*8);
+        decrypt_round(R2,R3,R0,R1,14*8);
+        decrypt_round(R0,R1,R2,R3,13*8);
+        decrypt_round(R2,R3,R0,R1,12*8);
+        decrypt_round(R0,R1,R2,R3,11*8);
+        decrypt_round(R2,R3,R0,R1,10*8);
+        decrypt_round(R0,R1,R2,R3,9*8);
+        decrypt_round(R2,R3,R0,R1,8*8);
+        decrypt_round(R0,R1,R2,R3,7*8);
+        decrypt_round(R2,R3,R0,R1,6*8);
+        decrypt_round(R0,R1,R2,R3,5*8);
+        decrypt_round(R2,R3,R0,R1,4*8);
+        decrypt_round(R0,R1,R2,R3,3*8);
+        decrypt_round(R2,R3,R0,R1,2*8);
+        decrypt_round(R0,R1,R2,R3,1*8);
+        decrypt_last_round(R2,R3,R0,R1,0);
+
+        input_whitening(%r10,%r11,a_offset)
+        movq    %r10,   (%rsi)
+
+        shl     $32,    R1
+        xor     R0,     R1
+
+        input_whitening(R1,%r11,c_offset)
+        movq    R1,     8(%rsi)
+
+        popq    R1
+        movq    $1,%rax
+        ret
diff --git a/arch/x86_64/crypto/twofish.c b/arch/x86_64/crypto/twofish.c
new file mode 100644
index 000000000000..182d91d5cfb9
--- /dev/null
+++ b/arch/x86_64/crypto/twofish.c
@@ -0,0 +1,97 @@
+/*
+ * Glue Code for optimized x86_64 assembler version of TWOFISH
+ *
+ * Originally Twofish for GPG
+ * By Matthew Skala <mskala@ansuz.sooke.bc.ca>, July 26, 1998
+ * 256-bit key length added March 20, 1999
+ * Some modifications to reduce the text size by Werner Koch, April, 1998
+ * Ported to the kerneli patch by Marc Mutz <Marc@Mutz.com>
+ * Ported to CryptoAPI by Colin Slater <hoho@tacomeat.net>
+ *
+ * The original author has disclaimed all copyright interest in this
+ * code and thus put it in the public domain. The subsequent authors
+ * have put this under the GNU General Public License.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
+ * USA
+ *
+ * This code is a "clean room" implementation, written from the paper
+ * _Twofish: A 128-Bit Block Cipher_ by Bruce Schneier, John Kelsey,
+ * Doug Whiting, David Wagner, Chris Hall, and Niels Ferguson, available
+ * through http://www.counterpane.com/twofish.html
+ *
+ * For background information on multiplication in finite fields, used for
+ * the matrix operations in the key schedule, see the book _Contemporary
+ * Abstract Algebra_ by Joseph A. Gallian, especially chapter 22 in the
+ * Third Edition.
+ */
+
+#include <crypto/twofish.h>
+#include <linux/crypto.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+
+asmlinkage void twofish_enc_blk(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
+asmlinkage void twofish_dec_blk(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
+
+static void twofish_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        twofish_enc_blk(tfm, dst, src);
+}
+
+static void twofish_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
+{
+        twofish_dec_blk(tfm, dst, src);
+}
+
+static struct crypto_alg alg = {
+        .cra_name               =       "twofish",
+        .cra_driver_name        =       "twofish-x86_64",
+        .cra_priority           =       200,
+        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
+        .cra_blocksize          =       TF_BLOCK_SIZE,
+        .cra_ctxsize            =       sizeof(struct twofish_ctx),
+        .cra_alignmask          =       3,
+        .cra_module             =       THIS_MODULE,
+        .cra_list               =       LIST_HEAD_INIT(alg.cra_list),
+        .cra_u                  =       {
+                .cipher = {
+                        .cia_min_keysize        =       TF_MIN_KEY_SIZE,
+                        .cia_max_keysize        =       TF_MAX_KEY_SIZE,
+                        .cia_setkey             =       twofish_setkey,
+                        .cia_encrypt            =       twofish_encrypt,
+                        .cia_decrypt            =       twofish_decrypt
+                }
+        }
+};
+
+static int __init init(void)
+{
+        return crypto_register_alg(&alg);
+}
+
+static void __exit fini(void)
+{
+        crypto_unregister_alg(&alg);
+}
+
+module_init(init);
+module_exit(fini);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION ("Twofish Cipher Algorithm, x86_64 asm optimized");
+MODULE_ALIAS("twofish");
diff --git a/arch/x86_64/kernel/e820.c b/arch/x86_64/kernel/e820.c
index 764bf23c7103..d6d7f731f6f0 100644
--- a/arch/x86_64/kernel/e820.c
+++ b/arch/x86_64/kernel/e820.c
@@ -108,6 +108,35 @@ e820_any_mapped(unsigned long start, unsigned long end, unsigned type)
         return 0;
 }
 
+/*
+ * This function checks if the entire range <start,end> is mapped with type.
+ *
+ * Note: this function only works correct if the e820 table is sorted and
+ * not-overlapping, which is the case
+ */
+int __init e820_all_mapped(unsigned long start, unsigned long end, unsigned type)
+{
+        int i;
+        for (i = 0; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+                if (type && ei->type != type)
+                        continue;
+                /* is the region (part) in overlap with the current region ?*/
+                if (ei->addr >= end || ei->addr + ei->size <= start)
+                        continue;
+
+                /* if the region is at the beginning of <start,end> we move
+                 * start to the end of the region since it's ok until there
+                 */
+                if (ei->addr <= start)
+                        start = ei->addr + ei->size;
+                /* if start is now at or beyond end, we're done, full coverage */
+                if (start >= end)
+                        return 1; /* we're done */
+        }
+        return 0;
+}
+
 /* 
  * Find a free area in a specific range. 
  */ 
diff --git a/arch/x86_64/pci/mmconfig.c b/arch/x86_64/pci/mmconfig.c
index 2d48a7941d48..3c55c76c6fd5 100644
--- a/arch/x86_64/pci/mmconfig.c
+++ b/arch/x86_64/pci/mmconfig.c
@@ -9,7 +9,6 @@
 #include <linux/init.h>
 #include <linux/acpi.h>
 #include <linux/bitmap.h>
-#include <linux/dmi.h>
 #include <asm/e820.h>
 
 #include "pci.h"
@@ -165,33 +164,11 @@ static __init void unreachable_devices(void)
         }
 }
 
-static int disable_mcfg(struct dmi_system_id *d)
-{
-        printk("PCI: %s detected. Disabling MCFG.\n", d->ident);
-        pci_probe &= ~PCI_PROBE_MMCONF;
-        return 0;
-}
-
-static struct dmi_system_id __initdata dmi_bad_mcfg[] = {
-        /* Has broken MCFG table that makes the system hang when used */
-        {
-         .callback = disable_mcfg,
-         .ident = "Intel D3C5105 SDV",
-         .matches = {
-                     DMI_MATCH(DMI_BIOS_VENDOR, "Intel"),
-                     DMI_MATCH(DMI_BOARD_NAME, "D26928"),
-                     },
-         },
-         {}
-};
-
 void __init pci_mmcfg_init(void)
 {
         int i;
 
-        dmi_check_system(dmi_bad_mcfg);
-
-        if ((pci_probe & (PCI_PROBE_MMCONF|PCI_PROBE_MMCONF_FORCE)) == 0)
+        if ((pci_probe & PCI_PROBE_MMCONF) == 0)
                 return;
 
         acpi_table_parse(ACPI_MCFG, acpi_parse_mcfg);
@@ -200,6 +177,15 @@ void __init pci_mmcfg_init(void)
             (pci_mmcfg_config[0].base_address == 0))
                 return;
 
+        if (!e820_all_mapped(pci_mmcfg_config[0].base_address,
+                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
+                        E820_RESERVED)) {
+                printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
+                                pci_mmcfg_config[0].base_address);
+                printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
+                return;
+        }
+
         /* RED-PEN i386 doesn't do _nocache right now */
         pci_mmcfg_virt = kmalloc(sizeof(*pci_mmcfg_virt) * pci_mmcfg_config_num, GFP_KERNEL);
         if (pci_mmcfg_virt == NULL) {