Merge tag 'powerpc-4.20-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux

Pull powerpc updates from Michael Ellerman:
 "Notable changes:

   - A large series to rewrite our SLB miss handling, replacing a lot of
     fairly complicated asm with much fewer lines of C.

   - Following on from that, we now maintain a cache of SLB entries for
     each process and preload them on context switch. Leading to a 27%
     speedup for our context switch benchmark on Power9.

   - Improvements to our handling of SLB multi-hit errors. We now print
     more debug information when they occur, and try to continue running
     by flushing the SLB and reloading, rather than treating them as
     fatal.

   - Enable THP migration on 64-bit Book3S machines (eg. Power7/8/9).

   - Add support for physical memory up to 2PB in the linear mapping on
     64-bit Book3S. We only support up to 512TB as regular system
     memory, otherwise the percpu allocator runs out of vmalloc space.

   - Add stack protector support for 32 and 64-bit, with a per-task
     canary.

   - Add support for PTRACE_SYSEMU and PTRACE_SYSEMU_SINGLESTEP.

   - Support recognising "big cores" on Power9, where two SMT4 cores are
     presented to us as a single SMT8 core.

   - A large series to cleanup some of our ioremap handling and PTE
     flags.

   - Add a driver for the PAPR SCM (storage class memory) interface,
     allowing guests to operate on SCM devices (acked by Dan).

   - Changes to our ftrace code to handle very large kernels, where we
     need to use a trampoline to get to ftrace_caller().

  And many other smaller enhancements and cleanups.

  Thanks to: Alan Modra, Alistair Popple, Aneesh Kumar K.V, Anton
  Blanchard, Aravinda Prasad, Bartlomiej Zolnierkiewicz, Benjamin
  Herrenschmidt, Breno Leitao, Cédric Le Goater, Christophe Leroy,
  Christophe Lombard, Dan Carpenter, Daniel Axtens, Finn Thain, Gautham
  R. Shenoy, Gustavo Romero, Haren Myneni, Hari Bathini, Jia Hongtao,
  Joel Stanley, John Allen, Laurent Dufour, Madhavan Srinivasan, Mahesh
  Salgaonkar, Mark Hairgrove, Masahiro Yamada, Michael Bringmann,
  Michael Neuling, Michal Suchanek, Murilo Opsfelder Araujo, Nathan
  Fontenot, Naveen N. Rao, Nicholas Piggin, Nick Desaulniers, Oliver
  O'Halloran, Paul Mackerras, Petr Vorel, Rashmica Gupta, Reza Arbab,
  Rob Herring, Sam Bobroff, Samuel Mendoza-Jonas, Scott Wood, Stan
  Johnson, Stephen Rothwell, Stewart Smith, Suraj Jitindar Singh, Tyrel
  Datwyler, Vaibhav Jain, Vasant Hegde, YueHaibing, zhong jiang"

* tag 'powerpc-4.20-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux: (221 commits)
  Revert "selftests/powerpc: Fix out-of-tree build errors"
  powerpc/msi: Fix compile error on mpc83xx
  powerpc: Fix stack protector crashes on CPU hotplug
  powerpc/traps: restore recoverability of machine_check interrupts
  powerpc/64/module: REL32 relocation range check
  powerpc/64s/radix: Fix radix__flush_tlb_collapsed_pmd double flushing pmd
  selftests/powerpc: Add a test of wild bctr
  powerpc/mm: Fix page table dump to work on Radix
  powerpc/mm/radix: Display if mappings are exec or not
  powerpc/mm/radix: Simplify split mapping logic
  powerpc/mm/radix: Remove the retry in the split mapping logic
  powerpc/mm/radix: Fix small page at boundary when splitting
  powerpc/mm/radix: Fix overuse of small pages in splitting logic
  powerpc/mm/radix: Fix off-by-one in split mapping logic
  powerpc/ftrace: Handle large kernel configs
  powerpc/mm: Fix WARN_ON with THP NUMA migration
  selftests/powerpc: Fix out-of-tree build errors
  powerpc/time: no steal_time when CONFIG_PPC_SPLPAR is not selected
  powerpc/time: Only set CONFIG_ARCH_HAS_SCALED_CPUTIME on PPC64
  powerpc/time: isolate scaled cputime accounting in dedicated functions.
  ...

253 files changed, 6305 insertions, 3400 deletions

diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 5b5f1ba76bba..47ca5cda0eef 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -2428,7 +2428,7 @@
                         seconds.  Use this parameter to check at some
                         other rate.  0 disables periodic checking.
 
-        memtest=        [KNL,X86,ARM] Enable memtest
+        memtest=        [KNL,X86,ARM,PPC] Enable memtest
                         Format: <integer>
                         default : 0 <disable>
                         Specifies the number of memtest passes to be
diff --git a/arch/m68k/mac/misc.c b/arch/m68k/mac/misc.c
index 1b083c500b9a..ebb3b6d169ea 100644
--- a/arch/m68k/mac/misc.c
+++ b/arch/m68k/mac/misc.c
@@ -37,35 +37,6 @@
 static void (*rom_reset)(void);
 
 #ifdef CONFIG_ADB_CUDA
-static time64_t cuda_read_time(void)
-{
-        struct adb_request req;
-        time64_t time;
-
-        if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME) < 0)
-                return 0;
-        while (!req.complete)
-                cuda_poll();
-
-        time = (u32)((req.reply[3] << 24) | (req.reply[4] << 16) |
-                     (req.reply[5] << 8) | req.reply[6]);
-
-        return time - RTC_OFFSET;
-}
-
-static void cuda_write_time(time64_t time)
-{
-        struct adb_request req;
-        u32 data = lower_32_bits(time + RTC_OFFSET);
-
-        if (cuda_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME,
-                         (data >> 24) & 0xFF, (data >> 16) & 0xFF,
-                         (data >> 8) & 0xFF, data & 0xFF) < 0)
-                return;
-        while (!req.complete)
-                cuda_poll();
-}
-
 static __u8 cuda_read_pram(int offset)
 {
         struct adb_request req;
@@ -91,33 +62,6 @@ static void cuda_write_pram(int offset, __u8 data)
 #endif /* CONFIG_ADB_CUDA */
 
 #ifdef CONFIG_ADB_PMU
-static time64_t pmu_read_time(void)
-{
-        struct adb_request req;
-        time64_t time;
-
-        if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)
-                return 0;
-        pmu_wait_complete(&req);
-
-        time = (u32)((req.reply[0] << 24) | (req.reply[1] << 16) |
-                     (req.reply[2] << 8) | req.reply[3]);
-
-        return time - RTC_OFFSET;
-}
-
-static void pmu_write_time(time64_t time)
-{
-        struct adb_request req;
-        u32 data = lower_32_bits(time + RTC_OFFSET);
-
-        if (pmu_request(&req, NULL, 5, PMU_SET_RTC,
-                        (data >> 24) & 0xFF, (data >> 16) & 0xFF,
-                        (data >> 8) & 0xFF, data & 0xFF) < 0)
-                return;
-        pmu_wait_complete(&req);
-}
-
 static __u8 pmu_read_pram(int offset)
 {
         struct adb_request req;
@@ -295,13 +239,17 @@ static time64_t via_read_time(void)
  * is basically any machine with Mac II-style ADB.
  */
 
-static void via_write_time(time64_t time)
+static void via_set_rtc_time(struct rtc_time *tm)
 {
         union {
                 __u8 cdata[4];
                 __u32 idata;
         } data;
         __u8 temp;
+        time64_t time;
+
+        time = mktime64(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+                        tm->tm_hour, tm->tm_min, tm->tm_sec);
 
         /* Clear the write protect bit */
 
@@ -641,12 +589,12 @@ int mac_hwclk(int op, struct rtc_time *t)
 #ifdef CONFIG_ADB_CUDA
                 case MAC_ADB_EGRET:
                 case MAC_ADB_CUDA:
-                        now = cuda_read_time();
+                        now = cuda_get_time();
                         break;
 #endif
 #ifdef CONFIG_ADB_PMU
                 case MAC_ADB_PB2:
-                        now = pmu_read_time();
+                        now = pmu_get_time();
                         break;
 #endif
                 default:
@@ -665,24 +613,21 @@ int mac_hwclk(int op, struct rtc_time *t)
                          __func__, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
                          t->tm_hour, t->tm_min, t->tm_sec);
 
-                now = mktime64(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
-                               t->tm_hour, t->tm_min, t->tm_sec);
-
                 switch (macintosh_config->adb_type) {
                 case MAC_ADB_IOP:
                 case MAC_ADB_II:
                 case MAC_ADB_PB1:
-                        via_write_time(now);
+                        via_set_rtc_time(t);
                         break;
 #ifdef CONFIG_ADB_CUDA
                 case MAC_ADB_EGRET:
                 case MAC_ADB_CUDA:
-                        cuda_write_time(now);
+                        cuda_set_rtc_time(t);
                         break;
 #endif
 #ifdef CONFIG_ADB_PMU
                 case MAC_ADB_PB2:
-                        pmu_write_time(now);
+                        pmu_set_rtc_time(t);
                         break;
 #endif
                 default:
diff --git a/arch/powerpc/Kbuild b/arch/powerpc/Kbuild
new file mode 100644
index 000000000000..1625a06802ca
--- /dev/null
+++ b/arch/powerpc/Kbuild
@@ -0,0 +1,16 @@
+subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
+
+obj-y += kernel/
+obj-y += mm/
+obj-y += lib/
+obj-y += sysdev/
+obj-y += platforms/
+obj-y += math-emu/
+obj-y += crypto/
+obj-y += net/
+
+obj-$(CONFIG_XMON) += xmon/
+obj-$(CONFIG_KVM)  += kvm/
+
+obj-$(CONFIG_PERF_EVENTS) += perf/
+obj-$(CONFIG_KEXEC_FILE)  += purgatory/
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index a80669209155..e84943d24e5c 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -137,7 +137,7 @@ config PPC
         select ARCH_HAS_PMEM_API                if PPC64
         select ARCH_HAS_PTE_SPECIAL
         select ARCH_HAS_MEMBARRIER_CALLBACKS
-        select ARCH_HAS_SCALED_CPUTIME          if VIRT_CPU_ACCOUNTING_NATIVE
+        select ARCH_HAS_SCALED_CPUTIME          if VIRT_CPU_ACCOUNTING_NATIVE && PPC64
         select ARCH_HAS_SG_CHAIN
         select ARCH_HAS_STRICT_KERNEL_RWX       if ((PPC_BOOK3S_64 || PPC32) && !RELOCATABLE && !HIBERNATION)
         select ARCH_HAS_TICK_BROADCAST          if GENERIC_CLOCKEVENTS_BROADCAST
@@ -180,6 +180,8 @@ config PPC
         select HAVE_ARCH_SECCOMP_FILTER
         select HAVE_ARCH_TRACEHOOK
         select HAVE_CBPF_JIT                    if !PPC64
+        select HAVE_STACKPROTECTOR              if PPC64 && $(cc-option,-mstack-protector-guard=tls -mstack-protector-guard-reg=r13)
+        select HAVE_STACKPROTECTOR              if PPC32 && $(cc-option,-mstack-protector-guard=tls -mstack-protector-guard-reg=r2)
         select HAVE_CONTEXT_TRACKING            if PPC64
         select HAVE_DEBUG_KMEMLEAK
         select HAVE_DEBUG_STACKOVERFLOW
@@ -188,6 +190,7 @@ config PPC
         select HAVE_EBPF_JIT                    if PPC64
         select HAVE_EFFICIENT_UNALIGNED_ACCESS  if !(CPU_LITTLE_ENDIAN && POWER7_CPU)
         select HAVE_FTRACE_MCOUNT_RECORD
+        select HAVE_FUNCTION_ERROR_INJECTION
         select HAVE_FUNCTION_GRAPH_TRACER
         select HAVE_FUNCTION_TRACER
         select HAVE_GCC_PLUGINS                 if GCC_VERSION >= 50200   # plugin support on gcc <= 5.1 is buggy on PPC
@@ -285,12 +288,10 @@ config ARCH_MAY_HAVE_PC_FDC
 
 config PPC_UDBG_16550
         bool
-        default n
 
 config GENERIC_TBSYNC
         bool
         default y if PPC32 && SMP
-        default n
 
 config AUDIT_ARCH
         bool
@@ -309,13 +310,11 @@ config EPAPR_BOOT
         bool
         help
           Used to allow a board to specify it wants an ePAPR compliant wrapper.
-        default n
 
 config DEFAULT_UIMAGE
         bool
         help
           Used to allow a board to specify it wants a uImage built by default
-        default n
 
 config ARCH_HIBERNATION_POSSIBLE
         bool
@@ -329,11 +328,9 @@ config ARCH_SUSPEND_POSSIBLE
 
 config PPC_DCR_NATIVE
         bool
-        default n
 
 config PPC_DCR_MMIO
         bool
-        default n
 
 config PPC_DCR
         bool
@@ -344,7 +341,6 @@ config PPC_OF_PLATFORM_PCI
         bool
         depends on PCI
         depends on PPC64 # not supported on 32 bits yet
-        default n
 
 config ARCH_SUPPORTS_DEBUG_PAGEALLOC
         depends on PPC32 || PPC_BOOK3S_64
@@ -447,14 +443,12 @@ config PPC_TRANSACTIONAL_MEM
        depends on SMP
        select ALTIVEC
        select VSX
-       default n
        ---help---
          Support user-mode Transactional Memory on POWERPC.
 
 config LD_HEAD_STUB_CATCH
         bool "Reserve 256 bytes to cope with linker stubs in HEAD text" if EXPERT
         depends on PPC64
-        default n
         help
           Very large kernels can cause linker branch stubs to be generated by
           code in head_64.S, which moves the head text sections out of their
@@ -557,7 +551,6 @@ config RELOCATABLE
 config RELOCATABLE_TEST
         bool "Test relocatable kernel"
         depends on (PPC64 && RELOCATABLE)
-        default n
         help
           This runs the relocatable kernel at the address it was initially
           loaded at, which tends to be non-zero and therefore test the
@@ -769,7 +762,6 @@ config PPC_SUBPAGE_PROT
 
 config PPC_COPRO_BASE
         bool
-        default n
 
 config SCHED_SMT
         bool "SMT (Hyperthreading) scheduler support"
@@ -892,7 +884,6 @@ config PPC_INDIRECT_PCI
         bool
         depends on PCI
         default y if 40x || 44x
-        default n
 
 config EISA
         bool
@@ -989,7 +980,6 @@ source "drivers/pcmcia/Kconfig"
 
 config HAS_RAPIDIO
         bool
-        default n
 
 config RAPIDIO
         tristate "RapidIO support"
@@ -1012,7 +1002,6 @@ endmenu
 
 config NONSTATIC_KERNEL
         bool
-        default n
 
 menu "Advanced setup"
         depends on PPC32
diff --git a/arch/powerpc/Kconfig.debug b/arch/powerpc/Kconfig.debug
index fd63cd914a74..f4961fbcb48d 100644
--- a/arch/powerpc/Kconfig.debug
+++ b/arch/powerpc/Kconfig.debug
@@ -2,7 +2,6 @@
 
 config PPC_DISABLE_WERROR
         bool "Don't build arch/powerpc code with -Werror"
-        default n
         help
           This option tells the compiler NOT to build the code under
           arch/powerpc with the -Werror flag (which means warnings
@@ -56,7 +55,6 @@ config PPC_EMULATED_STATS
 config CODE_PATCHING_SELFTEST
         bool "Run self-tests of the code-patching code"
         depends on DEBUG_KERNEL
-        default n
 
 config JUMP_LABEL_FEATURE_CHECKS
         bool "Enable use of jump label for cpu/mmu_has_feature()"
@@ -70,7 +68,6 @@ config JUMP_LABEL_FEATURE_CHECKS
 config JUMP_LABEL_FEATURE_CHECK_DEBUG
         bool "Do extra check on feature fixup calls"
         depends on DEBUG_KERNEL && JUMP_LABEL_FEATURE_CHECKS
-        default n
         help
           This tries to catch incorrect usage of cpu_has_feature() and
           mmu_has_feature() in the code.
@@ -80,16 +77,13 @@ config JUMP_LABEL_FEATURE_CHECK_DEBUG
 config FTR_FIXUP_SELFTEST
         bool "Run self-tests of the feature-fixup code"
         depends on DEBUG_KERNEL
-        default n
 
 config MSI_BITMAP_SELFTEST
         bool "Run self-tests of the MSI bitmap code"
         depends on DEBUG_KERNEL
-        default n
 
 config PPC_IRQ_SOFT_MASK_DEBUG
         bool "Include extra checks for powerpc irq soft masking"
-        default n
 
 config XMON
         bool "Include xmon kernel debugger"
diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile
index 42f225f6ec93..17be664dafa2 100644
--- a/arch/powerpc/Makefile
+++ b/arch/powerpc/Makefile
@@ -112,6 +112,13 @@ KBUILD_LDFLAGS	+= -m elf$(BITS)$(LDEMULATION)
 KBUILD_ARFLAGS  += --target=elf$(BITS)-$(GNUTARGET)
 endif
 
+cflags-$(CONFIG_STACKPROTECTOR) += -mstack-protector-guard=tls
+ifdef CONFIG_PPC64
+cflags-$(CONFIG_STACKPROTECTOR) += -mstack-protector-guard-reg=r13
+else
+cflags-$(CONFIG_STACKPROTECTOR) += -mstack-protector-guard-reg=r2
+endif
+
 LDFLAGS_vmlinux-y := -Bstatic
 LDFLAGS_vmlinux-$(CONFIG_RELOCATABLE) := -pie
 LDFLAGS_vmlinux := $(LDFLAGS_vmlinux-y)
@@ -160,8 +167,17 @@ else
 CFLAGS-$(CONFIG_GENERIC_CPU) += -mcpu=powerpc64
 endif
 
+ifdef CONFIG_FUNCTION_TRACER
+CC_FLAGS_FTRACE := -pg
 ifdef CONFIG_MPROFILE_KERNEL
-        CC_FLAGS_FTRACE := -pg -mprofile-kernel
+CC_FLAGS_FTRACE += -mprofile-kernel
+endif
+# Work around gcc code-gen bugs with -pg / -fno-omit-frame-pointer in gcc <= 4.8
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=44199
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52828
+ifneq ($(cc-name),clang)
+CC_FLAGS_FTRACE += $(call cc-ifversion, -lt, 0409, -mno-sched-epilog)
+endif
 endif
 
 CFLAGS-$(CONFIG_TARGET_CPU_BOOL) += $(call cc-option,-mcpu=$(CONFIG_TARGET_CPU))
@@ -229,16 +245,15 @@ ifdef CONFIG_6xx
 KBUILD_CFLAGS           += -mcpu=powerpc
 endif
 
-# Work around a gcc code-gen bug with -fno-omit-frame-pointer.
-ifdef CONFIG_FUNCTION_TRACER
-KBUILD_CFLAGS           += -mno-sched-epilog
-endif
-
 cpu-as-$(CONFIG_4xx)            += -Wa,-m405
 cpu-as-$(CONFIG_ALTIVEC)        += $(call as-option,-Wa$(comma)-maltivec)
 cpu-as-$(CONFIG_E200)           += -Wa,-me200
 cpu-as-$(CONFIG_E500)           += -Wa,-me500
-cpu-as-$(CONFIG_PPC_BOOK3S_64)  += -Wa,-mpower4
+
+# When using '-many -mpower4' gas will first try and find a matching power4
+# mnemonic and failing that it will allow any valid mnemonic that GAS knows
+# about. GCC will pass -many to GAS when assembling, clang does not.
+cpu-as-$(CONFIG_PPC_BOOK3S_64)  += -Wa,-mpower4 -Wa,-many
 cpu-as-$(CONFIG_PPC_E500MC)     += $(call as-option,-Wa$(comma)-me500mc)
 
 KBUILD_AFLAGS += $(cpu-as-y)
@@ -258,18 +273,8 @@ head-$(CONFIG_PPC_FPU)		+= arch/powerpc/kernel/fpu.o
 head-$(CONFIG_ALTIVEC)          += arch/powerpc/kernel/vector.o
 head-$(CONFIG_PPC_OF_BOOT_TRAMPOLINE)  += arch/powerpc/kernel/prom_init.o
 
-core-y                          += arch/powerpc/kernel/ \
-                                   arch/powerpc/mm/ \
-                                   arch/powerpc/lib/ \
-                                   arch/powerpc/sysdev/ \
-                                   arch/powerpc/platforms/ \
-                                   arch/powerpc/math-emu/ \
-                                   arch/powerpc/crypto/ \
-                                   arch/powerpc/net/
-core-$(CONFIG_XMON)             += arch/powerpc/xmon/
-core-$(CONFIG_KVM)              += arch/powerpc/kvm/
-core-$(CONFIG_PERF_EVENTS)      += arch/powerpc/perf/
-core-$(CONFIG_KEXEC_FILE)       += arch/powerpc/purgatory/
+# See arch/powerpc/Kbuild for content of core part of the kernel
+core-y += arch/powerpc/
 
 drivers-$(CONFIG_OPROFILE)      += arch/powerpc/oprofile/
 
@@ -397,40 +402,20 @@ archclean:
 
 archprepare: checkbin
 
-# Use the file '.tmp_gas_check' for binutils tests, as gas won't output
-# to stdout and these checks are run even on install targets.
-TOUT    := .tmp_gas_check
+ifdef CONFIG_STACKPROTECTOR
+prepare: stack_protector_prepare
 
-# Check gcc and binutils versions:
-# - gcc-3.4 and binutils-2.14 are a fatal combination
-# - Require gcc 4.0 or above on 64-bit
-# - gcc-4.2.0 has issues compiling modules on 64-bit
+stack_protector_prepare: prepare0
+ifdef CONFIG_PPC64
+        $(eval KBUILD_CFLAGS += -mstack-protector-guard-offset=$(shell awk '{if ($$2 == "PACA_CANARY") print $$3;}' include/generated/asm-offsets.h))
+else
+        $(eval KBUILD_CFLAGS += -mstack-protector-guard-offset=$(shell awk '{if ($$2 == "TASK_CANARY") print $$3;}' include/generated/asm-offsets.h))
+endif
+endif
+
+# Check toolchain versions:
+# - gcc-4.6 is the minimum kernel-wide version so nothing required.
 checkbin:
-        @if test "$(cc-name)" != "clang" \
-            && test "$(cc-version)" = "0304" ; then \
-                if ! /bin/echo mftb 5 | $(AS) -v -mppc -many -o $(TOUT) >/dev/null 2>&1 ; then \
-                        echo -n '*** ${VERSION}.${PATCHLEVEL} kernels no longer build '; \
-                        echo 'correctly with gcc-3.4 and your version of binutils.'; \
-                        echo '*** Please upgrade your binutils or downgrade your gcc'; \
-                        false; \
-                fi ; \
-        fi
-        @if test "$(cc-name)" != "clang" \
-            && test "$(cc-version)" -lt "0400" \
-            && test "x${CONFIG_PPC64}" = "xy" ; then \
-                echo -n "Sorry, GCC v4.0 or above is required to build " ; \
-                echo "the 64-bit powerpc kernel." ; \
-                false ; \
-        fi
-        @if test "$(cc-name)" != "clang" \
-            && test "$(cc-fullversion)" = "040200" \
-            && test "x${CONFIG_MODULES}${CONFIG_PPC64}" = "xyy" ; then \
-                echo -n '*** GCC-4.2.0 cannot compile the 64-bit powerpc ' ; \
-                echo 'kernel with modules enabled.' ; \
-                echo -n '*** Please use a different GCC version or ' ; \
-                echo 'disable kernel modules' ; \
-                false ; \
-        fi
         @if test "x${CONFIG_CPU_LITTLE_ENDIAN}" = "xy" \
             && $(LD) --version | head -1 | grep ' 2\.24$$' >/dev/null ; then \
                 echo -n '*** binutils 2.24 miscompiles weak symbols ' ; \
@@ -438,7 +423,3 @@ checkbin:
                 echo -n '*** Please use a different binutils version.' ; \
                 false ; \
         fi
-
-
-CLEAN_FILES += $(TOUT)
-
diff --git a/arch/powerpc/boot/.gitignore b/arch/powerpc/boot/.gitignore
index f92d0530ceb1..32034a0cc554 100644
--- a/arch/powerpc/boot/.gitignore
+++ b/arch/powerpc/boot/.gitignore
@@ -44,4 +44,5 @@ fdt_sw.c
 fdt_wip.c
 libfdt.h
 libfdt_internal.h
+autoconf.h
 
diff --git a/arch/powerpc/boot/Makefile b/arch/powerpc/boot/Makefile
index bca5c23767df..39354365f54a 100644
--- a/arch/powerpc/boot/Makefile
+++ b/arch/powerpc/boot/Makefile
@@ -32,8 +32,8 @@ else
 endif
 
 BOOTCFLAGS    := -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \
-                 -fno-strict-aliasing -Os -msoft-float -pipe \
-                 -fomit-frame-pointer -fno-builtin -fPIC -nostdinc \
+                 -fno-strict-aliasing -O2 -msoft-float -mno-altivec -mno-vsx \
+                 -pipe -fomit-frame-pointer -fno-builtin -fPIC -nostdinc \
                  -D$(compress-y)
 
 ifdef CONFIG_PPC64_BOOT_WRAPPER
@@ -197,9 +197,14 @@ $(obj)/empty.c:
 $(obj)/zImage.coff.lds $(obj)/zImage.ps3.lds : $(obj)/%: $(srctree)/$(src)/%.S
         $(Q)cp $< $@
 
+$(obj)/serial.c: $(obj)/autoconf.h
+
+$(obj)/autoconf.h: $(obj)/%: $(objtree)/include/generated/%
+        $(Q)cp $< $@
+
 clean-files := $(zlib-) $(zlibheader-) $(zliblinuxheader-) \
                 $(zlib-decomp-) $(libfdt) $(libfdtheader) \
-                empty.c zImage.coff.lds zImage.ps3.lds zImage.lds
+                autoconf.h empty.c zImage.coff.lds zImage.ps3.lds zImage.lds
 
 quiet_cmd_bootcc = BOOTCC  $@
       cmd_bootcc = $(BOOTCC) -Wp,-MD,$(depfile) $(BOOTCFLAGS) -c -o $@ $<
diff --git a/arch/powerpc/boot/crt0.S b/arch/powerpc/boot/crt0.S
index dcf2f15e6797..32dfe6d083f3 100644
--- a/arch/powerpc/boot/crt0.S
+++ b/arch/powerpc/boot/crt0.S
@@ -47,8 +47,10 @@ p_end:		.long	_end
 p_pstack:       .long   _platform_stack_top
 #endif
 
-        .weak   _zimage_start
         .globl  _zimage_start
+        /* Clang appears to require the .weak directive to be after the symbol
+         * is defined. See https://bugs.llvm.org/show_bug.cgi?id=38921  */
+        .weak   _zimage_start
 _zimage_start:
         .globl  _zimage_start_lib
 _zimage_start_lib:
diff --git a/arch/powerpc/boot/opal.c b/arch/powerpc/boot/opal.c
index 0272570d02de..dfb199ef5b94 100644
--- a/arch/powerpc/boot/opal.c
+++ b/arch/powerpc/boot/opal.c
@@ -13,8 +13,6 @@
 #include <libfdt.h>
 #include "../include/asm/opal-api.h"
 
-#ifdef CONFIG_PPC64_BOOT_WRAPPER
-
 /* Global OPAL struct used by opal-call.S */
 struct opal {
         u64 base;
@@ -101,9 +99,3 @@ int opal_console_init(void *devp, struct serial_console_data *scdp)
 
         return 0;
 }
-#else
-int opal_console_init(void *devp, struct serial_console_data *scdp)
-{
-        return -1;
-}
-#endif /* __powerpc64__ */
diff --git a/arch/powerpc/boot/serial.c b/arch/powerpc/boot/serial.c
index 48e3743faedf..f045f8494bf9 100644
--- a/arch/powerpc/boot/serial.c
+++ b/arch/powerpc/boot/serial.c
@@ -18,6 +18,7 @@
 #include "stdio.h"
 #include "io.h"
 #include "ops.h"
+#include "autoconf.h"
 
 static int serial_open(void)
 {
diff --git a/arch/powerpc/configs/g5_defconfig b/arch/powerpc/configs/g5_defconfig
index 67c39f4acede..f686cc1eac0b 100644
--- a/arch/powerpc/configs/g5_defconfig
+++ b/arch/powerpc/configs/g5_defconfig
@@ -262,3 +262,4 @@ CONFIG_CRYPTO_SERPENT=m
 CONFIG_CRYPTO_TEA=m
 CONFIG_CRYPTO_TWOFISH=m
 # CONFIG_CRYPTO_HW is not set
+CONFIG_PRINTK_TIME=y
diff --git a/arch/powerpc/configs/maple_defconfig b/arch/powerpc/configs/maple_defconfig
index 59e47ec85336..f71eddafb02f 100644
--- a/arch/powerpc/configs/maple_defconfig
+++ b/arch/powerpc/configs/maple_defconfig
@@ -112,3 +112,4 @@ CONFIG_PPC_EARLY_DEBUG=y
 CONFIG_CRYPTO_ECB=m
 CONFIG_CRYPTO_PCBC=m
 # CONFIG_CRYPTO_HW is not set
+CONFIG_PRINTK_TIME=y
diff --git a/arch/powerpc/configs/powernv_defconfig b/arch/powerpc/configs/powernv_defconfig
index 6ab34e60495f..ef2ef98d3f28 100644
--- a/arch/powerpc/configs/powernv_defconfig
+++ b/arch/powerpc/configs/powernv_defconfig
@@ -44,6 +44,9 @@ CONFIG_PPC_MEMTRACE=y
 # CONFIG_PPC_PSERIES is not set
 # CONFIG_PPC_OF_BOOT_TRAMPOLINE is not set
 CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y
+CONFIG_CPU_FREQ_GOV_POWERSAVE=y
+CONFIG_CPU_FREQ_GOV_USERSPACE=y
+CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y
 CONFIG_CPU_IDLE=y
 CONFIG_HZ_100=y
 CONFIG_BINFMT_MISC=m
@@ -350,3 +353,4 @@ CONFIG_VIRTUALIZATION=y
 CONFIG_KVM_BOOK3S_64=m
 CONFIG_KVM_BOOK3S_64_HV=m
 CONFIG_VHOST_NET=m
+CONFIG_PRINTK_TIME=y
diff --git a/arch/powerpc/configs/ppc64_defconfig b/arch/powerpc/configs/ppc64_defconfig
index 5033e630afea..f2515674a1e2 100644
--- a/arch/powerpc/configs/ppc64_defconfig
+++ b/arch/powerpc/configs/ppc64_defconfig
@@ -40,6 +40,9 @@ CONFIG_PS3_LPM=m
 CONFIG_PPC_IBM_CELL_BLADE=y
 CONFIG_RTAS_FLASH=m
 CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y
+CONFIG_CPU_FREQ_GOV_POWERSAVE=y
+CONFIG_CPU_FREQ_GOV_USERSPACE=y
+CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y
 CONFIG_CPU_FREQ_PMAC64=y
 CONFIG_HZ_100=y
 CONFIG_BINFMT_MISC=m
@@ -365,3 +368,4 @@ CONFIG_VIRTUALIZATION=y
 CONFIG_KVM_BOOK3S_64=m
 CONFIG_KVM_BOOK3S_64_HV=m
 CONFIG_VHOST_NET=m
+CONFIG_PRINTK_TIME=y
diff --git a/arch/powerpc/configs/ps3_defconfig b/arch/powerpc/configs/ps3_defconfig
index 187e2f7c12c8..cf8d55f67272 100644
--- a/arch/powerpc/configs/ps3_defconfig
+++ b/arch/powerpc/configs/ps3_defconfig
@@ -171,3 +171,4 @@ CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_MICHAEL_MIC=m
 CONFIG_CRYPTO_SALSA20=m
 CONFIG_CRYPTO_LZO=m
+CONFIG_PRINTK_TIME=y
diff --git a/arch/powerpc/configs/pseries_defconfig b/arch/powerpc/configs/pseries_defconfig
index 0dd5cf7b566d..5e09a40cbcbf 100644
--- a/arch/powerpc/configs/pseries_defconfig
+++ b/arch/powerpc/configs/pseries_defconfig
@@ -325,3 +325,4 @@ CONFIG_VIRTUALIZATION=y
 CONFIG_KVM_BOOK3S_64=m
 CONFIG_KVM_BOOK3S_64_HV=m
 CONFIG_VHOST_NET=m
+CONFIG_PRINTK_TIME=y
diff --git a/arch/powerpc/configs/skiroot_defconfig b/arch/powerpc/configs/skiroot_defconfig
index 6bd5e7261335..cfdd08897a06 100644
--- a/arch/powerpc/configs/skiroot_defconfig
+++ b/arch/powerpc/configs/skiroot_defconfig
@@ -3,20 +3,17 @@ CONFIG_ALTIVEC=y
 CONFIG_VSX=y
 CONFIG_NR_CPUS=2048
 CONFIG_CPU_LITTLE_ENDIAN=y
+CONFIG_KERNEL_XZ=y
 # CONFIG_SWAP is not set
 CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
 # CONFIG_CROSS_MEMORY_ATTACH is not set
 CONFIG_NO_HZ=y
 CONFIG_HIGH_RES_TIMERS=y
-CONFIG_TASKSTATS=y
-CONFIG_TASK_DELAY_ACCT=y
-CONFIG_TASK_XACCT=y
-CONFIG_TASK_IO_ACCOUNTING=y
+# CONFIG_CPU_ISOLATION is not set
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=20
-CONFIG_RELAY=y
 CONFIG_BLK_DEV_INITRD=y
 # CONFIG_RD_GZIP is not set
 # CONFIG_RD_BZIP2 is not set
@@ -24,8 +21,14 @@ CONFIG_BLK_DEV_INITRD=y
 # CONFIG_RD_LZO is not set
 # CONFIG_RD_LZ4 is not set
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_EXPERT=y
+# CONFIG_SGETMASK_SYSCALL is not set
+# CONFIG_SYSFS_SYSCALL is not set
+# CONFIG_SHMEM is not set
+# CONFIG_AIO is not set
 CONFIG_PERF_EVENTS=y
 # CONFIG_COMPAT_BRK is not set
+CONFIG_SLAB_FREELIST_HARDENED=y
 CONFIG_JUMP_LABEL=y
 CONFIG_STRICT_KERNEL_RWX=y
 CONFIG_MODULES=y
@@ -35,7 +38,9 @@ CONFIG_MODULE_SIG_FORCE=y
 CONFIG_MODULE_SIG_SHA512=y
 CONFIG_PARTITION_ADVANCED=y
 # CONFIG_IOSCHED_DEADLINE is not set
+# CONFIG_PPC_VAS is not set
 # CONFIG_PPC_PSERIES is not set
+# CONFIG_PPC_OF_BOOT_TRAMPOLINE is not set
 CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND=y
 CONFIG_CPU_IDLE=y
 CONFIG_HZ_100=y
@@ -48,8 +53,9 @@ CONFIG_NUMA=y
 CONFIG_PPC_64K_PAGES=y
 CONFIG_SCHED_SMT=y
 CONFIG_CMDLINE_BOOL=y
-CONFIG_CMDLINE="console=tty0 console=hvc0 powersave=off"
+CONFIG_CMDLINE="console=tty0 console=hvc0 ipr.fast_reboot=1 quiet"
 # CONFIG_SECCOMP is not set
+# CONFIG_PPC_MEM_KEYS is not set
 CONFIG_NET=y
 CONFIG_PACKET=y
 CONFIG_UNIX=y
@@ -60,7 +66,6 @@ CONFIG_SYN_COOKIES=y
 # CONFIG_INET_XFRM_MODE_TRANSPORT is not set
 # CONFIG_INET_XFRM_MODE_TUNNEL is not set
 # CONFIG_INET_XFRM_MODE_BEET is not set
-# CONFIG_IPV6 is not set
 CONFIG_DNS_RESOLVER=y
 # CONFIG_WIRELESS is not set
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
@@ -73,8 +78,10 @@ CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=65536
 CONFIG_VIRTIO_BLK=m
 CONFIG_BLK_DEV_NVME=m
-CONFIG_EEPROM_AT24=y
+CONFIG_NVME_MULTIPATH=y
+CONFIG_EEPROM_AT24=m
 # CONFIG_CXL is not set
+# CONFIG_OCXL is not set
 CONFIG_BLK_DEV_SD=m
 CONFIG_BLK_DEV_SR=m
 CONFIG_BLK_DEV_SR_VENDOR=y
@@ -85,7 +92,6 @@ CONFIG_SCSI_FC_ATTRS=y
 CONFIG_SCSI_CXGB3_ISCSI=m
 CONFIG_SCSI_CXGB4_ISCSI=m
 CONFIG_SCSI_BNX2_ISCSI=m
-CONFIG_BE2ISCSI=m
 CONFIG_SCSI_AACRAID=m
 CONFIG_MEGARAID_NEWGEN=y
 CONFIG_MEGARAID_MM=m
@@ -102,7 +108,7 @@ CONFIG_SCSI_VIRTIO=m
 CONFIG_SCSI_DH=y
 CONFIG_SCSI_DH_ALUA=m
 CONFIG_ATA=y
-CONFIG_SATA_AHCI=y
+CONFIG_SATA_AHCI=m
 # CONFIG_ATA_SFF is not set
 CONFIG_MD=y
 CONFIG_BLK_DEV_MD=m
@@ -119,25 +125,72 @@ CONFIG_DM_SNAPSHOT=m
 CONFIG_DM_MIRROR=m
 CONFIG_DM_ZERO=m
 CONFIG_DM_MULTIPATH=m
+# CONFIG_NET_VENDOR_3COM is not set
+# CONFIG_NET_VENDOR_ADAPTEC is not set
+# CONFIG_NET_VENDOR_AGERE is not set
+# CONFIG_NET_VENDOR_ALACRITECH is not set
 CONFIG_ACENIC=m
 CONFIG_ACENIC_OMIT_TIGON_I=y
-CONFIG_TIGON3=y
+# CONFIG_NET_VENDOR_AMAZON is not set
+# CONFIG_NET_VENDOR_AMD is not set
+# CONFIG_NET_VENDOR_AQUANTIA is not set
+# CONFIG_NET_VENDOR_ARC is not set
+# CONFIG_NET_VENDOR_ATHEROS is not set
+CONFIG_TIGON3=m
 CONFIG_BNX2X=m
-CONFIG_CHELSIO_T1=y
+# CONFIG_NET_VENDOR_BROCADE is not set
+# CONFIG_NET_CADENCE is not set
+# CONFIG_NET_VENDOR_CAVIUM is not set
+CONFIG_CHELSIO_T1=m
+# CONFIG_NET_VENDOR_CISCO is not set
+# CONFIG_NET_VENDOR_CORTINA is not set
+# CONFIG_NET_VENDOR_DEC is not set
+# CONFIG_NET_VENDOR_DLINK is not set
 CONFIG_BE2NET=m
-CONFIG_S2IO=m
-CONFIG_E100=m
+# CONFIG_NET_VENDOR_EZCHIP is not set
+# CONFIG_NET_VENDOR_HP is not set
+# CONFIG_NET_VENDOR_HUAWEI is not set
 CONFIG_E1000=m
-CONFIG_E1000E=m
+CONFIG_IGB=m
 CONFIG_IXGB=m
 CONFIG_IXGBE=m
+CONFIG_I40E=m
+CONFIG_S2IO=m
+# CONFIG_NET_VENDOR_MARVELL is not set
 CONFIG_MLX4_EN=m
+# CONFIG_MLX4_CORE_GEN2 is not set
 CONFIG_MLX5_CORE=m
-CONFIG_MLX5_CORE_EN=y
+# CONFIG_NET_VENDOR_MICREL is not set
 CONFIG_MYRI10GE=m
+# CONFIG_NET_VENDOR_NATSEMI is not set
+# CONFIG_NET_VENDOR_NETRONOME is not set
+# CONFIG_NET_VENDOR_NI is not set
+# CONFIG_NET_VENDOR_NVIDIA is not set
+# CONFIG_NET_VENDOR_OKI is not set
+# CONFIG_NET_PACKET_ENGINE is not set
 CONFIG_QLGE=m
 CONFIG_NETXEN_NIC=m
+# CONFIG_NET_VENDOR_QUALCOMM is not set
+# CONFIG_NET_VENDOR_RDC is not set
+# CONFIG_NET_VENDOR_REALTEK is not set
+# CONFIG_NET_VENDOR_RENESAS is not set
+# CONFIG_NET_VENDOR_ROCKER is not set
+# CONFIG_NET_VENDOR_SAMSUNG is not set
+# CONFIG_NET_VENDOR_SEEQ is not set
 CONFIG_SFC=m
+# CONFIG_NET_VENDOR_SILAN is not set
+# CONFIG_NET_VENDOR_SIS is not set
+# CONFIG_NET_VENDOR_SMSC is not set
+# CONFIG_NET_VENDOR_SOCIONEXT is not set
+# CONFIG_NET_VENDOR_STMICRO is not set
+# CONFIG_NET_VENDOR_SUN is not set
+# CONFIG_NET_VENDOR_SYNOPSYS is not set
+# CONFIG_NET_VENDOR_TEHUTI is not set
+# CONFIG_NET_VENDOR_TI is not set
+# CONFIG_NET_VENDOR_VIA is not set
+# CONFIG_NET_VENDOR_WIZNET is not set
+# CONFIG_NET_VENDOR_XILINX is not set
+CONFIG_PHYLIB=y
 # CONFIG_USB_NET_DRIVERS is not set
 # CONFIG_WLAN is not set
 CONFIG_INPUT_EVDEV=y
@@ -149,39 +202,51 @@ CONFIG_SERIAL_8250_CONSOLE=y
 CONFIG_IPMI_HANDLER=y
 CONFIG_IPMI_DEVICE_INTERFACE=y
 CONFIG_IPMI_POWERNV=y
+CONFIG_IPMI_WATCHDOG=y
 CONFIG_HW_RANDOM=y
+CONFIG_TCG_TPM=y
 CONFIG_TCG_TIS_I2C_NUVOTON=y
+CONFIG_I2C=y
 # CONFIG_I2C_COMPAT is not set
 CONFIG_I2C_CHARDEV=y
 # CONFIG_I2C_HELPER_AUTO is not set
-CONFIG_DRM=y
-CONFIG_DRM_RADEON=y
+CONFIG_I2C_ALGOBIT=y
+CONFIG_I2C_OPAL=m
+CONFIG_PPS=y
+CONFIG_SENSORS_IBMPOWERNV=m
+CONFIG_DRM=m
 CONFIG_DRM_AST=m
+CONFIG_FB=y
 CONFIG_FIRMWARE_EDID=y
-CONFIG_FB_MODE_HELPERS=y
-CONFIG_FB_OF=y
-CONFIG_FB_MATROX=y
-CONFIG_FB_MATROX_MILLENIUM=y
-CONFIG_FB_MATROX_MYSTIQUE=y
-CONFIG_FB_MATROX_G=y
-# CONFIG_LCD_CLASS_DEVICE is not set
-# CONFIG_BACKLIGHT_GENERIC is not set
 # CONFIG_VGA_CONSOLE is not set
+CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_LOGO=y
 # CONFIG_LOGO_LINUX_MONO is not set
 # CONFIG_LOGO_LINUX_VGA16 is not set
+CONFIG_HID_GENERIC=m
+CONFIG_HID_A4TECH=y
+CONFIG_HID_BELKIN=y
+CONFIG_HID_CHERRY=y
+CONFIG_HID_CHICONY=y
+CONFIG_HID_CYPRESS=y
+CONFIG_HID_EZKEY=y
+CONFIG_HID_ITE=y
+CONFIG_HID_KENSINGTON=y
+CONFIG_HID_LOGITECH=y
+CONFIG_HID_MICROSOFT=y
+CONFIG_HID_MONTEREY=y
 CONFIG_USB_HIDDEV=y
-CONFIG_USB=y
-CONFIG_USB_MON=y
-CONFIG_USB_XHCI_HCD=y
-CONFIG_USB_EHCI_HCD=y
+CONFIG_USB=m
+CONFIG_USB_XHCI_HCD=m
+CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_HCD_PPC_OF is not set
-CONFIG_USB_OHCI_HCD=y
-CONFIG_USB_STORAGE=y
+CONFIG_USB_OHCI_HCD=m
+CONFIG_USB_STORAGE=m
 CONFIG_RTC_CLASS=y
+CONFIG_RTC_DRV_OPAL=m
 CONFIG_RTC_DRV_GENERIC=m
 CONFIG_VIRT_DRIVERS=y
-CONFIG_VIRTIO_PCI=y
+CONFIG_VIRTIO_PCI=m
 # CONFIG_IOMMU_SUPPORT is not set
 CONFIG_EXT4_FS=m
 CONFIG_EXT4_FS_POSIX_ACL=y
@@ -195,10 +260,9 @@ CONFIG_UDF_FS=m
 CONFIG_MSDOS_FS=m
 CONFIG_VFAT_FS=m
 CONFIG_PROC_KCORE=y
-CONFIG_TMPFS=y
-CONFIG_TMPFS_POSIX_ACL=y
 # CONFIG_MISC_FILESYSTEMS is not set
 # CONFIG_NETWORK_FILESYSTEMS is not set
+CONFIG_NLS=y
 CONFIG_NLS_DEFAULT="utf8"
 CONFIG_NLS_CODEPAGE_437=y
 CONFIG_NLS_ASCII=y
@@ -207,26 +271,24 @@ CONFIG_NLS_UTF8=y
 CONFIG_CRC16=y
 CONFIG_CRC_ITU_T=y
 CONFIG_LIBCRC32C=y
+# CONFIG_XZ_DEC_X86 is not set
+# CONFIG_XZ_DEC_IA64 is not set
+# CONFIG_XZ_DEC_ARM is not set
+# CONFIG_XZ_DEC_ARMTHUMB is not set
+# CONFIG_XZ_DEC_SPARC is not set
 CONFIG_PRINTK_TIME=y
 CONFIG_MAGIC_SYSRQ=y
-CONFIG_DEBUG_KERNEL=y
 CONFIG_DEBUG_STACKOVERFLOW=y
 CONFIG_SOFTLOCKUP_DETECTOR=y
+CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC=y
 CONFIG_HARDLOCKUP_DETECTOR=y
 CONFIG_BOOTPARAM_HARDLOCKUP_PANIC=y
-CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC=y
 CONFIG_WQ_WATCHDOG=y
-CONFIG_SCHEDSTATS=y
+# CONFIG_SCHED_DEBUG is not set
 # CONFIG_FTRACE is not set
+# CONFIG_RUNTIME_TESTING_MENU is not set
 CONFIG_XMON=y
 CONFIG_XMON_DEFAULT=y
-CONFIG_SECURITY=y
-CONFIG_IMA=y
-CONFIG_EVM=y
+CONFIG_ENCRYPTED_KEYS=y
 # CONFIG_CRYPTO_ECHAINIV is not set
-CONFIG_CRYPTO_ECB=y
-CONFIG_CRYPTO_CMAC=y
-CONFIG_CRYPTO_MD4=y
-CONFIG_CRYPTO_ARC4=y
-CONFIG_CRYPTO_DES=y
 # CONFIG_CRYPTO_HW is not set
diff --git a/arch/powerpc/include/asm/accounting.h b/arch/powerpc/include/asm/accounting.h
index 3abcf98ed2e0..c607c5d835cc 100644
--- a/arch/powerpc/include/asm/accounting.h
+++ b/arch/powerpc/include/asm/accounting.h
@@ -15,8 +15,10 @@ struct cpu_accounting_data {
         /* Accumulated cputime values to flush on ticks*/
         unsigned long utime;
         unsigned long stime;
+#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
         unsigned long utime_scaled;
         unsigned long stime_scaled;
+#endif
         unsigned long gtime;
         unsigned long hardirq_time;
         unsigned long softirq_time;
@@ -25,8 +27,10 @@ struct cpu_accounting_data {
         /* Internal counters */
         unsigned long starttime;        /* TB value snapshot */
         unsigned long starttime_user;   /* TB value on exit to usermode */
+#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
         unsigned long startspurr;       /* SPURR value snapshot */
         unsigned long utime_sspurr;     /* ->user_time when ->startspurr set */
+#endif
 };
 
 #endif
diff --git a/arch/powerpc/include/asm/asm-prototypes.h b/arch/powerpc/include/asm/asm-prototypes.h
index c55ba3b4873b..ec691d489656 100644
--- a/arch/powerpc/include/asm/asm-prototypes.h
+++ b/arch/powerpc/include/asm/asm-prototypes.h
@@ -63,7 +63,6 @@ void program_check_exception(struct pt_regs *regs);
 void alignment_exception(struct pt_regs *regs);
 void slb_miss_bad_addr(struct pt_regs *regs);
 void StackOverflow(struct pt_regs *regs);
-void nonrecoverable_exception(struct pt_regs *regs);
 void kernel_fp_unavailable_exception(struct pt_regs *regs);
 void altivec_unavailable_exception(struct pt_regs *regs);
 void vsx_unavailable_exception(struct pt_regs *regs);
@@ -78,6 +77,8 @@ void kernel_bad_stack(struct pt_regs *regs);
 void system_reset_exception(struct pt_regs *regs);
 void machine_check_exception(struct pt_regs *regs);
 void emulation_assist_interrupt(struct pt_regs *regs);
+long do_slb_fault(struct pt_regs *regs, unsigned long ea);
+void do_bad_slb_fault(struct pt_regs *regs, unsigned long ea, long err);
 
 /* signals, syscalls and interrupts */
 long sys_swapcontext(struct ucontext __user *old_ctx,
diff --git a/arch/powerpc/include/asm/book3s/32/pgtable.h b/arch/powerpc/include/asm/book3s/32/pgtable.h
index 751cf931bb3f..e61dd3ae5bc0 100644
--- a/arch/powerpc/include/asm/book3s/32/pgtable.h
+++ b/arch/powerpc/include/asm/book3s/32/pgtable.h
@@ -8,7 +8,97 @@
 #include <asm/book3s/32/hash.h>
 
 /* And here we include common definitions */
-#include <asm/pte-common.h>
+
+#define _PAGE_KERNEL_RO         0
+#define _PAGE_KERNEL_ROX        0
+#define _PAGE_KERNEL_RW         (_PAGE_DIRTY | _PAGE_RW)
+#define _PAGE_KERNEL_RWX        (_PAGE_DIRTY | _PAGE_RW)
+
+#define _PAGE_HPTEFLAGS _PAGE_HASHPTE
+
+#ifndef __ASSEMBLY__
+
+static inline bool pte_user(pte_t pte)
+{
+        return pte_val(pte) & _PAGE_USER;
+}
+#endif /* __ASSEMBLY__ */
+
+/*
+ * Location of the PFN in the PTE. Most 32-bit platforms use the same
+ * as _PAGE_SHIFT here (ie, naturally aligned).
+ * Platform who don't just pre-define the value so we don't override it here.
+ */
+#define PTE_RPN_SHIFT   (PAGE_SHIFT)
+
+/*
+ * The mask covered by the RPN must be a ULL on 32-bit platforms with
+ * 64-bit PTEs.
+ */
+#ifdef CONFIG_PTE_64BIT
+#define PTE_RPN_MASK    (~((1ULL << PTE_RPN_SHIFT) - 1))
+#else
+#define PTE_RPN_MASK    (~((1UL << PTE_RPN_SHIFT) - 1))
+#endif
+
+/*
+ * _PAGE_CHG_MASK masks of bits that are to be preserved across
+ * pgprot changes.
+ */
+#define _PAGE_CHG_MASK  (PTE_RPN_MASK | _PAGE_HASHPTE | _PAGE_DIRTY | \
+                         _PAGE_ACCESSED | _PAGE_SPECIAL)
+
+/*
+ * We define 2 sets of base prot bits, one for basic pages (ie,
+ * cacheable kernel and user pages) and one for non cacheable
+ * pages. We always set _PAGE_COHERENT when SMP is enabled or
+ * the processor might need it for DMA coherency.
+ */
+#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED)
+#define _PAGE_BASE      (_PAGE_BASE_NC | _PAGE_COHERENT)
+
+/*
+ * Permission masks used to generate the __P and __S table.
+ *
+ * Note:__pgprot is defined in arch/powerpc/include/asm/page.h
+ *
+ * Write permissions imply read permissions for now.
+ */
+#define PAGE_NONE       __pgprot(_PAGE_BASE)
+#define PAGE_SHARED     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW)
+#define PAGE_SHARED_X   __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW)
+#define PAGE_COPY       __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_COPY_X     __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_READONLY   __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_READONLY_X __pgprot(_PAGE_BASE | _PAGE_USER)
+
+/* Permission masks used for kernel mappings */
+#define PAGE_KERNEL     __pgprot(_PAGE_BASE | _PAGE_KERNEL_RW)
+#define PAGE_KERNEL_NC  __pgprot(_PAGE_BASE_NC | _PAGE_KERNEL_RW | _PAGE_NO_CACHE)
+#define PAGE_KERNEL_NCG __pgprot(_PAGE_BASE_NC | _PAGE_KERNEL_RW | \
+                                 _PAGE_NO_CACHE | _PAGE_GUARDED)
+#define PAGE_KERNEL_X   __pgprot(_PAGE_BASE | _PAGE_KERNEL_RWX)
+#define PAGE_KERNEL_RO  __pgprot(_PAGE_BASE | _PAGE_KERNEL_RO)
+#define PAGE_KERNEL_ROX __pgprot(_PAGE_BASE | _PAGE_KERNEL_ROX)
+
+/*
+ * Protection used for kernel text. We want the debuggers to be able to
+ * set breakpoints anywhere, so don't write protect the kernel text
+ * on platforms where such control is possible.
+ */
+#if defined(CONFIG_KGDB) || defined(CONFIG_XMON) || defined(CONFIG_BDI_SWITCH) ||\
+        defined(CONFIG_KPROBES) || defined(CONFIG_DYNAMIC_FTRACE)
+#define PAGE_KERNEL_TEXT        PAGE_KERNEL_X
+#else
+#define PAGE_KERNEL_TEXT        PAGE_KERNEL_ROX
+#endif
+
+/* Make modules code happy. We don't set RO yet */
+#define PAGE_KERNEL_EXEC        PAGE_KERNEL_X
+
+/* Advertise special mapping type for AGP */
+#define PAGE_AGP                (PAGE_KERNEL_NC)
+#define HAVE_PAGE_AGP
 
 #define PTE_INDEX_SIZE  PTE_SHIFT
 #define PMD_INDEX_SIZE  0
@@ -219,7 +309,7 @@ static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
 static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addr,
                                       pte_t *ptep)
 {
-        pte_update(ptep, (_PAGE_RW | _PAGE_HWWRITE), _PAGE_RO);
+        pte_update(ptep, _PAGE_RW, 0);
 }
 static inline void huge_ptep_set_wrprotect(struct mm_struct *mm,
                                            unsigned long addr, pte_t *ptep)
@@ -234,10 +324,9 @@ static inline void __ptep_set_access_flags(struct vm_area_struct *vma,
                                            int psize)
 {
         unsigned long set = pte_val(entry) &
-                (_PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_RW | _PAGE_EXEC);
-        unsigned long clr = ~pte_val(entry) & _PAGE_RO;
+                (_PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_RW);
 
-        pte_update(ptep, clr, set);
+        pte_update(ptep, 0, set);
 
         flush_tlb_page(vma, address);
 }
@@ -292,7 +381,7 @@ static inline void __ptep_set_access_flags(struct vm_area_struct *vma,
 #define __pte_to_swp_entry(pte)         ((swp_entry_t) { pte_val(pte) >> 3 })
 #define __swp_entry_to_pte(x)           ((pte_t) { (x).val << 3 })
 
-int map_kernel_page(unsigned long va, phys_addr_t pa, int flags);
+int map_kernel_page(unsigned long va, phys_addr_t pa, pgprot_t prot);
 
 /* Generic accessors to PTE bits */
 static inline int pte_write(pte_t pte)          { return !!(pte_val(pte) & _PAGE_RW);}
@@ -301,13 +390,28 @@ static inline int pte_dirty(pte_t pte)		{ return !!(pte_val(pte) & _PAGE_DIRTY);
 static inline int pte_young(pte_t pte)          { return !!(pte_val(pte) & _PAGE_ACCESSED); }
 static inline int pte_special(pte_t pte)        { return !!(pte_val(pte) & _PAGE_SPECIAL); }
 static inline int pte_none(pte_t pte)           { return (pte_val(pte) & ~_PTE_NONE_MASK) == 0; }
-static inline pgprot_t pte_pgprot(pte_t pte)    { return __pgprot(pte_val(pte) & PAGE_PROT_BITS); }
+static inline bool pte_exec(pte_t pte)          { return true; }
 
 static inline int pte_present(pte_t pte)
 {
         return pte_val(pte) & _PAGE_PRESENT;
 }
 
+static inline bool pte_hw_valid(pte_t pte)
+{
+        return pte_val(pte) & _PAGE_PRESENT;
+}
+
+static inline bool pte_hashpte(pte_t pte)
+{
+        return !!(pte_val(pte) & _PAGE_HASHPTE);
+}
+
+static inline bool pte_ci(pte_t pte)
+{
+        return !!(pte_val(pte) & _PAGE_NO_CACHE);
+}
+
 /*
  * We only find page table entry in the last level
  * Hence no need for other accessors
@@ -315,17 +419,14 @@ static inline int pte_present(pte_t pte)
 #define pte_access_permitted pte_access_permitted
 static inline bool pte_access_permitted(pte_t pte, bool write)
 {
-        unsigned long pteval = pte_val(pte);
         /*
          * A read-only access is controlled by _PAGE_USER bit.
          * We have _PAGE_READ set for WRITE and EXECUTE
          */
-        unsigned long need_pte_bits = _PAGE_PRESENT | _PAGE_USER;
-
-        if (write)
-                need_pte_bits |= _PAGE_WRITE;
+        if (!pte_present(pte) || !pte_user(pte) || !pte_read(pte))
+                return false;
 
-        if ((pteval & need_pte_bits) != need_pte_bits)
+        if (write && !pte_write(pte))
                 return false;
 
         return true;
@@ -354,6 +455,11 @@ static inline pte_t pte_wrprotect(pte_t pte)
         return __pte(pte_val(pte) & ~_PAGE_RW);
 }
 
+static inline pte_t pte_exprotect(pte_t pte)
+{
+        return pte;
+}
+
 static inline pte_t pte_mkclean(pte_t pte)
 {
         return __pte(pte_val(pte) & ~_PAGE_DIRTY);
@@ -364,6 +470,16 @@ static inline pte_t pte_mkold(pte_t pte)
         return __pte(pte_val(pte) & ~_PAGE_ACCESSED);
 }
 
+static inline pte_t pte_mkexec(pte_t pte)
+{
+        return pte;
+}
+
+static inline pte_t pte_mkpte(pte_t pte)
+{
+        return pte;
+}
+
 static inline pte_t pte_mkwrite(pte_t pte)
 {
         return __pte(pte_val(pte) | _PAGE_RW);
@@ -389,6 +505,16 @@ static inline pte_t pte_mkhuge(pte_t pte)
         return pte;
 }
 
+static inline pte_t pte_mkprivileged(pte_t pte)
+{
+        return __pte(pte_val(pte) & ~_PAGE_USER);
+}
+
+static inline pte_t pte_mkuser(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_USER);
+}
+
 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 {
         return __pte((pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot));
diff --git a/arch/powerpc/include/asm/book3s/64/hash-4k.h b/arch/powerpc/include/asm/book3s/64/hash-4k.h
index 9a3798660cef..15bc16b1dc9c 100644
--- a/arch/powerpc/include/asm/book3s/64/hash-4k.h
+++ b/arch/powerpc/include/asm/book3s/64/hash-4k.h
@@ -66,7 +66,7 @@ static inline int hash__hugepd_ok(hugepd_t hpd)
          * if it is not a pte and have hugepd shift mask
          * set, then it is a hugepd directory pointer
          */
-        if (!(hpdval & _PAGE_PTE) &&
+        if (!(hpdval & _PAGE_PTE) && (hpdval & _PAGE_PRESENT) &&
             ((hpdval & HUGEPD_SHIFT_MASK) != 0))
                 return true;
         return false;
diff --git a/arch/powerpc/include/asm/book3s/64/hash.h b/arch/powerpc/include/asm/book3s/64/hash.h
index d52a51b2ce7b..247aff9cc6ba 100644
--- a/arch/powerpc/include/asm/book3s/64/hash.h
+++ b/arch/powerpc/include/asm/book3s/64/hash.h
@@ -18,6 +18,11 @@
 #include <asm/book3s/64/hash-4k.h>
 #endif
 
+/* Bits to set in a PMD/PUD/PGD entry valid bit*/
+#define HASH_PMD_VAL_BITS               (0x8000000000000000UL)
+#define HASH_PUD_VAL_BITS               (0x8000000000000000UL)
+#define HASH_PGD_VAL_BITS               (0x8000000000000000UL)
+
 /*
  * Size of EA range mapped by our pagetables.
  */
@@ -196,8 +201,7 @@ static inline void hpte_do_hugepage_flush(struct mm_struct *mm,
 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 
 
-extern int hash__map_kernel_page(unsigned long ea, unsigned long pa,
-                             unsigned long flags);
+int hash__map_kernel_page(unsigned long ea, unsigned long pa, pgprot_t prot);
 extern int __meminit hash__vmemmap_create_mapping(unsigned long start,
                                               unsigned long page_size,
                                               unsigned long phys);
diff --git a/arch/powerpc/include/asm/book3s/64/hugetlb.h b/arch/powerpc/include/asm/book3s/64/hugetlb.h
index 50888388a359..5b0177733994 100644
--- a/arch/powerpc/include/asm/book3s/64/hugetlb.h
+++ b/arch/powerpc/include/asm/book3s/64/hugetlb.h
@@ -39,4 +39,7 @@ static inline bool gigantic_page_supported(void)
 }
 #endif
 
+/* hugepd entry valid bit */
+#define HUGEPD_VAL_BITS         (0x8000000000000000UL)
+
 #endif
diff --git a/arch/powerpc/include/asm/book3s/64/mmu-hash.h b/arch/powerpc/include/asm/book3s/64/mmu-hash.h
index 66db23e2f4dc..12e522807f9f 100644
--- a/arch/powerpc/include/asm/book3s/64/mmu-hash.h
+++ b/arch/powerpc/include/asm/book3s/64/mmu-hash.h
@@ -30,7 +30,7 @@
  * SLB
  */
 
-#define SLB_NUM_BOLTED          3
+#define SLB_NUM_BOLTED          2
 #define SLB_CACHE_ENTRIES       8
 #define SLB_MIN_SIZE            32
 
@@ -499,6 +499,8 @@ int htab_remove_mapping(unsigned long vstart, unsigned long vend,
 extern void pseries_add_gpage(u64 addr, u64 page_size, unsigned long number_of_pages);
 extern void demote_segment_4k(struct mm_struct *mm, unsigned long addr);
 
+extern void hash__setup_new_exec(void);
+
 #ifdef CONFIG_PPC_PSERIES
 void hpte_init_pseries(void);
 #else
@@ -507,11 +509,18 @@ static inline void hpte_init_pseries(void) { }
 
 extern void hpte_init_native(void);
 
+struct slb_entry {
+        u64     esid;
+        u64     vsid;
+};
+
 extern void slb_initialize(void);
-extern void slb_flush_and_rebolt(void);
+void slb_flush_and_restore_bolted(void);
 void slb_flush_all_realmode(void);
 void __slb_restore_bolted_realmode(void);
 void slb_restore_bolted_realmode(void);
+void slb_save_contents(struct slb_entry *slb_ptr);
+void slb_dump_contents(struct slb_entry *slb_ptr);
 
 extern void slb_vmalloc_update(void);
 extern void slb_set_size(u16 size);
@@ -524,13 +533,9 @@ extern void slb_set_size(u16 size);
  * from mmu context id and effective segment id of the address.
  *
  * For user processes max context id is limited to MAX_USER_CONTEXT.
-
- * For kernel space, we use context ids 1-4 to map addresses as below:
- * NOTE: each context only support 64TB now.
- * 0x00001 -  [ 0xc000000000000000 - 0xc0003fffffffffff ]
- * 0x00002 -  [ 0xd000000000000000 - 0xd0003fffffffffff ]
- * 0x00003 -  [ 0xe000000000000000 - 0xe0003fffffffffff ]
- * 0x00004 -  [ 0xf000000000000000 - 0xf0003fffffffffff ]
+ * more details in get_user_context
+ *
+ * For kernel space get_kernel_context
  *
  * The proto-VSIDs are then scrambled into real VSIDs with the
  * multiplicative hash:
@@ -571,6 +576,21 @@ extern void slb_set_size(u16 size);
 #define ESID_BITS_1T_MASK       ((1 << ESID_BITS_1T) - 1)
 
 /*
+ * Now certain config support MAX_PHYSMEM more than 512TB. Hence we will need
+ * to use more than one context for linear mapping the kernel.
+ * For vmalloc and memmap, we use just one context with 512TB. With 64 byte
+ * struct page size, we need ony 32 TB in memmap for 2PB (51 bits (MAX_PHYSMEM_BITS)).
+ */
+#if (MAX_PHYSMEM_BITS > MAX_EA_BITS_PER_CONTEXT)
+#define MAX_KERNEL_CTX_CNT      (1UL << (MAX_PHYSMEM_BITS - MAX_EA_BITS_PER_CONTEXT))
+#else
+#define MAX_KERNEL_CTX_CNT      1
+#endif
+
+#define MAX_VMALLOC_CTX_CNT     1
+#define MAX_MEMMAP_CTX_CNT      1
+
+/*
  * 256MB segment
  * The proto-VSID space has 2^(CONTEX_BITS + ESID_BITS) - 1 segments
  * available for user + kernel mapping. VSID 0 is reserved as invalid, contexts
@@ -580,12 +600,13 @@ extern void slb_set_size(u16 size);
  * We also need to avoid the last segment of the last context, because that
  * would give a protovsid of 0x1fffffffff. That will result in a VSID 0
  * because of the modulo operation in vsid scramble.
+ *
+ * We add one extra context to MIN_USER_CONTEXT so that we can map kernel
+ * context easily. The +1 is to map the unused 0xe region mapping.
  */
 #define MAX_USER_CONTEXT        ((ASM_CONST(1) << CONTEXT_BITS) - 2)
-#define MIN_USER_CONTEXT        (5)
-
-/* Would be nice to use KERNEL_REGION_ID here */
-#define KERNEL_REGION_CONTEXT_OFFSET    (0xc - 1)
+#define MIN_USER_CONTEXT        (MAX_KERNEL_CTX_CNT + MAX_VMALLOC_CTX_CNT + \
+                                 MAX_MEMMAP_CTX_CNT + 2)
 
 /*
  * For platforms that support on 65bit VA we limit the context bits
@@ -746,6 +767,39 @@ static inline unsigned long get_vsid(unsigned long context, unsigned long ea,
 }
 
 /*
+ * For kernel space, we use context ids as below
+ * below. Range is 512TB per context.
+ *
+ * 0x00001 -  [ 0xc000000000000000 - 0xc001ffffffffffff]
+ * 0x00002 -  [ 0xc002000000000000 - 0xc003ffffffffffff]
+ * 0x00003 -  [ 0xc004000000000000 - 0xc005ffffffffffff]
+ * 0x00004 -  [ 0xc006000000000000 - 0xc007ffffffffffff]
+
+ * 0x00005 -  [ 0xd000000000000000 - 0xd001ffffffffffff ]
+ * 0x00006 -  Not used - Can map 0xe000000000000000 range.
+ * 0x00007 -  [ 0xf000000000000000 - 0xf001ffffffffffff ]
+ *
+ * So we can compute the context from the region (top nibble) by
+ * subtracting 11, or 0xc - 1.
+ */
+static inline unsigned long get_kernel_context(unsigned long ea)
+{
+        unsigned long region_id = REGION_ID(ea);
+        unsigned long ctx;
+        /*
+         * For linear mapping we do support multiple context
+         */
+        if (region_id == KERNEL_REGION_ID) {
+                /*
+                 * We already verified ea to be not beyond the addr limit.
+                 */
+                ctx =  1 + ((ea & ~REGION_MASK) >> MAX_EA_BITS_PER_CONTEXT);
+        } else
+                ctx = (region_id - 0xc) + MAX_KERNEL_CTX_CNT;
+        return ctx;
+}
+
+/*
  * This is only valid for addresses >= PAGE_OFFSET
  */
 static inline unsigned long get_kernel_vsid(unsigned long ea, int ssize)
@@ -755,20 +809,7 @@ static inline unsigned long get_kernel_vsid(unsigned long ea, int ssize)
         if (!is_kernel_addr(ea))
                 return 0;
 
-        /*
-         * For kernel space, we use context ids 1-4 to map the address space as
-         * below:
-         *
-         * 0x00001 -  [ 0xc000000000000000 - 0xc0003fffffffffff ]
-         * 0x00002 -  [ 0xd000000000000000 - 0xd0003fffffffffff ]
-         * 0x00003 -  [ 0xe000000000000000 - 0xe0003fffffffffff ]
-         * 0x00004 -  [ 0xf000000000000000 - 0xf0003fffffffffff ]
-         *
-         * So we can compute the context from the region (top nibble) by
-         * subtracting 11, or 0xc - 1.
-         */
-        context = (ea >> 60) - KERNEL_REGION_CONTEXT_OFFSET;
-
+        context = get_kernel_context(ea);
         return get_vsid(context, ea, ssize);
 }
 
diff --git a/arch/powerpc/include/asm/book3s/64/mmu.h b/arch/powerpc/include/asm/book3s/64/mmu.h
index 9c8c669a6b6a..6328857f259f 100644
--- a/arch/powerpc/include/asm/book3s/64/mmu.h
+++ b/arch/powerpc/include/asm/book3s/64/mmu.h
@@ -208,7 +208,7 @@ extern void radix_init_pseries(void);
 static inline void radix_init_pseries(void) { };
 #endif
 
-static inline int get_ea_context(mm_context_t *ctx, unsigned long ea)
+static inline int get_user_context(mm_context_t *ctx, unsigned long ea)
 {
         int index = ea >> MAX_EA_BITS_PER_CONTEXT;
 
@@ -223,7 +223,7 @@ static inline int get_ea_context(mm_context_t *ctx, unsigned long ea)
 static inline unsigned long get_user_vsid(mm_context_t *ctx,
                                           unsigned long ea, int ssize)
 {
-        unsigned long context = get_ea_context(ctx, ea);
+        unsigned long context = get_user_context(ctx, ea);
 
         return get_vsid(context, ea, ssize);
 }
diff --git a/arch/powerpc/include/asm/book3s/64/pgtable-64k.h b/arch/powerpc/include/asm/book3s/64/pgtable-64k.h
index d7ee249d6890..e3d4dd4ae2fa 100644
--- a/arch/powerpc/include/asm/book3s/64/pgtable-64k.h
+++ b/arch/powerpc/include/asm/book3s/64/pgtable-64k.h
@@ -10,6 +10,9 @@
  *
  * Defined in such a way that we can optimize away code block at build time
  * if CONFIG_HUGETLB_PAGE=n.
+ *
+ * returns true for pmd migration entries, THP, devmap, hugetlb
+ * But compile time dependent on CONFIG_HUGETLB_PAGE
  */
 static inline int pmd_huge(pmd_t pmd)
 {
diff --git a/arch/powerpc/include/asm/book3s/64/pgtable.h b/arch/powerpc/include/asm/book3s/64/pgtable.h
index 2a2486526d1f..cb5dd4078d42 100644
--- a/arch/powerpc/include/asm/book3s/64/pgtable.h
+++ b/arch/powerpc/include/asm/book3s/64/pgtable.h
@@ -14,10 +14,6 @@
  */
 #define _PAGE_BIT_SWAP_TYPE     0
 
-#define _PAGE_NA                0
-#define _PAGE_RO                0
-#define _PAGE_USER              0
-
 #define _PAGE_EXEC              0x00001 /* execute permission */
 #define _PAGE_WRITE             0x00002 /* write access allowed */
 #define _PAGE_READ              0x00004 /* read access allowed */
@@ -123,10 +119,6 @@
 #define _PAGE_KERNEL_RWX        (_PAGE_PRIVILEGED | _PAGE_DIRTY |       \
                                  _PAGE_RW | _PAGE_EXEC)
 /*
- * No page size encoding in the linux PTE
- */
-#define _PAGE_PSIZE             0
-/*
  * _PAGE_CHG_MASK masks of bits that are to be preserved across
  * pgprot changes
  */
@@ -137,19 +129,12 @@
 #define H_PTE_PKEY  (H_PTE_PKEY_BIT0 | H_PTE_PKEY_BIT1 | H_PTE_PKEY_BIT2 | \
                      H_PTE_PKEY_BIT3 | H_PTE_PKEY_BIT4)
 /*
- * Mask of bits returned by pte_pgprot()
- */
-#define PAGE_PROT_BITS  (_PAGE_SAO | _PAGE_NON_IDEMPOTENT | _PAGE_TOLERANT | \
-                         H_PAGE_4K_PFN | _PAGE_PRIVILEGED | _PAGE_ACCESSED | \
-                         _PAGE_READ | _PAGE_WRITE |  _PAGE_DIRTY | _PAGE_EXEC | \
-                         _PAGE_SOFT_DIRTY | H_PTE_PKEY)
-/*
  * We define 2 sets of base prot bits, one for basic pages (ie,
  * cacheable kernel and user pages) and one for non cacheable
  * pages. We always set _PAGE_COHERENT when SMP is enabled or
  * the processor might need it for DMA coherency.
  */
-#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_PSIZE)
+#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED)
 #define _PAGE_BASE      (_PAGE_BASE_NC)
 
 /* Permission masks used to generate the __P and __S table,
@@ -159,8 +144,6 @@
  * Write permissions imply read permissions for now (we could make write-only
  * pages on BookE but we don't bother for now). Execute permission control is
  * possible on platforms that define _PAGE_EXEC
- *
- * Note due to the way vm flags are laid out, the bits are XWR
  */
 #define PAGE_NONE       __pgprot(_PAGE_BASE | _PAGE_PRIVILEGED)
 #define PAGE_SHARED     __pgprot(_PAGE_BASE | _PAGE_RW)
@@ -170,24 +153,6 @@
 #define PAGE_READONLY   __pgprot(_PAGE_BASE | _PAGE_READ)
 #define PAGE_READONLY_X __pgprot(_PAGE_BASE | _PAGE_READ | _PAGE_EXEC)
 
-#define __P000  PAGE_NONE
-#define __P001  PAGE_READONLY
-#define __P010  PAGE_COPY
-#define __P011  PAGE_COPY
-#define __P100  PAGE_READONLY_X
-#define __P101  PAGE_READONLY_X
-#define __P110  PAGE_COPY_X
-#define __P111  PAGE_COPY_X
-
-#define __S000  PAGE_NONE
-#define __S001  PAGE_READONLY
-#define __S010  PAGE_SHARED
-#define __S011  PAGE_SHARED
-#define __S100  PAGE_READONLY_X
-#define __S101  PAGE_READONLY_X
-#define __S110  PAGE_SHARED_X
-#define __S111  PAGE_SHARED_X
-
 /* Permission masks used for kernel mappings */
 #define PAGE_KERNEL     __pgprot(_PAGE_BASE | _PAGE_KERNEL_RW)
 #define PAGE_KERNEL_NC  __pgprot(_PAGE_BASE_NC | _PAGE_KERNEL_RW | \
@@ -519,7 +484,11 @@ static inline int pte_special(pte_t pte)
         return !!(pte_raw(pte) & cpu_to_be64(_PAGE_SPECIAL));
 }
 
-static inline pgprot_t pte_pgprot(pte_t pte)    { return __pgprot(pte_val(pte) & PAGE_PROT_BITS); }
+static inline bool pte_exec(pte_t pte)
+{
+        return !!(pte_raw(pte) & cpu_to_be64(_PAGE_EXEC));
+}
+
 
 #ifdef CONFIG_HAVE_ARCH_SOFT_DIRTY
 static inline bool pte_soft_dirty(pte_t pte)
@@ -529,12 +498,12 @@ static inline bool pte_soft_dirty(pte_t pte)
 
 static inline pte_t pte_mksoft_dirty(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_SOFT_DIRTY);
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_SOFT_DIRTY));
 }
 
 static inline pte_t pte_clear_soft_dirty(pte_t pte)
 {
-        return __pte(pte_val(pte) & ~_PAGE_SOFT_DIRTY);
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_SOFT_DIRTY));
 }
 #endif /* CONFIG_HAVE_ARCH_SOFT_DIRTY */
 
@@ -555,7 +524,7 @@ static inline pte_t pte_mk_savedwrite(pte_t pte)
          */
         VM_BUG_ON((pte_raw(pte) & cpu_to_be64(_PAGE_PRESENT | _PAGE_RWX | _PAGE_PRIVILEGED)) !=
                   cpu_to_be64(_PAGE_PRESENT | _PAGE_PRIVILEGED));
-        return __pte(pte_val(pte) & ~_PAGE_PRIVILEGED);
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_PRIVILEGED));
 }
 
 #define pte_clear_savedwrite pte_clear_savedwrite
@@ -565,14 +534,14 @@ static inline pte_t pte_clear_savedwrite(pte_t pte)
          * Used by KSM subsystem to make a protnone pte readonly.
          */
         VM_BUG_ON(!pte_protnone(pte));
-        return __pte(pte_val(pte) | _PAGE_PRIVILEGED);
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_PRIVILEGED));
 }
 #else
 #define pte_clear_savedwrite pte_clear_savedwrite
 static inline pte_t pte_clear_savedwrite(pte_t pte)
 {
         VM_WARN_ON(1);
-        return __pte(pte_val(pte) & ~_PAGE_WRITE);
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_WRITE));
 }
 #endif /* CONFIG_NUMA_BALANCING */
 
@@ -587,6 +556,11 @@ static inline int pte_present(pte_t pte)
         return !!(pte_raw(pte) & cpu_to_be64(_PAGE_PRESENT | _PAGE_INVALID));
 }
 
+static inline bool pte_hw_valid(pte_t pte)
+{
+        return !!(pte_raw(pte) & cpu_to_be64(_PAGE_PRESENT));
+}
+
 #ifdef CONFIG_PPC_MEM_KEYS
 extern bool arch_pte_access_permitted(u64 pte, bool write, bool execute);
 #else
@@ -596,25 +570,22 @@ static inline bool arch_pte_access_permitted(u64 pte, bool write, bool execute)
 }
 #endif /* CONFIG_PPC_MEM_KEYS */
 
+static inline bool pte_user(pte_t pte)
+{
+        return !(pte_raw(pte) & cpu_to_be64(_PAGE_PRIVILEGED));
+}
+
 #define pte_access_permitted pte_access_permitted
 static inline bool pte_access_permitted(pte_t pte, bool write)
 {
-        unsigned long pteval = pte_val(pte);
-        /* Also check for pte_user */
-        unsigned long clear_pte_bits = _PAGE_PRIVILEGED;
         /*
          * _PAGE_READ is needed for any access and will be
          * cleared for PROT_NONE
          */
-        unsigned long need_pte_bits = _PAGE_PRESENT | _PAGE_READ;
-
-        if (write)
-                need_pte_bits |= _PAGE_WRITE;
-
-        if ((pteval & need_pte_bits) != need_pte_bits)
+        if (!pte_present(pte) || !pte_user(pte) || !pte_read(pte))
                 return false;
 
-        if ((pteval & clear_pte_bits) == clear_pte_bits)
+        if (write && !pte_write(pte))
                 return false;
 
         return arch_pte_access_permitted(pte_val(pte), write, 0);
@@ -643,17 +614,32 @@ static inline pte_t pte_wrprotect(pte_t pte)
 {
         if (unlikely(pte_savedwrite(pte)))
                 return pte_clear_savedwrite(pte);
-        return __pte(pte_val(pte) & ~_PAGE_WRITE);
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_WRITE));
+}
+
+static inline pte_t pte_exprotect(pte_t pte)
+{
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_EXEC));
 }
 
 static inline pte_t pte_mkclean(pte_t pte)
 {
-        return __pte(pte_val(pte) & ~_PAGE_DIRTY);
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_DIRTY));
 }
 
 static inline pte_t pte_mkold(pte_t pte)
 {
-        return __pte(pte_val(pte) & ~_PAGE_ACCESSED);
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_ACCESSED));
+}
+
+static inline pte_t pte_mkexec(pte_t pte)
+{
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_EXEC));
+}
+
+static inline pte_t pte_mkpte(pte_t pte)
+{
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_PTE));
 }
 
 static inline pte_t pte_mkwrite(pte_t pte)
@@ -661,22 +647,22 @@ static inline pte_t pte_mkwrite(pte_t pte)
         /*
          * write implies read, hence set both
          */
-        return __pte(pte_val(pte) | _PAGE_RW);
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_RW));
 }
 
 static inline pte_t pte_mkdirty(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_DIRTY | _PAGE_SOFT_DIRTY);
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_DIRTY | _PAGE_SOFT_DIRTY));
 }
 
 static inline pte_t pte_mkyoung(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_ACCESSED);
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_ACCESSED));
 }
 
 static inline pte_t pte_mkspecial(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_SPECIAL);
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_SPECIAL));
 }
 
 static inline pte_t pte_mkhuge(pte_t pte)
@@ -686,7 +672,17 @@ static inline pte_t pte_mkhuge(pte_t pte)
 
 static inline pte_t pte_mkdevmap(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_SPECIAL|_PAGE_DEVMAP);
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_SPECIAL | _PAGE_DEVMAP));
+}
+
+static inline pte_t pte_mkprivileged(pte_t pte)
+{
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_PRIVILEGED));
+}
+
+static inline pte_t pte_mkuser(pte_t pte)
+{
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_PRIVILEGED));
 }
 
 /*
@@ -705,12 +701,8 @@ static inline int pte_devmap(pte_t pte)
 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 {
         /* FIXME!! check whether this need to be a conditional */
-        return __pte((pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot));
-}
-
-static inline bool pte_user(pte_t pte)
-{
-        return !(pte_raw(pte) & cpu_to_be64(_PAGE_PRIVILEGED));
+        return __pte_raw((pte_raw(pte) & cpu_to_be64(_PAGE_CHG_MASK)) |
+                         cpu_to_be64(pgprot_val(newprot)));
 }
 
 /* Encode and de-code a swap entry */
@@ -741,6 +733,8 @@ static inline bool pte_user(pte_t pte)
  */
 #define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val((pte)) & ~_PAGE_PTE })
 #define __swp_entry_to_pte(x)   __pte((x).val | _PAGE_PTE)
+#define __pmd_to_swp_entry(pmd) (__pte_to_swp_entry(pmd_pte(pmd)))
+#define __swp_entry_to_pmd(x)   (pte_pmd(__swp_entry_to_pte(x)))
 
 #ifdef CONFIG_MEM_SOFT_DIRTY
 #define _PAGE_SWP_SOFT_DIRTY   (1UL << (SWP_TYPE_BITS + _PAGE_BIT_SWAP_TYPE))
@@ -751,7 +745,7 @@ static inline bool pte_user(pte_t pte)
 #ifdef CONFIG_HAVE_ARCH_SOFT_DIRTY
 static inline pte_t pte_swp_mksoft_dirty(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_SWP_SOFT_DIRTY);
+        return __pte_raw(pte_raw(pte) | cpu_to_be64(_PAGE_SWP_SOFT_DIRTY));
 }
 
 static inline bool pte_swp_soft_dirty(pte_t pte)
@@ -761,7 +755,7 @@ static inline bool pte_swp_soft_dirty(pte_t pte)
 
 static inline pte_t pte_swp_clear_soft_dirty(pte_t pte)
 {
-        return __pte(pte_val(pte) & ~_PAGE_SWP_SOFT_DIRTY);
+        return __pte_raw(pte_raw(pte) & cpu_to_be64(~_PAGE_SWP_SOFT_DIRTY));
 }
 #endif /* CONFIG_HAVE_ARCH_SOFT_DIRTY */
 
@@ -850,10 +844,10 @@ static inline pgprot_t pgprot_writecombine(pgprot_t prot)
  */
 static inline bool pte_ci(pte_t pte)
 {
-        unsigned long pte_v = pte_val(pte);
+        __be64 pte_v = pte_raw(pte);
 
-        if (((pte_v & _PAGE_CACHE_CTL) == _PAGE_TOLERANT) ||
-            ((pte_v & _PAGE_CACHE_CTL) == _PAGE_NON_IDEMPOTENT))
+        if (((pte_v & cpu_to_be64(_PAGE_CACHE_CTL)) == cpu_to_be64(_PAGE_TOLERANT)) ||
+            ((pte_v & cpu_to_be64(_PAGE_CACHE_CTL)) == cpu_to_be64(_PAGE_NON_IDEMPOTENT)))
                 return true;
         return false;
 }
@@ -875,8 +869,16 @@ static inline int pmd_none(pmd_t pmd)
 
 static inline int pmd_present(pmd_t pmd)
 {
+        /*
+         * A pmd is considerent present if _PAGE_PRESENT is set.
+         * We also need to consider the pmd present which is marked
+         * invalid during a split. Hence we look for _PAGE_INVALID
+         * if we find _PAGE_PRESENT cleared.
+         */
+        if (pmd_raw(pmd) & cpu_to_be64(_PAGE_PRESENT | _PAGE_INVALID))
+                return true;
 
-        return !pmd_none(pmd);
+        return false;
 }
 
 static inline int pmd_bad(pmd_t pmd)
@@ -903,7 +905,7 @@ static inline int pud_none(pud_t pud)
 
 static inline int pud_present(pud_t pud)
 {
-        return !pud_none(pud);
+        return (pud_raw(pud) & cpu_to_be64(_PAGE_PRESENT));
 }
 
 extern struct page *pud_page(pud_t pud);
@@ -950,7 +952,7 @@ static inline int pgd_none(pgd_t pgd)
 
 static inline int pgd_present(pgd_t pgd)
 {
-        return !pgd_none(pgd);
+        return (pgd_raw(pgd) & cpu_to_be64(_PAGE_PRESENT));
 }
 
 static inline pte_t pgd_pte(pgd_t pgd)
@@ -1020,17 +1022,16 @@ extern struct page *pgd_page(pgd_t pgd);
 #define pgd_ERROR(e) \
         pr_err("%s:%d: bad pgd %08lx.\n", __FILE__, __LINE__, pgd_val(e))
 
-static inline int map_kernel_page(unsigned long ea, unsigned long pa,
-                                  unsigned long flags)
+static inline int map_kernel_page(unsigned long ea, unsigned long pa, pgprot_t prot)
 {
         if (radix_enabled()) {
 #if defined(CONFIG_PPC_RADIX_MMU) && defined(DEBUG_VM)
                 unsigned long page_size = 1 << mmu_psize_defs[mmu_io_psize].shift;
                 WARN((page_size != PAGE_SIZE), "I/O page size != PAGE_SIZE");
 #endif
-                return radix__map_kernel_page(ea, pa, __pgprot(flags), PAGE_SIZE);
+                return radix__map_kernel_page(ea, pa, prot, PAGE_SIZE);
         }
-        return hash__map_kernel_page(ea, pa, flags);
+        return hash__map_kernel_page(ea, pa, prot);
 }
 
 static inline int __meminit vmemmap_create_mapping(unsigned long start,
@@ -1082,6 +1083,12 @@ static inline pte_t *pmdp_ptep(pmd_t *pmd)
 #define pmd_soft_dirty(pmd)    pte_soft_dirty(pmd_pte(pmd))
 #define pmd_mksoft_dirty(pmd)  pte_pmd(pte_mksoft_dirty(pmd_pte(pmd)))
 #define pmd_clear_soft_dirty(pmd) pte_pmd(pte_clear_soft_dirty(pmd_pte(pmd)))
+
+#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
+#define pmd_swp_mksoft_dirty(pmd)       pte_pmd(pte_swp_mksoft_dirty(pmd_pte(pmd)))
+#define pmd_swp_soft_dirty(pmd)         pte_swp_soft_dirty(pmd_pte(pmd))
+#define pmd_swp_clear_soft_dirty(pmd)   pte_pmd(pte_swp_clear_soft_dirty(pmd_pte(pmd)))
+#endif
 #endif /* CONFIG_HAVE_ARCH_SOFT_DIRTY */
 
 #ifdef CONFIG_NUMA_BALANCING
@@ -1127,6 +1134,10 @@ pmd_hugepage_update(struct mm_struct *mm, unsigned long addr, pmd_t *pmdp,
         return hash__pmd_hugepage_update(mm, addr, pmdp, clr, set);
 }
 
+/*
+ * returns true for pmd migration entries, THP, devmap, hugetlb
+ * But compile time dependent on THP config
+ */
 static inline int pmd_large(pmd_t pmd)
 {
         return !!(pmd_raw(pmd) & cpu_to_be64(_PAGE_PTE));
@@ -1161,8 +1172,22 @@ static inline void pmdp_set_wrprotect(struct mm_struct *mm, unsigned long addr,
                 pmd_hugepage_update(mm, addr, pmdp, 0, _PAGE_PRIVILEGED);
 }
 
+/*
+ * Only returns true for a THP. False for pmd migration entry.
+ * We also need to return true when we come across a pte that
+ * in between a thp split. While splitting THP, we mark the pmd
+ * invalid (pmdp_invalidate()) before we set it with pte page
+ * address. A pmd_trans_huge() check against a pmd entry during that time
+ * should return true.
+ * We should not call this on a hugetlb entry. We should check for HugeTLB
+ * entry using vma->vm_flags
+ * The page table walk rule is explained in Documentation/vm/transhuge.rst
+ */
 static inline int pmd_trans_huge(pmd_t pmd)
 {
+        if (!pmd_present(pmd))
+                return false;
+
         if (radix_enabled())
                 return radix__pmd_trans_huge(pmd);
         return hash__pmd_trans_huge(pmd);
diff --git a/arch/powerpc/include/asm/cputhreads.h b/arch/powerpc/include/asm/cputhreads.h
index d71a90924f3b..deb99fd6e060 100644
--- a/arch/powerpc/include/asm/cputhreads.h
+++ b/arch/powerpc/include/asm/cputhreads.h
@@ -23,11 +23,13 @@
 extern int threads_per_core;
 extern int threads_per_subcore;
 extern int threads_shift;
+extern bool has_big_cores;
 extern cpumask_t threads_core_mask;
 #else
 #define threads_per_core        1
 #define threads_per_subcore     1
 #define threads_shift           0
+#define has_big_cores           0
 #define threads_core_mask       (*get_cpu_mask(0))
 #endif
 
diff --git a/arch/powerpc/include/asm/cputime.h b/arch/powerpc/include/asm/cputime.h
index 133672744b2e..ae73dc8da2d4 100644
--- a/arch/powerpc/include/asm/cputime.h
+++ b/arch/powerpc/include/asm/cputime.h
@@ -61,7 +61,6 @@ static inline void arch_vtime_task_switch(struct task_struct *prev)
         struct cpu_accounting_data *acct0 = get_accounting(prev);
 
         acct->starttime = acct0->starttime;
-        acct->startspurr = acct0->startspurr;
 }
 #endif
 
diff --git a/arch/powerpc/include/asm/drmem.h b/arch/powerpc/include/asm/drmem.h
index ce242b9ea8c6..7c1d8e74b25d 100644
--- a/arch/powerpc/include/asm/drmem.h
+++ b/arch/powerpc/include/asm/drmem.h
@@ -99,4 +99,9 @@ void __init walk_drmem_lmbs_early(unsigned long node,
                         void (*func)(struct drmem_lmb *, const __be32 **));
 #endif
 
+static inline void invalidate_lmb_associativity_index(struct drmem_lmb *lmb)
+{
+        lmb->aa_index = 0xffffffff;
+}
+
 #endif /* _ASM_POWERPC_LMB_H */
diff --git a/arch/powerpc/include/asm/eeh.h b/arch/powerpc/include/asm/eeh.h
index 219637ea69a1..8b596d096ebe 100644
--- a/arch/powerpc/include/asm/eeh.h
+++ b/arch/powerpc/include/asm/eeh.h
@@ -43,7 +43,6 @@ struct pci_dn;
 #define EEH_VALID_PE_ZERO       0x10    /* PE#0 is valid                     */
 #define EEH_ENABLE_IO_FOR_LOG   0x20    /* Enable IO for log                 */
 #define EEH_EARLY_DUMP_LOG      0x40    /* Dump log immediately              */
-#define EEH_POSTPONED_PROBE     0x80    /* Powernv may postpone device probe */
 
 /*
  * Delay for PE reset, all in ms
@@ -99,13 +98,13 @@ struct eeh_pe {
         atomic_t pass_dev_cnt;          /* Count of passed through devs */
         struct eeh_pe *parent;          /* Parent PE                    */
         void *data;                     /* PE auxillary data            */
-        struct list_head child_list;    /* Link PE to the child list    */
-        struct list_head edevs;         /* Link list of EEH devices     */
-        struct list_head child;         /* Child PEs                    */
+        struct list_head child_list;    /* List of PEs below this PE    */
+        struct list_head child;         /* Memb. child_list/eeh_phb_pe  */
+        struct list_head edevs;         /* List of eeh_dev in this PE   */
 };
 
 #define eeh_pe_for_each_dev(pe, edev, tmp) \
-                list_for_each_entry_safe(edev, tmp, &pe->edevs, list)
+                list_for_each_entry_safe(edev, tmp, &pe->edevs, entry)
 
 #define eeh_for_each_pe(root, pe) \
         for (pe = root; pe; pe = eeh_pe_next(pe, root))
@@ -142,13 +141,12 @@ struct eeh_dev {
         int aer_cap;                    /* Saved AER capability         */
         int af_cap;                     /* Saved AF capability          */
         struct eeh_pe *pe;              /* Associated PE                */
-        struct list_head list;          /* Form link list in the PE     */
-        struct list_head rmv_list;      /* Record the removed edevs     */
+        struct list_head entry;         /* Membership in eeh_pe.edevs   */
+        struct list_head rmv_entry;     /* Membership in rmv_list       */
         struct pci_dn *pdn;             /* Associated PCI device node   */
         struct pci_dev *pdev;           /* Associated PCI device        */
         bool in_error;                  /* Error flag for edev          */
         struct pci_dev *physfn;         /* Associated SRIOV PF          */
-        struct pci_bus *bus;            /* PCI bus for partial hotplug  */
 };
 
 static inline struct pci_dn *eeh_dev_to_pdn(struct eeh_dev *edev)
@@ -207,9 +205,8 @@ struct eeh_ops {
         void* (*probe)(struct pci_dn *pdn, void *data);
         int (*set_option)(struct eeh_pe *pe, int option);
         int (*get_pe_addr)(struct eeh_pe *pe);
-        int (*get_state)(struct eeh_pe *pe, int *state);
+        int (*get_state)(struct eeh_pe *pe, int *delay);
         int (*reset)(struct eeh_pe *pe, int option);
-        int (*wait_state)(struct eeh_pe *pe, int max_wait);
         int (*get_log)(struct eeh_pe *pe, int severity, char *drv_log, unsigned long len);
         int (*configure_bridge)(struct eeh_pe *pe);
         int (*err_inject)(struct eeh_pe *pe, int type, int func,
@@ -243,11 +240,7 @@ static inline bool eeh_has_flag(int flag)
 
 static inline bool eeh_enabled(void)
 {
-        if (eeh_has_flag(EEH_FORCE_DISABLED) ||
-            !eeh_has_flag(EEH_ENABLED))
-                return false;
-
-        return true;
+        return eeh_has_flag(EEH_ENABLED) && !eeh_has_flag(EEH_FORCE_DISABLED);
 }
 
 static inline void eeh_serialize_lock(unsigned long *flags)
@@ -270,6 +263,7 @@ typedef void *(*eeh_edev_traverse_func)(struct eeh_dev *edev, void *flag);
 typedef void *(*eeh_pe_traverse_func)(struct eeh_pe *pe, void *flag);
 void eeh_set_pe_aux_size(int size);
 int eeh_phb_pe_create(struct pci_controller *phb);
+int eeh_wait_state(struct eeh_pe *pe, int max_wait);
 struct eeh_pe *eeh_phb_pe_get(struct pci_controller *phb);
 struct eeh_pe *eeh_pe_next(struct eeh_pe *pe, struct eeh_pe *root);
 struct eeh_pe *eeh_pe_get(struct pci_controller *phb,
diff --git a/arch/powerpc/include/asm/error-injection.h b/arch/powerpc/include/asm/error-injection.h
new file mode 100644
index 000000000000..62fd24739852
--- /dev/null
+++ b/arch/powerpc/include/asm/error-injection.h
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+
+#ifndef _ASM_ERROR_INJECTION_H
+#define _ASM_ERROR_INJECTION_H
+
+#include <linux/compiler.h>
+#include <linux/linkage.h>
+#include <asm/ptrace.h>
+#include <asm-generic/error-injection.h>
+
+void override_function_with_return(struct pt_regs *regs);
+
+#endif /* _ASM_ERROR_INJECTION_H */
diff --git a/arch/powerpc/include/asm/exception-64s.h b/arch/powerpc/include/asm/exception-64s.h
index a86feddddad0..3b4767ed3ec5 100644
--- a/arch/powerpc/include/asm/exception-64s.h
+++ b/arch/powerpc/include/asm/exception-64s.h
@@ -61,14 +61,6 @@
 #define MAX_MCE_DEPTH   4
 
 /*
- * EX_LR is only used in EXSLB and where it does not overlap with EX_DAR
- * EX_CCR similarly with DSISR, but being 4 byte registers there is a hole
- * in the save area so it's not necessary to overlap them. Could be used
- * for future savings though if another 4 byte register was to be saved.
- */
-#define EX_LR           EX_DAR
-
-/*
  * EX_R3 is only used by the bad_stack handler. bad_stack reloads and
  * saves DAR from SPRN_DAR, and EX_DAR is not used. So EX_R3 can overlap
  * with EX_DAR.
@@ -236,11 +228,10 @@
  * PPR save/restore macros used in exceptions_64s.S  
  * Used for P7 or later processors
  */
-#define SAVE_PPR(area, ra, rb)                                          \
+#define SAVE_PPR(area, ra)                                              \
 BEGIN_FTR_SECTION_NESTED(940)                                           \
-        ld      ra,PACACURRENT(r13);                                    \
-        ld      rb,area+EX_PPR(r13);    /* Read PPR from paca */        \
-        std     rb,TASKTHREADPPR(ra);                                   \
+        ld      ra,area+EX_PPR(r13);    /* Read PPR from paca */        \
+        std     ra,_PPR(r1);                                            \
 END_FTR_SECTION_NESTED(CPU_FTR_HAS_PPR,CPU_FTR_HAS_PPR,940)
 
 #define RESTORE_PPR_PACA(area, ra)                                      \
@@ -508,7 +499,7 @@ END_FTR_SECTION_NESTED(ftr,ftr,943)
 3:      EXCEPTION_PROLOG_COMMON_1();                                       \
         beq     4f;                     /* if from kernel mode          */ \
         ACCOUNT_CPU_USER_ENTRY(r13, r9, r10);                              \
-        SAVE_PPR(area, r9, r10);                                           \
+        SAVE_PPR(area, r9);                                                \
 4:      EXCEPTION_PROLOG_COMMON_2(area)                                    \
         EXCEPTION_PROLOG_COMMON_3(n)                                       \
         ACCOUNT_STOLEN_TIME
diff --git a/arch/powerpc/include/asm/firmware.h b/arch/powerpc/include/asm/firmware.h
index 7a051bd21f87..00bc42d95679 100644
--- a/arch/powerpc/include/asm/firmware.h
+++ b/arch/powerpc/include/asm/firmware.h
@@ -52,6 +52,8 @@
 #define FW_FEATURE_PRRN         ASM_CONST(0x0000000200000000)
 #define FW_FEATURE_DRMEM_V2     ASM_CONST(0x0000000400000000)
 #define FW_FEATURE_DRC_INFO     ASM_CONST(0x0000000800000000)
+#define FW_FEATURE_BLOCK_REMOVE ASM_CONST(0x0000001000000000)
+#define FW_FEATURE_PAPR_SCM     ASM_CONST(0x0000002000000000)
 
 #ifndef __ASSEMBLY__
 
@@ -69,7 +71,8 @@ enum {
                 FW_FEATURE_SET_MODE | FW_FEATURE_BEST_ENERGY |
                 FW_FEATURE_TYPE1_AFFINITY | FW_FEATURE_PRRN |
                 FW_FEATURE_HPT_RESIZE | FW_FEATURE_DRMEM_V2 |
-                FW_FEATURE_DRC_INFO,
+                FW_FEATURE_DRC_INFO | FW_FEATURE_BLOCK_REMOVE |
+                FW_FEATURE_PAPR_SCM,
         FW_FEATURE_PSERIES_ALWAYS = 0,
         FW_FEATURE_POWERNV_POSSIBLE = FW_FEATURE_OPAL,
         FW_FEATURE_POWERNV_ALWAYS = 0,
diff --git a/arch/powerpc/include/asm/fixmap.h b/arch/powerpc/include/asm/fixmap.h
index 41cc15c14eee..b9fbed84ddca 100644
--- a/arch/powerpc/include/asm/fixmap.h
+++ b/arch/powerpc/include/asm/fixmap.h
@@ -72,7 +72,7 @@ enum fixed_addresses {
 static inline void __set_fixmap(enum fixed_addresses idx,
                                 phys_addr_t phys, pgprot_t flags)
 {
-        map_kernel_page(fix_to_virt(idx), phys, pgprot_val(flags));
+        map_kernel_page(fix_to_virt(idx), phys, flags);
 }
 
 #endif /* !__ASSEMBLY__ */
diff --git a/arch/powerpc/include/asm/hvcall.h b/arch/powerpc/include/asm/hvcall.h
index 45e8789bb770..33a4fc891947 100644
--- a/arch/powerpc/include/asm/hvcall.h
+++ b/arch/powerpc/include/asm/hvcall.h
@@ -278,6 +278,7 @@
 #define H_COP                   0x304
 #define H_GET_MPP_X             0x314
 #define H_SET_MODE              0x31C
+#define H_BLOCK_REMOVE          0x328
 #define H_CLEAR_HPT             0x358
 #define H_REQUEST_VMC           0x360
 #define H_RESIZE_HPT_PREPARE    0x36C
@@ -295,7 +296,15 @@
 #define H_INT_ESB               0x3C8
 #define H_INT_SYNC              0x3CC
 #define H_INT_RESET             0x3D0
-#define MAX_HCALL_OPCODE        H_INT_RESET
+#define H_SCM_READ_METADATA     0x3E4
+#define H_SCM_WRITE_METADATA    0x3E8
+#define H_SCM_BIND_MEM          0x3EC
+#define H_SCM_UNBIND_MEM        0x3F0
+#define H_SCM_QUERY_BLOCK_MEM_BINDING 0x3F4
+#define H_SCM_QUERY_LOGICAL_MEM_BINDING 0x3F8
+#define H_SCM_MEM_QUERY         0x3FC
+#define H_SCM_BLOCK_CLEAR       0x400
+#define MAX_HCALL_OPCODE        H_SCM_BLOCK_CLEAR
 
 /* H_VIOCTL functions */
 #define H_GET_VIOA_DUMP_SIZE    0x01
diff --git a/arch/powerpc/include/asm/io.h b/arch/powerpc/include/asm/io.h
index e0331e754568..3ef40b703c4a 100644
--- a/arch/powerpc/include/asm/io.h
+++ b/arch/powerpc/include/asm/io.h
@@ -3,6 +3,9 @@
 #ifdef __KERNEL__
 
 #define ARCH_HAS_IOREMAP_WC
+#ifdef CONFIG_PPC32
+#define ARCH_HAS_IOREMAP_WT
+#endif
 
 /*
  * This program is free software; you can redistribute it and/or
@@ -108,25 +111,6 @@ extern bool isa_io_special;
 #define IO_SET_SYNC_FLAG()
 #endif
 
-/* gcc 4.0 and older doesn't have 'Z' constraint */
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ == 0)
-#define DEF_MMIO_IN_X(name, size, insn)                         \
-static inline u##size name(const volatile u##size __iomem *addr)        \
-{                                                                       \
-        u##size ret;                                                    \
-        __asm__ __volatile__("sync;"#insn" %0,0,%1;twi 0,%0,0;isync"    \
-                : "=r" (ret) : "r" (addr), "m" (*addr) : "memory");     \
-        return ret;                                                     \
-}
-
-#define DEF_MMIO_OUT_X(name, size, insn)                                \
-static inline void name(volatile u##size __iomem *addr, u##size val)    \
-{                                                                       \
-        __asm__ __volatile__("sync;"#insn" %1,0,%2"                     \
-                : "=m" (*addr) : "r" (val), "r" (addr) : "memory");     \
-        IO_SET_SYNC_FLAG();                                             \
-}
-#else /* newer gcc */
 #define DEF_MMIO_IN_X(name, size, insn)                         \
 static inline u##size name(const volatile u##size __iomem *addr)        \
 {                                                                       \
@@ -143,7 +127,6 @@ static inline void name(volatile u##size __iomem *addr, u##size val)	\
                 : "=Z" (*addr) : "r" (val) : "memory");                 \
         IO_SET_SYNC_FLAG();                                             \
 }
-#endif
 
 #define DEF_MMIO_IN_D(name, size, insn)                         \
 static inline u##size name(const volatile u##size __iomem *addr)        \
@@ -746,6 +729,10 @@ static inline void iosync(void)
  *
  * * ioremap_wc enables write combining
  *
+ * * ioremap_wt enables write through
+ *
+ * * ioremap_coherent maps coherent cached memory
+ *
  * * iounmap undoes such a mapping and can be hooked
  *
  * * __ioremap_at (and the pending __iounmap_at) are low level functions to
@@ -767,6 +754,8 @@ extern void __iomem *ioremap(phys_addr_t address, unsigned long size);
 extern void __iomem *ioremap_prot(phys_addr_t address, unsigned long size,
                                   unsigned long flags);
 extern void __iomem *ioremap_wc(phys_addr_t address, unsigned long size);
+void __iomem *ioremap_wt(phys_addr_t address, unsigned long size);
+void __iomem *ioremap_coherent(phys_addr_t address, unsigned long size);
 #define ioremap_nocache(addr, size)     ioremap((addr), (size))
 #define ioremap_uc(addr, size)          ioremap((addr), (size))
 #define ioremap_cache(addr, size) \
@@ -777,12 +766,12 @@ extern void iounmap(volatile void __iomem *addr);
 extern void __iomem *__ioremap(phys_addr_t, unsigned long size,
                                unsigned long flags);
 extern void __iomem *__ioremap_caller(phys_addr_t, unsigned long size,
-                                      unsigned long flags, void *caller);
+                                      pgprot_t prot, void *caller);
 
 extern void __iounmap(volatile void __iomem *addr);
 
 extern void __iomem * __ioremap_at(phys_addr_t pa, void *ea,
-                                   unsigned long size, unsigned long flags);
+                                   unsigned long size, pgprot_t prot);
 extern void __iounmap_at(void *ea, unsigned long size);
 
 /*
diff --git a/arch/powerpc/include/asm/kgdb.h b/arch/powerpc/include/asm/kgdb.h
index 9db24e77b9f4..a9e098a3b881 100644
--- a/arch/powerpc/include/asm/kgdb.h
+++ b/arch/powerpc/include/asm/kgdb.h
@@ -26,9 +26,12 @@
 #define BREAK_INSTR_SIZE        4
 #define BUFMAX                  ((NUMREGBYTES * 2) + 512)
 #define OUTBUFMAX               ((NUMREGBYTES * 2) + 512)
+
+#define BREAK_INSTR             0x7d821008      /* twge r2, r2 */
+
 static inline void arch_kgdb_breakpoint(void)
 {
-        asm(".long 0x7d821008"); /* twge r2, r2 */
+        asm(stringify_in_c(.long BREAK_INSTR));
 }
 #define CACHE_FLUSH_IS_SAFE     1
 #define DBG_MAX_REG_NUM     70
diff --git a/arch/powerpc/include/asm/machdep.h b/arch/powerpc/include/asm/machdep.h
index a47de82fb8e2..8311869005fa 100644
--- a/arch/powerpc/include/asm/machdep.h
+++ b/arch/powerpc/include/asm/machdep.h
@@ -35,7 +35,7 @@ struct machdep_calls {
         char            *name;
 #ifdef CONFIG_PPC64
         void __iomem *  (*ioremap)(phys_addr_t addr, unsigned long size,
-                                   unsigned long flags, void *caller);
+                                   pgprot_t prot, void *caller);
         void            (*iounmap)(volatile void __iomem *token);
 
 #ifdef CONFIG_PM
@@ -108,6 +108,7 @@ struct machdep_calls {
 
         /* Early exception handlers called in realmode */
         int             (*hmi_exception_early)(struct pt_regs *regs);
+        long            (*machine_check_early)(struct pt_regs *regs);
 
         /* Called during machine check exception to retrive fixup address. */
         bool            (*mce_check_early_recovery)(struct pt_regs *regs);
diff --git a/arch/powerpc/include/asm/mce.h b/arch/powerpc/include/asm/mce.h
index 3a1226e9b465..a8b8903e1844 100644
--- a/arch/powerpc/include/asm/mce.h
+++ b/arch/powerpc/include/asm/mce.h
@@ -210,4 +210,7 @@ extern void release_mce_event(void);
 extern void machine_check_queue_event(void);
 extern void machine_check_print_event_info(struct machine_check_event *evt,
                                            bool user_mode);
+#ifdef CONFIG_PPC_BOOK3S_64
+void flush_and_reload_slb(void);
+#endif /* CONFIG_PPC_BOOK3S_64 */
 #endif /* __ASM_PPC64_MCE_H__ */
diff --git a/arch/powerpc/include/asm/mmu.h b/arch/powerpc/include/asm/mmu.h
index 13ea441ac531..eb20eb3b8fb0 100644
--- a/arch/powerpc/include/asm/mmu.h
+++ b/arch/powerpc/include/asm/mmu.h
@@ -309,6 +309,21 @@ static inline u16 get_mm_addr_key(struct mm_struct *mm, unsigned long address)
  */
 #define MMU_PAGE_COUNT  16
 
+/*
+ * If we store section details in page->flags we can't increase the MAX_PHYSMEM_BITS
+ * if we increase SECTIONS_WIDTH we will not store node details in page->flags and
+ * page_to_nid does a page->section->node lookup
+ * Hence only increase for VMEMMAP. Further depending on SPARSEMEM_EXTREME reduce
+ * memory requirements with large number of sections.
+ * 51 bits is the max physical real address on POWER9
+ */
+#if defined(CONFIG_SPARSEMEM_VMEMMAP) && defined(CONFIG_SPARSEMEM_EXTREME) &&   \
+        defined (CONFIG_PPC_64K_PAGES)
+#define MAX_PHYSMEM_BITS        51
+#else
+#define MAX_PHYSMEM_BITS        46
+#endif
+
 #ifdef CONFIG_PPC_BOOK3S_64
 #include <asm/book3s/64/mmu.h>
 #else /* CONFIG_PPC_BOOK3S_64 */
diff --git a/arch/powerpc/include/asm/mmu_context.h b/arch/powerpc/include/asm/mmu_context.h
index b694d6af1150..0381394a425b 100644
--- a/arch/powerpc/include/asm/mmu_context.h
+++ b/arch/powerpc/include/asm/mmu_context.h
@@ -82,7 +82,7 @@ static inline bool need_extra_context(struct mm_struct *mm, unsigned long ea)
 {
         int context_id;
 
-        context_id = get_ea_context(&mm->context, ea);
+        context_id = get_user_context(&mm->context, ea);
         if (!context_id)
                 return true;
         return false;
diff --git a/arch/powerpc/include/asm/mpic.h b/arch/powerpc/include/asm/mpic.h
index fad8ddd697ac..0abf2e7fd222 100644
--- a/arch/powerpc/include/asm/mpic.h
+++ b/arch/powerpc/include/asm/mpic.h
@@ -393,7 +393,14 @@ extern struct bus_type mpic_subsys;
 #define MPIC_REGSET_TSI108              MPIC_REGSET(1)  /* Tsi108/109 PIC */
 
 /* Get the version of primary MPIC */
+#ifdef CONFIG_MPIC
 extern u32 fsl_mpic_primary_get_version(void);
+#else
+static inline u32 fsl_mpic_primary_get_version(void)
+{
+        return 0;
+}
+#endif
 
 /* Allocate the controller structure and setup the linux irq descs
  * for the range if interrupts passed in. No HW initialization is
diff --git a/arch/powerpc/include/asm/nohash/32/pgtable.h b/arch/powerpc/include/asm/nohash/32/pgtable.h
index a507a65b0866..f7b129a83054 100644
--- a/arch/powerpc/include/asm/nohash/32/pgtable.h
+++ b/arch/powerpc/include/asm/nohash/32/pgtable.h
@@ -128,14 +128,65 @@ extern int icache_44x_need_flush;
 #include <asm/nohash/32/pte-8xx.h>
 #endif
 
-/* And here we include common definitions */
-#include <asm/pte-common.h>
+/*
+ * Location of the PFN in the PTE. Most 32-bit platforms use the same
+ * as _PAGE_SHIFT here (ie, naturally aligned).
+ * Platform who don't just pre-define the value so we don't override it here.
+ */
+#ifndef PTE_RPN_SHIFT
+#define PTE_RPN_SHIFT   (PAGE_SHIFT)
+#endif
+
+/*
+ * The mask covered by the RPN must be a ULL on 32-bit platforms with
+ * 64-bit PTEs.
+ */
+#if defined(CONFIG_PPC32) && defined(CONFIG_PTE_64BIT)
+#define PTE_RPN_MASK    (~((1ULL << PTE_RPN_SHIFT) - 1))
+#else
+#define PTE_RPN_MASK    (~((1UL << PTE_RPN_SHIFT) - 1))
+#endif
+
+/*
+ * _PAGE_CHG_MASK masks of bits that are to be preserved across
+ * pgprot changes.
+ */
+#define _PAGE_CHG_MASK  (PTE_RPN_MASK | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_SPECIAL)
 
 #ifndef __ASSEMBLY__
 
 #define pte_clear(mm, addr, ptep) \
         do { pte_update(ptep, ~0, 0); } while (0)
 
+#ifndef pte_mkwrite
+static inline pte_t pte_mkwrite(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_RW);
+}
+#endif
+
+static inline pte_t pte_mkdirty(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_DIRTY);
+}
+
+static inline pte_t pte_mkyoung(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_ACCESSED);
+}
+
+#ifndef pte_wrprotect
+static inline pte_t pte_wrprotect(pte_t pte)
+{
+        return __pte(pte_val(pte) & ~_PAGE_RW);
+}
+#endif
+
+static inline pte_t pte_mkexec(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_EXEC);
+}
+
 #define pmd_none(pmd)           (!pmd_val(pmd))
 #define pmd_bad(pmd)            (pmd_val(pmd) & _PMD_BAD)
 #define pmd_present(pmd)        (pmd_val(pmd) & _PMD_PRESENT_MASK)
@@ -244,7 +295,10 @@ static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
 static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addr,
                                       pte_t *ptep)
 {
-        pte_update(ptep, (_PAGE_RW | _PAGE_HWWRITE), _PAGE_RO);
+        unsigned long clr = ~pte_val(pte_wrprotect(__pte(~0)));
+        unsigned long set = pte_val(pte_wrprotect(__pte(0)));
+
+        pte_update(ptep, clr, set);
 }
 static inline void huge_ptep_set_wrprotect(struct mm_struct *mm,
                                            unsigned long addr, pte_t *ptep)
@@ -258,9 +312,10 @@ static inline void __ptep_set_access_flags(struct vm_area_struct *vma,
                                            unsigned long address,
                                            int psize)
 {
-        unsigned long set = pte_val(entry) &
-                (_PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_RW | _PAGE_EXEC);
-        unsigned long clr = ~pte_val(entry) & (_PAGE_RO | _PAGE_NA);
+        pte_t pte_set = pte_mkyoung(pte_mkdirty(pte_mkwrite(pte_mkexec(__pte(0)))));
+        pte_t pte_clr = pte_mkyoung(pte_mkdirty(pte_mkwrite(pte_mkexec(__pte(~0)))));
+        unsigned long set = pte_val(entry) & pte_val(pte_set);
+        unsigned long clr = ~pte_val(entry) & ~pte_val(pte_clr);
 
         pte_update(ptep, clr, set);
 
@@ -323,7 +378,7 @@ static inline int pte_young(pte_t pte)
 #define __pte_to_swp_entry(pte)         ((swp_entry_t) { pte_val(pte) >> 3 })
 #define __swp_entry_to_pte(x)           ((pte_t) { (x).val << 3 })
 
-int map_kernel_page(unsigned long va, phys_addr_t pa, int flags);
+int map_kernel_page(unsigned long va, phys_addr_t pa, pgprot_t prot);
 
 #endif /* !__ASSEMBLY__ */
 
diff --git a/arch/powerpc/include/asm/nohash/32/pte-40x.h b/arch/powerpc/include/asm/nohash/32/pte-40x.h
index bb4b3a4b92a0..661f4599f2fc 100644
--- a/arch/powerpc/include/asm/nohash/32/pte-40x.h
+++ b/arch/powerpc/include/asm/nohash/32/pte-40x.h
@@ -50,13 +50,56 @@
 #define _PAGE_EXEC      0x200   /* hardware: EX permission */
 #define _PAGE_ACCESSED  0x400   /* software: R: page referenced */
 
+/* No page size encoding in the linux PTE */
+#define _PAGE_PSIZE             0
+
+/* cache related flags non existing on 40x */
+#define _PAGE_COHERENT  0
+
+#define _PAGE_KERNEL_RO         0
+#define _PAGE_KERNEL_ROX        _PAGE_EXEC
+#define _PAGE_KERNEL_RW         (_PAGE_DIRTY | _PAGE_RW | _PAGE_HWWRITE)
+#define _PAGE_KERNEL_RWX        (_PAGE_DIRTY | _PAGE_RW | _PAGE_HWWRITE | _PAGE_EXEC)
+
 #define _PMD_PRESENT    0x400   /* PMD points to page of PTEs */
+#define _PMD_PRESENT_MASK       _PMD_PRESENT
 #define _PMD_BAD        0x802
 #define _PMD_SIZE_4M    0x0c0
 #define _PMD_SIZE_16M   0x0e0
+#define _PMD_USER       0
+
+#define _PTE_NONE_MASK  0
 
 /* Until my rework is finished, 40x still needs atomic PTE updates */
 #define PTE_ATOMIC_UPDATES      1
 
+#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED)
+#define _PAGE_BASE      (_PAGE_BASE_NC)
+
+/* Permission masks used to generate the __P and __S table */
+#define PAGE_NONE       __pgprot(_PAGE_BASE)
+#define PAGE_SHARED     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW)
+#define PAGE_SHARED_X   __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW | _PAGE_EXEC)
+#define PAGE_COPY       __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_COPY_X     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_EXEC)
+#define PAGE_READONLY   __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_READONLY_X __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_EXEC)
+
+#ifndef __ASSEMBLY__
+static inline pte_t pte_wrprotect(pte_t pte)
+{
+        return __pte(pte_val(pte) & ~(_PAGE_RW | _PAGE_HWWRITE));
+}
+
+#define pte_wrprotect pte_wrprotect
+
+static inline pte_t pte_mkclean(pte_t pte)
+{
+        return __pte(pte_val(pte) & ~(_PAGE_DIRTY | _PAGE_HWWRITE));
+}
+
+#define pte_mkclean pte_mkclean
+#endif
+
 #endif /* __KERNEL__ */
 #endif /*  _ASM_POWERPC_NOHASH_32_PTE_40x_H */
diff --git a/arch/powerpc/include/asm/nohash/32/pte-44x.h b/arch/powerpc/include/asm/nohash/32/pte-44x.h
index f812c0272364..78bc304f750e 100644
--- a/arch/powerpc/include/asm/nohash/32/pte-44x.h
+++ b/arch/powerpc/include/asm/nohash/32/pte-44x.h
@@ -85,14 +85,44 @@
 #define _PAGE_NO_CACHE  0x00000400              /* H: I bit */
 #define _PAGE_WRITETHRU 0x00000800              /* H: W bit */
 
+/* No page size encoding in the linux PTE */
+#define _PAGE_PSIZE             0
+
+#define _PAGE_KERNEL_RO         0
+#define _PAGE_KERNEL_ROX        _PAGE_EXEC
+#define _PAGE_KERNEL_RW         (_PAGE_DIRTY | _PAGE_RW)
+#define _PAGE_KERNEL_RWX        (_PAGE_DIRTY | _PAGE_RW | _PAGE_EXEC)
+
 /* TODO: Add large page lowmem mapping support */
 #define _PMD_PRESENT    0
 #define _PMD_PRESENT_MASK (PAGE_MASK)
 #define _PMD_BAD        (~PAGE_MASK)
+#define _PMD_USER       0
 
 /* ERPN in a PTE never gets cleared, ignore it */
 #define _PTE_NONE_MASK  0xffffffff00000000ULL
 
+/*
+ * We define 2 sets of base prot bits, one for basic pages (ie,
+ * cacheable kernel and user pages) and one for non cacheable
+ * pages. We always set _PAGE_COHERENT when SMP is enabled or
+ * the processor might need it for DMA coherency.
+ */
+#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED)
+#if defined(CONFIG_SMP)
+#define _PAGE_BASE      (_PAGE_BASE_NC | _PAGE_COHERENT)
+#else
+#define _PAGE_BASE      (_PAGE_BASE_NC)
+#endif
+
+/* Permission masks used to generate the __P and __S table */
+#define PAGE_NONE       __pgprot(_PAGE_BASE)
+#define PAGE_SHARED     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW)
+#define PAGE_SHARED_X   __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW | _PAGE_EXEC)
+#define PAGE_COPY       __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_COPY_X     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_EXEC)
+#define PAGE_READONLY   __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_READONLY_X __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_EXEC)
 
 #endif /* __KERNEL__ */
 #endif /*  _ASM_POWERPC_NOHASH_32_PTE_44x_H */
diff --git a/arch/powerpc/include/asm/nohash/32/pte-8xx.h b/arch/powerpc/include/asm/nohash/32/pte-8xx.h
index f04cb46ae8a1..6bfe041ef59d 100644
--- a/arch/powerpc/include/asm/nohash/32/pte-8xx.h
+++ b/arch/powerpc/include/asm/nohash/32/pte-8xx.h
@@ -29,10 +29,10 @@
  */
 
 /* Definitions for 8xx embedded chips. */
-#define _PAGE_PRESENT   0x0001  /* Page is valid */
-#define _PAGE_NO_CACHE  0x0002  /* I: cache inhibit */
-#define _PAGE_PRIVILEGED        0x0004  /* No ASID (context) compare */
-#define _PAGE_HUGE      0x0008  /* SPS: Small Page Size (1 if 16k, 512k or 8M)*/
+#define _PAGE_PRESENT   0x0001  /* V: Page is valid */
+#define _PAGE_NO_CACHE  0x0002  /* CI: cache inhibit */
+#define _PAGE_SH        0x0004  /* SH: No ASID (context) compare */
+#define _PAGE_SPS       0x0008  /* SPS: Small Page Size (1 if 16k, 512k or 8M)*/
 #define _PAGE_DIRTY     0x0100  /* C: page changed */
 
 /* These 4 software bits must be masked out when the L2 entry is loaded
@@ -46,18 +46,95 @@
 #define _PAGE_NA        0x0200  /* Supervisor NA, User no access */
 #define _PAGE_RO        0x0600  /* Supervisor RO, User no access */
 
+/* cache related flags non existing on 8xx */
+#define _PAGE_COHERENT  0
+#define _PAGE_WRITETHRU 0
+
+#define _PAGE_KERNEL_RO         (_PAGE_SH | _PAGE_RO)
+#define _PAGE_KERNEL_ROX        (_PAGE_SH | _PAGE_RO | _PAGE_EXEC)
+#define _PAGE_KERNEL_RW         (_PAGE_SH | _PAGE_DIRTY)
+#define _PAGE_KERNEL_RWX        (_PAGE_SH | _PAGE_DIRTY | _PAGE_EXEC)
+
 #define _PMD_PRESENT    0x0001
+#define _PMD_PRESENT_MASK       _PMD_PRESENT
 #define _PMD_BAD        0x0fd0
 #define _PMD_PAGE_MASK  0x000c
 #define _PMD_PAGE_8M    0x000c
 #define _PMD_PAGE_512K  0x0004
 #define _PMD_USER       0x0020  /* APG 1 */
 
+#define _PTE_NONE_MASK  0
+
 /* Until my rework is finished, 8xx still needs atomic PTE updates */
 #define PTE_ATOMIC_UPDATES      1
 
 #ifdef CONFIG_PPC_16K_PAGES
-#define _PAGE_PSIZE     _PAGE_HUGE
+#define _PAGE_PSIZE     _PAGE_SPS
+#else
+#define _PAGE_PSIZE             0
+#endif
+
+#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_PSIZE)
+#define _PAGE_BASE      (_PAGE_BASE_NC)
+
+/* Permission masks used to generate the __P and __S table */
+#define PAGE_NONE       __pgprot(_PAGE_BASE | _PAGE_NA)
+#define PAGE_SHARED     __pgprot(_PAGE_BASE)
+#define PAGE_SHARED_X   __pgprot(_PAGE_BASE | _PAGE_EXEC)
+#define PAGE_COPY       __pgprot(_PAGE_BASE | _PAGE_RO)
+#define PAGE_COPY_X     __pgprot(_PAGE_BASE | _PAGE_RO | _PAGE_EXEC)
+#define PAGE_READONLY   __pgprot(_PAGE_BASE | _PAGE_RO)
+#define PAGE_READONLY_X __pgprot(_PAGE_BASE | _PAGE_RO | _PAGE_EXEC)
+
+#ifndef __ASSEMBLY__
+static inline pte_t pte_wrprotect(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_RO);
+}
+
+#define pte_wrprotect pte_wrprotect
+
+static inline int pte_write(pte_t pte)
+{
+        return !(pte_val(pte) & _PAGE_RO);
+}
+
+#define pte_write pte_write
+
+static inline pte_t pte_mkwrite(pte_t pte)
+{
+        return __pte(pte_val(pte) & ~_PAGE_RO);
+}
+
+#define pte_mkwrite pte_mkwrite
+
+static inline bool pte_user(pte_t pte)
+{
+        return !(pte_val(pte) & _PAGE_SH);
+}
+
+#define pte_user pte_user
+
+static inline pte_t pte_mkprivileged(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_SH);
+}
+
+#define pte_mkprivileged pte_mkprivileged
+
+static inline pte_t pte_mkuser(pte_t pte)
+{
+        return __pte(pte_val(pte) & ~_PAGE_SH);
+}
+
+#define pte_mkuser pte_mkuser
+
+static inline pte_t pte_mkhuge(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_SPS);
+}
+
+#define pte_mkhuge pte_mkhuge
 #endif
 
 #endif /* __KERNEL__ */
diff --git a/arch/powerpc/include/asm/nohash/32/pte-fsl-booke.h b/arch/powerpc/include/asm/nohash/32/pte-fsl-booke.h
index d1ee24e9e137..0fc1bd42bb3e 100644
--- a/arch/powerpc/include/asm/nohash/32/pte-fsl-booke.h
+++ b/arch/powerpc/include/asm/nohash/32/pte-fsl-booke.h
@@ -31,11 +31,44 @@
 #define _PAGE_WRITETHRU 0x00400 /* H: W bit */
 #define _PAGE_SPECIAL   0x00800 /* S: Special page */
 
+#define _PAGE_KERNEL_RO         0
+#define _PAGE_KERNEL_ROX        _PAGE_EXEC
+#define _PAGE_KERNEL_RW         (_PAGE_DIRTY | _PAGE_RW)
+#define _PAGE_KERNEL_RWX        (_PAGE_DIRTY | _PAGE_RW | _PAGE_EXEC)
+
+/* No page size encoding in the linux PTE */
+#define _PAGE_PSIZE             0
+
 #define _PMD_PRESENT    0
 #define _PMD_PRESENT_MASK (PAGE_MASK)
 #define _PMD_BAD        (~PAGE_MASK)
+#define _PMD_USER       0
+
+#define _PTE_NONE_MASK  0
 
 #define PTE_WIMGE_SHIFT (6)
 
+/*
+ * We define 2 sets of base prot bits, one for basic pages (ie,
+ * cacheable kernel and user pages) and one for non cacheable
+ * pages. We always set _PAGE_COHERENT when SMP is enabled or
+ * the processor might need it for DMA coherency.
+ */
+#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED)
+#if defined(CONFIG_SMP) || defined(CONFIG_PPC_E500MC)
+#define _PAGE_BASE      (_PAGE_BASE_NC | _PAGE_COHERENT)
+#else
+#define _PAGE_BASE      (_PAGE_BASE_NC)
+#endif
+
+/* Permission masks used to generate the __P and __S table */
+#define PAGE_NONE       __pgprot(_PAGE_BASE)
+#define PAGE_SHARED     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW)
+#define PAGE_SHARED_X   __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW | _PAGE_EXEC)
+#define PAGE_COPY       __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_COPY_X     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_EXEC)
+#define PAGE_READONLY   __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_READONLY_X __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_EXEC)
+
 #endif /* __KERNEL__ */
 #endif /*  _ASM_POWERPC_NOHASH_32_PTE_FSL_BOOKE_H */
diff --git a/arch/powerpc/include/asm/nohash/64/pgtable.h b/arch/powerpc/include/asm/nohash/64/pgtable.h
index 7cd6809f4d33..dc6bb9da3f23 100644
--- a/arch/powerpc/include/asm/nohash/64/pgtable.h
+++ b/arch/powerpc/include/asm/nohash/64/pgtable.h
@@ -89,11 +89,47 @@
  * Include the PTE bits definitions
  */
 #include <asm/nohash/pte-book3e.h>
-#include <asm/pte-common.h>
+
+#define _PAGE_SAO       0
+
+#define PTE_RPN_MASK    (~((1UL << PTE_RPN_SHIFT) - 1))
+
+/*
+ * _PAGE_CHG_MASK masks of bits that are to be preserved across
+ * pgprot changes.
+ */
+#define _PAGE_CHG_MASK  (PTE_RPN_MASK | _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_SPECIAL)
+
+#define H_PAGE_4K_PFN 0
 
 #ifndef __ASSEMBLY__
 /* pte_clear moved to later in this file */
 
+static inline pte_t pte_mkwrite(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_RW);
+}
+
+static inline pte_t pte_mkdirty(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_DIRTY);
+}
+
+static inline pte_t pte_mkyoung(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_ACCESSED);
+}
+
+static inline pte_t pte_wrprotect(pte_t pte)
+{
+        return __pte(pte_val(pte) & ~_PAGE_RW);
+}
+
+static inline pte_t pte_mkexec(pte_t pte)
+{
+        return __pte(pte_val(pte) | _PAGE_EXEC);
+}
+
 #define PMD_BAD_BITS            (PTE_TABLE_SIZE-1)
 #define PUD_BAD_BITS            (PMD_TABLE_SIZE-1)
 
@@ -327,8 +363,7 @@ static inline void __ptep_set_access_flags(struct vm_area_struct *vma,
 #define __pte_to_swp_entry(pte)         ((swp_entry_t) { pte_val((pte)) })
 #define __swp_entry_to_pte(x)           __pte((x).val)
 
-extern int map_kernel_page(unsigned long ea, unsigned long pa,
-                           unsigned long flags);
+int map_kernel_page(unsigned long ea, unsigned long pa, pgprot_t prot);
 extern int __meminit vmemmap_create_mapping(unsigned long start,
                                             unsigned long page_size,
                                             unsigned long phys);
diff --git a/arch/powerpc/include/asm/nohash/pgtable.h b/arch/powerpc/include/asm/nohash/pgtable.h
index b321c82b3624..70ff23974b59 100644
--- a/arch/powerpc/include/asm/nohash/pgtable.h
+++ b/arch/powerpc/include/asm/nohash/pgtable.h
@@ -8,18 +8,50 @@
 #include <asm/nohash/32/pgtable.h>
 #endif
 
+/* Permission masks used for kernel mappings */
+#define PAGE_KERNEL     __pgprot(_PAGE_BASE | _PAGE_KERNEL_RW)
+#define PAGE_KERNEL_NC  __pgprot(_PAGE_BASE_NC | _PAGE_KERNEL_RW | _PAGE_NO_CACHE)
+#define PAGE_KERNEL_NCG __pgprot(_PAGE_BASE_NC | _PAGE_KERNEL_RW | \
+                                 _PAGE_NO_CACHE | _PAGE_GUARDED)
+#define PAGE_KERNEL_X   __pgprot(_PAGE_BASE | _PAGE_KERNEL_RWX)
+#define PAGE_KERNEL_RO  __pgprot(_PAGE_BASE | _PAGE_KERNEL_RO)
+#define PAGE_KERNEL_ROX __pgprot(_PAGE_BASE | _PAGE_KERNEL_ROX)
+
+/*
+ * Protection used for kernel text. We want the debuggers to be able to
+ * set breakpoints anywhere, so don't write protect the kernel text
+ * on platforms where such control is possible.
+ */
+#if defined(CONFIG_KGDB) || defined(CONFIG_XMON) || defined(CONFIG_BDI_SWITCH) ||\
+        defined(CONFIG_KPROBES) || defined(CONFIG_DYNAMIC_FTRACE)
+#define PAGE_KERNEL_TEXT        PAGE_KERNEL_X
+#else
+#define PAGE_KERNEL_TEXT        PAGE_KERNEL_ROX
+#endif
+
+/* Make modules code happy. We don't set RO yet */
+#define PAGE_KERNEL_EXEC        PAGE_KERNEL_X
+
+/* Advertise special mapping type for AGP */
+#define PAGE_AGP                (PAGE_KERNEL_NC)
+#define HAVE_PAGE_AGP
+
 #ifndef __ASSEMBLY__
 
 /* Generic accessors to PTE bits */
+#ifndef pte_write
 static inline int pte_write(pte_t pte)
 {
-        return (pte_val(pte) & (_PAGE_RW | _PAGE_RO)) != _PAGE_RO;
+        return pte_val(pte) & _PAGE_RW;
 }
+#endif
 static inline int pte_read(pte_t pte)           { return 1; }
 static inline int pte_dirty(pte_t pte)          { return pte_val(pte) & _PAGE_DIRTY; }
 static inline int pte_special(pte_t pte)        { return pte_val(pte) & _PAGE_SPECIAL; }
 static inline int pte_none(pte_t pte)           { return (pte_val(pte) & ~_PTE_NONE_MASK) == 0; }
-static inline pgprot_t pte_pgprot(pte_t pte)    { return __pgprot(pte_val(pte) & PAGE_PROT_BITS); }
+static inline bool pte_hashpte(pte_t pte)       { return false; }
+static inline bool pte_ci(pte_t pte)            { return pte_val(pte) & _PAGE_NO_CACHE; }
+static inline bool pte_exec(pte_t pte)          { return pte_val(pte) & _PAGE_EXEC; }
 
 #ifdef CONFIG_NUMA_BALANCING
 /*
@@ -29,8 +61,7 @@ static inline pgprot_t pte_pgprot(pte_t pte)	{ return __pgprot(pte_val(pte) & PA
  */
 static inline int pte_protnone(pte_t pte)
 {
-        return (pte_val(pte) &
-                (_PAGE_PRESENT | _PAGE_USER)) == _PAGE_PRESENT;
+        return pte_present(pte) && !pte_user(pte);
 }
 
 static inline int pmd_protnone(pmd_t pmd)
@@ -44,6 +75,23 @@ static inline int pte_present(pte_t pte)
         return pte_val(pte) & _PAGE_PRESENT;
 }
 
+static inline bool pte_hw_valid(pte_t pte)
+{
+        return pte_val(pte) & _PAGE_PRESENT;
+}
+
+/*
+ * Don't just check for any non zero bits in __PAGE_USER, since for book3e
+ * and PTE_64BIT, PAGE_KERNEL_X contains _PAGE_BAP_SR which is also in
+ * _PAGE_USER.  Need to explicitly match _PAGE_BAP_UR bit in that case too.
+ */
+#ifndef pte_user
+static inline bool pte_user(pte_t pte)
+{
+        return (pte_val(pte) & _PAGE_USER) == _PAGE_USER;
+}
+#endif
+
 /*
  * We only find page table entry in the last level
  * Hence no need for other accessors
@@ -77,53 +125,53 @@ static inline unsigned long pte_pfn(pte_t pte)	{
         return pte_val(pte) >> PTE_RPN_SHIFT; }
 
 /* Generic modifiers for PTE bits */
-static inline pte_t pte_wrprotect(pte_t pte)
+static inline pte_t pte_exprotect(pte_t pte)
 {
-        pte_basic_t ptev;
-
-        ptev = pte_val(pte) & ~(_PAGE_RW | _PAGE_HWWRITE);
-        ptev |= _PAGE_RO;
-        return __pte(ptev);
+        return __pte(pte_val(pte) & ~_PAGE_EXEC);
 }
 
+#ifndef pte_mkclean
 static inline pte_t pte_mkclean(pte_t pte)
 {
-        return __pte(pte_val(pte) & ~(_PAGE_DIRTY | _PAGE_HWWRITE));
+        return __pte(pte_val(pte) & ~_PAGE_DIRTY);
 }
+#endif
 
 static inline pte_t pte_mkold(pte_t pte)
 {
         return __pte(pte_val(pte) & ~_PAGE_ACCESSED);
 }
 
-static inline pte_t pte_mkwrite(pte_t pte)
+static inline pte_t pte_mkpte(pte_t pte)
 {
-        pte_basic_t ptev;
-
-        ptev = pte_val(pte) & ~_PAGE_RO;
-        ptev |= _PAGE_RW;
-        return __pte(ptev);
+        return pte;
 }
 
-static inline pte_t pte_mkdirty(pte_t pte)
+static inline pte_t pte_mkspecial(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_DIRTY);
+        return __pte(pte_val(pte) | _PAGE_SPECIAL);
 }
 
-static inline pte_t pte_mkyoung(pte_t pte)
+#ifndef pte_mkhuge
+static inline pte_t pte_mkhuge(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_ACCESSED);
+        return __pte(pte_val(pte));
 }
+#endif
 
-static inline pte_t pte_mkspecial(pte_t pte)
+#ifndef pte_mkprivileged
+static inline pte_t pte_mkprivileged(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_SPECIAL);
+        return __pte(pte_val(pte) & ~_PAGE_USER);
 }
+#endif
 
-static inline pte_t pte_mkhuge(pte_t pte)
+#ifndef pte_mkuser
+static inline pte_t pte_mkuser(pte_t pte)
 {
-        return __pte(pte_val(pte) | _PAGE_HUGE);
+        return __pte(pte_val(pte) | _PAGE_USER);
 }
+#endif
 
 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 {
@@ -197,6 +245,8 @@ extern int ptep_set_access_flags(struct vm_area_struct *vma, unsigned long addre
 #if _PAGE_WRITETHRU != 0
 #define pgprot_cached_wthru(prot) (__pgprot((pgprot_val(prot) & ~_PAGE_CACHE_CTL) | \
                                             _PAGE_COHERENT | _PAGE_WRITETHRU))
+#else
+#define pgprot_cached_wthru(prot)       pgprot_noncached(prot)
 #endif
 
 #define pgprot_cached_noncoherent(prot) \
diff --git a/arch/powerpc/include/asm/nohash/pte-book3e.h b/arch/powerpc/include/asm/nohash/pte-book3e.h
index 12730b81cd98..dd40d200f274 100644
--- a/arch/powerpc/include/asm/nohash/pte-book3e.h
+++ b/arch/powerpc/include/asm/nohash/pte-book3e.h
@@ -77,7 +77,48 @@
 #define _PMD_PRESENT    0
 #define _PMD_PRESENT_MASK (PAGE_MASK)
 #define _PMD_BAD        (~PAGE_MASK)
+#define _PMD_USER       0
+#else
+#define _PTE_NONE_MASK  0
+#endif
+
+/*
+ * We define 2 sets of base prot bits, one for basic pages (ie,
+ * cacheable kernel and user pages) and one for non cacheable
+ * pages. We always set _PAGE_COHERENT when SMP is enabled or
+ * the processor might need it for DMA coherency.
+ */
+#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_PSIZE)
+#if defined(CONFIG_SMP)
+#define _PAGE_BASE      (_PAGE_BASE_NC | _PAGE_COHERENT)
+#else
+#define _PAGE_BASE      (_PAGE_BASE_NC)
 #endif
 
+/* Permission masks used to generate the __P and __S table */
+#define PAGE_NONE       __pgprot(_PAGE_BASE)
+#define PAGE_SHARED     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW)
+#define PAGE_SHARED_X   __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW | _PAGE_EXEC)
+#define PAGE_COPY       __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_COPY_X     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_EXEC)
+#define PAGE_READONLY   __pgprot(_PAGE_BASE | _PAGE_USER)
+#define PAGE_READONLY_X __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_EXEC)
+
+#ifndef __ASSEMBLY__
+static inline pte_t pte_mkprivileged(pte_t pte)
+{
+        return __pte((pte_val(pte) & ~_PAGE_USER) | _PAGE_PRIVILEGED);
+}
+
+#define pte_mkprivileged pte_mkprivileged
+
+static inline pte_t pte_mkuser(pte_t pte)
+{
+        return __pte((pte_val(pte) & ~_PAGE_PRIVILEGED) | _PAGE_USER);
+}
+
+#define pte_mkuser pte_mkuser
+#endif /* __ASSEMBLY__ */
+
 #endif /* __KERNEL__ */
 #endif /*  _ASM_POWERPC_NOHASH_PTE_BOOK3E_H */
diff --git a/arch/powerpc/include/asm/opal-api.h b/arch/powerpc/include/asm/opal-api.h
index 8365353330b4..870fb7b239ea 100644
--- a/arch/powerpc/include/asm/opal-api.h
+++ b/arch/powerpc/include/asm/opal-api.h
@@ -1050,6 +1050,7 @@ enum OpalSysCooling {
 enum {
         OPAL_REBOOT_NORMAL              = 0,
         OPAL_REBOOT_PLATFORM_ERROR      = 1,
+        OPAL_REBOOT_FULL_IPL            = 2,
 };
 
 /* Argument to OPAL_PCI_TCE_KILL */
diff --git a/arch/powerpc/include/asm/paca.h b/arch/powerpc/include/asm/paca.h
index ad4f16164619..e843bc5d1a0f 100644
--- a/arch/powerpc/include/asm/paca.h
+++ b/arch/powerpc/include/asm/paca.h
@@ -113,7 +113,13 @@ struct paca_struct {
                                  * on the linear mapping */
         /* SLB related definitions */
         u16 vmalloc_sllp;
-        u16 slb_cache_ptr;
+        u8 slb_cache_ptr;
+        u8 stab_rr;                     /* stab/slb round-robin counter */
+#ifdef CONFIG_DEBUG_VM
+        u8 in_kernel_slb_handler;
+#endif
+        u32 slb_used_bitmap;            /* Bitmaps for first 32 SLB entries. */
+        u32 slb_kern_bitmap;
         u32 slb_cache[SLB_CACHE_ENTRIES];
 #endif /* CONFIG_PPC_BOOK3S_64 */
 
@@ -160,7 +166,6 @@ struct paca_struct {
          */
         struct task_struct *__current;  /* Pointer to current */
         u64 kstack;                     /* Saved Kernel stack addr */
-        u64 stab_rr;                    /* stab/slb round-robin counter */
         u64 saved_r1;                   /* r1 save for RTAS calls or PM or EE=0 */
         u64 saved_msr;                  /* MSR saved here by enter_rtas */
         u16 trap_save;                  /* Used when bad stack is encountered */
@@ -250,6 +255,15 @@ struct paca_struct {
 #ifdef CONFIG_PPC_PSERIES
         u8 *mce_data_buf;               /* buffer to hold per cpu rtas errlog */
 #endif /* CONFIG_PPC_PSERIES */
+
+#ifdef CONFIG_PPC_BOOK3S_64
+        /* Capture SLB related old contents in MCE handler. */
+        struct slb_entry *mce_faulty_slbs;
+        u16 slb_save_cache_ptr;
+#endif /* CONFIG_PPC_BOOK3S_64 */
+#ifdef CONFIG_STACKPROTECTOR
+        unsigned long canary;
+#endif
 } ____cacheline_aligned;
 
 extern void copy_mm_to_paca(struct mm_struct *mm);
diff --git a/arch/powerpc/include/asm/pgtable.h b/arch/powerpc/include/asm/pgtable.h
index 14c79a7dc855..9679b7519a35 100644
--- a/arch/powerpc/include/asm/pgtable.h
+++ b/arch/powerpc/include/asm/pgtable.h
@@ -20,6 +20,25 @@ struct mm_struct;
 #include <asm/nohash/pgtable.h>
 #endif /* !CONFIG_PPC_BOOK3S */
 
+/* Note due to the way vm flags are laid out, the bits are XWR */
+#define __P000  PAGE_NONE
+#define __P001  PAGE_READONLY
+#define __P010  PAGE_COPY
+#define __P011  PAGE_COPY
+#define __P100  PAGE_READONLY_X
+#define __P101  PAGE_READONLY_X
+#define __P110  PAGE_COPY_X
+#define __P111  PAGE_COPY_X
+
+#define __S000  PAGE_NONE
+#define __S001  PAGE_READONLY
+#define __S010  PAGE_SHARED
+#define __S011  PAGE_SHARED
+#define __S100  PAGE_READONLY_X
+#define __S101  PAGE_READONLY_X
+#define __S110  PAGE_SHARED_X
+#define __S111  PAGE_SHARED_X
+
 #ifndef __ASSEMBLY__
 
 #include <asm/tlbflush.h>
@@ -27,6 +46,16 @@ struct mm_struct;
 /* Keep these as a macros to avoid include dependency mess */
 #define pte_page(x)             pfn_to_page(pte_pfn(x))
 #define mk_pte(page, pgprot)    pfn_pte(page_to_pfn(page), (pgprot))
+/*
+ * Select all bits except the pfn
+ */
+static inline pgprot_t pte_pgprot(pte_t pte)
+{
+        unsigned long pte_flags;
+
+        pte_flags = pte_val(pte) & ~PTE_RPN_MASK;
+        return __pgprot(pte_flags);
+}
 
 /*
  * ZERO_PAGE is a global shared page that is always zero: used
diff --git a/arch/powerpc/include/asm/ppc-pci.h b/arch/powerpc/include/asm/ppc-pci.h
index 726288048652..f67da277d652 100644
--- a/arch/powerpc/include/asm/ppc-pci.h
+++ b/arch/powerpc/include/asm/ppc-pci.h
@@ -58,6 +58,7 @@ void eeh_save_bars(struct eeh_dev *edev);
 int rtas_write_config(struct pci_dn *, int where, int size, u32 val);
 int rtas_read_config(struct pci_dn *, int where, int size, u32 *val);
 void eeh_pe_state_mark(struct eeh_pe *pe, int state);
+void eeh_pe_mark_isolated(struct eeh_pe *pe);
 void eeh_pe_state_clear(struct eeh_pe *pe, int state);
 void eeh_pe_state_mark_with_cfg(struct eeh_pe *pe, int state);
 void eeh_pe_dev_mode_mark(struct eeh_pe *pe, int mode);
diff --git a/arch/powerpc/include/asm/processor.h b/arch/powerpc/include/asm/processor.h
index 52fadded5c1e..7d04d60a39c9 100644
--- a/arch/powerpc/include/asm/processor.h
+++ b/arch/powerpc/include/asm/processor.h
@@ -32,9 +32,9 @@
 /* Default SMT priority is set to 3. Use 11- 13bits to save priority. */
 #define PPR_PRIORITY 3
 #ifdef __ASSEMBLY__
-#define INIT_PPR (PPR_PRIORITY << 50)
+#define DEFAULT_PPR (PPR_PRIORITY << 50)
 #else
-#define INIT_PPR ((u64)PPR_PRIORITY << 50)
+#define DEFAULT_PPR ((u64)PPR_PRIORITY << 50)
 #endif /* __ASSEMBLY__ */
 #endif /* CONFIG_PPC64 */
 
@@ -273,6 +273,7 @@ struct thread_struct {
 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
         struct arch_hw_breakpoint hw_brk; /* info on the hardware breakpoint */
         unsigned long   trap_nr;        /* last trap # on this thread */
+        u8 load_slb;                    /* Ages out SLB preload cache entries */
         u8 load_fp;
 #ifdef CONFIG_ALTIVEC
         u8 load_vec;
@@ -341,7 +342,6 @@ struct thread_struct {
          * onwards.
          */
         int             dscr_inherit;
-        unsigned long   ppr;    /* used to save/restore SMT priority */
         unsigned long   tidr;
 #endif
 #ifdef CONFIG_PPC_BOOK3S_64
@@ -389,7 +389,6 @@ struct thread_struct {
         .regs = (struct pt_regs *)INIT_SP - 1, /* XXX bogus, I think */ \
         .addr_limit = KERNEL_DS, \
         .fpexc_mode = 0, \
-        .ppr = INIT_PPR, \
         .fscr = FSCR_TAR | FSCR_EBB \
 }
 #endif
diff --git a/arch/powerpc/include/asm/pte-common.h b/arch/powerpc/include/asm/pte-common.h
deleted file mode 100644
index bef56141a549..000000000000
--- a/arch/powerpc/include/asm/pte-common.h
+++ /dev/null
@@ -1,219 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/* Included from asm/pgtable-*.h only ! */
-
-/*
- * Some bits are only used on some cpu families... Make sure that all
- * the undefined gets a sensible default
- */
-#ifndef _PAGE_HASHPTE
-#define _PAGE_HASHPTE   0
-#endif
-#ifndef _PAGE_HWWRITE
-#define _PAGE_HWWRITE   0
-#endif
-#ifndef _PAGE_EXEC
-#define _PAGE_EXEC      0
-#endif
-#ifndef _PAGE_ENDIAN
-#define _PAGE_ENDIAN    0
-#endif
-#ifndef _PAGE_COHERENT
-#define _PAGE_COHERENT  0
-#endif
-#ifndef _PAGE_WRITETHRU
-#define _PAGE_WRITETHRU 0
-#endif
-#ifndef _PAGE_4K_PFN
-#define _PAGE_4K_PFN            0
-#endif
-#ifndef _PAGE_SAO
-#define _PAGE_SAO       0
-#endif
-#ifndef _PAGE_PSIZE
-#define _PAGE_PSIZE             0
-#endif
-/* _PAGE_RO and _PAGE_RW shall not be defined at the same time */
-#ifndef _PAGE_RO
-#define _PAGE_RO 0
-#else
-#define _PAGE_RW 0
-#endif
-
-#ifndef _PAGE_PTE
-#define _PAGE_PTE 0
-#endif
-/* At least one of _PAGE_PRIVILEGED or _PAGE_USER must be defined */
-#ifndef _PAGE_PRIVILEGED
-#define _PAGE_PRIVILEGED 0
-#else
-#ifndef _PAGE_USER
-#define _PAGE_USER 0
-#endif
-#endif
-#ifndef _PAGE_NA
-#define _PAGE_NA 0
-#endif
-#ifndef _PAGE_HUGE
-#define _PAGE_HUGE 0
-#endif
-
-#ifndef _PMD_PRESENT_MASK
-#define _PMD_PRESENT_MASK       _PMD_PRESENT
-#endif
-#ifndef _PMD_USER
-#define _PMD_USER       0
-#endif
-#ifndef _PAGE_KERNEL_RO
-#define _PAGE_KERNEL_RO         (_PAGE_PRIVILEGED | _PAGE_RO)
-#endif
-#ifndef _PAGE_KERNEL_ROX
-#define _PAGE_KERNEL_ROX        (_PAGE_PRIVILEGED | _PAGE_RO | _PAGE_EXEC)
-#endif
-#ifndef _PAGE_KERNEL_RW
-#define _PAGE_KERNEL_RW         (_PAGE_PRIVILEGED | _PAGE_DIRTY | _PAGE_RW | \
-                                 _PAGE_HWWRITE)
-#endif
-#ifndef _PAGE_KERNEL_RWX
-#define _PAGE_KERNEL_RWX        (_PAGE_PRIVILEGED | _PAGE_DIRTY | _PAGE_RW | \
-                                 _PAGE_HWWRITE | _PAGE_EXEC)
-#endif
-#ifndef _PAGE_HPTEFLAGS
-#define _PAGE_HPTEFLAGS _PAGE_HASHPTE
-#endif
-#ifndef _PTE_NONE_MASK
-#define _PTE_NONE_MASK  _PAGE_HPTEFLAGS
-#endif
-
-#ifndef __ASSEMBLY__
-
-/*
- * Don't just check for any non zero bits in __PAGE_USER, since for book3e
- * and PTE_64BIT, PAGE_KERNEL_X contains _PAGE_BAP_SR which is also in
- * _PAGE_USER.  Need to explicitly match _PAGE_BAP_UR bit in that case too.
- */
-static inline bool pte_user(pte_t pte)
-{
-        return (pte_val(pte) & (_PAGE_USER | _PAGE_PRIVILEGED)) == _PAGE_USER;
-}
-#endif /* __ASSEMBLY__ */
-
-/* Location of the PFN in the PTE. Most 32-bit platforms use the same
- * as _PAGE_SHIFT here (ie, naturally aligned).
- * Platform who don't just pre-define the value so we don't override it here
- */
-#ifndef PTE_RPN_SHIFT
-#define PTE_RPN_SHIFT   (PAGE_SHIFT)
-#endif
-
-/* The mask covered by the RPN must be a ULL on 32-bit platforms with
- * 64-bit PTEs
- */
-#if defined(CONFIG_PPC32) && defined(CONFIG_PTE_64BIT)
-#define PTE_RPN_MASK    (~((1ULL<<PTE_RPN_SHIFT)-1))
-#else
-#define PTE_RPN_MASK    (~((1UL<<PTE_RPN_SHIFT)-1))
-#endif
-
-/* _PAGE_CHG_MASK masks of bits that are to be preserved across
- * pgprot changes
- */
-#define _PAGE_CHG_MASK  (PTE_RPN_MASK | _PAGE_HPTEFLAGS | _PAGE_DIRTY | \
-                         _PAGE_ACCESSED | _PAGE_SPECIAL)
-
-/* Mask of bits returned by pte_pgprot() */
-#define PAGE_PROT_BITS  (_PAGE_GUARDED | _PAGE_COHERENT | _PAGE_NO_CACHE | \
-                         _PAGE_WRITETHRU | _PAGE_ENDIAN | _PAGE_4K_PFN | \
-                         _PAGE_USER | _PAGE_ACCESSED | _PAGE_RO | _PAGE_NA | \
-                         _PAGE_PRIVILEGED | \
-                         _PAGE_RW | _PAGE_HWWRITE | _PAGE_DIRTY | _PAGE_EXEC)
-
-/*
- * We define 2 sets of base prot bits, one for basic pages (ie,
- * cacheable kernel and user pages) and one for non cacheable
- * pages. We always set _PAGE_COHERENT when SMP is enabled or
- * the processor might need it for DMA coherency.
- */
-#define _PAGE_BASE_NC   (_PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_PSIZE)
-#if defined(CONFIG_SMP) || defined(CONFIG_PPC_STD_MMU) || \
-        defined(CONFIG_PPC_E500MC)
-#define _PAGE_BASE      (_PAGE_BASE_NC | _PAGE_COHERENT)
-#else
-#define _PAGE_BASE      (_PAGE_BASE_NC)
-#endif
-
-/* Permission masks used to generate the __P and __S table,
- *
- * Note:__pgprot is defined in arch/powerpc/include/asm/page.h
- *
- * Write permissions imply read permissions for now (we could make write-only
- * pages on BookE but we don't bother for now). Execute permission control is
- * possible on platforms that define _PAGE_EXEC
- *
- * Note due to the way vm flags are laid out, the bits are XWR
- */
-#define PAGE_NONE       __pgprot(_PAGE_BASE | _PAGE_NA)
-#define PAGE_SHARED     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW)
-#define PAGE_SHARED_X   __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RW | \
-                                 _PAGE_EXEC)
-#define PAGE_COPY       __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RO)
-#define PAGE_COPY_X     __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RO | \
-                                 _PAGE_EXEC)
-#define PAGE_READONLY   __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RO)
-#define PAGE_READONLY_X __pgprot(_PAGE_BASE | _PAGE_USER | _PAGE_RO | \
-                                 _PAGE_EXEC)
-
-#define __P000  PAGE_NONE
-#define __P001  PAGE_READONLY
-#define __P010  PAGE_COPY
-#define __P011  PAGE_COPY
-#define __P100  PAGE_READONLY_X
-#define __P101  PAGE_READONLY_X
-#define __P110  PAGE_COPY_X
-#define __P111  PAGE_COPY_X
-
-#define __S000  PAGE_NONE
-#define __S001  PAGE_READONLY
-#define __S010  PAGE_SHARED
-#define __S011  PAGE_SHARED
-#define __S100  PAGE_READONLY_X
-#define __S101  PAGE_READONLY_X
-#define __S110  PAGE_SHARED_X
-#define __S111  PAGE_SHARED_X
-
-/* Permission masks used for kernel mappings */
-#define PAGE_KERNEL     __pgprot(_PAGE_BASE | _PAGE_KERNEL_RW)
-#define PAGE_KERNEL_NC  __pgprot(_PAGE_BASE_NC | _PAGE_KERNEL_RW | \
-                                 _PAGE_NO_CACHE)
-#define PAGE_KERNEL_NCG __pgprot(_PAGE_BASE_NC | _PAGE_KERNEL_RW | \
-                                 _PAGE_NO_CACHE | _PAGE_GUARDED)
-#define PAGE_KERNEL_X   __pgprot(_PAGE_BASE | _PAGE_KERNEL_RWX)
-#define PAGE_KERNEL_RO  __pgprot(_PAGE_BASE | _PAGE_KERNEL_RO)
-#define PAGE_KERNEL_ROX __pgprot(_PAGE_BASE | _PAGE_KERNEL_ROX)
-
-/* Protection used for kernel text. We want the debuggers to be able to
- * set breakpoints anywhere, so don't write protect the kernel text
- * on platforms where such control is possible.
- */
-#if defined(CONFIG_KGDB) || defined(CONFIG_XMON) || defined(CONFIG_BDI_SWITCH) ||\
-        defined(CONFIG_KPROBES) || defined(CONFIG_DYNAMIC_FTRACE)
-#define PAGE_KERNEL_TEXT        PAGE_KERNEL_X
-#else
-#define PAGE_KERNEL_TEXT        PAGE_KERNEL_ROX
-#endif
-
-/* Make modules code happy. We don't set RO yet */
-#define PAGE_KERNEL_EXEC        PAGE_KERNEL_X
-
-/* Advertise special mapping type for AGP */
-#define PAGE_AGP                (PAGE_KERNEL_NC)
-#define HAVE_PAGE_AGP
-
-#ifndef _PAGE_READ
-/* if not defined, we should not find _PAGE_WRITE too */
-#define _PAGE_READ 0
-#define _PAGE_WRITE _PAGE_RW
-#endif
-
-#ifndef H_PAGE_4K_PFN
-#define H_PAGE_4K_PFN 0
-#endif
diff --git a/arch/powerpc/include/asm/ptrace.h b/arch/powerpc/include/asm/ptrace.h
index 5b480e1d5909..f73886a1a7f5 100644
--- a/arch/powerpc/include/asm/ptrace.h
+++ b/arch/powerpc/include/asm/ptrace.h
@@ -26,6 +26,37 @@
 #include <uapi/asm/ptrace.h>
 #include <asm/asm-const.h>
 
+#ifndef __ASSEMBLY__
+struct pt_regs
+{
+        union {
+                struct user_pt_regs user_regs;
+                struct {
+                        unsigned long gpr[32];
+                        unsigned long nip;
+                        unsigned long msr;
+                        unsigned long orig_gpr3;
+                        unsigned long ctr;
+                        unsigned long link;
+                        unsigned long xer;
+                        unsigned long ccr;
+#ifdef CONFIG_PPC64
+                        unsigned long softe;
+#else
+                        unsigned long mq;
+#endif
+                        unsigned long trap;
+                        unsigned long dar;
+                        unsigned long dsisr;
+                        unsigned long result;
+                };
+        };
+
+#ifdef CONFIG_PPC64
+        unsigned long ppr;
+#endif
+};
+#endif
 
 #ifdef __powerpc64__
 
@@ -102,6 +133,11 @@ static inline long regs_return_value(struct pt_regs *regs)
                 return -regs->gpr[3];
 }
 
+static inline void regs_set_return_value(struct pt_regs *regs, unsigned long rc)
+{
+        regs->gpr[3] = rc;
+}
+
 #ifdef __powerpc64__
 #define user_mode(regs) ((((regs)->msr) >> MSR_PR_LG) & 0x1)
 #else
diff --git a/arch/powerpc/include/asm/reg.h b/arch/powerpc/include/asm/reg.h
index c90698972f42..de52c3166ba4 100644
--- a/arch/powerpc/include/asm/reg.h
+++ b/arch/powerpc/include/asm/reg.h
@@ -118,11 +118,16 @@
 #define MSR_TS_S        __MASK(MSR_TS_S_LG)     /*  Transaction Suspended */
 #define MSR_TS_T        __MASK(MSR_TS_T_LG)     /*  Transaction Transactional */
 #define MSR_TS_MASK     (MSR_TS_T | MSR_TS_S)   /* Transaction State bits */
-#define MSR_TM_ACTIVE(x) (((x) & MSR_TS_MASK) != 0) /* Transaction active? */
 #define MSR_TM_RESV(x) (((x) & MSR_TS_MASK) == MSR_TS_MASK) /* Reserved */
 #define MSR_TM_TRANSACTIONAL(x) (((x) & MSR_TS_MASK) == MSR_TS_T)
 #define MSR_TM_SUSPENDED(x)     (((x) & MSR_TS_MASK) == MSR_TS_S)
 
+#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
+#define MSR_TM_ACTIVE(x) (((x) & MSR_TS_MASK) != 0) /* Transaction active? */
+#else
+#define MSR_TM_ACTIVE(x) 0
+#endif
+
 #if defined(CONFIG_PPC_BOOK3S_64)
 #define MSR_64BIT       MSR_SF
 
diff --git a/arch/powerpc/include/asm/rtas.h b/arch/powerpc/include/asm/rtas.h
index 71e393c46a49..bb38dd67d47d 100644
--- a/arch/powerpc/include/asm/rtas.h
+++ b/arch/powerpc/include/asm/rtas.h
@@ -125,6 +125,7 @@ struct rtas_suspend_me_data {
 #define RTAS_TYPE_INFO                  0xE2
 #define RTAS_TYPE_DEALLOC               0xE3
 #define RTAS_TYPE_DUMP                  0xE4
+#define RTAS_TYPE_HOTPLUG               0xE5
 /* I don't add PowerMGM events right now, this is a different topic */ 
 #define RTAS_TYPE_PMGM_POWER_SW_ON      0x60
 #define RTAS_TYPE_PMGM_POWER_SW_OFF     0x61
@@ -185,11 +186,23 @@ static inline uint8_t rtas_error_disposition(const struct rtas_error_log *elog)
         return (elog->byte1 & 0x18) >> 3;
 }
 
+static inline
+void rtas_set_disposition_recovered(struct rtas_error_log *elog)
+{
+        elog->byte1 &= ~0x18;
+        elog->byte1 |= (RTAS_DISP_FULLY_RECOVERED << 3);
+}
+
 static inline uint8_t rtas_error_extended(const struct rtas_error_log *elog)
 {
         return (elog->byte1 & 0x04) >> 2;
 }
 
+static inline uint8_t rtas_error_initiator(const struct rtas_error_log *elog)
+{
+        return (elog->byte2 & 0xf0) >> 4;
+}
+
 #define rtas_error_type(x)      ((x)->byte3)
 
 static inline
@@ -275,6 +288,7 @@ inline uint32_t rtas_ext_event_company_id(struct rtas_ext_event_log_v6 *ext_log)
 #define PSERIES_ELOG_SECT_ID_CALL_HOME          (('C' << 8) | 'H')
 #define PSERIES_ELOG_SECT_ID_USER_DEF           (('U' << 8) | 'D')
 #define PSERIES_ELOG_SECT_ID_HOTPLUG            (('H' << 8) | 'P')
+#define PSERIES_ELOG_SECT_ID_MCE                (('M' << 8) | 'C')
 
 /* Vendor specific Platform Event Log Format, Version 6, section header */
 struct pseries_errorlog {
@@ -316,6 +330,7 @@ struct pseries_hp_errorlog {
 #define PSERIES_HP_ELOG_RESOURCE_MEM    2
 #define PSERIES_HP_ELOG_RESOURCE_SLOT   3
 #define PSERIES_HP_ELOG_RESOURCE_PHB    4
+#define PSERIES_HP_ELOG_RESOURCE_PMEM   6
 
 #define PSERIES_HP_ELOG_ACTION_ADD      1
 #define PSERIES_HP_ELOG_ACTION_REMOVE   2
diff --git a/arch/powerpc/include/asm/slice.h b/arch/powerpc/include/asm/slice.h
index e40406cf5628..a595461c9cb0 100644
--- a/arch/powerpc/include/asm/slice.h
+++ b/arch/powerpc/include/asm/slice.h
@@ -32,6 +32,7 @@ void slice_set_range_psize(struct mm_struct *mm, unsigned long start,
                            unsigned long len, unsigned int psize);
 
 void slice_init_new_context_exec(struct mm_struct *mm);
+void slice_setup_new_exec(void);
 
 #endif /* __ASSEMBLY__ */
 
diff --git a/arch/powerpc/include/asm/smp.h b/arch/powerpc/include/asm/smp.h
index 95b66a0c639b..41695745032c 100644
--- a/arch/powerpc/include/asm/smp.h
+++ b/arch/powerpc/include/asm/smp.h
@@ -100,6 +100,7 @@ static inline void set_hard_smp_processor_id(int cpu, int phys)
 DECLARE_PER_CPU(cpumask_var_t, cpu_sibling_map);
 DECLARE_PER_CPU(cpumask_var_t, cpu_l2_cache_map);
 DECLARE_PER_CPU(cpumask_var_t, cpu_core_map);
+DECLARE_PER_CPU(cpumask_var_t, cpu_smallcore_map);
 
 static inline struct cpumask *cpu_sibling_mask(int cpu)
 {
@@ -116,6 +117,11 @@ static inline struct cpumask *cpu_l2_cache_mask(int cpu)
         return per_cpu(cpu_l2_cache_map, cpu);
 }
 
+static inline struct cpumask *cpu_smallcore_mask(int cpu)
+{
+        return per_cpu(cpu_smallcore_map, cpu);
+}
+
 extern int cpu_to_core_id(int cpu);
 
 /* Since OpenPIC has only 4 IPIs, we use slightly different message numbers.
@@ -166,6 +172,11 @@ static inline const struct cpumask *cpu_sibling_mask(int cpu)
         return cpumask_of(cpu);
 }
 
+static inline const struct cpumask *cpu_smallcore_mask(int cpu)
+{
+        return cpumask_of(cpu);
+}
+
 #endif /* CONFIG_SMP */
 
 #ifdef CONFIG_PPC64
diff --git a/arch/powerpc/include/asm/sparsemem.h b/arch/powerpc/include/asm/sparsemem.h
index 28f5dae25db6..68da49320592 100644
--- a/arch/powerpc/include/asm/sparsemem.h
+++ b/arch/powerpc/include/asm/sparsemem.h
@@ -9,17 +9,6 @@
  * MAX_PHYSMEM_BITS             2^N: how much memory we can have in that space
  */
 #define SECTION_SIZE_BITS       24
-/*
- * If we store section details in page->flags we can't increase the MAX_PHYSMEM_BITS
- * if we increase SECTIONS_WIDTH we will not store node details in page->flags and
- * page_to_nid does a page->section->node lookup
- * Hence only increase for VMEMMAP.
- */
-#ifdef CONFIG_SPARSEMEM_VMEMMAP
-#define MAX_PHYSMEM_BITS        47
-#else
-#define MAX_PHYSMEM_BITS        46
-#endif
 
 #endif /* CONFIG_SPARSEMEM */
 
diff --git a/arch/powerpc/include/asm/stackprotector.h b/arch/powerpc/include/asm/stackprotector.h
new file mode 100644
index 000000000000..1c8460e23583
--- /dev/null
+++ b/arch/powerpc/include/asm/stackprotector.h
@@ -0,0 +1,38 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * GCC stack protector support.
+ *
+ */
+
+#ifndef _ASM_STACKPROTECTOR_H
+#define _ASM_STACKPROTECTOR_H
+
+#include <linux/random.h>
+#include <linux/version.h>
+#include <asm/reg.h>
+#include <asm/current.h>
+#include <asm/paca.h>
+
+/*
+ * Initialize the stackprotector canary value.
+ *
+ * NOTE: this must only be called from functions that never return,
+ * and it must always be inlined.
+ */
+static __always_inline void boot_init_stack_canary(void)
+{
+        unsigned long canary;
+
+        /* Try to get a semi random initial value. */
+        canary = get_random_canary();
+        canary ^= mftb();
+        canary ^= LINUX_VERSION_CODE;
+        canary &= CANARY_MASK;
+
+        current->stack_canary = canary;
+#ifdef CONFIG_PPC64
+        get_paca()->canary = canary;
+#endif
+}
+
+#endif  /* _ASM_STACKPROTECTOR_H */
diff --git a/arch/powerpc/include/asm/thread_info.h b/arch/powerpc/include/asm/thread_info.h
index 3c0002044bc9..544cac0474cb 100644
--- a/arch/powerpc/include/asm/thread_info.h
+++ b/arch/powerpc/include/asm/thread_info.h
@@ -29,6 +29,7 @@
 #include <asm/page.h>
 #include <asm/accounting.h>
 
+#define SLB_PRELOAD_NR  16U
 /*
  * low level task data.
  */
@@ -44,6 +45,10 @@ struct thread_info {
 #if defined(CONFIG_VIRT_CPU_ACCOUNTING_NATIVE) && defined(CONFIG_PPC32)
         struct cpu_accounting_data accounting;
 #endif
+        unsigned char slb_preload_nr;
+        unsigned char slb_preload_tail;
+        u32 slb_preload_esid[SLB_PRELOAD_NR];
+
         /* low level flags - has atomic operations done on it */
         unsigned long   flags ____cacheline_aligned_in_smp;
 };
@@ -72,6 +77,12 @@ static inline struct thread_info *current_thread_info(void)
 }
 
 extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);
+
+#ifdef CONFIG_PPC_BOOK3S_64
+void arch_setup_new_exec(void);
+#define arch_setup_new_exec arch_setup_new_exec
+#endif
+
 #endif /* __ASSEMBLY__ */
 
 /*
@@ -81,7 +92,7 @@ extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src
 #define TIF_SIGPENDING          1       /* signal pending */
 #define TIF_NEED_RESCHED        2       /* rescheduling necessary */
 #define TIF_FSCHECK             3       /* Check FS is USER_DS on return */
-#define TIF_32BIT               4       /* 32 bit binary */
+#define TIF_SYSCALL_EMU         4       /* syscall emulation active */
 #define TIF_RESTORE_TM          5       /* need to restore TM FP/VEC/VSX */
 #define TIF_PATCH_PENDING       6       /* pending live patching update */
 #define TIF_SYSCALL_AUDIT       7       /* syscall auditing active */
@@ -100,6 +111,7 @@ extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src
 #define TIF_ELF2ABI             18      /* function descriptors must die! */
 #endif
 #define TIF_POLLING_NRFLAG      19      /* true if poll_idle() is polling TIF_NEED_RESCHED */
+#define TIF_32BIT               20      /* 32 bit binary */
 
 /* as above, but as bit values */
 #define _TIF_SYSCALL_TRACE      (1<<TIF_SYSCALL_TRACE)
@@ -120,9 +132,10 @@ extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src
 #define _TIF_EMULATE_STACK_STORE        (1<<TIF_EMULATE_STACK_STORE)
 #define _TIF_NOHZ               (1<<TIF_NOHZ)
 #define _TIF_FSCHECK            (1<<TIF_FSCHECK)
+#define _TIF_SYSCALL_EMU        (1<<TIF_SYSCALL_EMU)
 #define _TIF_SYSCALL_DOTRACE    (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | \
                                  _TIF_SECCOMP | _TIF_SYSCALL_TRACEPOINT | \
-                                 _TIF_NOHZ)
+                                 _TIF_NOHZ | _TIF_SYSCALL_EMU)
 
 #define _TIF_USER_WORK_MASK     (_TIF_SIGPENDING | _TIF_NEED_RESCHED | \
                                  _TIF_NOTIFY_RESUME | _TIF_UPROBE | \
diff --git a/arch/powerpc/include/asm/trace.h b/arch/powerpc/include/asm/trace.h
index d018e8602694..58ef8c43a89d 100644
--- a/arch/powerpc/include/asm/trace.h
+++ b/arch/powerpc/include/asm/trace.h
@@ -201,6 +201,21 @@ TRACE_EVENT(tlbie,
                 __entry->r)
 );
 
+TRACE_EVENT(tlbia,
+
+        TP_PROTO(unsigned long id),
+        TP_ARGS(id),
+        TP_STRUCT__entry(
+                __field(unsigned long, id)
+                ),
+
+        TP_fast_assign(
+                __entry->id = id;
+                ),
+
+        TP_printk("ctx.id=0x%lx", __entry->id)
+);
+
 #endif /* _TRACE_POWERPC_H */
 
 #undef TRACE_INCLUDE_PATH
diff --git a/arch/powerpc/include/asm/uaccess.h b/arch/powerpc/include/asm/uaccess.h
index bac225bb7f64..15bea9a0f260 100644
--- a/arch/powerpc/include/asm/uaccess.h
+++ b/arch/powerpc/include/asm/uaccess.h
@@ -260,7 +260,7 @@ do {								\
 ({                                                              \
         long __gu_err;                                          \
         __long_type(*(ptr)) __gu_val;                           \
-        const __typeof__(*(ptr)) __user *__gu_addr = (ptr);     \
+        __typeof__(*(ptr)) __user *__gu_addr = (ptr);   \
         __chk_user_ptr(ptr);                                    \
         if (!is_kernel_addr((unsigned long)__gu_addr))          \
                 might_fault();                                  \
@@ -274,7 +274,7 @@ do {								\
 ({                                                                      \
         long __gu_err = -EFAULT;                                        \
         __long_type(*(ptr)) __gu_val = 0;                               \
-        const __typeof__(*(ptr)) __user *__gu_addr = (ptr);             \
+        __typeof__(*(ptr)) __user *__gu_addr = (ptr);           \
         might_fault();                                                  \
         if (access_ok(VERIFY_READ, __gu_addr, (size))) {                \
                 barrier_nospec();                                       \
@@ -288,7 +288,7 @@ do {								\
 ({                                                              \
         long __gu_err;                                          \
         __long_type(*(ptr)) __gu_val;                           \
-        const __typeof__(*(ptr)) __user *__gu_addr = (ptr);     \
+        __typeof__(*(ptr)) __user *__gu_addr = (ptr);   \
         __chk_user_ptr(ptr);                                    \
         barrier_nospec();                                       \
         __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
diff --git a/arch/powerpc/include/asm/user.h b/arch/powerpc/include/asm/user.h
index 5c0e082eae7b..99443b8594e7 100644
--- a/arch/powerpc/include/asm/user.h
+++ b/arch/powerpc/include/asm/user.h
@@ -31,7 +31,7 @@
  *      to write an integer number of pages.
  */
 struct user {
-        struct pt_regs  regs;                   /* entire machine state */
+        struct user_pt_regs regs;               /* entire machine state */
         size_t          u_tsize;                /* text size (pages) */
         size_t          u_dsize;                /* data size (pages) */
         size_t          u_ssize;                /* stack size (pages) */
diff --git a/arch/powerpc/include/uapi/asm/ptrace.h b/arch/powerpc/include/uapi/asm/ptrace.h
index 5e3edc2a7634..f5f1ccc740fc 100644
--- a/arch/powerpc/include/uapi/asm/ptrace.h
+++ b/arch/powerpc/include/uapi/asm/ptrace.h
@@ -29,7 +29,12 @@
 
 #ifndef __ASSEMBLY__
 
-struct pt_regs {
+#ifdef __KERNEL__
+struct user_pt_regs
+#else
+struct pt_regs
+#endif
+{
         unsigned long gpr[32];
         unsigned long nip;
         unsigned long msr;
@@ -160,6 +165,10 @@ struct pt_regs {
 #define PTRACE_GETVSRREGS       0x1b
 #define PTRACE_SETVSRREGS       0x1c
 
+/* Syscall emulation defines */
+#define PTRACE_SYSEMU                   0x1d
+#define PTRACE_SYSEMU_SINGLESTEP        0x1e
+
 /*
  * Get or set a debug register. The first 16 are DABR registers and the
  * second 16 are IABR registers.
diff --git a/arch/powerpc/include/uapi/asm/sigcontext.h b/arch/powerpc/include/uapi/asm/sigcontext.h
index 2fbe485acdb4..630aeda56d59 100644
--- a/arch/powerpc/include/uapi/asm/sigcontext.h
+++ b/arch/powerpc/include/uapi/asm/sigcontext.h
@@ -22,7 +22,11 @@ struct sigcontext {
 #endif
         unsigned long   handler;
         unsigned long   oldmask;
-        struct pt_regs  __user *regs;
+#ifdef __KERNEL__
+        struct user_pt_regs __user *regs;
+#else
+        struct pt_regs  *regs;
+#endif
 #ifdef __powerpc64__
         elf_gregset_t   gp_regs;
         elf_fpregset_t  fp_regs;
diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index 3b66f2c19c84..53d4b8d5b54d 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -5,7 +5,8 @@
 
 CFLAGS_ptrace.o         += -DUTS_MACHINE='"$(UTS_MACHINE)"'
 
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
+# Disable clang warning for using setjmp without setjmp.h header
+CFLAGS_crash.o          += $(call cc-disable-warning, builtin-requires-header)
 
 ifdef CONFIG_PPC64
 CFLAGS_prom_init.o      += $(NO_MINIMAL_TOC)
@@ -20,12 +21,14 @@ CFLAGS_prom_init.o += $(DISABLE_LATENT_ENTROPY_PLUGIN)
 CFLAGS_btext.o += $(DISABLE_LATENT_ENTROPY_PLUGIN)
 CFLAGS_prom.o += $(DISABLE_LATENT_ENTROPY_PLUGIN)
 
+CFLAGS_prom_init.o += $(call cc-option, -fno-stack-protector)
+
 ifdef CONFIG_FUNCTION_TRACER
 # Do not trace early boot code
-CFLAGS_REMOVE_cputable.o = -mno-sched-epilog $(CC_FLAGS_FTRACE)
-CFLAGS_REMOVE_prom_init.o = -mno-sched-epilog $(CC_FLAGS_FTRACE)
-CFLAGS_REMOVE_btext.o = -mno-sched-epilog $(CC_FLAGS_FTRACE)
-CFLAGS_REMOVE_prom.o = -mno-sched-epilog $(CC_FLAGS_FTRACE)
+CFLAGS_REMOVE_cputable.o = $(CC_FLAGS_FTRACE)
+CFLAGS_REMOVE_prom_init.o = $(CC_FLAGS_FTRACE)
+CFLAGS_REMOVE_btext.o = $(CC_FLAGS_FTRACE)
+CFLAGS_REMOVE_prom.o = $(CC_FLAGS_FTRACE)
 endif
 
 obj-y                           := cputable.o ptrace.o syscalls.o \
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index d68b9ef38328..9ffc72ded73a 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -79,11 +79,16 @@ int main(void)
 {
         OFFSET(THREAD, task_struct, thread);
         OFFSET(MM, task_struct, mm);
+#ifdef CONFIG_STACKPROTECTOR
+        OFFSET(TASK_CANARY, task_struct, stack_canary);
+#ifdef CONFIG_PPC64
+        OFFSET(PACA_CANARY, paca_struct, canary);
+#endif
+#endif
         OFFSET(MMCONTEXTID, mm_struct, context.id);
 #ifdef CONFIG_PPC64
         DEFINE(SIGSEGV, SIGSEGV);
         DEFINE(NMI_MASK, NMI_MASK);
-        OFFSET(TASKTHREADPPR, task_struct, thread.ppr);
 #else
         OFFSET(THREAD_INFO, task_struct, stack);
         DEFINE(THREAD_INFO_GAP, _ALIGN_UP(sizeof(struct thread_info), 16));
@@ -173,7 +178,6 @@ int main(void)
         OFFSET(PACAKSAVE, paca_struct, kstack);
         OFFSET(PACACURRENT, paca_struct, __current);
         OFFSET(PACASAVEDMSR, paca_struct, saved_msr);
-        OFFSET(PACASTABRR, paca_struct, stab_rr);
         OFFSET(PACAR1, paca_struct, saved_r1);
         OFFSET(PACATOC, paca_struct, kernel_toc);
         OFFSET(PACAKBASE, paca_struct, kernelbase);
@@ -212,6 +216,7 @@ int main(void)
 #ifdef CONFIG_PPC_BOOK3S_64
         OFFSET(PACASLBCACHE, paca_struct, slb_cache);
         OFFSET(PACASLBCACHEPTR, paca_struct, slb_cache_ptr);
+        OFFSET(PACASTABRR, paca_struct, stab_rr);
         OFFSET(PACAVMALLOCSLLP, paca_struct, vmalloc_sllp);
 #ifdef CONFIG_PPC_MM_SLICES
         OFFSET(MMUPSIZESLLP, mmu_psize_def, sllp);
@@ -274,11 +279,6 @@ int main(void)
         /* Interrupt register frame */
         DEFINE(INT_FRAME_SIZE, STACK_INT_FRAME_SIZE);
         DEFINE(SWITCH_FRAME_SIZE, STACK_FRAME_OVERHEAD + sizeof(struct pt_regs));
-#ifdef CONFIG_PPC64
-        /* 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);
-#endif /* CONFIG_PPC64 */
         STACK_PT_REGS_OFFSET(GPR0, gpr[0]);
         STACK_PT_REGS_OFFSET(GPR1, gpr[1]);
         STACK_PT_REGS_OFFSET(GPR2, gpr[2]);
@@ -322,10 +322,7 @@ int main(void)
         STACK_PT_REGS_OFFSET(_ESR, dsisr);
 #else /* CONFIG_PPC64 */
         STACK_PT_REGS_OFFSET(SOFTE, softe);
-
-        /* These _only_ to be used with {PROM,RTAS}_FRAME_SIZE!!! */
-        DEFINE(_SRR0, STACK_FRAME_OVERHEAD+sizeof(struct pt_regs));
-        DEFINE(_SRR1, STACK_FRAME_OVERHEAD+sizeof(struct pt_regs)+8);
+        STACK_PT_REGS_OFFSET(_PPR, ppr);
 #endif /* CONFIG_PPC64 */
 
 #if defined(CONFIG_PPC32)
diff --git a/arch/powerpc/kernel/btext.c b/arch/powerpc/kernel/btext.c
index b2072d5bbf2b..b4241ed1456e 100644
--- a/arch/powerpc/kernel/btext.c
+++ b/arch/powerpc/kernel/btext.c
@@ -163,7 +163,7 @@ void btext_map(void)
         offset = ((unsigned long) dispDeviceBase) - base;
         size = dispDeviceRowBytes * dispDeviceRect[3] + offset
                 + dispDeviceRect[0];
-        vbase = __ioremap(base, size, pgprot_val(pgprot_noncached_wc(__pgprot(0))));
+        vbase = ioremap_wc(base, size);
         if (!vbase)
                 return;
         logicalDisplayBase = vbase + offset;
diff --git a/arch/powerpc/kernel/cacheinfo.c b/arch/powerpc/kernel/cacheinfo.c
index a8f20e5928e1..be57bd07596d 100644
--- a/arch/powerpc/kernel/cacheinfo.c
+++ b/arch/powerpc/kernel/cacheinfo.c
@@ -20,6 +20,8 @@
 #include <linux/percpu.h>
 #include <linux/slab.h>
 #include <asm/prom.h>
+#include <asm/cputhreads.h>
+#include <asm/smp.h>
 
 #include "cacheinfo.h"
 
@@ -627,17 +629,48 @@ static ssize_t level_show(struct kobject *k, struct kobj_attribute *attr, char *
 static struct kobj_attribute cache_level_attr =
         __ATTR(level, 0444, level_show, NULL);
 
+static unsigned int index_dir_to_cpu(struct cache_index_dir *index)
+{
+        struct kobject *index_dir_kobj = &index->kobj;
+        struct kobject *cache_dir_kobj = index_dir_kobj->parent;
+        struct kobject *cpu_dev_kobj = cache_dir_kobj->parent;
+        struct device *dev = kobj_to_dev(cpu_dev_kobj);
+
+        return dev->id;
+}
+
+/*
+ * On big-core systems, each core has two groups of CPUs each of which
+ * has its own L1-cache. The thread-siblings which share l1-cache with
+ * @cpu can be obtained via cpu_smallcore_mask().
+ */
+static const struct cpumask *get_big_core_shared_cpu_map(int cpu, struct cache *cache)
+{
+        if (cache->level == 1)
+                return cpu_smallcore_mask(cpu);
+
+        return &cache->shared_cpu_map;
+}
+
 static ssize_t shared_cpu_map_show(struct kobject *k, struct kobj_attribute *attr, char *buf)
 {
         struct cache_index_dir *index;
         struct cache *cache;
-        int ret;
+        const struct cpumask *mask;
+        int ret, cpu;
 
         index = kobj_to_cache_index_dir(k);
         cache = index->cache;
 
+        if (has_big_cores) {
+                cpu = index_dir_to_cpu(index);
+                mask = get_big_core_shared_cpu_map(cpu, cache);
+        } else {
+                mask  = &cache->shared_cpu_map;
+        }
+
         ret = scnprintf(buf, PAGE_SIZE - 1, "%*pb\n",
-                        cpumask_pr_args(&cache->shared_cpu_map));
+                        cpumask_pr_args(mask));
         buf[ret++] = '\n';
         buf[ret] = '\0';
         return ret;
diff --git a/arch/powerpc/kernel/crash_dump.c b/arch/powerpc/kernel/crash_dump.c
index d10ad258d41a..bbdc4706c159 100644
--- a/arch/powerpc/kernel/crash_dump.c
+++ b/arch/powerpc/kernel/crash_dump.c
@@ -110,7 +110,7 @@ ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
                 vaddr = __va(paddr);
                 csize = copy_oldmem_vaddr(vaddr, buf, csize, offset, userbuf);
         } else {
-                vaddr = __ioremap(paddr, PAGE_SIZE, 0);
+                vaddr = ioremap_cache(paddr, PAGE_SIZE);
                 csize = copy_oldmem_vaddr(vaddr, buf, csize, offset, userbuf);
                 iounmap(vaddr);
         }
diff --git a/arch/powerpc/kernel/eeh.c b/arch/powerpc/kernel/eeh.c
index 6ebba3e48b01..6cae6b56ffd6 100644
--- a/arch/powerpc/kernel/eeh.c
+++ b/arch/powerpc/kernel/eeh.c
@@ -169,6 +169,11 @@ static size_t eeh_dump_dev_log(struct eeh_dev *edev, char *buf, size_t len)
         int n = 0, l = 0;
         char buffer[128];
 
+        if (!pdn) {
+                pr_warn("EEH: Note: No error log for absent device.\n");
+                return 0;
+        }
+
         n += scnprintf(buf+n, len-n, "%04x:%02x:%02x.%01x\n",
                        pdn->phb->global_number, pdn->busno,
                        PCI_SLOT(pdn->devfn), PCI_FUNC(pdn->devfn));
@@ -399,7 +404,7 @@ static int eeh_phb_check_failure(struct eeh_pe *pe)
         }
 
         /* Isolate the PHB and send event */
-        eeh_pe_state_mark(phb_pe, EEH_PE_ISOLATED);
+        eeh_pe_mark_isolated(phb_pe);
         eeh_serialize_unlock(flags);
 
         pr_err("EEH: PHB#%x failure detected, location: %s\n",
@@ -558,7 +563,7 @@ int eeh_dev_check_failure(struct eeh_dev *edev)
          * with other functions on this device, and functions under
          * bridges.
          */
-        eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
+        eeh_pe_mark_isolated(pe);
         eeh_serialize_unlock(flags);
 
         /* Most EEH events are due to device driver bugs.  Having
@@ -676,7 +681,7 @@ int eeh_pci_enable(struct eeh_pe *pe, int function)
 
         /* Check if the request is finished successfully */
         if (active_flag) {
-                rc = eeh_ops->wait_state(pe, PCI_BUS_RESET_WAIT_MSEC);
+                rc = eeh_wait_state(pe, PCI_BUS_RESET_WAIT_MSEC);
                 if (rc < 0)
                         return rc;
 
@@ -825,7 +830,8 @@ int pcibios_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state stat
                 eeh_pe_state_clear(pe, EEH_PE_ISOLATED);
                 break;
         case pcie_hot_reset:
-                eeh_pe_state_mark_with_cfg(pe, EEH_PE_ISOLATED);
+                eeh_pe_mark_isolated(pe);
+                eeh_pe_state_clear(pe, EEH_PE_CFG_BLOCKED);
                 eeh_ops->set_option(pe, EEH_OPT_FREEZE_PE);
                 eeh_pe_dev_traverse(pe, eeh_disable_and_save_dev_state, dev);
                 if (!(pe->type & EEH_PE_VF))
@@ -833,7 +839,8 @@ int pcibios_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state stat
                 eeh_ops->reset(pe, EEH_RESET_HOT);
                 break;
         case pcie_warm_reset:
-                eeh_pe_state_mark_with_cfg(pe, EEH_PE_ISOLATED);
+                eeh_pe_mark_isolated(pe);
+                eeh_pe_state_clear(pe, EEH_PE_CFG_BLOCKED);
                 eeh_ops->set_option(pe, EEH_OPT_FREEZE_PE);
                 eeh_pe_dev_traverse(pe, eeh_disable_and_save_dev_state, dev);
                 if (!(pe->type & EEH_PE_VF))
@@ -913,16 +920,15 @@ int eeh_pe_reset_full(struct eeh_pe *pe)
                         break;
 
                 /* Wait until the PE is in a functioning state */
-                state = eeh_ops->wait_state(pe, PCI_BUS_RESET_WAIT_MSEC);
-                if (eeh_state_active(state))
-                        break;
-
+                state = eeh_wait_state(pe, PCI_BUS_RESET_WAIT_MSEC);
                 if (state < 0) {
                         pr_warn("%s: Unrecoverable slot failure on PHB#%x-PE#%x",
                                 __func__, pe->phb->global_number, pe->addr);
                         ret = -ENOTRECOVERABLE;
                         break;
                 }
+                if (eeh_state_active(state))
+                        break;
 
                 /* Set error in case this is our last attempt */
                 ret = -EIO;
@@ -1036,6 +1042,11 @@ void eeh_probe_devices(void)
                 pdn = hose->pci_data;
                 traverse_pci_dn(pdn, eeh_ops->probe, NULL);
         }
+        if (eeh_enabled())
+                pr_info("EEH: PCI Enhanced I/O Error Handling Enabled\n");
+        else
+                pr_info("EEH: No capable adapters found\n");
+
 }
 
 /**
@@ -1079,18 +1090,7 @@ static int eeh_init(void)
                 eeh_dev_phb_init_dynamic(hose);
 
         /* Initialize EEH event */
-        ret = eeh_event_init();
-        if (ret)
-                return ret;
-
-        eeh_probe_devices();
-
-        if (eeh_enabled())
-                pr_info("EEH: PCI Enhanced I/O Error Handling Enabled\n");
-        else if (!eeh_has_flag(EEH_POSTPONED_PROBE))
-                pr_info("EEH: No capable adapters found\n");
-
-        return ret;
+        return eeh_event_init();
 }
 
 core_initcall_sync(eeh_init);
diff --git a/arch/powerpc/kernel/eeh_dev.c b/arch/powerpc/kernel/eeh_dev.c
index a34e6912c15e..d8c90f3284b5 100644
--- a/arch/powerpc/kernel/eeh_dev.c
+++ b/arch/powerpc/kernel/eeh_dev.c
@@ -60,8 +60,6 @@ struct eeh_dev *eeh_dev_init(struct pci_dn *pdn)
         /* Associate EEH device with OF node */
         pdn->edev = edev;
         edev->pdn = pdn;
-        INIT_LIST_HEAD(&edev->list);
-        INIT_LIST_HEAD(&edev->rmv_list);
 
         return edev;
 }
diff --git a/arch/powerpc/kernel/eeh_driver.c b/arch/powerpc/kernel/eeh_driver.c
index 67619b4b3f96..9446248eb6b8 100644
--- a/arch/powerpc/kernel/eeh_driver.c
+++ b/arch/powerpc/kernel/eeh_driver.c
@@ -35,8 +35,8 @@
 #include <asm/rtas.h>
 
 struct eeh_rmv_data {
-        struct list_head edev_list;
-        int removed;
+        struct list_head removed_vf_list;
+        int removed_dev_count;
 };
 
 static int eeh_result_priority(enum pci_ers_result result)
@@ -281,6 +281,10 @@ static void eeh_pe_report_edev(struct eeh_dev *edev, eeh_report_fn fn,
         struct pci_driver *driver;
         enum pci_ers_result new_result;
 
+        if (!edev->pdev) {
+                eeh_edev_info(edev, "no device");
+                return;
+        }
         device_lock(&edev->pdev->dev);
         if (eeh_edev_actionable(edev)) {
                 driver = eeh_pcid_get(edev->pdev);
@@ -400,7 +404,7 @@ static void *eeh_dev_restore_state(struct eeh_dev *edev, void *userdata)
          * EEH device is created.
          */
         if (edev->pe && (edev->pe->state & EEH_PE_CFG_RESTRICTED)) {
-                if (list_is_last(&edev->list, &edev->pe->edevs))
+                if (list_is_last(&edev->entry, &edev->pe->edevs))
                         eeh_pe_restore_bars(edev->pe);
 
                 return NULL;
@@ -465,10 +469,9 @@ static enum pci_ers_result eeh_report_failure(struct eeh_dev *edev,
         return rc;
 }
 
-static void *eeh_add_virt_device(void *data, void *userdata)
+static void *eeh_add_virt_device(struct eeh_dev *edev)
 {
         struct pci_driver *driver;
-        struct eeh_dev *edev = (struct eeh_dev *)data;
         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
         struct pci_dn *pdn = eeh_dev_to_pdn(edev);
 
@@ -499,7 +502,6 @@ static void *eeh_rmv_device(struct eeh_dev *edev, void *userdata)
         struct pci_driver *driver;
         struct pci_dev *dev = eeh_dev_to_pci_dev(edev);
         struct eeh_rmv_data *rmv_data = (struct eeh_rmv_data *)userdata;
-        int *removed = rmv_data ? &rmv_data->removed : NULL;
 
         /*
          * Actually, we should remove the PCI bridges as well.
@@ -521,7 +523,7 @@ static void *eeh_rmv_device(struct eeh_dev *edev, void *userdata)
         if (eeh_dev_removed(edev))
                 return NULL;
 
-        if (removed) {
+        if (rmv_data) {
                 if (eeh_pe_passed(edev->pe))
                         return NULL;
                 driver = eeh_pcid_get(dev);
@@ -539,10 +541,9 @@ static void *eeh_rmv_device(struct eeh_dev *edev, void *userdata)
         /* Remove it from PCI subsystem */
         pr_debug("EEH: Removing %s without EEH sensitive driver\n",
                  pci_name(dev));
-        edev->bus = dev->bus;
         edev->mode |= EEH_DEV_DISCONNECTED;
-        if (removed)
-                (*removed)++;
+        if (rmv_data)
+                rmv_data->removed_dev_count++;
 
         if (edev->physfn) {
 #ifdef CONFIG_PCI_IOV
@@ -558,7 +559,7 @@ static void *eeh_rmv_device(struct eeh_dev *edev, void *userdata)
                 pdn->pe_number = IODA_INVALID_PE;
 #endif
                 if (rmv_data)
-                        list_add(&edev->rmv_list, &rmv_data->edev_list);
+                        list_add(&edev->rmv_entry, &rmv_data->removed_vf_list);
         } else {
                 pci_lock_rescan_remove();
                 pci_stop_and_remove_bus_device(dev);
@@ -727,7 +728,7 @@ static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus,
          * the device up before the scripts have taken it down,
          * potentially weird things happen.
          */
-        if (!driver_eeh_aware || rmv_data->removed) {
+        if (!driver_eeh_aware || rmv_data->removed_dev_count) {
                 pr_info("EEH: Sleep 5s ahead of %s hotplug\n",
                         (driver_eeh_aware ? "partial" : "complete"));
                 ssleep(5);
@@ -737,10 +738,10 @@ static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus,
                  * PE. We should disconnect it so the binding can be
                  * rebuilt when adding PCI devices.
                  */
-                edev = list_first_entry(&pe->edevs, struct eeh_dev, list);
+                edev = list_first_entry(&pe->edevs, struct eeh_dev, entry);
                 eeh_pe_traverse(pe, eeh_pe_detach_dev, NULL);
                 if (pe->type & EEH_PE_VF) {
-                        eeh_add_virt_device(edev, NULL);
+                        eeh_add_virt_device(edev);
                 } else {
                         if (!driver_eeh_aware)
                                 eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
@@ -789,7 +790,8 @@ void eeh_handle_normal_event(struct eeh_pe *pe)
         struct eeh_pe *tmp_pe;
         int rc = 0;
         enum pci_ers_result result = PCI_ERS_RESULT_NONE;
-        struct eeh_rmv_data rmv_data = {LIST_HEAD_INIT(rmv_data.edev_list), 0};
+        struct eeh_rmv_data rmv_data =
+                {LIST_HEAD_INIT(rmv_data.removed_vf_list), 0};
 
         bus = eeh_pe_bus_get(pe);
         if (!bus) {
@@ -806,10 +808,8 @@ void eeh_handle_normal_event(struct eeh_pe *pe)
                 pr_err("EEH: PHB#%x-PE#%x has failed %d times in the last hour and has been permanently disabled.\n",
                        pe->phb->global_number, pe->addr,
                        pe->freeze_count);
-                goto hard_fail;
+                result = PCI_ERS_RESULT_DISCONNECT;
         }
-        pr_warn("EEH: This PCI device has failed %d times in the last hour and will be permanently disabled after %d failures.\n",
-                pe->freeze_count, eeh_max_freezes);
 
         /* Walk the various device drivers attached to this slot through
          * a reset sequence, giving each an opportunity to do what it needs
@@ -821,31 +821,39 @@ void eeh_handle_normal_event(struct eeh_pe *pe)
          * the error. Override the result if necessary to have partially
          * hotplug for this case.
          */
-        pr_info("EEH: Notify device drivers to shutdown\n");
-        eeh_set_channel_state(pe, pci_channel_io_frozen);
-        eeh_set_irq_state(pe, false);
-        eeh_pe_report("error_detected(IO frozen)", pe, eeh_report_error,
-                      &result);
-        if ((pe->type & EEH_PE_PHB) &&
-            result != PCI_ERS_RESULT_NONE &&
-            result != PCI_ERS_RESULT_NEED_RESET)
-                result = PCI_ERS_RESULT_NEED_RESET;
+        if (result != PCI_ERS_RESULT_DISCONNECT) {
+                pr_warn("EEH: This PCI device has failed %d times in the last hour and will be permanently disabled after %d failures.\n",
+                        pe->freeze_count, eeh_max_freezes);
+                pr_info("EEH: Notify device drivers to shutdown\n");
+                eeh_set_channel_state(pe, pci_channel_io_frozen);
+                eeh_set_irq_state(pe, false);
+                eeh_pe_report("error_detected(IO frozen)", pe,
+                              eeh_report_error, &result);
+                if ((pe->type & EEH_PE_PHB) &&
+                    result != PCI_ERS_RESULT_NONE &&
+                    result != PCI_ERS_RESULT_NEED_RESET)
+                        result = PCI_ERS_RESULT_NEED_RESET;
+        }
 
         /* Get the current PCI slot state. This can take a long time,
          * sometimes over 300 seconds for certain systems.
          */
-        rc = eeh_ops->wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
-        if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
-                pr_warn("EEH: Permanent failure\n");
-                goto hard_fail;
+        if (result != PCI_ERS_RESULT_DISCONNECT) {
+                rc = eeh_wait_state(pe, MAX_WAIT_FOR_RECOVERY*1000);
+                if (rc < 0 || rc == EEH_STATE_NOT_SUPPORT) {
+                        pr_warn("EEH: Permanent failure\n");
+                        result = PCI_ERS_RESULT_DISCONNECT;
+                }
         }
 
         /* Since rtas may enable MMIO when posting the error log,
          * don't post the error log until after all dev drivers
          * have been informed.
          */
-        pr_info("EEH: Collect temporary log\n");
-        eeh_slot_error_detail(pe, EEH_LOG_TEMP);
+        if (result != PCI_ERS_RESULT_DISCONNECT) {
+                pr_info("EEH: Collect temporary log\n");
+                eeh_slot_error_detail(pe, EEH_LOG_TEMP);
+        }
 
         /* If all device drivers were EEH-unaware, then shut
          * down all of the device drivers, and hope they
@@ -857,7 +865,7 @@ void eeh_handle_normal_event(struct eeh_pe *pe)
                 if (rc) {
                         pr_warn("%s: Unable to reset, err=%d\n",
                                 __func__, rc);
-                        goto hard_fail;
+                        result = PCI_ERS_RESULT_DISCONNECT;
                 }
         }
 
@@ -866,9 +874,9 @@ void eeh_handle_normal_event(struct eeh_pe *pe)
                 pr_info("EEH: Enable I/O for affected devices\n");
                 rc = eeh_pci_enable(pe, EEH_OPT_THAW_MMIO);
 
-                if (rc < 0)
-                        goto hard_fail;
-                if (rc) {
+                if (rc < 0) {
+                        result = PCI_ERS_RESULT_DISCONNECT;
+                } else if (rc) {
                         result = PCI_ERS_RESULT_NEED_RESET;
                 } else {
                         pr_info("EEH: Notify device drivers to resume I/O\n");
@@ -882,9 +890,9 @@ void eeh_handle_normal_event(struct eeh_pe *pe)
                 pr_info("EEH: Enabled DMA for affected devices\n");
                 rc = eeh_pci_enable(pe, EEH_OPT_THAW_DMA);
 
-                if (rc < 0)
-                        goto hard_fail;
-                if (rc) {
+                if (rc < 0) {
+                        result = PCI_ERS_RESULT_DISCONNECT;
+                } else if (rc) {
                         result = PCI_ERS_RESULT_NEED_RESET;
                 } else {
                         /*
@@ -897,12 +905,6 @@ void eeh_handle_normal_event(struct eeh_pe *pe)
                 }
         }
 
-        /* If any device has a hard failure, then shut off everything. */
-        if (result == PCI_ERS_RESULT_DISCONNECT) {
-                pr_warn("EEH: Device driver gave up\n");
-                goto hard_fail;
-        }
-
         /* If any device called out for a reset, then reset the slot */
         if (result == PCI_ERS_RESULT_NEED_RESET) {
                 pr_info("EEH: Reset without hotplug activity\n");
@@ -910,88 +912,81 @@ void eeh_handle_normal_event(struct eeh_pe *pe)
                 if (rc) {
                         pr_warn("%s: Cannot reset, err=%d\n",
                                 __func__, rc);
-                        goto hard_fail;
+                        result = PCI_ERS_RESULT_DISCONNECT;
+                } else {
+                        result = PCI_ERS_RESULT_NONE;
+                        eeh_set_channel_state(pe, pci_channel_io_normal);
+                        eeh_set_irq_state(pe, true);
+                        eeh_pe_report("slot_reset", pe, eeh_report_reset,
+                                      &result);
                 }
-
-                pr_info("EEH: Notify device drivers "
-                        "the completion of reset\n");
-                result = PCI_ERS_RESULT_NONE;
-                eeh_set_channel_state(pe, pci_channel_io_normal);
-                eeh_set_irq_state(pe, true);
-                eeh_pe_report("slot_reset", pe, eeh_report_reset, &result);
-        }
-
-        /* All devices should claim they have recovered by now. */
-        if ((result != PCI_ERS_RESULT_RECOVERED) &&
-            (result != PCI_ERS_RESULT_NONE)) {
-                pr_warn("EEH: Not recovered\n");
-                goto hard_fail;
-        }
-
-        /*
-         * For those hot removed VFs, we should add back them after PF get
-         * recovered properly.
-         */
-        list_for_each_entry_safe(edev, tmp, &rmv_data.edev_list, rmv_list) {
-                eeh_add_virt_device(edev, NULL);
-                list_del(&edev->rmv_list);
         }
 
-        /* Tell all device drivers that they can resume operations */
-        pr_info("EEH: Notify device driver to resume\n");
-        eeh_set_channel_state(pe, pci_channel_io_normal);
-        eeh_set_irq_state(pe, true);
-        eeh_pe_report("resume", pe, eeh_report_resume, NULL);
-        eeh_for_each_pe(pe, tmp_pe) {
-                eeh_pe_for_each_dev(tmp_pe, edev, tmp) {
-                        edev->mode &= ~EEH_DEV_NO_HANDLER;
-                        edev->in_error = false;
+        if ((result == PCI_ERS_RESULT_RECOVERED) ||
+            (result == PCI_ERS_RESULT_NONE)) {
+                /*
+                 * For those hot removed VFs, we should add back them after PF
+                 * get recovered properly.
+                 */
+                list_for_each_entry_safe(edev, tmp, &rmv_data.removed_vf_list,
+                                         rmv_entry) {
+                        eeh_add_virt_device(edev);
+                        list_del(&edev->rmv_entry);
                 }
-        }
 
-        pr_info("EEH: Recovery successful.\n");
-        goto final;
+                /* Tell all device drivers that they can resume operations */
+                pr_info("EEH: Notify device driver to resume\n");
+                eeh_set_channel_state(pe, pci_channel_io_normal);
+                eeh_set_irq_state(pe, true);
+                eeh_pe_report("resume", pe, eeh_report_resume, NULL);
+                eeh_for_each_pe(pe, tmp_pe) {
+                        eeh_pe_for_each_dev(tmp_pe, edev, tmp) {
+                                edev->mode &= ~EEH_DEV_NO_HANDLER;
+                                edev->in_error = false;
+                        }
+                }
 
-hard_fail:
-        /*
-         * About 90% of all real-life EEH failures in the field
-         * are due to poorly seated PCI cards. Only 10% or so are
-         * due to actual, failed cards.
-         */
-        pr_err("EEH: Unable to recover from failure from PHB#%x-PE#%x.\n"
-               "Please try reseating or replacing it\n",
-                pe->phb->global_number, pe->addr);
+                pr_info("EEH: Recovery successful.\n");
+        } else  {
+                /*
+                 * About 90% of all real-life EEH failures in the field
+                 * are due to poorly seated PCI cards. Only 10% or so are
+                 * due to actual, failed cards.
+                 */
+                pr_err("EEH: Unable to recover from failure from PHB#%x-PE#%x.\n"
+                       "Please try reseating or replacing it\n",
+                        pe->phb->global_number, pe->addr);
 
-        eeh_slot_error_detail(pe, EEH_LOG_PERM);
+                eeh_slot_error_detail(pe, EEH_LOG_PERM);
 
-        /* Notify all devices that they're about to go down. */
-        eeh_set_channel_state(pe, pci_channel_io_perm_failure);
-        eeh_set_irq_state(pe, false);
-        eeh_pe_report("error_detected(permanent failure)", pe,
-                      eeh_report_failure, NULL);
+                /* Notify all devices that they're about to go down. */
+                eeh_set_channel_state(pe, pci_channel_io_perm_failure);
+                eeh_set_irq_state(pe, false);
+                eeh_pe_report("error_detected(permanent failure)", pe,
+                              eeh_report_failure, NULL);
 
-        /* Mark the PE to be removed permanently */
-        eeh_pe_state_mark(pe, EEH_PE_REMOVED);
+                /* Mark the PE to be removed permanently */
+                eeh_pe_state_mark(pe, EEH_PE_REMOVED);
 
-        /*
-         * Shut down the device drivers for good. We mark
-         * all removed devices correctly to avoid access
-         * the their PCI config any more.
-         */
-        if (pe->type & EEH_PE_VF) {
-                eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
-                eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
-        } else {
-                eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
-                eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
+                /*
+                 * Shut down the device drivers for good. We mark
+                 * all removed devices correctly to avoid access
+                 * the their PCI config any more.
+                 */
+                if (pe->type & EEH_PE_VF) {
+                        eeh_pe_dev_traverse(pe, eeh_rmv_device, NULL);
+                        eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
+                } else {
+                        eeh_pe_state_clear(pe, EEH_PE_PRI_BUS);
+                        eeh_pe_dev_mode_mark(pe, EEH_DEV_REMOVED);
 
-                pci_lock_rescan_remove();
-                pci_hp_remove_devices(bus);
-                pci_unlock_rescan_remove();
-                /* The passed PE should no longer be used */
-                return;
+                        pci_lock_rescan_remove();
+                        pci_hp_remove_devices(bus);
+                        pci_unlock_rescan_remove();
+                        /* The passed PE should no longer be used */
+                        return;
+                }
         }
-final:
         eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
 }
 
@@ -1026,7 +1021,7 @@ void eeh_handle_special_event(void)
                                 phb_pe = eeh_phb_pe_get(hose);
                                 if (!phb_pe) continue;
 
-                                eeh_pe_state_mark(phb_pe, EEH_PE_ISOLATED);
+                                eeh_pe_mark_isolated(phb_pe);
                         }
 
                         eeh_serialize_unlock(flags);
@@ -1041,11 +1036,9 @@ void eeh_handle_special_event(void)
                         /* Purge all events of the PHB */
                         eeh_remove_event(pe, true);
 
-                        if (rc == EEH_NEXT_ERR_DEAD_PHB)
-                                eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
-                        else
-                                eeh_pe_state_mark(pe,
-                                        EEH_PE_ISOLATED | EEH_PE_RECOVERING);
+                        if (rc != EEH_NEXT_ERR_DEAD_PHB)
+                                eeh_pe_state_mark(pe, EEH_PE_RECOVERING);
+                        eeh_pe_mark_isolated(pe);
 
                         eeh_serialize_unlock(flags);
 
diff --git a/arch/powerpc/kernel/eeh_pe.c b/arch/powerpc/kernel/eeh_pe.c
index 1b238ecc553e..6fa2032e0594 100644
--- a/arch/powerpc/kernel/eeh_pe.c
+++ b/arch/powerpc/kernel/eeh_pe.c
@@ -75,7 +75,6 @@ static struct eeh_pe *eeh_pe_alloc(struct pci_controller *phb, int type)
         pe->type = type;
         pe->phb = phb;
         INIT_LIST_HEAD(&pe->child_list);
-        INIT_LIST_HEAD(&pe->child);
         INIT_LIST_HEAD(&pe->edevs);
 
         pe->data = (void *)pe + ALIGN(sizeof(struct eeh_pe),
@@ -110,6 +109,57 @@ int eeh_phb_pe_create(struct pci_controller *phb)
 }
 
 /**
+ * eeh_wait_state - Wait for PE state
+ * @pe: EEH PE
+ * @max_wait: maximal period in millisecond
+ *
+ * Wait for the state of associated PE. It might take some time
+ * to retrieve the PE's state.
+ */
+int eeh_wait_state(struct eeh_pe *pe, int max_wait)
+{
+        int ret;
+        int mwait;
+
+        /*
+         * According to PAPR, the state of PE might be temporarily
+         * unavailable. Under the circumstance, we have to wait
+         * for indicated time determined by firmware. The maximal
+         * wait time is 5 minutes, which is acquired from the original
+         * EEH implementation. Also, the original implementation
+         * also defined the minimal wait time as 1 second.
+         */
+#define EEH_STATE_MIN_WAIT_TIME (1000)
+#define EEH_STATE_MAX_WAIT_TIME (300 * 1000)
+
+        while (1) {
+                ret = eeh_ops->get_state(pe, &mwait);
+
+                if (ret != EEH_STATE_UNAVAILABLE)
+                        return ret;
+
+                if (max_wait <= 0) {
+                        pr_warn("%s: Timeout when getting PE's state (%d)\n",
+                                __func__, max_wait);
+                        return EEH_STATE_NOT_SUPPORT;
+                }
+
+                if (mwait < EEH_STATE_MIN_WAIT_TIME) {
+                        pr_warn("%s: Firmware returned bad wait value %d\n",
+                                __func__, mwait);
+                        mwait = EEH_STATE_MIN_WAIT_TIME;
+                } else if (mwait > EEH_STATE_MAX_WAIT_TIME) {
+                        pr_warn("%s: Firmware returned too long wait value %d\n",
+                                __func__, mwait);
+                        mwait = EEH_STATE_MAX_WAIT_TIME;
+                }
+
+                msleep(min(mwait, max_wait));
+                max_wait -= mwait;
+        }
+}
+
+/**
  * eeh_phb_pe_get - Retrieve PHB PE based on the given PHB
  * @phb: PCI controller
  *
@@ -360,7 +410,7 @@ int eeh_add_to_parent_pe(struct eeh_dev *edev)
                 edev->pe = pe;
 
                 /* Put the edev to PE */
-                list_add_tail(&edev->list, &pe->edevs);
+                list_add_tail(&edev->entry, &pe->edevs);
                 pr_debug("EEH: Add %04x:%02x:%02x.%01x to Bus PE#%x\n",
                          pdn->phb->global_number,
                          pdn->busno,
@@ -369,7 +419,7 @@ int eeh_add_to_parent_pe(struct eeh_dev *edev)
                          pe->addr);
                 return 0;
         } else if (pe && (pe->type & EEH_PE_INVALID)) {
-                list_add_tail(&edev->list, &pe->edevs);
+                list_add_tail(&edev->entry, &pe->edevs);
                 edev->pe = pe;
                 /*
                  * We're running to here because of PCI hotplug caused by
@@ -379,7 +429,7 @@ int eeh_add_to_parent_pe(struct eeh_dev *edev)
                 while (parent) {
                         if (!(parent->type & EEH_PE_INVALID))
                                 break;
-                        parent->type &= ~(EEH_PE_INVALID | EEH_PE_KEEP);
+                        parent->type &= ~EEH_PE_INVALID;
                         parent = parent->parent;
                 }
 
@@ -429,7 +479,7 @@ int eeh_add_to_parent_pe(struct eeh_dev *edev)
          * link the EEH device accordingly.
          */
         list_add_tail(&pe->child, &parent->child_list);
-        list_add_tail(&edev->list, &pe->edevs);
+        list_add_tail(&edev->entry, &pe->edevs);
         edev->pe = pe;
         pr_debug("EEH: Add %04x:%02x:%02x.%01x to "
                  "Device PE#%x, Parent PE#%x\n",
@@ -457,7 +507,8 @@ int eeh_rmv_from_parent_pe(struct eeh_dev *edev)
         int cnt;
         struct pci_dn *pdn = eeh_dev_to_pdn(edev);
 
-        if (!edev->pe) {
+        pe = eeh_dev_to_pe(edev);
+        if (!pe) {
                 pr_debug("%s: No PE found for device %04x:%02x:%02x.%01x\n",
                          __func__,  pdn->phb->global_number,
                          pdn->busno,
@@ -467,9 +518,8 @@ int eeh_rmv_from_parent_pe(struct eeh_dev *edev)
         }
 
         /* Remove the EEH device */
-        pe = eeh_dev_to_pe(edev);
         edev->pe = NULL;
-        list_del(&edev->list);
+        list_del(&edev->entry);
 
         /*
          * Check if the parent PE includes any EEH devices.
@@ -541,56 +591,50 @@ void eeh_pe_update_time_stamp(struct eeh_pe *pe)
 }
 
 /**
- * __eeh_pe_state_mark - Mark the state for the PE
- * @data: EEH PE
- * @flag: state
+ * eeh_pe_state_mark - Mark specified state for PE and its associated device
+ * @pe: EEH PE
  *
- * The function is used to mark the indicated state for the given
- * PE. Also, the associated PCI devices will be put into IO frozen
- * state as well.
+ * EEH error affects the current PE and its child PEs. The function
+ * is used to mark appropriate state for the affected PEs and the
+ * associated devices.
  */
-static void *__eeh_pe_state_mark(struct eeh_pe *pe, void *flag)
+void eeh_pe_state_mark(struct eeh_pe *root, int state)
 {
-        int state = *((int *)flag);
-        struct eeh_dev *edev, *tmp;
-        struct pci_dev *pdev;
-
-        /* Keep the state of permanently removed PE intact */
-        if (pe->state & EEH_PE_REMOVED)
-                return NULL;
-
-        pe->state |= state;
-
-        /* Offline PCI devices if applicable */
-        if (!(state & EEH_PE_ISOLATED))
-                return NULL;
-
-        eeh_pe_for_each_dev(pe, edev, tmp) {
-                pdev = eeh_dev_to_pci_dev(edev);
-                if (pdev)
-                        pdev->error_state = pci_channel_io_frozen;
-        }
-
-        /* Block PCI config access if required */
-        if (pe->state & EEH_PE_CFG_RESTRICTED)
-                pe->state |= EEH_PE_CFG_BLOCKED;
+        struct eeh_pe *pe;
 
-        return NULL;
+        eeh_for_each_pe(root, pe)
+                if (!(pe->state & EEH_PE_REMOVED))
+                        pe->state |= state;
 }
+EXPORT_SYMBOL_GPL(eeh_pe_state_mark);
 
 /**
- * eeh_pe_state_mark - Mark specified state for PE and its associated device
+ * eeh_pe_mark_isolated
  * @pe: EEH PE
  *
- * EEH error affects the current PE and its child PEs. The function
- * is used to mark appropriate state for the affected PEs and the
- * associated devices.
+ * Record that a PE has been isolated by marking the PE and it's children as
+ * EEH_PE_ISOLATED (and EEH_PE_CFG_BLOCKED, if required) and their PCI devices
+ * as pci_channel_io_frozen.
  */
-void eeh_pe_state_mark(struct eeh_pe *pe, int state)
+void eeh_pe_mark_isolated(struct eeh_pe *root)
 {
-        eeh_pe_traverse(pe, __eeh_pe_state_mark, &state);
+        struct eeh_pe *pe;
+        struct eeh_dev *edev;
+        struct pci_dev *pdev;
+
+        eeh_pe_state_mark(root, EEH_PE_ISOLATED);
+        eeh_for_each_pe(root, pe) {
+                list_for_each_entry(edev, &pe->edevs, entry) {
+                        pdev = eeh_dev_to_pci_dev(edev);
+                        if (pdev)
+                                pdev->error_state = pci_channel_io_frozen;
+                }
+                /* Block PCI config access if required */
+                if (pe->state & EEH_PE_CFG_RESTRICTED)
+                        pe->state |= EEH_PE_CFG_BLOCKED;
+        }
 }
-EXPORT_SYMBOL_GPL(eeh_pe_state_mark);
+EXPORT_SYMBOL_GPL(eeh_pe_mark_isolated);
 
 static void *__eeh_pe_dev_mode_mark(struct eeh_dev *edev, void *flag)
 {
@@ -671,28 +715,6 @@ void eeh_pe_state_clear(struct eeh_pe *pe, int state)
         eeh_pe_traverse(pe, __eeh_pe_state_clear, &state);
 }
 
-/**
- * eeh_pe_state_mark_with_cfg - Mark PE state with unblocked config space
- * @pe: PE
- * @state: PE state to be set
- *
- * Set specified flag to PE and its child PEs. The PCI config space
- * of some PEs is blocked automatically when EEH_PE_ISOLATED is set,
- * which isn't needed in some situations. The function allows to set
- * the specified flag to indicated PEs without blocking their PCI
- * config space.
- */
-void eeh_pe_state_mark_with_cfg(struct eeh_pe *pe, int state)
-{
-        eeh_pe_traverse(pe, __eeh_pe_state_mark, &state);
-        if (!(state & EEH_PE_ISOLATED))
-                return;
-
-        /* Clear EEH_PE_CFG_BLOCKED, which might be set just now */
-        state = EEH_PE_CFG_BLOCKED;
-        eeh_pe_traverse(pe, __eeh_pe_state_clear, &state);
-}
-
 /*
  * Some PCI bridges (e.g. PLX bridges) have primary/secondary
  * buses assigned explicitly by firmware, and we probably have
@@ -945,7 +967,7 @@ struct pci_bus *eeh_pe_bus_get(struct eeh_pe *pe)
                 return pe->bus;
 
         /* Retrieve the parent PCI bus of first (top) PCI device */
-        edev = list_first_entry_or_null(&pe->edevs, struct eeh_dev, list);
+        edev = list_first_entry_or_null(&pe->edevs, struct eeh_dev, entry);
         pdev = eeh_dev_to_pci_dev(edev);
         if (pdev)
                 return pdev->bus;
diff --git a/arch/powerpc/kernel/entry_32.S b/arch/powerpc/kernel/entry_32.S
index e58c3f467db5..77decded1175 100644
--- a/arch/powerpc/kernel/entry_32.S
+++ b/arch/powerpc/kernel/entry_32.S
@@ -794,7 +794,7 @@ END_FTR_SECTION_IFSET(CPU_FTR_601)
         lis     r10,MSR_KERNEL@h
         ori     r10,r10,MSR_KERNEL@l
         bl      transfer_to_handler_full
-        .long   nonrecoverable_exception
+        .long   unrecoverable_exception
         .long   ret_from_except
 #endif
 
@@ -1297,7 +1297,7 @@ END_FTR_SECTION_IFSET(CPU_FTR_601)
         rlwinm  r3,r3,0,0,30
         stw     r3,_TRAP(r1)
 4:      addi    r3,r1,STACK_FRAME_OVERHEAD
-        bl      nonrecoverable_exception
+        bl      unrecoverable_exception
         /* shouldn't return */
         b       4b
 
diff --git a/arch/powerpc/kernel/entry_64.S b/arch/powerpc/kernel/entry_64.S
index 2206912ea4f0..7b1693adff2a 100644
--- a/arch/powerpc/kernel/entry_64.S
+++ b/arch/powerpc/kernel/entry_64.S
@@ -171,7 +171,7 @@ system_call:			/* label this so stack traces look sane */
  * based on caller's run-mode / personality.
  */
         ld      r11,SYS_CALL_TABLE@toc(2)
-        andi.   r10,r10,_TIF_32BIT
+        andis.  r10,r10,_TIF_32BIT@h
         beq     15f
         addi    r11,r11,8       /* use 32-bit syscall entries */
         clrldi  r3,r3,32
@@ -386,10 +386,9 @@ END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
 
 4:      /* Anything else left to do? */
 BEGIN_FTR_SECTION
-        lis     r3,INIT_PPR@highest     /* Set thread.ppr = 3 */
-        ld      r10,PACACURRENT(r13)
+        lis     r3,DEFAULT_PPR@highest  /* Set default PPR */
         sldi    r3,r3,32        /* bits 11-13 are used for ppr */
-        std     r3,TASKTHREADPPR(r10)
+        std     r3,_PPR(r1)
 END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
 
         andi.   r0,r9,(_TIF_SYSCALL_DOTRACE|_TIF_SINGLESTEP)
@@ -624,6 +623,10 @@ _GLOBAL(_switch)
 
         addi    r6,r4,-THREAD   /* Convert THREAD to 'current' */
         std     r6,PACACURRENT(r13)     /* Set new 'current' */
+#if defined(CONFIG_STACKPROTECTOR)
+        ld      r6, TASK_CANARY(r6)
+        std     r6, PACA_CANARY(r13)
+#endif
 
         ld      r8,KSP(r4)      /* new stack pointer */
 #ifdef CONFIG_PPC_BOOK3S_64
@@ -672,7 +675,9 @@ END_MMU_FTR_SECTION_IFSET(MMU_FTR_1T_SEGMENT)
 
         isync
         slbie   r6
+BEGIN_FTR_SECTION
         slbie   r6              /* Workaround POWER5 < DD2.1 issue */
+END_FTR_SECTION_IFCLR(CPU_FTR_ARCH_207S)
         slbmte  r7,r0
         isync
 2:
@@ -936,12 +941,6 @@ fast_exception_return:
         andi.   r0,r3,MSR_RI
         beq-    .Lunrecov_restore
 
-        /* Load PPR from thread struct before we clear MSR:RI */
-BEGIN_FTR_SECTION
-        ld      r2,PACACURRENT(r13)
-        ld      r2,TASKTHREADPPR(r2)
-END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
-
         /*
          * Clear RI before restoring r13.  If we are returning to
          * userspace and we take an exception after restoring r13,
@@ -962,7 +961,9 @@ END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
         andi.   r0,r3,MSR_PR
         beq     1f
 BEGIN_FTR_SECTION
-        mtspr   SPRN_PPR,r2     /* Restore PPR */
+        /* Restore PPR */
+        ld      r2,_PPR(r1)
+        mtspr   SPRN_PPR,r2
 END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
         ACCOUNT_CPU_USER_EXIT(r13, r2, r4)
         REST_GPR(13, r1)
@@ -1118,7 +1119,7 @@ _ASM_NOKPROBE_SYMBOL(fast_exception_return);
 _GLOBAL(enter_rtas)
         mflr    r0
         std     r0,16(r1)
-        stdu    r1,-RTAS_FRAME_SIZE(r1) /* Save SP and create stack space. */
+        stdu    r1,-SWITCH_FRAME_SIZE(r1) /* Save SP and create stack space. */
 
         /* Because RTAS is running in 32b mode, it clobbers the high order half
          * of all registers that it saves.  We therefore save those registers
@@ -1250,7 +1251,7 @@ rtas_restore_regs:
         ld      r8,_DSISR(r1)
         mtdsisr r8
 
-        addi    r1,r1,RTAS_FRAME_SIZE   /* Unstack our frame */
+        addi    r1,r1,SWITCH_FRAME_SIZE /* Unstack our frame */
         ld      r0,16(r1)               /* get return address */
 
         mtlr    r0
@@ -1261,7 +1262,7 @@ rtas_restore_regs:
 _GLOBAL(enter_prom)
         mflr    r0
         std     r0,16(r1)
-        stdu    r1,-PROM_FRAME_SIZE(r1) /* Save SP and create stack space */
+        stdu    r1,-SWITCH_FRAME_SIZE(r1) /* Save SP and create stack space */
 
         /* Because PROM is running in 32b mode, it clobbers the high order half
          * of all registers that it saves.  We therefore save those registers
@@ -1318,8 +1319,8 @@ _GLOBAL(enter_prom)
         REST_10GPRS(22, r1)
         ld      r4,_CCR(r1)
         mtcr    r4
-        
-        addi    r1,r1,PROM_FRAME_SIZE
+
+        addi    r1,r1,SWITCH_FRAME_SIZE
         ld      r0,16(r1)
         mtlr    r0
         blr
diff --git a/arch/powerpc/kernel/exceptions-64s.S b/arch/powerpc/kernel/exceptions-64s.S
index 2d8fc8c9da7a..89d32bb79d5e 100644
--- a/arch/powerpc/kernel/exceptions-64s.S
+++ b/arch/powerpc/kernel/exceptions-64s.S
@@ -244,14 +244,13 @@ EXC_REAL_BEGIN(machine_check, 0x200, 0x100)
         SET_SCRATCH0(r13)               /* save r13 */
         EXCEPTION_PROLOG_0(PACA_EXMC)
 BEGIN_FTR_SECTION
-        b       machine_check_powernv_early
+        b       machine_check_common_early
 FTR_SECTION_ELSE
         b       machine_check_pSeries_0
 ALT_FTR_SECTION_END_IFSET(CPU_FTR_HVMODE)
 EXC_REAL_END(machine_check, 0x200, 0x100)
 EXC_VIRT_NONE(0x4200, 0x100)
-TRAMP_REAL_BEGIN(machine_check_powernv_early)
-BEGIN_FTR_SECTION
+TRAMP_REAL_BEGIN(machine_check_common_early)
         EXCEPTION_PROLOG_1(PACA_EXMC, NOTEST, 0x200)
         /*
          * Register contents:
@@ -305,7 +304,9 @@ BEGIN_FTR_SECTION
         /* Save r9 through r13 from EXMC save area to stack frame. */
         EXCEPTION_PROLOG_COMMON_2(PACA_EXMC)
         mfmsr   r11                     /* get MSR value */
+BEGIN_FTR_SECTION
         ori     r11,r11,MSR_ME          /* turn on ME bit */
+END_FTR_SECTION_IFSET(CPU_FTR_HVMODE)
         ori     r11,r11,MSR_RI          /* turn on RI bit */
         LOAD_HANDLER(r12, machine_check_handle_early)
 1:      mtspr   SPRN_SRR0,r12
@@ -324,13 +325,15 @@ BEGIN_FTR_SECTION
         andc    r11,r11,r10             /* Turn off MSR_ME */
         b       1b
         b       .       /* prevent speculative execution */
-END_FTR_SECTION_IFSET(CPU_FTR_HVMODE)
 
 TRAMP_REAL_BEGIN(machine_check_pSeries)
         .globl machine_check_fwnmi
 machine_check_fwnmi:
         SET_SCRATCH0(r13)               /* save r13 */
         EXCEPTION_PROLOG_0(PACA_EXMC)
+BEGIN_FTR_SECTION
+        b       machine_check_common_early
+END_FTR_SECTION_IFCLR(CPU_FTR_HVMODE)
 machine_check_pSeries_0:
         EXCEPTION_PROLOG_1(PACA_EXMC, KVMTEST_PR, 0x200)
         /*
@@ -440,6 +443,9 @@ EXC_COMMON_BEGIN(machine_check_handle_early)
         bl      machine_check_early
         std     r3,RESULT(r1)   /* Save result */
         ld      r12,_MSR(r1)
+BEGIN_FTR_SECTION
+        b       4f
+END_FTR_SECTION_IFCLR(CPU_FTR_HVMODE)
 
 #ifdef  CONFIG_PPC_P7_NAP
         /*
@@ -463,11 +469,12 @@ EXC_COMMON_BEGIN(machine_check_handle_early)
          */
         rldicl. r11,r12,4,63            /* See if MC hit while in HV mode. */
         beq     5f
-        andi.   r11,r12,MSR_PR          /* See if coming from user. */
+4:      andi.   r11,r12,MSR_PR          /* See if coming from user. */
         bne     9f                      /* continue in V mode if we are. */
 
 5:
 #ifdef CONFIG_KVM_BOOK3S_64_HANDLER
+BEGIN_FTR_SECTION
         /*
          * We are coming from kernel context. Check if we are coming from
          * guest. if yes, then we can continue. We will fall through
@@ -476,6 +483,7 @@ EXC_COMMON_BEGIN(machine_check_handle_early)
         lbz     r11,HSTATE_IN_GUEST(r13)
         cmpwi   r11,0                   /* Check if coming from guest */
         bne     9f                      /* continue if we are. */
+END_FTR_SECTION_IFSET(CPU_FTR_HVMODE)
 #endif
         /*
          * At this point we are not sure about what context we come from.
@@ -510,6 +518,7 @@ EXC_COMMON_BEGIN(machine_check_handle_early)
         cmpdi   r3,0            /* see if we handled MCE successfully */
 
         beq     1b              /* if !handled then panic */
+BEGIN_FTR_SECTION
         /*
          * Return from MC interrupt.
          * Queue up the MCE event so that we can log it later, while
@@ -518,10 +527,24 @@ EXC_COMMON_BEGIN(machine_check_handle_early)
         bl      machine_check_queue_event
         MACHINE_CHECK_HANDLER_WINDUP
         RFI_TO_USER_OR_KERNEL
+FTR_SECTION_ELSE
+        /*
+         * pSeries: Return from MC interrupt. Before that stay on emergency
+         * stack and call machine_check_exception to log the MCE event.
+         */
+        LOAD_HANDLER(r10,mce_return)
+        mtspr   SPRN_SRR0,r10
+        ld      r10,PACAKMSR(r13)
+        mtspr   SPRN_SRR1,r10
+        RFI_TO_KERNEL
+        b       .
+ALT_FTR_SECTION_END_IFSET(CPU_FTR_HVMODE)
 9:
         /* Deliver the machine check to host kernel in V mode. */
         MACHINE_CHECK_HANDLER_WINDUP
-        b       machine_check_pSeries
+        SET_SCRATCH0(r13)               /* save r13 */
+        EXCEPTION_PROLOG_0(PACA_EXMC)
+        b       machine_check_pSeries_0
 
 EXC_COMMON_BEGIN(unrecover_mce)
         /* Invoke machine_check_exception to print MCE event and panic. */
@@ -535,6 +558,13 @@ EXC_COMMON_BEGIN(unrecover_mce)
         bl      unrecoverable_exception
         b       1b
 
+EXC_COMMON_BEGIN(mce_return)
+        /* Invoke machine_check_exception to print MCE event and return. */
+        addi    r3,r1,STACK_FRAME_OVERHEAD
+        bl      machine_check_exception
+        MACHINE_CHECK_HANDLER_WINDUP
+        RFI_TO_KERNEL
+        b       .
 
 EXC_REAL(data_access, 0x300, 0x80)
 EXC_VIRT(data_access, 0x4300, 0x80, 0x300)
@@ -566,28 +596,36 @@ ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_TYPE_RADIX)
 
 
 EXC_REAL_BEGIN(data_access_slb, 0x380, 0x80)
-        SET_SCRATCH0(r13)
-        EXCEPTION_PROLOG_0(PACA_EXSLB)
-        EXCEPTION_PROLOG_1(PACA_EXSLB, KVMTEST_PR, 0x380)
-        mr      r12,r3  /* save r3 */
-        mfspr   r3,SPRN_DAR
-        mfspr   r11,SPRN_SRR1
-        crset   4*cr6+eq
-        BRANCH_TO_COMMON(r10, slb_miss_common)
+EXCEPTION_PROLOG(PACA_EXSLB, data_access_slb_common, EXC_STD, KVMTEST_PR, 0x380);
 EXC_REAL_END(data_access_slb, 0x380, 0x80)
 
 EXC_VIRT_BEGIN(data_access_slb, 0x4380, 0x80)
-        SET_SCRATCH0(r13)
-        EXCEPTION_PROLOG_0(PACA_EXSLB)
-        EXCEPTION_PROLOG_1(PACA_EXSLB, NOTEST, 0x380)
-        mr      r12,r3  /* save r3 */
-        mfspr   r3,SPRN_DAR
-        mfspr   r11,SPRN_SRR1
-        crset   4*cr6+eq
-        BRANCH_TO_COMMON(r10, slb_miss_common)
+EXCEPTION_RELON_PROLOG(PACA_EXSLB, data_access_slb_common, EXC_STD, NOTEST, 0x380);
 EXC_VIRT_END(data_access_slb, 0x4380, 0x80)
+
 TRAMP_KVM_SKIP(PACA_EXSLB, 0x380)
 
+EXC_COMMON_BEGIN(data_access_slb_common)
+        mfspr   r10,SPRN_DAR
+        std     r10,PACA_EXSLB+EX_DAR(r13)
+        EXCEPTION_PROLOG_COMMON(0x380, PACA_EXSLB)
+        ld      r4,PACA_EXSLB+EX_DAR(r13)
+        std     r4,_DAR(r1)
+        addi    r3,r1,STACK_FRAME_OVERHEAD
+        bl      do_slb_fault
+        cmpdi   r3,0
+        bne-    1f
+        b       fast_exception_return
+1:      /* Error case */
+        std     r3,RESULT(r1)
+        bl      save_nvgprs
+        RECONCILE_IRQ_STATE(r10, r11)
+        ld      r4,_DAR(r1)
+        ld      r5,RESULT(r1)
+        addi    r3,r1,STACK_FRAME_OVERHEAD
+        bl      do_bad_slb_fault
+        b       ret_from_except
+
 
 EXC_REAL(instruction_access, 0x400, 0x80)
 EXC_VIRT(instruction_access, 0x4400, 0x80, 0x400)
@@ -610,160 +648,34 @@ ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_TYPE_RADIX)
 
 
 EXC_REAL_BEGIN(instruction_access_slb, 0x480, 0x80)
-        SET_SCRATCH0(r13)
-        EXCEPTION_PROLOG_0(PACA_EXSLB)
-        EXCEPTION_PROLOG_1(PACA_EXSLB, KVMTEST_PR, 0x480)
-        mr      r12,r3  /* save r3 */
-        mfspr   r3,SPRN_SRR0            /* SRR0 is faulting address */
-        mfspr   r11,SPRN_SRR1
-        crclr   4*cr6+eq
-        BRANCH_TO_COMMON(r10, slb_miss_common)
+EXCEPTION_PROLOG(PACA_EXSLB, instruction_access_slb_common, EXC_STD, KVMTEST_PR, 0x480);
 EXC_REAL_END(instruction_access_slb, 0x480, 0x80)
 
 EXC_VIRT_BEGIN(instruction_access_slb, 0x4480, 0x80)
-        SET_SCRATCH0(r13)
-        EXCEPTION_PROLOG_0(PACA_EXSLB)
-        EXCEPTION_PROLOG_1(PACA_EXSLB, NOTEST, 0x480)
-        mr      r12,r3  /* save r3 */
-        mfspr   r3,SPRN_SRR0            /* SRR0 is faulting address */
-        mfspr   r11,SPRN_SRR1
-        crclr   4*cr6+eq
-        BRANCH_TO_COMMON(r10, slb_miss_common)
+EXCEPTION_RELON_PROLOG(PACA_EXSLB, instruction_access_slb_common, EXC_STD, NOTEST, 0x480);
 EXC_VIRT_END(instruction_access_slb, 0x4480, 0x80)
-TRAMP_KVM(PACA_EXSLB, 0x480)
-
-
-/*
- * This handler is used by the 0x380 and 0x480 SLB miss interrupts, as well as
- * the virtual mode 0x4380 and 0x4480 interrupts if AIL is enabled.
- */
-EXC_COMMON_BEGIN(slb_miss_common)
-        /*
-         * r13 points to the PACA, r9 contains the saved CR,
-         * r12 contains the saved r3,
-         * r11 contain the saved SRR1, SRR0 is still ready for return
-         * r3 has the faulting address
-         * r9 - r13 are saved in paca->exslb.
-         * cr6.eq is set for a D-SLB miss, clear for a I-SLB miss
-         * We assume we aren't going to take any exceptions during this
-         * procedure.
-         */
-        mflr    r10
-        stw     r9,PACA_EXSLB+EX_CCR(r13)       /* save CR in exc. frame */
-        std     r10,PACA_EXSLB+EX_LR(r13)       /* save LR */
-
-        andi.   r9,r11,MSR_PR   // Check for exception from userspace
-        cmpdi   cr4,r9,MSR_PR   // And save the result in CR4 for later
-
-        /*
-         * Test MSR_RI before calling slb_allocate_realmode, because the
-         * MSR in r11 gets clobbered. However we still want to allocate
-         * SLB in case MSR_RI=0, to minimise the risk of getting stuck in
-         * recursive SLB faults. So use cr5 for this, which is preserved.
-         */
-        andi.   r11,r11,MSR_RI  /* check for unrecoverable exception */
-        cmpdi   cr5,r11,MSR_RI
-
-        crset   4*cr0+eq
-#ifdef CONFIG_PPC_BOOK3S_64
-BEGIN_MMU_FTR_SECTION
-        bl      slb_allocate
-END_MMU_FTR_SECTION_IFCLR(MMU_FTR_TYPE_RADIX)
-#endif
-
-        ld      r10,PACA_EXSLB+EX_LR(r13)
-        lwz     r9,PACA_EXSLB+EX_CCR(r13)       /* get saved CR */
-        mtlr    r10
-
-        /*
-         * Large address, check whether we have to allocate new contexts.
-         */
-        beq-    8f
 
-        bne-    cr5,2f          /* if unrecoverable exception, oops */
-
-        /* All done -- return from exception. */
-
-        bne     cr4,1f          /* returning to kernel */
-
-        mtcrf   0x80,r9
-        mtcrf   0x08,r9         /* MSR[PR] indication is in cr4 */
-        mtcrf   0x04,r9         /* MSR[RI] indication is in cr5 */
-        mtcrf   0x02,r9         /* I/D indication is in cr6 */
-        mtcrf   0x01,r9         /* slb_allocate uses cr0 and cr7 */
-
-        RESTORE_CTR(r9, PACA_EXSLB)
-        RESTORE_PPR_PACA(PACA_EXSLB, r9)
-        mr      r3,r12
-        ld      r9,PACA_EXSLB+EX_R9(r13)
-        ld      r10,PACA_EXSLB+EX_R10(r13)
-        ld      r11,PACA_EXSLB+EX_R11(r13)
-        ld      r12,PACA_EXSLB+EX_R12(r13)
-        ld      r13,PACA_EXSLB+EX_R13(r13)
-        RFI_TO_USER
-        b       .       /* prevent speculative execution */
-1:
-        mtcrf   0x80,r9
-        mtcrf   0x08,r9         /* MSR[PR] indication is in cr4 */
-        mtcrf   0x04,r9         /* MSR[RI] indication is in cr5 */
-        mtcrf   0x02,r9         /* I/D indication is in cr6 */
-        mtcrf   0x01,r9         /* slb_allocate uses cr0 and cr7 */
-
-        RESTORE_CTR(r9, PACA_EXSLB)
-        RESTORE_PPR_PACA(PACA_EXSLB, r9)
-        mr      r3,r12
-        ld      r9,PACA_EXSLB+EX_R9(r13)
-        ld      r10,PACA_EXSLB+EX_R10(r13)
-        ld      r11,PACA_EXSLB+EX_R11(r13)
-        ld      r12,PACA_EXSLB+EX_R12(r13)
-        ld      r13,PACA_EXSLB+EX_R13(r13)
-        RFI_TO_KERNEL
-        b       .       /* prevent speculative execution */
-
-
-2:      std     r3,PACA_EXSLB+EX_DAR(r13)
-        mr      r3,r12
-        mfspr   r11,SPRN_SRR0
-        mfspr   r12,SPRN_SRR1
-        LOAD_HANDLER(r10,unrecov_slb)
-        mtspr   SPRN_SRR0,r10
-        ld      r10,PACAKMSR(r13)
-        mtspr   SPRN_SRR1,r10
-        RFI_TO_KERNEL
-        b       .
-
-8:      std     r3,PACA_EXSLB+EX_DAR(r13)
-        mr      r3,r12
-        mfspr   r11,SPRN_SRR0
-        mfspr   r12,SPRN_SRR1
-        LOAD_HANDLER(r10, large_addr_slb)
-        mtspr   SPRN_SRR0,r10
-        ld      r10,PACAKMSR(r13)
-        mtspr   SPRN_SRR1,r10
-        RFI_TO_KERNEL
-        b       .
+TRAMP_KVM(PACA_EXSLB, 0x480)
 
-EXC_COMMON_BEGIN(unrecov_slb)
-        EXCEPTION_PROLOG_COMMON(0x4100, PACA_EXSLB)
-        RECONCILE_IRQ_STATE(r10, r11)
+EXC_COMMON_BEGIN(instruction_access_slb_common)
+        EXCEPTION_PROLOG_COMMON(0x480, PACA_EXSLB)
+        ld      r4,_NIP(r1)
+        addi    r3,r1,STACK_FRAME_OVERHEAD
+        bl      do_slb_fault
+        cmpdi   r3,0
+        bne-    1f
+        b       fast_exception_return
+1:      /* Error case */
+        std     r3,RESULT(r1)
         bl      save_nvgprs
-1:      addi    r3,r1,STACK_FRAME_OVERHEAD
-        bl      unrecoverable_exception
-        b       1b
-
-EXC_COMMON_BEGIN(large_addr_slb)
-        EXCEPTION_PROLOG_COMMON(0x380, PACA_EXSLB)
         RECONCILE_IRQ_STATE(r10, r11)
-        ld      r3, PACA_EXSLB+EX_DAR(r13)
-        std     r3, _DAR(r1)
-        beq     cr6, 2f
-        li      r10, 0x481              /* fix trap number for I-SLB miss */
-        std     r10, _TRAP(r1)
-2:      bl      save_nvgprs
-        addi    r3, r1, STACK_FRAME_OVERHEAD
-        bl      slb_miss_large_addr
+        ld      r4,_NIP(r1)
+        ld      r5,RESULT(r1)
+        addi    r3,r1,STACK_FRAME_OVERHEAD
+        bl      do_bad_slb_fault
         b       ret_from_except
 
+
 EXC_REAL_BEGIN(hardware_interrupt, 0x500, 0x100)
         .globl hardware_interrupt_hv;
 hardware_interrupt_hv:
diff --git a/arch/powerpc/kernel/fadump.c b/arch/powerpc/kernel/fadump.c
index a711d22339ea..761b28b1427d 100644
--- a/arch/powerpc/kernel/fadump.c
+++ b/arch/powerpc/kernel/fadump.c
@@ -1444,8 +1444,8 @@ static ssize_t fadump_register_store(struct kobject *kobj,
                 break;
         case 1:
                 if (fw_dump.dump_registered == 1) {
-                        ret = -EEXIST;
-                        goto unlock_out;
+                        /* Un-register Firmware-assisted dump */
+                        fadump_unregister_dump(&fdm);
                 }
                 /* Register Firmware-assisted dump */
                 ret = register_fadump();
diff --git a/arch/powerpc/kernel/head_8xx.S b/arch/powerpc/kernel/head_8xx.S
index 6582f824d620..134a573a9f2d 100644
--- a/arch/powerpc/kernel/head_8xx.S
+++ b/arch/powerpc/kernel/head_8xx.S
@@ -642,7 +642,7 @@ DTLBMissIMMR:
         mtspr   SPRN_MD_TWC, r10
         mfspr   r10, SPRN_IMMR                  /* Get current IMMR */
         rlwinm  r10, r10, 0, 0xfff80000         /* Get 512 kbytes boundary */
-        ori     r10, r10, 0xf0 | MD_SPS16K | _PAGE_PRIVILEGED | _PAGE_DIRTY | \
+        ori     r10, r10, 0xf0 | MD_SPS16K | _PAGE_SH | _PAGE_DIRTY | \
                           _PAGE_PRESENT | _PAGE_NO_CACHE
         mtspr   SPRN_MD_RPN, r10        /* Update TLB entry */
 
@@ -660,7 +660,7 @@ DTLBMissLinear:
         li      r11, MD_PS8MEG | MD_SVALID | M_APG2
         mtspr   SPRN_MD_TWC, r11
         rlwinm  r10, r10, 0, 0x0f800000 /* 8xx supports max 256Mb RAM */
-        ori     r10, r10, 0xf0 | MD_SPS16K | _PAGE_PRIVILEGED | _PAGE_DIRTY | \
+        ori     r10, r10, 0xf0 | MD_SPS16K | _PAGE_SH | _PAGE_DIRTY | \
                           _PAGE_PRESENT
         mtspr   SPRN_MD_RPN, r10        /* Update TLB entry */
 
@@ -679,7 +679,7 @@ ITLBMissLinear:
         li      r11, MI_PS8MEG | MI_SVALID | M_APG2
         mtspr   SPRN_MI_TWC, r11
         rlwinm  r10, r10, 0, 0x0f800000 /* 8xx supports max 256Mb RAM */
-        ori     r10, r10, 0xf0 | MI_SPS16K | _PAGE_PRIVILEGED | _PAGE_DIRTY | \
+        ori     r10, r10, 0xf0 | MI_SPS16K | _PAGE_SH | _PAGE_DIRTY | \
                           _PAGE_PRESENT
         mtspr   SPRN_MI_RPN, r10        /* Update TLB entry */
 
diff --git a/arch/powerpc/kernel/io-workarounds.c b/arch/powerpc/kernel/io-workarounds.c
index aa9f1b8261db..7e89d02a84e1 100644
--- a/arch/powerpc/kernel/io-workarounds.c
+++ b/arch/powerpc/kernel/io-workarounds.c
@@ -153,10 +153,10 @@ static const struct ppc_pci_io iowa_pci_io = {
 
 #ifdef CONFIG_PPC_INDIRECT_MMIO
 static void __iomem *iowa_ioremap(phys_addr_t addr, unsigned long size,
-                                  unsigned long flags, void *caller)
+                                  pgprot_t prot, void *caller)
 {
         struct iowa_bus *bus;
-        void __iomem *res = __ioremap_caller(addr, size, flags, caller);
+        void __iomem *res = __ioremap_caller(addr, size, prot, caller);
         int busno;
 
         bus = iowa_pci_find(0, (unsigned long)addr);
diff --git a/arch/powerpc/kernel/iommu.c b/arch/powerpc/kernel/iommu.c
index 19b4c628f3be..f0dc680e659a 100644
--- a/arch/powerpc/kernel/iommu.c
+++ b/arch/powerpc/kernel/iommu.c
@@ -785,9 +785,9 @@ dma_addr_t iommu_map_page(struct device *dev, struct iommu_table *tbl,
 
         vaddr = page_address(page) + offset;
         uaddr = (unsigned long)vaddr;
-        npages = iommu_num_pages(uaddr, size, IOMMU_PAGE_SIZE(tbl));
 
         if (tbl) {
+                npages = iommu_num_pages(uaddr, size, IOMMU_PAGE_SIZE(tbl));
                 align = 0;
                 if (tbl->it_page_shift < PAGE_SHIFT && size >= PAGE_SIZE &&
                     ((unsigned long)vaddr & ~PAGE_MASK) == 0)
diff --git a/arch/powerpc/kernel/isa-bridge.c b/arch/powerpc/kernel/isa-bridge.c
index 1df6c74aa731..fda3ae48480c 100644
--- a/arch/powerpc/kernel/isa-bridge.c
+++ b/arch/powerpc/kernel/isa-bridge.c
@@ -110,14 +110,14 @@ static void pci_process_ISA_OF_ranges(struct device_node *isa_node,
                 size = 0x10000;
 
         __ioremap_at(phb_io_base_phys, (void *)ISA_IO_BASE,
-                     size, pgprot_val(pgprot_noncached(__pgprot(0))));
+                     size, pgprot_noncached(PAGE_KERNEL));
         return;
 
 inval_range:
         printk(KERN_ERR "no ISA IO ranges or unexpected isa range, "
                "mapping 64k\n");
         __ioremap_at(phb_io_base_phys, (void *)ISA_IO_BASE,
-                     0x10000, pgprot_val(pgprot_noncached(__pgprot(0))));
+                     0x10000, pgprot_noncached(PAGE_KERNEL));
 }
 
 
@@ -253,7 +253,7 @@ void __init isa_bridge_init_non_pci(struct device_node *np)
          */
         isa_io_base = ISA_IO_BASE;
         __ioremap_at(pbase, (void *)ISA_IO_BASE,
-                     size, pgprot_val(pgprot_noncached(__pgprot(0))));
+                     size, pgprot_noncached(PAGE_KERNEL));
 
         pr_debug("ISA: Non-PCI bridge is %pOF\n", np);
 }
diff --git a/arch/powerpc/kernel/kgdb.c b/arch/powerpc/kernel/kgdb.c
index 35e240a0a408..59c578f865aa 100644
--- a/arch/powerpc/kernel/kgdb.c
+++ b/arch/powerpc/kernel/kgdb.c
@@ -24,6 +24,7 @@
 #include <asm/processor.h>
 #include <asm/machdep.h>
 #include <asm/debug.h>
+#include <asm/code-patching.h>
 #include <linux/slab.h>
 
 /*
@@ -144,7 +145,7 @@ static int kgdb_handle_breakpoint(struct pt_regs *regs)
         if (kgdb_handle_exception(1, SIGTRAP, 0, regs) != 0)
                 return 0;
 
-        if (*(u32 *) (regs->nip) == *(u32 *) (&arch_kgdb_ops.gdb_bpt_instr))
+        if (*(u32 *)regs->nip == BREAK_INSTR)
                 regs->nip += BREAK_INSTR_SIZE;
 
         return 1;
@@ -441,16 +442,42 @@ int kgdb_arch_handle_exception(int vector, int signo, int err_code,
         return -1;
 }
 
+int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
+{
+        int err;
+        unsigned int instr;
+        unsigned int *addr = (unsigned int *)bpt->bpt_addr;
+
+        err = probe_kernel_address(addr, instr);
+        if (err)
+                return err;
+
+        err = patch_instruction(addr, BREAK_INSTR);
+        if (err)
+                return -EFAULT;
+
+        *(unsigned int *)bpt->saved_instr = instr;
+
+        return 0;
+}
+
+int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
+{
+        int err;
+        unsigned int instr = *(unsigned int *)bpt->saved_instr;
+        unsigned int *addr = (unsigned int *)bpt->bpt_addr;
+
+        err = patch_instruction(addr, instr);
+        if (err)
+                return -EFAULT;
+
+        return 0;
+}
+
 /*
  * Global data
  */
-struct kgdb_arch arch_kgdb_ops = {
-#ifdef __LITTLE_ENDIAN__
-        .gdb_bpt_instr = {0x08, 0x10, 0x82, 0x7d},
-#else
-        .gdb_bpt_instr = {0x7d, 0x82, 0x10, 0x08},
-#endif
-};
+struct kgdb_arch arch_kgdb_ops;
 
 static int kgdb_not_implemented(struct pt_regs *regs)
 {
diff --git a/arch/powerpc/kernel/mce.c b/arch/powerpc/kernel/mce.c
index efdd16a79075..bd933a75f0bc 100644
--- a/arch/powerpc/kernel/mce.c
+++ b/arch/powerpc/kernel/mce.c
@@ -488,10 +488,11 @@ long machine_check_early(struct pt_regs *regs)
 {
         long handled = 0;
 
-        __this_cpu_inc(irq_stat.mce_exceptions);
-
-        if (cur_cpu_spec && cur_cpu_spec->machine_check_early)
-                handled = cur_cpu_spec->machine_check_early(regs);
+        /*
+         * See if platform is capable of handling machine check.
+         */
+        if (ppc_md.machine_check_early)
+                handled = ppc_md.machine_check_early(regs);
         return handled;
 }
 
diff --git a/arch/powerpc/kernel/mce_power.c b/arch/powerpc/kernel/mce_power.c
index 3497c8329c1d..6b800eec31f2 100644
--- a/arch/powerpc/kernel/mce_power.c
+++ b/arch/powerpc/kernel/mce_power.c
@@ -60,7 +60,7 @@ static unsigned long addr_to_pfn(struct pt_regs *regs, unsigned long addr)
 
 /* flush SLBs and reload */
 #ifdef CONFIG_PPC_BOOK3S_64
-static void flush_and_reload_slb(void)
+void flush_and_reload_slb(void)
 {
         /* Invalidate all SLBs */
         slb_flush_all_realmode();
@@ -89,6 +89,13 @@ static void flush_and_reload_slb(void)
 
 static void flush_erat(void)
 {
+#ifdef CONFIG_PPC_BOOK3S_64
+        if (!early_cpu_has_feature(CPU_FTR_ARCH_300)) {
+                flush_and_reload_slb();
+                return;
+        }
+#endif
+        /* PPC_INVALIDATE_ERAT can only be used on ISA v3 and newer */
         asm volatile(PPC_INVALIDATE_ERAT : : :"memory");
 }
 
diff --git a/arch/powerpc/kernel/module.c b/arch/powerpc/kernel/module.c
index 77371c9ef3d8..2d861a36662e 100644
--- a/arch/powerpc/kernel/module.c
+++ b/arch/powerpc/kernel/module.c
@@ -74,6 +74,14 @@ int module_finalize(const Elf_Ehdr *hdr,
                                   (void *)sect->sh_addr + sect->sh_size);
 #endif /* CONFIG_PPC64 */
 
+#ifdef PPC64_ELF_ABI_v1
+        sect = find_section(hdr, sechdrs, ".opd");
+        if (sect != NULL) {
+                me->arch.start_opd = sect->sh_addr;
+                me->arch.end_opd = sect->sh_addr + sect->sh_size;
+        }
+#endif /* PPC64_ELF_ABI_v1 */
+
 #ifdef CONFIG_PPC_BARRIER_NOSPEC
         sect = find_section(hdr, sechdrs, "__spec_barrier_fixup");
         if (sect != NULL)
diff --git a/arch/powerpc/kernel/module_64.c b/arch/powerpc/kernel/module_64.c
index b8d61e019d06..8661eea78503 100644
--- a/arch/powerpc/kernel/module_64.c
+++ b/arch/powerpc/kernel/module_64.c
@@ -360,11 +360,6 @@ int module_frob_arch_sections(Elf64_Ehdr *hdr,
                 else if (strcmp(secstrings+sechdrs[i].sh_name,"__versions")==0)
                         dedotify_versions((void *)hdr + sechdrs[i].sh_offset,
                                           sechdrs[i].sh_size);
-                else if (!strcmp(secstrings + sechdrs[i].sh_name, ".opd")) {
-                        me->arch.start_opd = sechdrs[i].sh_addr;
-                        me->arch.end_opd = sechdrs[i].sh_addr +
-                                           sechdrs[i].sh_size;
-                }
 
                 /* We don't handle .init for the moment: rename to _init */
                 while ((p = strstr(secstrings + sechdrs[i].sh_name, ".init")))
@@ -685,7 +680,14 @@ int apply_relocate_add(Elf64_Shdr *sechdrs,
 
                 case R_PPC64_REL32:
                         /* 32 bits relative (used by relative exception tables) */
-                        *(u32 *)location = value - (unsigned long)location;
+                        /* Convert value to relative */
+                        value -= (unsigned long)location;
+                        if (value + 0x80000000 > 0xffffffff) {
+                                pr_err("%s: REL32 %li out of range!\n",
+                                       me->name, (long int)value);
+                                return -ENOEXEC;
+                        }
+                        *(u32 *)location = value;
                         break;
 
                 case R_PPC64_TOCSAVE:
diff --git a/arch/powerpc/kernel/pci_32.c b/arch/powerpc/kernel/pci_32.c
index d63b488d34d7..4da8ed576229 100644
--- a/arch/powerpc/kernel/pci_32.c
+++ b/arch/powerpc/kernel/pci_32.c
@@ -17,7 +17,6 @@
 #include <linux/of.h>
 #include <linux/slab.h>
 #include <linux/export.h>
-#include <linux/syscalls.h>
 
 #include <asm/processor.h>
 #include <asm/io.h>
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index dff28f903512..9d8c10d55407 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -159,7 +159,7 @@ static int pcibios_map_phb_io_space(struct pci_controller *hose)
 
         /* Establish the mapping */
         if (__ioremap_at(phys_page, area->addr, size_page,
-                         pgprot_val(pgprot_noncached(__pgprot(0)))) == NULL)
+                         pgprot_noncached(PAGE_KERNEL)) == NULL)
                 return -ENOMEM;
 
         /* Fixup hose IO resource */
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 5d983d8bac27..4d5322cfad25 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -43,6 +43,7 @@
 #include <linux/uaccess.h>
 #include <linux/elf-randomize.h>
 #include <linux/pkeys.h>
+#include <linux/seq_buf.h>
 
 #include <asm/pgtable.h>
 #include <asm/io.h>
@@ -65,6 +66,7 @@
 #include <asm/livepatch.h>
 #include <asm/cpu_has_feature.h>
 #include <asm/asm-prototypes.h>
+#include <asm/stacktrace.h>
 
 #include <linux/kprobes.h>
 #include <linux/kdebug.h>
@@ -102,24 +104,18 @@ static void check_if_tm_restore_required(struct task_struct *tsk)
         }
 }
 
-static inline bool msr_tm_active(unsigned long msr)
-{
-        return MSR_TM_ACTIVE(msr);
-}
-
 static bool tm_active_with_fp(struct task_struct *tsk)
 {
-        return msr_tm_active(tsk->thread.regs->msr) &&
+        return MSR_TM_ACTIVE(tsk->thread.regs->msr) &&
                 (tsk->thread.ckpt_regs.msr & MSR_FP);
 }
 
 static bool tm_active_with_altivec(struct task_struct *tsk)
 {
-        return msr_tm_active(tsk->thread.regs->msr) &&
+        return MSR_TM_ACTIVE(tsk->thread.regs->msr) &&
                 (tsk->thread.ckpt_regs.msr & MSR_VEC);
 }
 #else
-static inline bool msr_tm_active(unsigned long msr) { return false; }
 static inline void check_if_tm_restore_required(struct task_struct *tsk) { }
 static inline bool tm_active_with_fp(struct task_struct *tsk) { return false; }
 static inline bool tm_active_with_altivec(struct task_struct *tsk) { return false; }
@@ -247,7 +243,8 @@ void enable_kernel_fp(void)
                  * giveup as this would save  to the 'live' structure not the
                  * checkpointed structure.
                  */
-                if(!msr_tm_active(cpumsr) && msr_tm_active(current->thread.regs->msr))
+                if (!MSR_TM_ACTIVE(cpumsr) &&
+                     MSR_TM_ACTIVE(current->thread.regs->msr))
                         return;
                 __giveup_fpu(current);
         }
@@ -311,7 +308,8 @@ void enable_kernel_altivec(void)
                  * giveup as this would save  to the 'live' structure not the
                  * checkpointed structure.
                  */
-                if(!msr_tm_active(cpumsr) && msr_tm_active(current->thread.regs->msr))
+                if (!MSR_TM_ACTIVE(cpumsr) &&
+                     MSR_TM_ACTIVE(current->thread.regs->msr))
                         return;
                 __giveup_altivec(current);
         }
@@ -397,7 +395,8 @@ void enable_kernel_vsx(void)
                  * giveup as this would save  to the 'live' structure not the
                  * checkpointed structure.
                  */
-                if(!msr_tm_active(cpumsr) && msr_tm_active(current->thread.regs->msr))
+                if (!MSR_TM_ACTIVE(cpumsr) &&
+                     MSR_TM_ACTIVE(current->thread.regs->msr))
                         return;
                 __giveup_vsx(current);
         }
@@ -530,7 +529,7 @@ void restore_math(struct pt_regs *regs)
 {
         unsigned long msr;
 
-        if (!msr_tm_active(regs->msr) &&
+        if (!MSR_TM_ACTIVE(regs->msr) &&
                 !current->thread.load_fp && !loadvec(current->thread))
                 return;
 
@@ -1252,17 +1251,16 @@ struct task_struct *__switch_to(struct task_struct *prev,
         return last;
 }
 
-static int instructions_to_print = 16;
+#define NR_INSN_TO_PRINT        16
 
 static void show_instructions(struct pt_regs *regs)
 {
         int i;
-        unsigned long pc = regs->nip - (instructions_to_print * 3 / 4 *
-                        sizeof(int));
+        unsigned long pc = regs->nip - (NR_INSN_TO_PRINT * 3 / 4 * sizeof(int));
 
         printk("Instruction dump:");
 
-        for (i = 0; i < instructions_to_print; i++) {
+        for (i = 0; i < NR_INSN_TO_PRINT; i++) {
                 int instr;
 
                 if (!(i % 8))
@@ -1277,7 +1275,7 @@ static void show_instructions(struct pt_regs *regs)
 #endif
 
                 if (!__kernel_text_address(pc) ||
-                     probe_kernel_address((unsigned int __user *)pc, instr)) {
+                    probe_kernel_address((const void *)pc, instr)) {
                         pr_cont("XXXXXXXX ");
                 } else {
                         if (regs->nip == pc)
@@ -1295,43 +1293,43 @@ static void show_instructions(struct pt_regs *regs)
 void show_user_instructions(struct pt_regs *regs)
 {
         unsigned long pc;
-        int i;
+        int n = NR_INSN_TO_PRINT;
+        struct seq_buf s;
+        char buf[96]; /* enough for 8 times 9 + 2 chars */
 
-        pc = regs->nip - (instructions_to_print * 3 / 4 * sizeof(int));
+        pc = regs->nip - (NR_INSN_TO_PRINT * 3 / 4 * sizeof(int));
 
         /*
          * Make sure the NIP points at userspace, not kernel text/data or
          * elsewhere.
          */
-        if (!__access_ok(pc, instructions_to_print * sizeof(int), USER_DS)) {
+        if (!__access_ok(pc, NR_INSN_TO_PRINT * sizeof(int), USER_DS)) {
                 pr_info("%s[%d]: Bad NIP, not dumping instructions.\n",
                         current->comm, current->pid);
                 return;
         }
 
-        pr_info("%s[%d]: code: ", current->comm, current->pid);
+        seq_buf_init(&s, buf, sizeof(buf));
 
-        for (i = 0; i < instructions_to_print; i++) {
-                int instr;
+        while (n) {
+                int i;
 
-                if (!(i % 8) && (i > 0)) {
-                        pr_cont("\n");
-                        pr_info("%s[%d]: code: ", current->comm, current->pid);
-                }
+                seq_buf_clear(&s);
 
-                if (probe_kernel_address((unsigned int __user *)pc, instr)) {
-                        pr_cont("XXXXXXXX ");
-                } else {
-                        if (regs->nip == pc)
-                                pr_cont("<%08x> ", instr);
-                        else
-                                pr_cont("%08x ", instr);
+                for (i = 0; i < 8 && n; i++, n--, pc += sizeof(int)) {
+                        int instr;
+
+                        if (probe_kernel_address((const void *)pc, instr)) {
+                                seq_buf_printf(&s, "XXXXXXXX ");
+                                continue;
+                        }
+                        seq_buf_printf(&s, regs->nip == pc ? "<%08x> " : "%08x ", instr);
                 }
 
-                pc += sizeof(int);
+                if (!seq_buf_has_overflowed(&s))
+                        pr_info("%s[%d]: code: %s\n", current->comm,
+                                current->pid, s.buffer);
         }
-
-        pr_cont("\n");
 }
 
 struct regbit {
@@ -1485,6 +1483,15 @@ void flush_thread(void)
 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
 }
 
+#ifdef CONFIG_PPC_BOOK3S_64
+void arch_setup_new_exec(void)
+{
+        if (radix_enabled())
+                return;
+        hash__setup_new_exec();
+}
+#endif
+
 int set_thread_uses_vas(void)
 {
 #ifdef CONFIG_PPC_BOOK3S_64
@@ -1705,7 +1712,7 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
                 p->thread.dscr = mfspr(SPRN_DSCR);
         }
         if (cpu_has_feature(CPU_FTR_HAS_PPR))
-                p->thread.ppr = INIT_PPR;
+                childregs->ppr = DEFAULT_PPR;
 
         p->thread.tidr = 0;
 #endif
@@ -1713,6 +1720,8 @@ int copy_thread(unsigned long clone_flags, unsigned long usp,
         return 0;
 }
 
+void preload_new_slb_context(unsigned long start, unsigned long sp);
+
 /*
  * Set up a thread for executing a new program
  */
@@ -1720,6 +1729,10 @@ void start_thread(struct pt_regs *regs, unsigned long start, unsigned long sp)
 {
 #ifdef CONFIG_PPC64
         unsigned long load_addr = regs->gpr[2]; /* saved by ELF_PLAT_INIT */
+
+#ifdef CONFIG_PPC_BOOK3S_64
+        preload_new_slb_context(start, sp);
+#endif
 #endif
 
         /*
@@ -1810,6 +1823,7 @@ void start_thread(struct pt_regs *regs, unsigned long start, unsigned long sp)
 #ifdef CONFIG_VSX
         current->thread.used_vsr = 0;
 #endif
+        current->thread.load_slb = 0;
         current->thread.load_fp = 0;
         memset(&current->thread.fp_state, 0, sizeof(current->thread.fp_state));
         current->thread.fp_save_area = NULL;
diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index 9b38a2e5dd35..f33ff4163a51 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -43,11 +43,13 @@
 #include <asm/btext.h>
 #include <asm/sections.h>
 #include <asm/machdep.h>
-#include <asm/opal.h>
 #include <asm/asm-prototypes.h>
 
 #include <linux/linux_logo.h>
 
+/* All of prom_init bss lives here */
+#define __prombss __section(.bss.prominit)
+
 /*
  * Eventually bump that one up
  */
@@ -87,7 +89,7 @@
 #define OF_WORKAROUNDS  0
 #else
 #define OF_WORKAROUNDS  of_workarounds
-int of_workarounds;
+static int of_workarounds __prombss;
 #endif
 
 #define OF_WA_CLAIM     1       /* do phys/virt claim separately, then map */
@@ -148,29 +150,31 @@ extern void copy_and_flush(unsigned long dest, unsigned long src,
                            unsigned long size, unsigned long offset);
 
 /* prom structure */
-static struct prom_t __initdata prom;
+static struct prom_t __prombss prom;
 
-static unsigned long prom_entry __initdata;
+static unsigned long __prombss prom_entry;
 
 #define PROM_SCRATCH_SIZE 256
 
-static char __initdata of_stdout_device[256];
-static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
+static char __prombss of_stdout_device[256];
+static char __prombss prom_scratch[PROM_SCRATCH_SIZE];
 
-static unsigned long __initdata dt_header_start;
-static unsigned long __initdata dt_struct_start, dt_struct_end;
-static unsigned long __initdata dt_string_start, dt_string_end;
+static unsigned long __prombss dt_header_start;
+static unsigned long __prombss dt_struct_start, dt_struct_end;
+static unsigned long __prombss dt_string_start, dt_string_end;
 
-static unsigned long __initdata prom_initrd_start, prom_initrd_end;
+static unsigned long __prombss prom_initrd_start, prom_initrd_end;
 
 #ifdef CONFIG_PPC64
-static int __initdata prom_iommu_force_on;
-static int __initdata prom_iommu_off;
-static unsigned long __initdata prom_tce_alloc_start;
-static unsigned long __initdata prom_tce_alloc_end;
+static int __prombss prom_iommu_force_on;
+static int __prombss prom_iommu_off;
+static unsigned long __prombss prom_tce_alloc_start;
+static unsigned long __prombss prom_tce_alloc_end;
 #endif
 
-static bool prom_radix_disable __initdata = !IS_ENABLED(CONFIG_PPC_RADIX_MMU_DEFAULT);
+#ifdef CONFIG_PPC_PSERIES
+static bool __prombss prom_radix_disable;
+#endif
 
 struct platform_support {
         bool hash_mmu;
@@ -188,26 +192,25 @@ struct platform_support {
 #define PLATFORM_LPAR           0x0001
 #define PLATFORM_POWERMAC       0x0400
 #define PLATFORM_GENERIC        0x0500
-#define PLATFORM_OPAL           0x0600
 
-static int __initdata of_platform;
+static int __prombss of_platform;
 
-static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
+static char __prombss prom_cmd_line[COMMAND_LINE_SIZE];
 
-static unsigned long __initdata prom_memory_limit;
+static unsigned long __prombss prom_memory_limit;
 
-static unsigned long __initdata alloc_top;
-static unsigned long __initdata alloc_top_high;
-static unsigned long __initdata alloc_bottom;
-static unsigned long __initdata rmo_top;
-static unsigned long __initdata ram_top;
+static unsigned long __prombss alloc_top;
+static unsigned long __prombss alloc_top_high;
+static unsigned long __prombss alloc_bottom;
+static unsigned long __prombss rmo_top;
+static unsigned long __prombss ram_top;
 
-static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
-static int __initdata mem_reserve_cnt;
+static struct mem_map_entry __prombss mem_reserve_map[MEM_RESERVE_MAP_SIZE];
+static int __prombss mem_reserve_cnt;
 
-static cell_t __initdata regbuf[1024];
+static cell_t __prombss regbuf[1024];
 
-static bool rtas_has_query_cpu_stopped;
+static bool  __prombss rtas_has_query_cpu_stopped;
 
 
 /*
@@ -522,8 +525,8 @@ static void add_string(char **str, const char *q)
 
 static char *tohex(unsigned int x)
 {
-        static char digits[] = "0123456789abcdef";
-        static char result[9];
+        static const char digits[] __initconst = "0123456789abcdef";
+        static char result[9] __prombss;
         int i;
 
         result[8] = 0;
@@ -664,6 +667,8 @@ static void __init early_cmdline_parse(void)
 #endif
         }
 
+#ifdef CONFIG_PPC_PSERIES
+        prom_radix_disable = !IS_ENABLED(CONFIG_PPC_RADIX_MMU_DEFAULT);
         opt = strstr(prom_cmd_line, "disable_radix");
         if (opt) {
                 opt += 13;
@@ -679,9 +684,10 @@ static void __init early_cmdline_parse(void)
         }
         if (prom_radix_disable)
                 prom_debug("Radix disabled from cmdline\n");
+#endif /* CONFIG_PPC_PSERIES */
 }
 
-#if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
+#ifdef CONFIG_PPC_PSERIES
 /*
  * The architecture vector has an array of PVR mask/value pairs,
  * followed by # option vectors - 1, followed by the option vectors.
@@ -782,7 +788,7 @@ struct ibm_arch_vec {
         struct option_vector6 vec6;
 } __packed;
 
-struct ibm_arch_vec __cacheline_aligned ibm_architecture_vec = {
+static const struct ibm_arch_vec ibm_architecture_vec_template __initconst = {
         .pvrs = {
                 {
                         .mask = cpu_to_be32(0xfffe0000), /* POWER5/POWER5+ */
@@ -920,9 +926,11 @@ struct ibm_arch_vec __cacheline_aligned ibm_architecture_vec = {
         },
 };
 
+static struct ibm_arch_vec __prombss ibm_architecture_vec  ____cacheline_aligned;
+
 /* Old method - ELF header with PT_NOTE sections only works on BE */
 #ifdef __BIG_ENDIAN__
-static struct fake_elf {
+static const struct fake_elf {
         Elf32_Ehdr      elfhdr;
         Elf32_Phdr      phdr[2];
         struct chrpnote {
@@ -955,7 +963,7 @@ static struct fake_elf {
                         u32     ignore_me;
                 } rpadesc;
         } rpanote;
-} fake_elf = {
+} fake_elf __initconst = {
         .elfhdr = {
                 .e_ident = { 0x7f, 'E', 'L', 'F',
                              ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
@@ -1129,14 +1137,21 @@ static void __init prom_check_platform_support(void)
         };
         int prop_len = prom_getproplen(prom.chosen,
                                        "ibm,arch-vec-5-platform-support");
+
+        /* First copy the architecture vec template */
+        ibm_architecture_vec = ibm_architecture_vec_template;
+
         if (prop_len > 1) {
                 int i;
-                u8 vec[prop_len];
+                u8 vec[8];
                 prom_debug("Found ibm,arch-vec-5-platform-support, len: %d\n",
                            prop_len);
+                if (prop_len > sizeof(vec))
+                        prom_printf("WARNING: ibm,arch-vec-5-platform-support longer than expected (len: %d)\n",
+                                    prop_len);
                 prom_getprop(prom.chosen, "ibm,arch-vec-5-platform-support",
                              &vec, sizeof(vec));
-                for (i = 0; i < prop_len; i += 2) {
+                for (i = 0; i < sizeof(vec); i += 2) {
                         prom_debug("%d: index = 0x%x val = 0x%x\n", i / 2
                                                                   , vec[i]
                                                                   , vec[i + 1]);
@@ -1225,7 +1240,7 @@ static void __init prom_send_capabilities(void)
         }
 #endif /* __BIG_ENDIAN__ */
 }
-#endif /* #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) */
+#endif /* CONFIG_PPC_PSERIES */
 
 /*
  * Memory allocation strategy... our layout is normally:
@@ -1562,88 +1577,6 @@ static void __init prom_close_stdin(void)
         }
 }
 
-#ifdef CONFIG_PPC_POWERNV
-
-#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
-static u64 __initdata prom_opal_base;
-static u64 __initdata prom_opal_entry;
-#endif
-
-/*
- * Allocate room for and instantiate OPAL
- */
-static void __init prom_instantiate_opal(void)
-{
-        phandle opal_node;
-        ihandle opal_inst;
-        u64 base, entry;
-        u64 size = 0, align = 0x10000;
-        __be64 val64;
-        u32 rets[2];
-
-        prom_debug("prom_instantiate_opal: start...\n");
-
-        opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
-        prom_debug("opal_node: %x\n", opal_node);
-        if (!PHANDLE_VALID(opal_node))
-                return;
-
-        val64 = 0;
-        prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64));
-        size = be64_to_cpu(val64);
-        if (size == 0)
-                return;
-        val64 = 0;
-        prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64));
-        align = be64_to_cpu(val64);
-
-        base = alloc_down(size, align, 0);
-        if (base == 0) {
-                prom_printf("OPAL allocation failed !\n");
-                return;
-        }
-
-        opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
-        if (!IHANDLE_VALID(opal_inst)) {
-                prom_printf("opening opal package failed (%x)\n", opal_inst);
-                return;
-        }
-
-        prom_printf("instantiating opal at 0x%llx...", base);
-
-        if (call_prom_ret("call-method", 4, 3, rets,
-                          ADDR("load-opal-runtime"),
-                          opal_inst,
-                          base >> 32, base & 0xffffffff) != 0
-            || (rets[0] == 0 && rets[1] == 0)) {
-                prom_printf(" failed\n");
-                return;
-        }
-        entry = (((u64)rets[0]) << 32) | rets[1];
-
-        prom_printf(" done\n");
-
-        reserve_mem(base, size);
-
-        prom_debug("opal base     = 0x%llx\n", base);
-        prom_debug("opal align    = 0x%llx\n", align);
-        prom_debug("opal entry    = 0x%llx\n", entry);
-        prom_debug("opal size     = 0x%llx\n", size);
-
-        prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
-                     &base, sizeof(base));
-        prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
-                     &entry, sizeof(entry));
-
-#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
-        prom_opal_base = base;
-        prom_opal_entry = entry;
-#endif
-        prom_debug("prom_instantiate_opal: end...\n");
-}
-
-#endif /* CONFIG_PPC_POWERNV */
-
 /*
  * Allocate room for and instantiate RTAS
  */
@@ -2150,10 +2083,6 @@ static int __init prom_find_machine_type(void)
                 }
         }
 #ifdef CONFIG_PPC64
-        /* Try to detect OPAL */
-        if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
-                return PLATFORM_OPAL;
-
         /* Try to figure out if it's an IBM pSeries or any other
          * PAPR compliant platform. We assume it is if :
          *  - /device_type is "chrp" (please, do NOT use that for future
@@ -2202,7 +2131,7 @@ static void __init prom_check_displays(void)
         ihandle ih;
         int i;
 
-        static unsigned char default_colors[] = {
+        static const unsigned char default_colors[] __initconst = {
                 0x00, 0x00, 0x00,
                 0x00, 0x00, 0xaa,
                 0x00, 0xaa, 0x00,
@@ -2398,7 +2327,7 @@ static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
         unsigned long soff;
         unsigned char *valp;
-        static char pname[MAX_PROPERTY_NAME];
+        static char pname[MAX_PROPERTY_NAME] __prombss;
         int l, room, has_phandle = 0;
 
         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
@@ -2481,14 +2410,11 @@ static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
                         has_phandle = 1;
         }
 
-        /* Add a "linux,phandle" property if no "phandle" property already
-         * existed (can happen with OPAL)
-         */
+        /* Add a "phandle" property if none already exist */
         if (!has_phandle) {
-                soff = dt_find_string("linux,phandle");
+                soff = dt_find_string("phandle");
                 if (soff == 0)
-                        prom_printf("WARNING: Can't find string index for"
-                                    " <linux-phandle> node %s\n", path);
+                        prom_printf("WARNING: Can't find string index for <phandle> node %s\n", path);
                 else {
                         dt_push_token(OF_DT_PROP, mem_start, mem_end);
                         dt_push_token(4, mem_start, mem_end);
@@ -2548,9 +2474,9 @@ static void __init flatten_device_tree(void)
         dt_string_start = mem_start;
         mem_start += 4; /* hole */
 
-        /* Add "linux,phandle" in there, we'll need it */
+        /* Add "phandle" in there, we'll need it */
         namep = make_room(&mem_start, &mem_end, 16, 1);
-        strcpy(namep, "linux,phandle");
+        strcpy(namep, "phandle");
         mem_start = (unsigned long)namep + strlen(namep) + 1;
 
         /* Build string array */
@@ -3172,7 +3098,7 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
          */
         early_cmdline_parse();
 
-#if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
+#ifdef CONFIG_PPC_PSERIES
         /*
          * On pSeries, inform the firmware about our capabilities
          */
@@ -3216,15 +3142,9 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
          * On non-powermacs, try to instantiate RTAS. PowerMacs don't
          * have a usable RTAS implementation.
          */
-        if (of_platform != PLATFORM_POWERMAC &&
-            of_platform != PLATFORM_OPAL)
+        if (of_platform != PLATFORM_POWERMAC)
                 prom_instantiate_rtas();
 
-#ifdef CONFIG_PPC_POWERNV
-        if (of_platform == PLATFORM_OPAL)
-                prom_instantiate_opal();
-#endif /* CONFIG_PPC_POWERNV */
-
 #ifdef CONFIG_PPC64
         /* instantiate sml */
         prom_instantiate_sml();
@@ -3237,8 +3157,7 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
          *
          * (This must be done after instanciating RTAS)
          */
-        if (of_platform != PLATFORM_POWERMAC &&
-            of_platform != PLATFORM_OPAL)
+        if (of_platform != PLATFORM_POWERMAC)
                 prom_hold_cpus();
 
         /*
@@ -3282,11 +3201,9 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
         /*
          * in case stdin is USB and still active on IBM machines...
          * Unfortunately quiesce crashes on some powermacs if we have
-         * closed stdin already (in particular the powerbook 101). It
-         * appears that the OPAL version of OFW doesn't like it either.
+         * closed stdin already (in particular the powerbook 101).
          */
-        if (of_platform != PLATFORM_POWERMAC &&
-            of_platform != PLATFORM_OPAL)
+        if (of_platform != PLATFORM_POWERMAC)
                 prom_close_stdin();
 
         /*
@@ -3304,10 +3221,8 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
         hdr = dt_header_start;
 
         /* Don't print anything after quiesce under OPAL, it crashes OFW */
-        if (of_platform != PLATFORM_OPAL) {
-                prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase);
-                prom_debug("->dt_header_start=0x%lx\n", hdr);
-        }
+        prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase);
+        prom_debug("->dt_header_start=0x%lx\n", hdr);
 
 #ifdef CONFIG_PPC32
         reloc_got2(-offset);
@@ -3315,13 +3230,7 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
         unreloc_toc();
 #endif
 
-#ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
-        /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
-        __start(hdr, kbase, 0, 0, 0,
-                prom_opal_base, prom_opal_entry);
-#else
         __start(hdr, kbase, 0, 0, 0, 0, 0);
-#endif
 
         return 0;
 }
diff --git a/arch/powerpc/kernel/prom_init_check.sh b/arch/powerpc/kernel/prom_init_check.sh
index acb6b9226352..667df97d2595 100644
--- a/arch/powerpc/kernel/prom_init_check.sh
+++ b/arch/powerpc/kernel/prom_init_check.sh
@@ -28,6 +28,18 @@ OBJ="$2"
 
 ERROR=0
 
+function check_section()
+{
+    file=$1
+    section=$2
+    size=$(objdump -h -j $section $file 2>/dev/null | awk "\$2 == \"$section\" {print \$3}")
+    size=${size:-0}
+    if [ $size -ne 0 ]; then
+        ERROR=1
+        echo "Error: Section $section not empty in prom_init.c" >&2
+    fi
+}
+
 for UNDEF in $($NM -u $OBJ | awk '{print $2}')
 do
         # On 64-bit nm gives us the function descriptors, which have
@@ -66,4 +78,8 @@ do
         fi
 done
 
+check_section $OBJ .data
+check_section $OBJ .bss
+check_section $OBJ .init.data
+
 exit $ERROR
diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
index 9667666eb18e..afb819f4ca68 100644
--- a/arch/powerpc/kernel/ptrace.c
+++ b/arch/powerpc/kernel/ptrace.c
@@ -297,7 +297,7 @@ int ptrace_get_reg(struct task_struct *task, int regno, unsigned long *data)
         }
 #endif
 
-        if (regno < (sizeof(struct pt_regs) / sizeof(unsigned long))) {
+        if (regno < (sizeof(struct user_pt_regs) / sizeof(unsigned long))) {
                 *data = ((unsigned long *)task->thread.regs)[regno];
                 return 0;
         }
@@ -360,10 +360,10 @@ static int gpr_get(struct task_struct *target, const struct user_regset *regset,
                 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
                                           &target->thread.regs->orig_gpr3,
                                           offsetof(struct pt_regs, orig_gpr3),
-                                          sizeof(struct pt_regs));
+                                          sizeof(struct user_pt_regs));
         if (!ret)
                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
-                                               sizeof(struct pt_regs), -1);
+                                               sizeof(struct user_pt_regs), -1);
 
         return ret;
 }
@@ -853,10 +853,10 @@ static int tm_cgpr_get(struct task_struct *target,
                 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
                                           &target->thread.ckpt_regs.orig_gpr3,
                                           offsetof(struct pt_regs, orig_gpr3),
-                                          sizeof(struct pt_regs));
+                                          sizeof(struct user_pt_regs));
         if (!ret)
                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
-                                               sizeof(struct pt_regs), -1);
+                                               sizeof(struct user_pt_regs), -1);
 
         return ret;
 }
@@ -1609,7 +1609,7 @@ static int ppr_get(struct task_struct *target,
                       void *kbuf, void __user *ubuf)
 {
         return user_regset_copyout(&pos, &count, &kbuf, &ubuf,
-                                   &target->thread.ppr, 0, sizeof(u64));
+                                   &target->thread.regs->ppr, 0, sizeof(u64));
 }
 
 static int ppr_set(struct task_struct *target,
@@ -1618,7 +1618,7 @@ static int ppr_set(struct task_struct *target,
                       const void *kbuf, const void __user *ubuf)
 {
         return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
-                                  &target->thread.ppr, 0, sizeof(u64));
+                                  &target->thread.regs->ppr, 0, sizeof(u64));
 }
 
 static int dscr_get(struct task_struct *target,
@@ -2508,6 +2508,7 @@ void ptrace_disable(struct task_struct *child)
 {
         /* make sure the single step bit is not set. */
         user_disable_single_step(child);
+        clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
 }
 
 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
@@ -3130,7 +3131,7 @@ long arch_ptrace(struct task_struct *child, long request,
         case PTRACE_GETREGS:    /* Get all pt_regs from the child. */
                 return copy_regset_to_user(child, &user_ppc_native_view,
                                            REGSET_GPR,
-                                           0, sizeof(struct pt_regs),
+                                           0, sizeof(struct user_pt_regs),
                                            datavp);
 
 #ifdef CONFIG_PPC64
@@ -3139,7 +3140,7 @@ long arch_ptrace(struct task_struct *child, long request,
         case PTRACE_SETREGS:    /* Set all gp regs in the child. */
                 return copy_regset_from_user(child, &user_ppc_native_view,
                                              REGSET_GPR,
-                                             0, sizeof(struct pt_regs),
+                                             0, sizeof(struct user_pt_regs),
                                              datavp);
 
         case PTRACE_GETFPREGS: /* Get the child FPU state (FPR0...31 + FPSCR) */
@@ -3264,6 +3265,16 @@ long do_syscall_trace_enter(struct pt_regs *regs)
 {
         user_exit();
 
+        if (test_thread_flag(TIF_SYSCALL_EMU)) {
+                ptrace_report_syscall(regs);
+                /*
+                 * Returning -1 will skip the syscall execution. We want to
+                 * avoid clobbering any register also, thus, not 'gotoing'
+                 * skip label.
+                 */
+                return -1;
+        }
+
         /*
          * The tracer may decide to abort the syscall, if so tracehook
          * will return !0. Note that the tracer may also just change
@@ -3324,3 +3335,42 @@ void do_syscall_trace_leave(struct pt_regs *regs)
 
         user_enter();
 }
+
+void __init pt_regs_check(void)
+{
+        BUILD_BUG_ON(offsetof(struct pt_regs, gpr) !=
+                     offsetof(struct user_pt_regs, gpr));
+        BUILD_BUG_ON(offsetof(struct pt_regs, nip) !=
+                     offsetof(struct user_pt_regs, nip));
+        BUILD_BUG_ON(offsetof(struct pt_regs, msr) !=
+                     offsetof(struct user_pt_regs, msr));
+        BUILD_BUG_ON(offsetof(struct pt_regs, msr) !=
+                     offsetof(struct user_pt_regs, msr));
+        BUILD_BUG_ON(offsetof(struct pt_regs, orig_gpr3) !=
+                     offsetof(struct user_pt_regs, orig_gpr3));
+        BUILD_BUG_ON(offsetof(struct pt_regs, ctr) !=
+                     offsetof(struct user_pt_regs, ctr));
+        BUILD_BUG_ON(offsetof(struct pt_regs, link) !=
+                     offsetof(struct user_pt_regs, link));
+        BUILD_BUG_ON(offsetof(struct pt_regs, xer) !=
+                     offsetof(struct user_pt_regs, xer));
+        BUILD_BUG_ON(offsetof(struct pt_regs, ccr) !=
+                     offsetof(struct user_pt_regs, ccr));
+#ifdef __powerpc64__
+        BUILD_BUG_ON(offsetof(struct pt_regs, softe) !=
+                     offsetof(struct user_pt_regs, softe));
+#else
+        BUILD_BUG_ON(offsetof(struct pt_regs, mq) !=
+                     offsetof(struct user_pt_regs, mq));
+#endif
+        BUILD_BUG_ON(offsetof(struct pt_regs, trap) !=
+                     offsetof(struct user_pt_regs, trap));
+        BUILD_BUG_ON(offsetof(struct pt_regs, dar) !=
+                     offsetof(struct user_pt_regs, dar));
+        BUILD_BUG_ON(offsetof(struct pt_regs, dsisr) !=
+                     offsetof(struct user_pt_regs, dsisr));
+        BUILD_BUG_ON(offsetof(struct pt_regs, result) !=
+                     offsetof(struct user_pt_regs, result));
+
+        BUILD_BUG_ON(sizeof(struct user_pt_regs) > sizeof(struct pt_regs));
+}
diff --git a/arch/powerpc/kernel/rtas.c b/arch/powerpc/kernel/rtas.c
index 8afd146bc9c7..de35bd8f047f 100644
--- a/arch/powerpc/kernel/rtas.c
+++ b/arch/powerpc/kernel/rtas.c
@@ -981,7 +981,15 @@ int rtas_ibm_suspend_me(u64 handle)
                 goto out;
         }
 
-        stop_topology_update();
+        cpu_hotplug_disable();
+
+        /* Check if we raced with a CPU-Offline Operation */
+        if (unlikely(!cpumask_equal(cpu_present_mask, cpu_online_mask))) {
+                pr_err("%s: Raced against a concurrent CPU-Offline\n",
+                       __func__);
+                atomic_set(&data.error, -EBUSY);
+                goto out_hotplug_enable;
+        }
 
         /* Call function on all CPUs.  One of us will make the
          * rtas call
@@ -994,7 +1002,8 @@ int rtas_ibm_suspend_me(u64 handle)
         if (atomic_read(&data.error) != 0)
                 printk(KERN_ERR "Error doing global join\n");
 
-        start_topology_update();
+out_hotplug_enable:
+        cpu_hotplug_enable();
 
         /* Take down CPUs not online prior to suspend */
         cpuret = rtas_offline_cpus_mask(offline_mask);
diff --git a/arch/powerpc/kernel/rtasd.c b/arch/powerpc/kernel/rtasd.c
index 44d66c33d59d..38cadae4ca4f 100644
--- a/arch/powerpc/kernel/rtasd.c
+++ b/arch/powerpc/kernel/rtasd.c
@@ -91,6 +91,8 @@ static char *rtas_event_type(int type)
                         return "Dump Notification Event";
                 case RTAS_TYPE_PRRN:
                         return "Platform Resource Reassignment Event";
+                case RTAS_TYPE_HOTPLUG:
+                        return "Hotplug Event";
         }
 
         return rtas_type[0];
@@ -150,8 +152,10 @@ static void printk_log_rtas(char *buf, int len)
         } else {
                 struct rtas_error_log *errlog = (struct rtas_error_log *)buf;
 
-                printk(RTAS_DEBUG "event: %d, Type: %s, Severity: %d\n",
-                       error_log_cnt, rtas_event_type(rtas_error_type(errlog)),
+                printk(RTAS_DEBUG "event: %d, Type: %s (%d), Severity: %d\n",
+                       error_log_cnt,
+                       rtas_event_type(rtas_error_type(errlog)),
+                       rtas_error_type(errlog),
                        rtas_error_severity(errlog));
         }
 }
@@ -274,27 +278,16 @@ void pSeries_log_error(char *buf, unsigned int err_type, int fatal)
 }
 
 #ifdef CONFIG_PPC_PSERIES
-static s32 prrn_update_scope;
-
-static void prrn_work_fn(struct work_struct *work)
+static void handle_prrn_event(s32 scope)
 {
         /*
          * For PRRN, we must pass the negative of the scope value in
          * the RTAS event.
          */
-        pseries_devicetree_update(-prrn_update_scope);
+        pseries_devicetree_update(-scope);
         numa_update_cpu_topology(false);
 }
 
-static DECLARE_WORK(prrn_work, prrn_work_fn);
-
-static void prrn_schedule_update(u32 scope)
-{
-        flush_work(&prrn_work);
-        prrn_update_scope = scope;
-        schedule_work(&prrn_work);
-}
-
 static void handle_rtas_event(const struct rtas_error_log *log)
 {
         if (rtas_error_type(log) != RTAS_TYPE_PRRN || !prrn_is_enabled())
@@ -303,7 +296,7 @@ static void handle_rtas_event(const struct rtas_error_log *log)
         /* For PRRN Events the extended log length is used to denote
          * the scope for calling rtas update-nodes.
          */
-        prrn_schedule_update(rtas_error_extended_log_length(log));
+        handle_prrn_event(rtas_error_extended_log_length(log));
 }
 
 #else
diff --git a/arch/powerpc/kernel/setup-common.c b/arch/powerpc/kernel/setup-common.c
index 93fa0c99681e..9ca9db707bcb 100644
--- a/arch/powerpc/kernel/setup-common.c
+++ b/arch/powerpc/kernel/setup-common.c
@@ -33,6 +33,7 @@
 #include <linux/serial_8250.h>
 #include <linux/percpu.h>
 #include <linux/memblock.h>
+#include <linux/bootmem.h>
 #include <linux/of_platform.h>
 #include <linux/hugetlb.h>
 #include <asm/debugfs.h>
@@ -966,6 +967,8 @@ void __init setup_arch(char **cmdline_p)
 
         initmem_init();
 
+        early_memtest(min_low_pfn << PAGE_SHIFT, max_low_pfn << PAGE_SHIFT);
+
 #ifdef CONFIG_DUMMY_CONSOLE
         conswitchp = &dummy_con;
 #endif
diff --git a/arch/powerpc/kernel/setup_64.c b/arch/powerpc/kernel/setup_64.c
index 6a501b25dd85..faf00222b324 100644
--- a/arch/powerpc/kernel/setup_64.c
+++ b/arch/powerpc/kernel/setup_64.c
@@ -243,13 +243,19 @@ static void cpu_ready_for_interrupts(void)
         }
 
         /*
-         * Fixup HFSCR:TM based on CPU features. The bit is set by our
-         * early asm init because at that point we haven't updated our
-         * CPU features from firmware and device-tree. Here we have,
-         * so let's do it.
+         * Set HFSCR:TM based on CPU features:
+         * In the special case of TM no suspend (P9N DD2.1), Linux is
+         * told TM is off via the dt-ftrs but told to (partially) use
+         * it via OPAL_REINIT_CPUS_TM_SUSPEND_DISABLED. So HFSCR[TM]
+         * will be off from dt-ftrs but we need to turn it on for the
+         * no suspend case.
          */
-        if (cpu_has_feature(CPU_FTR_HVMODE) && !cpu_has_feature(CPU_FTR_TM_COMP))
-                mtspr(SPRN_HFSCR, mfspr(SPRN_HFSCR) & ~HFSCR_TM);
+        if (cpu_has_feature(CPU_FTR_HVMODE)) {
+                if (cpu_has_feature(CPU_FTR_TM_COMP))
+                        mtspr(SPRN_HFSCR, mfspr(SPRN_HFSCR) | HFSCR_TM);
+                else
+                        mtspr(SPRN_HFSCR, mfspr(SPRN_HFSCR) & ~HFSCR_TM);
+        }
 
         /* Set IR and DR in PACA MSR */
         get_paca()->kernel_msr = MSR_KERNEL;
diff --git a/arch/powerpc/kernel/smp.c b/arch/powerpc/kernel/smp.c
index 61c1fadbc644..3f15edf25a0d 100644
--- a/arch/powerpc/kernel/smp.c
+++ b/arch/powerpc/kernel/smp.c
@@ -34,6 +34,8 @@
 #include <linux/topology.h>
 #include <linux/profile.h>
 #include <linux/processor.h>
+#include <linux/random.h>
+#include <linux/stackprotector.h>
 
 #include <asm/ptrace.h>
 #include <linux/atomic.h>
@@ -74,14 +76,32 @@ static DEFINE_PER_CPU(int, cpu_state) = { 0 };
 #endif
 
 struct thread_info *secondary_ti;
+bool has_big_cores;
 
 DEFINE_PER_CPU(cpumask_var_t, cpu_sibling_map);
+DEFINE_PER_CPU(cpumask_var_t, cpu_smallcore_map);
 DEFINE_PER_CPU(cpumask_var_t, cpu_l2_cache_map);
 DEFINE_PER_CPU(cpumask_var_t, cpu_core_map);
 
 EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
 EXPORT_PER_CPU_SYMBOL(cpu_l2_cache_map);
 EXPORT_PER_CPU_SYMBOL(cpu_core_map);
+EXPORT_SYMBOL_GPL(has_big_cores);
+
+#define MAX_THREAD_LIST_SIZE    8
+#define THREAD_GROUP_SHARE_L1   1
+struct thread_groups {
+        unsigned int property;
+        unsigned int nr_groups;
+        unsigned int threads_per_group;
+        unsigned int thread_list[MAX_THREAD_LIST_SIZE];
+};
+
+/*
+ * On big-cores system, cpu_l1_cache_map for each CPU corresponds to
+ * the set its siblings that share the L1-cache.
+ */
+DEFINE_PER_CPU(cpumask_var_t, cpu_l1_cache_map);
 
 /* SMP operations for this machine */
 struct smp_ops_t *smp_ops;
@@ -674,6 +694,185 @@ static void set_cpus_unrelated(int i, int j,
 }
 #endif
 
+/*
+ * parse_thread_groups: Parses the "ibm,thread-groups" device tree
+ *                      property for the CPU device node @dn and stores
+ *                      the parsed output in the thread_groups
+ *                      structure @tg if the ibm,thread-groups[0]
+ *                      matches @property.
+ *
+ * @dn: The device node of the CPU device.
+ * @tg: Pointer to a thread group structure into which the parsed
+ *      output of "ibm,thread-groups" is stored.
+ * @property: The property of the thread-group that the caller is
+ *            interested in.
+ *
+ * ibm,thread-groups[0..N-1] array defines which group of threads in
+ * the CPU-device node can be grouped together based on the property.
+ *
+ * ibm,thread-groups[0] tells us the property based on which the
+ * threads are being grouped together. If this value is 1, it implies
+ * that the threads in the same group share L1, translation cache.
+ *
+ * ibm,thread-groups[1] tells us how many such thread groups exist.
+ *
+ * ibm,thread-groups[2] tells us the number of threads in each such
+ * group.
+ *
+ * ibm,thread-groups[3..N-1] is the list of threads identified by
+ * "ibm,ppc-interrupt-server#s" arranged as per their membership in
+ * the grouping.
+ *
+ * Example: If ibm,thread-groups = [1,2,4,5,6,7,8,9,10,11,12] it
+ * implies that there are 2 groups of 4 threads each, where each group
+ * of threads share L1, translation cache.
+ *
+ * The "ibm,ppc-interrupt-server#s" of the first group is {5,6,7,8}
+ * and the "ibm,ppc-interrupt-server#s" of the second group is {9, 10,
+ * 11, 12} structure
+ *
+ * Returns 0 on success, -EINVAL if the property does not exist,
+ * -ENODATA if property does not have a value, and -EOVERFLOW if the
+ * property data isn't large enough.
+ */
+static int parse_thread_groups(struct device_node *dn,
+                               struct thread_groups *tg,
+                               unsigned int property)
+{
+        int i;
+        u32 thread_group_array[3 + MAX_THREAD_LIST_SIZE];
+        u32 *thread_list;
+        size_t total_threads;
+        int ret;
+
+        ret = of_property_read_u32_array(dn, "ibm,thread-groups",
+                                         thread_group_array, 3);
+        if (ret)
+                return ret;
+
+        tg->property = thread_group_array[0];
+        tg->nr_groups = thread_group_array[1];
+        tg->threads_per_group = thread_group_array[2];
+        if (tg->property != property ||
+            tg->nr_groups < 1 ||
+            tg->threads_per_group < 1)
+                return -ENODATA;
+
+        total_threads = tg->nr_groups * tg->threads_per_group;
+
+        ret = of_property_read_u32_array(dn, "ibm,thread-groups",
+                                         thread_group_array,
+                                         3 + total_threads);
+        if (ret)
+                return ret;
+
+        thread_list = &thread_group_array[3];
+
+        for (i = 0 ; i < total_threads; i++)
+                tg->thread_list[i] = thread_list[i];
+
+        return 0;
+}
+
+/*
+ * get_cpu_thread_group_start : Searches the thread group in tg->thread_list
+ *                              that @cpu belongs to.
+ *
+ * @cpu : The logical CPU whose thread group is being searched.
+ * @tg : The thread-group structure of the CPU node which @cpu belongs
+ *       to.
+ *
+ * Returns the index to tg->thread_list that points to the the start
+ * of the thread_group that @cpu belongs to.
+ *
+ * Returns -1 if cpu doesn't belong to any of the groups pointed to by
+ * tg->thread_list.
+ */
+static int get_cpu_thread_group_start(int cpu, struct thread_groups *tg)
+{
+        int hw_cpu_id = get_hard_smp_processor_id(cpu);
+        int i, j;
+
+        for (i = 0; i < tg->nr_groups; i++) {
+                int group_start = i * tg->threads_per_group;
+
+                for (j = 0; j < tg->threads_per_group; j++) {
+                        int idx = group_start + j;
+
+                        if (tg->thread_list[idx] == hw_cpu_id)
+                                return group_start;
+                }
+        }
+
+        return -1;
+}
+
+static int init_cpu_l1_cache_map(int cpu)
+
+{
+        struct device_node *dn = of_get_cpu_node(cpu, NULL);
+        struct thread_groups tg = {.property = 0,
+                                   .nr_groups = 0,
+                                   .threads_per_group = 0};
+        int first_thread = cpu_first_thread_sibling(cpu);
+        int i, cpu_group_start = -1, err = 0;
+
+        if (!dn)
+                return -ENODATA;
+
+        err = parse_thread_groups(dn, &tg, THREAD_GROUP_SHARE_L1);
+        if (err)
+                goto out;
+
+        zalloc_cpumask_var_node(&per_cpu(cpu_l1_cache_map, cpu),
+                                GFP_KERNEL,
+                                cpu_to_node(cpu));
+
+        cpu_group_start = get_cpu_thread_group_start(cpu, &tg);
+
+        if (unlikely(cpu_group_start == -1)) {
+                WARN_ON_ONCE(1);
+                err = -ENODATA;
+                goto out;
+        }
+
+        for (i = first_thread; i < first_thread + threads_per_core; i++) {
+                int i_group_start = get_cpu_thread_group_start(i, &tg);
+
+                if (unlikely(i_group_start == -1)) {
+                        WARN_ON_ONCE(1);
+                        err = -ENODATA;
+                        goto out;
+                }
+
+                if (i_group_start == cpu_group_start)
+                        cpumask_set_cpu(i, per_cpu(cpu_l1_cache_map, cpu));
+        }
+
+out:
+        of_node_put(dn);
+        return err;
+}
+
+static int init_big_cores(void)
+{
+        int cpu;
+
+        for_each_possible_cpu(cpu) {
+                int err = init_cpu_l1_cache_map(cpu);
+
+                if (err)
+                        return err;
+
+                zalloc_cpumask_var_node(&per_cpu(cpu_smallcore_map, cpu),
+                                        GFP_KERNEL,
+                                        cpu_to_node(cpu));
+        }
+
+        has_big_cores = true;
+        return 0;
+}
+
 void __init smp_prepare_cpus(unsigned int max_cpus)
 {
         unsigned int cpu;
@@ -712,6 +911,12 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
         cpumask_set_cpu(boot_cpuid, cpu_l2_cache_mask(boot_cpuid));
         cpumask_set_cpu(boot_cpuid, cpu_core_mask(boot_cpuid));
 
+        init_big_cores();
+        if (has_big_cores) {
+                cpumask_set_cpu(boot_cpuid,
+                                cpu_smallcore_mask(boot_cpuid));
+        }
+
         if (smp_ops && smp_ops->probe)
                 smp_ops->probe();
 }
@@ -995,10 +1200,28 @@ static void remove_cpu_from_masks(int cpu)
                 set_cpus_unrelated(cpu, i, cpu_core_mask);
                 set_cpus_unrelated(cpu, i, cpu_l2_cache_mask);
                 set_cpus_unrelated(cpu, i, cpu_sibling_mask);
+                if (has_big_cores)
+                        set_cpus_unrelated(cpu, i, cpu_smallcore_mask);
         }
 }
 #endif
 
+static inline void add_cpu_to_smallcore_masks(int cpu)
+{
+        struct cpumask *this_l1_cache_map = per_cpu(cpu_l1_cache_map, cpu);
+        int i, first_thread = cpu_first_thread_sibling(cpu);
+
+        if (!has_big_cores)
+                return;
+
+        cpumask_set_cpu(cpu, cpu_smallcore_mask(cpu));
+
+        for (i = first_thread; i < first_thread + threads_per_core; i++) {
+                if (cpu_online(i) && cpumask_test_cpu(i, this_l1_cache_map))
+                        set_cpus_related(i, cpu, cpu_smallcore_mask);
+        }
+}
+
 static void add_cpu_to_masks(int cpu)
 {
         int first_thread = cpu_first_thread_sibling(cpu);
@@ -1015,6 +1238,7 @@ static void add_cpu_to_masks(int cpu)
                 if (cpu_online(i))
                         set_cpus_related(i, cpu, cpu_sibling_mask);
 
+        add_cpu_to_smallcore_masks(cpu);
         /*
          * Copy the thread sibling mask into the cache sibling mask
          * and mark any CPUs that share an L2 with this CPU.
@@ -1044,6 +1268,7 @@ static bool shared_caches;
 void start_secondary(void *unused)
 {
         unsigned int cpu = smp_processor_id();
+        struct cpumask *(*sibling_mask)(int) = cpu_sibling_mask;
 
         mmgrab(&init_mm);
         current->active_mm = &init_mm;
@@ -1069,11 +1294,13 @@ void start_secondary(void *unused)
         /* Update topology CPU masks */
         add_cpu_to_masks(cpu);
 
+        if (has_big_cores)
+                sibling_mask = cpu_smallcore_mask;
         /*
          * Check for any shared caches. Note that this must be done on a
          * per-core basis because one core in the pair might be disabled.
          */
-        if (!cpumask_equal(cpu_l2_cache_mask(cpu), cpu_sibling_mask(cpu)))
+        if (!cpumask_equal(cpu_l2_cache_mask(cpu), sibling_mask(cpu)))
                 shared_caches = true;
 
         set_numa_node(numa_cpu_lookup_table[cpu]);
@@ -1083,6 +1310,8 @@ void start_secondary(void *unused)
         notify_cpu_starting(cpu);
         set_cpu_online(cpu, true);
 
+        boot_init_stack_canary();
+
         local_irq_enable();
 
         /* We can enable ftrace for secondary cpus now */
@@ -1140,6 +1369,13 @@ static const struct cpumask *shared_cache_mask(int cpu)
         return cpu_l2_cache_mask(cpu);
 }
 
+#ifdef CONFIG_SCHED_SMT
+static const struct cpumask *smallcore_smt_mask(int cpu)
+{
+        return cpu_smallcore_mask(cpu);
+}
+#endif
+
 static struct sched_domain_topology_level power9_topology[] = {
 #ifdef CONFIG_SCHED_SMT
         { cpu_smt_mask, powerpc_smt_flags, SD_INIT_NAME(SMT) },
@@ -1167,6 +1403,13 @@ void __init smp_cpus_done(unsigned int max_cpus)
         shared_proc_topology_init();
         dump_numa_cpu_topology();
 
+#ifdef CONFIG_SCHED_SMT
+        if (has_big_cores) {
+                pr_info("Using small cores at SMT level\n");
+                power9_topology[0].mask = smallcore_smt_mask;
+                powerpc_topology[0].mask = smallcore_smt_mask;
+        }
+#endif
         /*
          * If any CPU detects that it's sharing a cache with another CPU then
          * use the deeper topology that is aware of this sharing.
diff --git a/arch/powerpc/kernel/swsusp_asm64.S b/arch/powerpc/kernel/swsusp_asm64.S
index f83bf6f72cb0..185216becb8b 100644
--- a/arch/powerpc/kernel/swsusp_asm64.S
+++ b/arch/powerpc/kernel/swsusp_asm64.S
@@ -262,7 +262,7 @@ END_FW_FTR_SECTION_IFCLR(FW_FEATURE_LPAR)
 
         addi    r1,r1,-128
 #ifdef CONFIG_PPC_BOOK3S_64
-        bl      slb_flush_and_rebolt
+        bl      slb_flush_and_restore_bolted
 #endif
         bl      do_after_copyback
         addi    r1,r1,128
diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index 70f145e02487..3646affae963 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -111,6 +111,7 @@ struct clock_event_device decrementer_clockevent = {
         .rating                 = 200,
         .irq                    = 0,
         .set_next_event         = decrementer_set_next_event,
+        .set_state_oneshot_stopped = decrementer_shutdown,
         .set_state_shutdown     = decrementer_shutdown,
         .tick_resume            = decrementer_shutdown,
         .features               = CLOCK_EVT_FEAT_ONESHOT |
@@ -175,7 +176,7 @@ static void calc_cputime_factors(void)
  * Read the SPURR on systems that have it, otherwise the PURR,
  * or if that doesn't exist return the timebase value passed in.
  */
-static unsigned long read_spurr(unsigned long tb)
+static inline unsigned long read_spurr(unsigned long tb)
 {
         if (cpu_has_feature(CPU_FTR_SPURR))
                 return mfspr(SPRN_SPURR);
@@ -281,26 +282,17 @@ static inline u64 calculate_stolen_time(u64 stop_tb)
  * Account time for a transition between system, hard irq
  * or soft irq state.
  */
-static unsigned long vtime_delta(struct task_struct *tsk,
-                                 unsigned long *stime_scaled,
-                                 unsigned long *steal_time)
+static unsigned long vtime_delta_scaled(struct cpu_accounting_data *acct,
+                                        unsigned long now, unsigned long stime)
 {
-        unsigned long now, nowscaled, deltascaled;
-        unsigned long stime;
+        unsigned long stime_scaled = 0;
+#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
+        unsigned long nowscaled, deltascaled;
         unsigned long utime, utime_scaled;
-        struct cpu_accounting_data *acct = get_accounting(tsk);
 
-        WARN_ON_ONCE(!irqs_disabled());
-
-        now = mftb();
         nowscaled = read_spurr(now);
-        stime = now - acct->starttime;
-        acct->starttime = now;
         deltascaled = nowscaled - acct->startspurr;
         acct->startspurr = nowscaled;
-
-        *steal_time = calculate_stolen_time(now);
-
         utime = acct->utime - acct->utime_sspurr;
         acct->utime_sspurr = acct->utime;
 
@@ -314,17 +306,38 @@ static unsigned long vtime_delta(struct task_struct *tsk,
          * the user ticks get saved up in paca->user_time_scaled to be
          * used by account_process_tick.
          */
-        *stime_scaled = stime;
+        stime_scaled = stime;
         utime_scaled = utime;
         if (deltascaled != stime + utime) {
                 if (utime) {
-                        *stime_scaled = deltascaled * stime / (stime + utime);
-                        utime_scaled = deltascaled - *stime_scaled;
+                        stime_scaled = deltascaled * stime / (stime + utime);
+                        utime_scaled = deltascaled - stime_scaled;
                 } else {
-                        *stime_scaled = deltascaled;
+                        stime_scaled = deltascaled;
                 }
         }
         acct->utime_scaled += utime_scaled;
+#endif
+
+        return stime_scaled;
+}
+
+static unsigned long vtime_delta(struct task_struct *tsk,
+                                 unsigned long *stime_scaled,
+                                 unsigned long *steal_time)
+{
+        unsigned long now, stime;
+        struct cpu_accounting_data *acct = get_accounting(tsk);
+
+        WARN_ON_ONCE(!irqs_disabled());
+
+        now = mftb();
+        stime = now - acct->starttime;
+        acct->starttime = now;
+
+        *stime_scaled = vtime_delta_scaled(acct, now, stime);
+
+        *steal_time = calculate_stolen_time(now);
 
         return stime;
 }
@@ -341,7 +354,9 @@ void vtime_account_system(struct task_struct *tsk)
 
         if ((tsk->flags & PF_VCPU) && !irq_count()) {
                 acct->gtime += stime;
+#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
                 acct->utime_scaled += stime_scaled;
+#endif
         } else {
                 if (hardirq_count())
                         acct->hardirq_time += stime;
@@ -350,7 +365,9 @@ void vtime_account_system(struct task_struct *tsk)
                 else
                         acct->stime += stime;
 
+#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
                 acct->stime_scaled += stime_scaled;
+#endif
         }
 }
 EXPORT_SYMBOL_GPL(vtime_account_system);
@@ -364,6 +381,21 @@ void vtime_account_idle(struct task_struct *tsk)
         acct->idle_time += stime + steal_time;
 }
 
+static void vtime_flush_scaled(struct task_struct *tsk,
+                               struct cpu_accounting_data *acct)
+{
+#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
+        if (acct->utime_scaled)
+                tsk->utimescaled += cputime_to_nsecs(acct->utime_scaled);
+        if (acct->stime_scaled)
+                tsk->stimescaled += cputime_to_nsecs(acct->stime_scaled);
+
+        acct->utime_scaled = 0;
+        acct->utime_sspurr = 0;
+        acct->stime_scaled = 0;
+#endif
+}
+
 /*
  * Account the whole cputime accumulated in the paca
  * Must be called with interrupts disabled.
@@ -378,14 +410,13 @@ void vtime_flush(struct task_struct *tsk)
         if (acct->utime)
                 account_user_time(tsk, cputime_to_nsecs(acct->utime));
 
-        if (acct->utime_scaled)
-                tsk->utimescaled += cputime_to_nsecs(acct->utime_scaled);
-
         if (acct->gtime)
                 account_guest_time(tsk, cputime_to_nsecs(acct->gtime));
 
-        if (acct->steal_time)
+        if (IS_ENABLED(CONFIG_PPC_SPLPAR) && acct->steal_time) {
                 account_steal_time(cputime_to_nsecs(acct->steal_time));
+                acct->steal_time = 0;
+        }
 
         if (acct->idle_time)
                 account_idle_time(cputime_to_nsecs(acct->idle_time));
@@ -393,8 +424,6 @@ void vtime_flush(struct task_struct *tsk)
         if (acct->stime)
                 account_system_index_time(tsk, cputime_to_nsecs(acct->stime),
                                           CPUTIME_SYSTEM);
-        if (acct->stime_scaled)
-                tsk->stimescaled += cputime_to_nsecs(acct->stime_scaled);
 
         if (acct->hardirq_time)
                 account_system_index_time(tsk, cputime_to_nsecs(acct->hardirq_time),
@@ -403,14 +432,12 @@ void vtime_flush(struct task_struct *tsk)
                 account_system_index_time(tsk, cputime_to_nsecs(acct->softirq_time),
                                           CPUTIME_SOFTIRQ);
 
+        vtime_flush_scaled(tsk, acct);
+
         acct->utime = 0;
-        acct->utime_scaled = 0;
-        acct->utime_sspurr = 0;
         acct->gtime = 0;
-        acct->steal_time = 0;
         acct->idle_time = 0;
         acct->stime = 0;
-        acct->stime_scaled = 0;
         acct->hardirq_time = 0;
         acct->softirq_time = 0;
 }
@@ -984,10 +1011,14 @@ static void register_decrementer_clockevent(int cpu)
         *dec = decrementer_clockevent;
         dec->cpumask = cpumask_of(cpu);
 
+        clockevents_config_and_register(dec, ppc_tb_freq, 2, decrementer_max);
+
         printk_once(KERN_DEBUG "clockevent: %s mult[%x] shift[%d] cpu[%d]\n",
                     dec->name, dec->mult, dec->shift, cpu);
 
-        clockevents_register_device(dec);
+        /* Set values for KVM, see kvm_emulate_dec() */
+        decrementer_clockevent.mult = dec->mult;
+        decrementer_clockevent.shift = dec->shift;
 }
 
 static void enable_large_decrementer(void)
@@ -1035,18 +1066,7 @@ static void __init set_decrementer_max(void)
 
 static void __init init_decrementer_clockevent(void)
 {
-        int cpu = smp_processor_id();
-
-        clockevents_calc_mult_shift(&decrementer_clockevent, ppc_tb_freq, 4);
-
-        decrementer_clockevent.max_delta_ns =
-                clockevent_delta2ns(decrementer_max, &decrementer_clockevent);
-        decrementer_clockevent.max_delta_ticks = decrementer_max;
-        decrementer_clockevent.min_delta_ns =
-                clockevent_delta2ns(2, &decrementer_clockevent);
-        decrementer_clockevent.min_delta_ticks = 2;
-
-        register_decrementer_clockevent(cpu);
+        register_decrementer_clockevent(smp_processor_id());
 }
 
 void secondary_cpu_time_init(void)
diff --git a/arch/powerpc/kernel/tm.S b/arch/powerpc/kernel/tm.S
index 7716374786bd..9fabdce255cd 100644
--- a/arch/powerpc/kernel/tm.S
+++ b/arch/powerpc/kernel/tm.S
@@ -92,13 +92,14 @@ _GLOBAL(tm_abort)
         blr
 EXPORT_SYMBOL_GPL(tm_abort);
 
-/* void tm_reclaim(struct thread_struct *thread,
+/*
+ * void tm_reclaim(struct thread_struct *thread,
  *                 uint8_t cause)
  *
  *      - Performs a full reclaim.  This destroys outstanding
- *        transactions and updates thread->regs.tm_ckpt_* with the
- *        original checkpointed state.  Note that thread->regs is
- *        unchanged.
+ *        transactions and updates thread.ckpt_regs, thread.ckfp_state and
+ *        thread.ckvr_state with the original checkpointed state.  Note that
+ *        thread->regs is unchanged.
  *
  * Purpose is to both abort transactions of, and preserve the state of,
  * a transactions at a context switch. We preserve/restore both sets of process
@@ -163,15 +164,16 @@ _GLOBAL(tm_reclaim)
          */
         TRECLAIM(R4)                            /* Cause in r4 */
 
-        /* ******************** GPRs ******************** */
-        /* Stash the checkpointed r13 away in the scratch SPR and get the real
-         *  paca
+        /*
+         * ******************** GPRs ********************
+         * Stash the checkpointed r13 in the scratch SPR and get the real paca.
          */
         SET_SCRATCH0(r13)
         GET_PACA(r13)
 
-        /* Stash the checkpointed r1 away in paca tm_scratch and get the real
-         * stack pointer back
+        /*
+         * Stash the checkpointed r1 away in paca->tm_scratch and get the real
+         * stack pointer back into r1.
          */
         std     r1, PACATMSCRATCH(r13)
         ld      r1, PACAR1(r13)
@@ -209,14 +211,15 @@ _GLOBAL(tm_reclaim)
 
         addi    r7, r12, PT_CKPT_REGS           /* Thread's ckpt_regs */
 
-        /* Make r7 look like an exception frame so that we
-         * can use the neat GPRx(n) macros.  r7 is NOT a pt_regs ptr!
+        /*
+         * Make r7 look like an exception frame so that we can use the neat
+         * GPRx(n) macros. r7 is NOT a pt_regs ptr!
          */
         subi    r7, r7, STACK_FRAME_OVERHEAD
 
         /* Sync the userland GPRs 2-12, 14-31 to thread->regs: */
         SAVE_GPR(0, r7)                         /* user r0 */
-        SAVE_GPR(2, r7)                 /* user r2 */
+        SAVE_GPR(2, r7)                         /* user r2 */
         SAVE_4GPRS(3, r7)                       /* user r3-r6 */
         SAVE_GPR(8, r7)                         /* user r8 */
         SAVE_GPR(9, r7)                         /* user r9 */
@@ -237,7 +240,8 @@ _GLOBAL(tm_reclaim)
         /* ******************** NIP ******************** */
         mfspr   r3, SPRN_TFHAR
         std     r3, _NIP(r7)                    /* Returns to failhandler */
-        /* The checkpointed NIP is ignored when rescheduling/rechkpting,
+        /*
+         * The checkpointed NIP is ignored when rescheduling/rechkpting,
          * but is used in signal return to 'wind back' to the abort handler.
          */
 
@@ -260,12 +264,13 @@ _GLOBAL(tm_reclaim)
         std     r3, THREAD_TM_TAR(r12)
         std     r4, THREAD_TM_DSCR(r12)
 
-        /* MSR and flags:  We don't change CRs, and we don't need to alter
-         * MSR.
+        /*
+         * MSR and flags: We don't change CRs, and we don't need to alter MSR.
          */
 
 
-        /* ******************** FPR/VR/VSRs ************
+        /*
+         * ******************** FPR/VR/VSRs ************
          * After reclaiming, capture the checkpointed FPRs/VRs.
          *
          * We enabled VEC/FP/VSX in the msr above, so we can execute these
@@ -275,7 +280,7 @@ _GLOBAL(tm_reclaim)
 
         /* Altivec (VEC/VMX/VR)*/
         addi    r7, r3, THREAD_CKVRSTATE
-        SAVE_32VRS(0, r6, r7)   /* r6 scratch, r7 transact vr state */
+        SAVE_32VRS(0, r6, r7)   /* r6 scratch, r7 ckvr_state */
         mfvscr  v0
         li      r6, VRSTATE_VSCR
         stvx    v0, r7, r6
@@ -286,12 +291,13 @@ _GLOBAL(tm_reclaim)
 
         /* Floating Point (FP) */
         addi    r7, r3, THREAD_CKFPSTATE
-        SAVE_32FPRS_VSRS(0, R6, R7)     /* r6 scratch, r7 transact fp state */
+        SAVE_32FPRS_VSRS(0, R6, R7)     /* r6 scratch, r7 ckfp_state */
         mffs    fr0
         stfd    fr0,FPSTATE_FPSCR(r7)
 
 
-        /* TM regs, incl TEXASR -- these live in thread_struct.  Note they've
+        /*
+         * TM regs, incl TEXASR -- these live in thread_struct.  Note they've
          * been updated by the treclaim, to explain to userland the failure
          * cause (aborted).
          */
@@ -327,7 +333,7 @@ _GLOBAL(tm_reclaim)
         blr
 
 
-       /*
+        /*
          * void __tm_recheckpoint(struct thread_struct *thread)
          *      - Restore the checkpointed register state saved by tm_reclaim
          *        when we switch_to a process.
@@ -343,7 +349,8 @@ _GLOBAL(__tm_recheckpoint)
         std     r2, STK_GOT(r1)
         stdu    r1, -TM_FRAME_SIZE(r1)
 
-        /* We've a struct pt_regs at [r1+STACK_FRAME_OVERHEAD].
+        /*
+         * We've a struct pt_regs at [r1+STACK_FRAME_OVERHEAD].
          * This is used for backing up the NVGPRs:
          */
         SAVE_NVGPRS(r1)
@@ -352,8 +359,9 @@ _GLOBAL(__tm_recheckpoint)
 
         addi    r7, r3, PT_CKPT_REGS            /* Thread's ckpt_regs */
 
-        /* Make r7 look like an exception frame so that we
-         * can use the neat GPRx(n) macros.  r7 is now NOT a pt_regs ptr!
+        /*
+         * Make r7 look like an exception frame so that we can use the neat
+         * GPRx(n) macros. r7 is now NOT a pt_regs ptr!
          */
         subi    r7, r7, STACK_FRAME_OVERHEAD
 
@@ -421,14 +429,15 @@ restore_gprs:
 
         REST_NVGPRS(r7)                         /* GPR14-31 */
 
-        /* Load up PPR and DSCR here so we don't run with user values for long
-         */
+        /* Load up PPR and DSCR here so we don't run with user values for long */
         mtspr   SPRN_DSCR, r5
         mtspr   SPRN_PPR, r6
 
-        /* Do final sanity check on TEXASR to make sure FS is set.  Do this
+        /*
+         * Do final sanity check on TEXASR to make sure FS is set. Do this
          * here before we load up the userspace r1 so any bugs we hit will get
-         * a call chain */
+         * a call chain.
+         */
         mfspr   r5, SPRN_TEXASR
         srdi    r5, r5, 16
         li      r6, (TEXASR_FS)@h
@@ -436,8 +445,9 @@ restore_gprs:
 1:      tdeqi   r6, 0
         EMIT_BUG_ENTRY 1b,__FILE__,__LINE__,0
 
-        /* Do final sanity check on MSR to make sure we are not transactional
-         * or suspended
+        /*
+         * Do final sanity check on MSR to make sure we are not transactional
+         * or suspended.
          */
         mfmsr   r6
         li      r5, (MSR_TS_MASK)@higher
@@ -453,8 +463,8 @@ restore_gprs:
         REST_GPR(6, r7)
 
         /*
-         * Store r1 and r5 on the stack so that we can access them
-         * after we clear MSR RI.
+         * Store r1 and r5 on the stack so that we can access them after we
+         * clear MSR RI.
          */
 
         REST_GPR(5, r7)
@@ -484,7 +494,8 @@ restore_gprs:
 
         HMT_MEDIUM
 
-        /* Our transactional state has now changed.
+        /*
+         * Our transactional state has now changed.
          *
          * Now just get out of here.  Transactional (current) state will be
          * updated once restore is called on the return path in the _switch-ed
diff --git a/arch/powerpc/kernel/trace/Makefile b/arch/powerpc/kernel/trace/Makefile
index d22d8bafb643..b1725ad3e13d 100644
--- a/arch/powerpc/kernel/trace/Makefile
+++ b/arch/powerpc/kernel/trace/Makefile
@@ -3,11 +3,9 @@
 # Makefile for the powerpc trace subsystem
 #
 
-subdir-ccflags-$(CONFIG_PPC_WERROR)     := -Werror
-
 ifdef CONFIG_FUNCTION_TRACER
 # do not trace tracer code
-CFLAGS_REMOVE_ftrace.o = -mno-sched-epilog $(CC_FLAGS_FTRACE)
+CFLAGS_REMOVE_ftrace.o = $(CC_FLAGS_FTRACE)
 endif
 
 obj32-$(CONFIG_FUNCTION_TRACER)         += ftrace_32.o
diff --git a/arch/powerpc/kernel/trace/ftrace.c b/arch/powerpc/kernel/trace/ftrace.c
index 4bfbb54dee51..4bf051d3e21e 100644
--- a/arch/powerpc/kernel/trace/ftrace.c
+++ b/arch/powerpc/kernel/trace/ftrace.c
@@ -30,6 +30,16 @@
 
 
 #ifdef CONFIG_DYNAMIC_FTRACE
+
+/*
+ * We generally only have a single long_branch tramp and at most 2 or 3 plt
+ * tramps generated. But, we don't use the plt tramps currently. We also allot
+ * 2 tramps after .text and .init.text. So, we only end up with around 3 usable
+ * tramps in total. Set aside 8 just to be sure.
+ */
+#define NUM_FTRACE_TRAMPS       8
+static unsigned long ftrace_tramps[NUM_FTRACE_TRAMPS];
+
 static unsigned int
 ftrace_call_replace(unsigned long ip, unsigned long addr, int link)
 {
@@ -85,13 +95,16 @@ static int test_24bit_addr(unsigned long ip, unsigned long addr)
         return create_branch((unsigned int *)ip, addr, 0);
 }
 
-#ifdef CONFIG_MODULES
-
 static int is_bl_op(unsigned int op)
 {
         return (op & 0xfc000003) == 0x48000001;
 }
 
+static int is_b_op(unsigned int op)
+{
+        return (op & 0xfc000003) == 0x48000000;
+}
+
 static unsigned long find_bl_target(unsigned long ip, unsigned int op)
 {
         static int offset;
@@ -104,6 +117,7 @@ static unsigned long find_bl_target(unsigned long ip, unsigned int op)
         return ip + (long)offset;
 }
 
+#ifdef CONFIG_MODULES
 #ifdef CONFIG_PPC64
 static int
 __ftrace_make_nop(struct module *mod,
@@ -270,6 +284,146 @@ __ftrace_make_nop(struct module *mod,
 #endif /* PPC64 */
 #endif /* CONFIG_MODULES */
 
+static unsigned long find_ftrace_tramp(unsigned long ip)
+{
+        int i;
+
+        /*
+         * We have the compiler generated long_branch tramps at the end
+         * and we prefer those
+         */
+        for (i = NUM_FTRACE_TRAMPS - 1; i >= 0; i--)
+                if (!ftrace_tramps[i])
+                        continue;
+                else if (create_branch((void *)ip, ftrace_tramps[i], 0))
+                        return ftrace_tramps[i];
+
+        return 0;
+}
+
+static int add_ftrace_tramp(unsigned long tramp)
+{
+        int i;
+
+        for (i = 0; i < NUM_FTRACE_TRAMPS; i++)
+                if (!ftrace_tramps[i]) {
+                        ftrace_tramps[i] = tramp;
+                        return 0;
+                }
+
+        return -1;
+}
+
+/*
+ * If this is a compiler generated long_branch trampoline (essentially, a
+ * trampoline that has a branch to _mcount()), we re-write the branch to
+ * instead go to ftrace_[regs_]caller() and note down the location of this
+ * trampoline.
+ */
+static int setup_mcount_compiler_tramp(unsigned long tramp)
+{
+        int i, op;
+        unsigned long ptr;
+        static unsigned long ftrace_plt_tramps[NUM_FTRACE_TRAMPS];
+
+        /* Is this a known long jump tramp? */
+        for (i = 0; i < NUM_FTRACE_TRAMPS; i++)
+                if (!ftrace_tramps[i])
+                        break;
+                else if (ftrace_tramps[i] == tramp)
+                        return 0;
+
+        /* Is this a known plt tramp? */
+        for (i = 0; i < NUM_FTRACE_TRAMPS; i++)
+                if (!ftrace_plt_tramps[i])
+                        break;
+                else if (ftrace_plt_tramps[i] == tramp)
+                        return -1;
+
+        /* New trampoline -- read where this goes */
+        if (probe_kernel_read(&op, (void *)tramp, sizeof(int))) {
+                pr_debug("Fetching opcode failed.\n");
+                return -1;
+        }
+
+        /* Is this a 24 bit branch? */
+        if (!is_b_op(op)) {
+                pr_debug("Trampoline is not a long branch tramp.\n");
+                return -1;
+        }
+
+        /* lets find where the pointer goes */
+        ptr = find_bl_target(tramp, op);
+
+        if (ptr != ppc_global_function_entry((void *)_mcount)) {
+                pr_debug("Trampoline target %p is not _mcount\n", (void *)ptr);
+                return -1;
+        }
+
+        /* Let's re-write the tramp to go to ftrace_[regs_]caller */
+#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
+        ptr = ppc_global_function_entry((void *)ftrace_regs_caller);
+#else
+        ptr = ppc_global_function_entry((void *)ftrace_caller);
+#endif
+        if (!create_branch((void *)tramp, ptr, 0)) {
+                pr_debug("%ps is not reachable from existing mcount tramp\n",
+                                (void *)ptr);
+                return -1;
+        }
+
+        if (patch_branch((unsigned int *)tramp, ptr, 0)) {
+                pr_debug("REL24 out of range!\n");
+                return -1;
+        }
+
+        if (add_ftrace_tramp(tramp)) {
+                pr_debug("No tramp locations left\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+static int __ftrace_make_nop_kernel(struct dyn_ftrace *rec, unsigned long addr)
+{
+        unsigned long tramp, ip = rec->ip;
+        unsigned int op;
+
+        /* Read where this goes */
+        if (probe_kernel_read(&op, (void *)ip, sizeof(int))) {
+                pr_err("Fetching opcode failed.\n");
+                return -EFAULT;
+        }
+
+        /* Make sure that that this is still a 24bit jump */
+        if (!is_bl_op(op)) {
+                pr_err("Not expected bl: opcode is %x\n", op);
+                return -EINVAL;
+        }
+
+        /* Let's find where the pointer goes */
+        tramp = find_bl_target(ip, op);
+
+        pr_devel("ip:%lx jumps to %lx", ip, tramp);
+
+        if (setup_mcount_compiler_tramp(tramp)) {
+                /* Are other trampolines reachable? */
+                if (!find_ftrace_tramp(ip)) {
+                        pr_err("No ftrace trampolines reachable from %ps\n",
+                                        (void *)ip);
+                        return -EINVAL;
+                }
+        }
+
+        if (patch_instruction((unsigned int *)ip, PPC_INST_NOP)) {
+                pr_err("Patching NOP failed.\n");
+                return -EPERM;
+        }
+
+        return 0;
+}
+
 int ftrace_make_nop(struct module *mod,
                     struct dyn_ftrace *rec, unsigned long addr)
 {
@@ -286,7 +440,8 @@ int ftrace_make_nop(struct module *mod,
                 old = ftrace_call_replace(ip, addr, 1);
                 new = PPC_INST_NOP;
                 return ftrace_modify_code(ip, old, new);
-        }
+        } else if (core_kernel_text(ip))
+                return __ftrace_make_nop_kernel(rec, addr);
 
 #ifdef CONFIG_MODULES
         /*
@@ -456,6 +611,53 @@ __ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 #endif /* CONFIG_PPC64 */
 #endif /* CONFIG_MODULES */
 
+static int __ftrace_make_call_kernel(struct dyn_ftrace *rec, unsigned long addr)
+{
+        unsigned int op;
+        void *ip = (void *)rec->ip;
+        unsigned long tramp, entry, ptr;
+
+        /* Make sure we're being asked to patch branch to a known ftrace addr */
+        entry = ppc_global_function_entry((void *)ftrace_caller);
+        ptr = ppc_global_function_entry((void *)addr);
+
+        if (ptr != entry) {
+#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
+                entry = ppc_global_function_entry((void *)ftrace_regs_caller);
+                if (ptr != entry) {
+#endif
+                        pr_err("Unknown ftrace addr to patch: %ps\n", (void *)ptr);
+                        return -EINVAL;
+#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
+                }
+#endif
+        }
+
+        /* Make sure we have a nop */
+        if (probe_kernel_read(&op, ip, sizeof(op))) {
+                pr_err("Unable to read ftrace location %p\n", ip);
+                return -EFAULT;
+        }
+
+        if (op != PPC_INST_NOP) {
+                pr_err("Unexpected call sequence at %p: %x\n", ip, op);
+                return -EINVAL;
+        }
+
+        tramp = find_ftrace_tramp((unsigned long)ip);
+        if (!tramp) {
+                pr_err("No ftrace trampolines reachable from %ps\n", ip);
+                return -EINVAL;
+        }
+
+        if (patch_branch(ip, tramp, BRANCH_SET_LINK)) {
+                pr_err("Error patching branch to ftrace tramp!\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 {
         unsigned long ip = rec->ip;
@@ -471,7 +673,8 @@ int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
                 old = PPC_INST_NOP;
                 new = ftrace_call_replace(ip, addr, 1);
                 return ftrace_modify_code(ip, old, new);
-        }
+        } else if (core_kernel_text(ip))
+                return __ftrace_make_call_kernel(rec, addr);
 
 #ifdef CONFIG_MODULES
         /*
@@ -603,6 +806,12 @@ int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
                 old = ftrace_call_replace(ip, old_addr, 1);
                 new = ftrace_call_replace(ip, addr, 1);
                 return ftrace_modify_code(ip, old, new);
+        } else if (core_kernel_text(ip)) {
+                /*
+                 * We always patch out of range locations to go to the regs
+                 * variant, so there is nothing to do here
+                 */
+                return 0;
         }
 
 #ifdef CONFIG_MODULES
@@ -654,10 +863,54 @@ void arch_ftrace_update_code(int command)
         ftrace_modify_all_code(command);
 }
 
+#ifdef CONFIG_PPC64
+#define PACATOC offsetof(struct paca_struct, kernel_toc)
+
+#define PPC_LO(v) ((v) & 0xffff)
+#define PPC_HI(v) (((v) >> 16) & 0xffff)
+#define PPC_HA(v) PPC_HI ((v) + 0x8000)
+
+extern unsigned int ftrace_tramp_text[], ftrace_tramp_init[];
+
+int __init ftrace_dyn_arch_init(void)
+{
+        int i;
+        unsigned int *tramp[] = { ftrace_tramp_text, ftrace_tramp_init };
+        u32 stub_insns[] = {
+                0xe98d0000 | PACATOC,   /* ld      r12,PACATOC(r13)     */
+                0x3d8c0000,             /* addis   r12,r12,<high>       */
+                0x398c0000,             /* addi    r12,r12,<low>        */
+                0x7d8903a6,             /* mtctr   r12                  */
+                0x4e800420,             /* bctr                         */
+        };
+#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
+        unsigned long addr = ppc_global_function_entry((void *)ftrace_regs_caller);
+#else
+        unsigned long addr = ppc_global_function_entry((void *)ftrace_caller);
+#endif
+        long reladdr = addr - kernel_toc_addr();
+
+        if (reladdr > 0x7FFFFFFF || reladdr < -(0x80000000L)) {
+                pr_err("Address of %ps out of range of kernel_toc.\n",
+                                (void *)addr);
+                return -1;
+        }
+
+        for (i = 0; i < 2; i++) {
+                memcpy(tramp[i], stub_insns, sizeof(stub_insns));
+                tramp[i][1] |= PPC_HA(reladdr);
+                tramp[i][2] |= PPC_LO(reladdr);
+                add_ftrace_tramp((unsigned long)tramp[i]);
+        }
+
+        return 0;
+}
+#else
 int __init ftrace_dyn_arch_init(void)
 {
         return 0;
 }
+#endif
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
diff --git a/arch/powerpc/kernel/trace/ftrace_64.S b/arch/powerpc/kernel/trace/ftrace_64.S
index e25f77c10a72..1782af2d1496 100644
--- a/arch/powerpc/kernel/trace/ftrace_64.S
+++ b/arch/powerpc/kernel/trace/ftrace_64.S
@@ -14,6 +14,18 @@
 #include <asm/ppc-opcode.h>
 #include <asm/export.h>
 
+.pushsection ".tramp.ftrace.text","aw",@progbits;
+.globl ftrace_tramp_text
+ftrace_tramp_text:
+        .space 64
+.popsection
+
+.pushsection ".tramp.ftrace.init","aw",@progbits;
+.globl ftrace_tramp_init
+ftrace_tramp_init:
+        .space 64
+.popsection
+
 _GLOBAL(mcount)
 _GLOBAL(_mcount)
 EXPORT_SYMBOL(_mcount)
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index ab1bd06d7c44..9a86572db1ef 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -247,8 +247,6 @@ static void oops_end(unsigned long flags, struct pt_regs *regs,
                 mdelay(MSEC_PER_SEC);
         }
 
-        if (in_interrupt())
-                panic("Fatal exception in interrupt");
         if (panic_on_oops)
                 panic("Fatal exception");
         do_exit(signr);
@@ -535,10 +533,10 @@ int machine_check_e500mc(struct pt_regs *regs)
         printk("Caused by (from MCSR=%lx): ", reason);
 
         if (reason & MCSR_MCP)
-                printk("Machine Check Signal\n");
+                pr_cont("Machine Check Signal\n");
 
         if (reason & MCSR_ICPERR) {
-                printk("Instruction Cache Parity Error\n");
+                pr_cont("Instruction Cache Parity Error\n");
 
                 /*
                  * This is recoverable by invalidating the i-cache.
@@ -556,7 +554,7 @@ int machine_check_e500mc(struct pt_regs *regs)
         }
 
         if (reason & MCSR_DCPERR_MC) {
-                printk("Data Cache Parity Error\n");
+                pr_cont("Data Cache Parity Error\n");
 
                 /*
                  * In write shadow mode we auto-recover from the error, but it
@@ -575,38 +573,38 @@ int machine_check_e500mc(struct pt_regs *regs)
         }
 
         if (reason & MCSR_L2MMU_MHIT) {
-                printk("Hit on multiple TLB entries\n");
+                pr_cont("Hit on multiple TLB entries\n");
                 recoverable = 0;
         }
 
         if (reason & MCSR_NMI)
-                printk("Non-maskable interrupt\n");
+                pr_cont("Non-maskable interrupt\n");
 
         if (reason & MCSR_IF) {
-                printk("Instruction Fetch Error Report\n");
+                pr_cont("Instruction Fetch Error Report\n");
                 recoverable = 0;
         }
 
         if (reason & MCSR_LD) {
-                printk("Load Error Report\n");
+                pr_cont("Load Error Report\n");
                 recoverable = 0;
         }
 
         if (reason & MCSR_ST) {
-                printk("Store Error Report\n");
+                pr_cont("Store Error Report\n");
                 recoverable = 0;
         }
 
         if (reason & MCSR_LDG) {
-                printk("Guarded Load Error Report\n");
+                pr_cont("Guarded Load Error Report\n");
                 recoverable = 0;
         }
 
         if (reason & MCSR_TLBSYNC)
-                printk("Simultaneous tlbsync operations\n");
+                pr_cont("Simultaneous tlbsync operations\n");
 
         if (reason & MCSR_BSL2_ERR) {
-                printk("Level 2 Cache Error\n");
+                pr_cont("Level 2 Cache Error\n");
                 recoverable = 0;
         }
 
@@ -616,7 +614,7 @@ int machine_check_e500mc(struct pt_regs *regs)
                 addr = mfspr(SPRN_MCAR);
                 addr |= (u64)mfspr(SPRN_MCARU) << 32;
 
-                printk("Machine Check %s Address: %#llx\n",
+                pr_cont("Machine Check %s Address: %#llx\n",
                        reason & MCSR_MEA ? "Effective" : "Physical", addr);
         }
 
@@ -640,29 +638,29 @@ int machine_check_e500(struct pt_regs *regs)
         printk("Caused by (from MCSR=%lx): ", reason);
 
         if (reason & MCSR_MCP)
-                printk("Machine Check Signal\n");
+                pr_cont("Machine Check Signal\n");
         if (reason & MCSR_ICPERR)
-                printk("Instruction Cache Parity Error\n");
+                pr_cont("Instruction Cache Parity Error\n");
         if (reason & MCSR_DCP_PERR)
-                printk("Data Cache Push Parity Error\n");
+                pr_cont("Data Cache Push Parity Error\n");
         if (reason & MCSR_DCPERR)
-                printk("Data Cache Parity Error\n");
+                pr_cont("Data Cache Parity Error\n");
         if (reason & MCSR_BUS_IAERR)
-                printk("Bus - Instruction Address Error\n");
+                pr_cont("Bus - Instruction Address Error\n");
         if (reason & MCSR_BUS_RAERR)
-                printk("Bus - Read Address Error\n");
+                pr_cont("Bus - Read Address Error\n");
         if (reason & MCSR_BUS_WAERR)
-                printk("Bus - Write Address Error\n");
+                pr_cont("Bus - Write Address Error\n");
         if (reason & MCSR_BUS_IBERR)
-                printk("Bus - Instruction Data Error\n");
+                pr_cont("Bus - Instruction Data Error\n");
         if (reason & MCSR_BUS_RBERR)
-                printk("Bus - Read Data Bus Error\n");
+                pr_cont("Bus - Read Data Bus Error\n");
         if (reason & MCSR_BUS_WBERR)
-                printk("Bus - Write Data Bus Error\n");
+                pr_cont("Bus - Write Data Bus Error\n");
         if (reason & MCSR_BUS_IPERR)
-                printk("Bus - Instruction Parity Error\n");
+                pr_cont("Bus - Instruction Parity Error\n");
         if (reason & MCSR_BUS_RPERR)
-                printk("Bus - Read Parity Error\n");
+                pr_cont("Bus - Read Parity Error\n");
 
         return 0;
 }
@@ -680,19 +678,19 @@ int machine_check_e200(struct pt_regs *regs)
         printk("Caused by (from MCSR=%lx): ", reason);
 
         if (reason & MCSR_MCP)
-                printk("Machine Check Signal\n");
+                pr_cont("Machine Check Signal\n");
         if (reason & MCSR_CP_PERR)
-                printk("Cache Push Parity Error\n");
+                pr_cont("Cache Push Parity Error\n");
         if (reason & MCSR_CPERR)
-                printk("Cache Parity Error\n");
+                pr_cont("Cache Parity Error\n");
         if (reason & MCSR_EXCP_ERR)
-                printk("ISI, ITLB, or Bus Error on first instruction fetch for an exception handler\n");
+                pr_cont("ISI, ITLB, or Bus Error on first instruction fetch for an exception handler\n");
         if (reason & MCSR_BUS_IRERR)
-                printk("Bus - Read Bus Error on instruction fetch\n");
+                pr_cont("Bus - Read Bus Error on instruction fetch\n");
         if (reason & MCSR_BUS_DRERR)
-                printk("Bus - Read Bus Error on data load\n");
+                pr_cont("Bus - Read Bus Error on data load\n");
         if (reason & MCSR_BUS_WRERR)
-                printk("Bus - Write Bus Error on buffered store or cache line push\n");
+                pr_cont("Bus - Write Bus Error on buffered store or cache line push\n");
 
         return 0;
 }
@@ -705,30 +703,30 @@ int machine_check_generic(struct pt_regs *regs)
         printk("Caused by (from SRR1=%lx): ", reason);
         switch (reason & 0x601F0000) {
         case 0x80000:
-                printk("Machine check signal\n");
+                pr_cont("Machine check signal\n");
                 break;
         case 0:         /* for 601 */
         case 0x40000:
         case 0x140000:  /* 7450 MSS error and TEA */
-                printk("Transfer error ack signal\n");
+                pr_cont("Transfer error ack signal\n");
                 break;
         case 0x20000:
-                printk("Data parity error signal\n");
+                pr_cont("Data parity error signal\n");
                 break;
         case 0x10000:
-                printk("Address parity error signal\n");
+                pr_cont("Address parity error signal\n");
                 break;
         case 0x20000000:
-                printk("L1 Data Cache error\n");
+                pr_cont("L1 Data Cache error\n");
                 break;
         case 0x40000000:
-                printk("L1 Instruction Cache error\n");
+                pr_cont("L1 Instruction Cache error\n");
                 break;
         case 0x00100000:
-                printk("L2 data cache parity error\n");
+                pr_cont("L2 data cache parity error\n");
                 break;
         default:
-                printk("Unknown values in msr\n");
+                pr_cont("Unknown values in msr\n");
         }
         return 0;
 }
@@ -741,9 +739,7 @@ void machine_check_exception(struct pt_regs *regs)
         if (!nested)
                 nmi_enter();
 
-        /* 64s accounts the mce in machine_check_early when in HVMODE */
-        if (!IS_ENABLED(CONFIG_PPC_BOOK3S_64) || !cpu_has_feature(CPU_FTR_HVMODE))
-                __this_cpu_inc(irq_stat.mce_exceptions);
+        __this_cpu_inc(irq_stat.mce_exceptions);
 
         add_taint(TAINT_MACHINE_CHECK, LOCKDEP_NOW_UNRELIABLE);
 
@@ -767,12 +763,17 @@ void machine_check_exception(struct pt_regs *regs)
         if (check_io_access(regs))
                 goto bail;
 
-        die("Machine check", regs, SIGBUS);
-
         /* Must die if the interrupt is not recoverable */
         if (!(regs->msr & MSR_RI))
                 nmi_panic(regs, "Unrecoverable Machine check");
 
+        if (!nested)
+                nmi_exit();
+
+        die("Machine check", regs, SIGBUS);
+
+        return;
+
 bail:
         if (!nested)
                 nmi_exit();
@@ -1433,7 +1434,7 @@ void program_check_exception(struct pt_regs *regs)
                         goto bail;
                 } else {
                         printk(KERN_EMERG "Unexpected TM Bad Thing exception "
-                               "at %lx (msr 0x%x)\n", regs->nip, reason);
+                               "at %lx (msr 0x%lx)\n", regs->nip, regs->msr);
                         die("Unrecoverable exception", regs, SIGABRT);
                 }
         }
@@ -1547,14 +1548,6 @@ void StackOverflow(struct pt_regs *regs)
         panic("kernel stack overflow");
 }
 
-void nonrecoverable_exception(struct pt_regs *regs)
-{
-        printk(KERN_ERR "Non-recoverable exception at PC=%lx MSR=%lx\n",
-               regs->nip, regs->msr);
-        debugger(regs);
-        die("nonrecoverable exception", regs, SIGKILL);
-}
-
 void kernel_fp_unavailable_exception(struct pt_regs *regs)
 {
         enum ctx_state prev_state = exception_enter();
@@ -1750,16 +1743,20 @@ void fp_unavailable_tm(struct pt_regs *regs)
          * checkpointed FP registers need to be loaded.
          */
         tm_reclaim_current(TM_CAUSE_FAC_UNAV);
-        /* Reclaim didn't save out any FPRs to transact_fprs. */
+
+        /*
+         * Reclaim initially saved out bogus (lazy) FPRs to ckfp_state, and
+         * then it was overwrite by the thr->fp_state by tm_reclaim_thread().
+         *
+         * At this point, ck{fp,vr}_state contains the exact values we want to
+         * recheckpoint.
+         */
 
         /* Enable FP for the task: */
         current->thread.load_fp = 1;
 
-        /* This loads and recheckpoints the FP registers from
-         * thread.fpr[].  They will remain in registers after the
-         * checkpoint so we don't need to reload them after.
-         * If VMX is in use, the VRs now hold checkpointed values,
-         * so we don't want to load the VRs from the thread_struct.
+        /*
+         * Recheckpoint all the checkpointed ckpt, ck{fp, vr}_state registers.
          */
         tm_recheckpoint(&current->thread);
 }
@@ -2086,8 +2083,8 @@ void SPEFloatingPointRoundException(struct pt_regs *regs)
  */
 void unrecoverable_exception(struct pt_regs *regs)
 {
-        printk(KERN_EMERG "Unrecoverable exception %lx at %lx\n",
-               regs->trap, regs->nip);
+        pr_emerg("Unrecoverable exception %lx at %lx (msr=%lx)\n",
+                 regs->trap, regs->nip, regs->msr);
         die("Unrecoverable exception", regs, SIGABRT);
 }
 NOKPROBE_SYMBOL(unrecoverable_exception);
diff --git a/arch/powerpc/kernel/vdso32/datapage.S b/arch/powerpc/kernel/vdso32/datapage.S
index 3745113fcc65..2a7eb5452aba 100644
--- a/arch/powerpc/kernel/vdso32/datapage.S
+++ b/arch/powerpc/kernel/vdso32/datapage.S
@@ -37,6 +37,7 @@ data_page_branch:
         mtlr    r0
         addi    r3, r3, __kernel_datapage_offset-data_page_branch
         lwz     r0,0(r3)
+  .cfi_restore lr
         add     r3,r0,r3
         blr
   .cfi_endproc
diff --git a/arch/powerpc/kernel/vdso32/gettimeofday.S b/arch/powerpc/kernel/vdso32/gettimeofday.S
index 769c2624e0a6..1e0bc5955a40 100644
--- a/arch/powerpc/kernel/vdso32/gettimeofday.S
+++ b/arch/powerpc/kernel/vdso32/gettimeofday.S
@@ -139,6 +139,7 @@ V_FUNCTION_BEGIN(__kernel_clock_gettime)
          */
 99:
         li      r0,__NR_clock_gettime
+  .cfi_restore lr
         sc
         blr
   .cfi_endproc
diff --git a/arch/powerpc/kernel/vdso64/datapage.S b/arch/powerpc/kernel/vdso64/datapage.S
index abf17feffe40..bf9668691511 100644
--- a/arch/powerpc/kernel/vdso64/datapage.S
+++ b/arch/powerpc/kernel/vdso64/datapage.S
@@ -37,6 +37,7 @@ data_page_branch:
         mtlr    r0
         addi    r3, r3, __kernel_datapage_offset-data_page_branch
         lwz     r0,0(r3)
+  .cfi_restore lr
         add     r3,r0,r3
         blr
   .cfi_endproc
diff --git a/arch/powerpc/kernel/vdso64/gettimeofday.S b/arch/powerpc/kernel/vdso64/gettimeofday.S
index c002adcc694c..a4ed9edfd5f0 100644
--- a/arch/powerpc/kernel/vdso64/gettimeofday.S
+++ b/arch/powerpc/kernel/vdso64/gettimeofday.S
@@ -169,6 +169,7 @@ V_FUNCTION_BEGIN(__kernel_clock_gettime)
          */
 99:
         li      r0,__NR_clock_gettime
+  .cfi_restore lr
         sc
         blr
   .cfi_endproc
diff --git a/arch/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S
index 105a976323aa..434581bcd5b4 100644
--- a/arch/powerpc/kernel/vmlinux.lds.S
+++ b/arch/powerpc/kernel/vmlinux.lds.S
@@ -4,6 +4,9 @@
 #else
 #define PROVIDE32(x)    PROVIDE(x)
 #endif
+
+#define BSS_FIRST_SECTIONS *(.bss.prominit)
+
 #include <asm/page.h>
 #include <asm-generic/vmlinux.lds.h>
 #include <asm/cache.h>
@@ -99,6 +102,9 @@ SECTIONS
 #endif
                 /* careful! __ftr_alt_* sections need to be close to .text */
                 *(.text.hot TEXT_MAIN .text.fixup .text.unlikely .fixup __ftr_alt_* .ref.text);
+#ifdef CONFIG_PPC64
+                *(.tramp.ftrace.text);
+#endif
                 SCHED_TEXT
                 CPUIDLE_TEXT
                 LOCK_TEXT
@@ -181,7 +187,15 @@ SECTIONS
  */
         . = ALIGN(STRICT_ALIGN_SIZE);
         __init_begin = .;
-        INIT_TEXT_SECTION(PAGE_SIZE) :kernel
+        . = ALIGN(PAGE_SIZE);
+        .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
+                _sinittext = .;
+                INIT_TEXT
+                _einittext = .;
+#ifdef CONFIG_PPC64
+                *(.tramp.ftrace.init);
+#endif
+        } :kernel
 
         /* .exit.text is discarded at runtime, not link time,
          * to deal with references from __bug_table
diff --git a/arch/powerpc/kvm/Makefile b/arch/powerpc/kvm/Makefile
index e814f40ab836..64f1135e7732 100644
--- a/arch/powerpc/kvm/Makefile
+++ b/arch/powerpc/kvm/Makefile
@@ -3,8 +3,6 @@
 # Makefile for Kernel-based Virtual Machine module
 #
 
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
-
 ccflags-y := -Ivirt/kvm -Iarch/powerpc/kvm
 KVM := ../../../virt/kvm
 
diff --git a/arch/powerpc/lib/Makefile b/arch/powerpc/lib/Makefile
index 670286808928..3bf9fc6fd36c 100644
--- a/arch/powerpc/lib/Makefile
+++ b/arch/powerpc/lib/Makefile
@@ -3,8 +3,6 @@
 # Makefile for ppc-specific library files..
 #
 
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
-
 ccflags-$(CONFIG_PPC64) := $(NO_MINIMAL_TOC)
 
 CFLAGS_REMOVE_code-patching.o = $(CC_FLAGS_FTRACE)
@@ -14,6 +12,8 @@ obj-y += string.o alloc.o code-patching.o feature-fixups.o
 
 obj-$(CONFIG_PPC32)     += div64.o copy_32.o crtsavres.o strlen_32.o
 
+obj-$(CONFIG_FUNCTION_ERROR_INJECTION)  += error-inject.o
+
 # See corresponding test in arch/powerpc/Makefile
 # 64-bit linker creates .sfpr on demand for final link (vmlinux),
 # so it is only needed for modules, and only for older linkers which
diff --git a/arch/powerpc/lib/code-patching.c b/arch/powerpc/lib/code-patching.c
index 5ffee298745f..89502cbccb1b 100644
--- a/arch/powerpc/lib/code-patching.c
+++ b/arch/powerpc/lib/code-patching.c
@@ -98,8 +98,7 @@ static int map_patch_area(void *addr, unsigned long text_poke_addr)
         else
                 pfn = __pa_symbol(addr) >> PAGE_SHIFT;
 
-        err = map_kernel_page(text_poke_addr, (pfn << PAGE_SHIFT),
-                                pgprot_val(PAGE_KERNEL));
+        err = map_kernel_page(text_poke_addr, (pfn << PAGE_SHIFT), PAGE_KERNEL);
 
         pr_devel("Mapped addr %lx with pfn %lx:%d\n", text_poke_addr, pfn, err);
         if (err)
diff --git a/arch/powerpc/lib/error-inject.c b/arch/powerpc/lib/error-inject.c
new file mode 100644
index 000000000000..407b992fb02f
--- /dev/null
+++ b/arch/powerpc/lib/error-inject.c
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+#include <linux/error-injection.h>
+#include <linux/kprobes.h>
+#include <linux/uaccess.h>
+
+void override_function_with_return(struct pt_regs *regs)
+{
+        /*
+         * Emulate 'blr'. 'regs' represents the state on entry of a predefined
+         * function in the kernel/module, captured on a kprobe. We don't need
+         * to worry about 32-bit userspace on a 64-bit kernel.
+         */
+        regs->nip = regs->link;
+}
+NOKPROBE_SYMBOL(override_function_with_return);
diff --git a/arch/powerpc/lib/mem_64.S b/arch/powerpc/lib/mem_64.S
index ec531de99996..3c3be02f33b7 100644
--- a/arch/powerpc/lib/mem_64.S
+++ b/arch/powerpc/lib/mem_64.S
@@ -40,7 +40,7 @@ _GLOBAL(memset)
 .Lms:   PPC_MTOCRF(1,r0)
         mr      r6,r3
         blt     cr1,8f
-        beq+    3f                      /* if already 8-byte aligned */
+        beq     3f                      /* if already 8-byte aligned */
         subf    r5,r0,r5
         bf      31,1f
         stb     r4,0(r6)
@@ -85,7 +85,7 @@ _GLOBAL(memset)
         addi    r6,r6,8
 8:      cmpwi   r5,0
         PPC_MTOCRF(1,r5)
-        beqlr+
+        beqlr
         bf      29,9f
         stw     r4,0(r6)
         addi    r6,r6,4
diff --git a/arch/powerpc/mm/8xx_mmu.c b/arch/powerpc/mm/8xx_mmu.c
index cf77d755246d..36484a2ef915 100644
--- a/arch/powerpc/mm/8xx_mmu.c
+++ b/arch/powerpc/mm/8xx_mmu.c
@@ -67,7 +67,7 @@ void __init MMU_init_hw(void)
         /* PIN up to the 3 first 8Mb after IMMR in DTLB table */
 #ifdef CONFIG_PIN_TLB_DATA
         unsigned long ctr = mfspr(SPRN_MD_CTR) & 0xfe000000;
-        unsigned long flags = 0xf0 | MD_SPS16K | _PAGE_PRIVILEGED | _PAGE_DIRTY;
+        unsigned long flags = 0xf0 | MD_SPS16K | _PAGE_SH | _PAGE_DIRTY;
 #ifdef CONFIG_PIN_TLB_IMMR
         int i = 29;
 #else
@@ -91,11 +91,10 @@ static void __init mmu_mapin_immr(void)
 {
         unsigned long p = PHYS_IMMR_BASE;
         unsigned long v = VIRT_IMMR_BASE;
-        unsigned long f = pgprot_val(PAGE_KERNEL_NCG);
         int offset;
 
         for (offset = 0; offset < IMMR_SIZE; offset += PAGE_SIZE)
-                map_kernel_page(v + offset, p + offset, f);
+                map_kernel_page(v + offset, p + offset, PAGE_KERNEL_NCG);
 }
 
 /* Address of instructions to patch */
diff --git a/arch/powerpc/mm/Makefile b/arch/powerpc/mm/Makefile
index cdf6a9960046..ca96e7be4d0e 100644
--- a/arch/powerpc/mm/Makefile
+++ b/arch/powerpc/mm/Makefile
@@ -3,10 +3,10 @@
 # Makefile for the linux ppc-specific parts of the memory manager.
 #
 
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
-
 ccflags-$(CONFIG_PPC64) := $(NO_MINIMAL_TOC)
 
+CFLAGS_REMOVE_slb.o = $(CC_FLAGS_FTRACE)
+
 obj-y                           := fault.o mem.o pgtable.o mmap.o \
                                    init_$(BITS).o pgtable_$(BITS).o \
                                    init-common.o mmu_context.o drmem.o
@@ -15,7 +15,7 @@ obj-$(CONFIG_PPC_MMU_NOHASH)	+= mmu_context_nohash.o tlb_nohash.o \
 obj-$(CONFIG_PPC_BOOK3E)        += tlb_low_$(BITS)e.o
 hash64-$(CONFIG_PPC_NATIVE)     := hash_native_64.o
 obj-$(CONFIG_PPC_BOOK3E_64)   += pgtable-book3e.o
-obj-$(CONFIG_PPC_BOOK3S_64)     += pgtable-hash64.o hash_utils_64.o slb_low.o slb.o $(hash64-y) mmu_context_book3s64.o pgtable-book3s64.o
+obj-$(CONFIG_PPC_BOOK3S_64)     += pgtable-hash64.o hash_utils_64.o slb.o $(hash64-y) mmu_context_book3s64.o pgtable-book3s64.o
 obj-$(CONFIG_PPC_RADIX_MMU)     += pgtable-radix.o tlb-radix.o
 obj-$(CONFIG_PPC_STD_MMU_32)    += ppc_mmu_32.o hash_low_32.o mmu_context_hash32.o
 obj-$(CONFIG_PPC_STD_MMU)       += tlb_hash$(BITS).o
@@ -43,5 +43,12 @@ obj-$(CONFIG_HIGHMEM)		+= highmem.o
 obj-$(CONFIG_PPC_COPRO_BASE)    += copro_fault.o
 obj-$(CONFIG_SPAPR_TCE_IOMMU)   += mmu_context_iommu.o
 obj-$(CONFIG_PPC_PTDUMP)        += dump_linuxpagetables.o
+ifdef CONFIG_PPC_PTDUMP
+obj-$(CONFIG_4xx)               += dump_linuxpagetables-generic.o
+obj-$(CONFIG_PPC_8xx)           += dump_linuxpagetables-8xx.o
+obj-$(CONFIG_PPC_BOOK3E_MMU)    += dump_linuxpagetables-generic.o
+obj-$(CONFIG_PPC_BOOK3S_32)     += dump_linuxpagetables-generic.o
+obj-$(CONFIG_PPC_BOOK3S_64)     += dump_linuxpagetables-book3s64.o
+endif
 obj-$(CONFIG_PPC_HTDUMP)        += dump_hashpagetable.o
 obj-$(CONFIG_PPC_MEM_KEYS)      += pkeys.o
diff --git a/arch/powerpc/mm/dma-noncoherent.c b/arch/powerpc/mm/dma-noncoherent.c
index 382528475433..b6e7b5952ab5 100644
--- a/arch/powerpc/mm/dma-noncoherent.c
+++ b/arch/powerpc/mm/dma-noncoherent.c
@@ -228,7 +228,7 @@ __dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *handle, gfp_t
                 do {
                         SetPageReserved(page);
                         map_kernel_page(vaddr, page_to_phys(page),
-                                 pgprot_val(pgprot_noncached(PAGE_KERNEL)));
+                                        pgprot_noncached(PAGE_KERNEL));
                         page++;
                         vaddr += PAGE_SIZE;
                 } while (size -= PAGE_SIZE);
diff --git a/arch/powerpc/mm/dump_linuxpagetables-8xx.c b/arch/powerpc/mm/dump_linuxpagetables-8xx.c
new file mode 100644
index 000000000000..ab9e3f24db2f
--- /dev/null
+++ b/arch/powerpc/mm/dump_linuxpagetables-8xx.c
@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * From split of dump_linuxpagetables.c
+ * Copyright 2016, Rashmica Gupta, IBM Corp.
+ *
+ */
+#include <linux/kernel.h>
+#include <asm/pgtable.h>
+
+#include "dump_linuxpagetables.h"
+
+static const struct flag_info flag_array[] = {
+        {
+                .mask   = _PAGE_SH,
+                .val    = 0,
+                .set    = "user",
+                .clear  = "    ",
+        }, {
+                .mask   = _PAGE_RO | _PAGE_NA,
+                .val    = 0,
+                .set    = "rw",
+        }, {
+                .mask   = _PAGE_RO | _PAGE_NA,
+                .val    = _PAGE_RO,
+                .set    = "r ",
+        }, {
+                .mask   = _PAGE_RO | _PAGE_NA,
+                .val    = _PAGE_NA,
+                .set    = "  ",
+        }, {
+                .mask   = _PAGE_EXEC,
+                .val    = _PAGE_EXEC,
+                .set    = " X ",
+                .clear  = "   ",
+        }, {
+                .mask   = _PAGE_PRESENT,
+                .val    = _PAGE_PRESENT,
+                .set    = "present",
+                .clear  = "       ",
+        }, {
+                .mask   = _PAGE_GUARDED,
+                .val    = _PAGE_GUARDED,
+                .set    = "guarded",
+                .clear  = "       ",
+        }, {
+                .mask   = _PAGE_DIRTY,
+                .val    = _PAGE_DIRTY,
+                .set    = "dirty",
+                .clear  = "     ",
+        }, {
+                .mask   = _PAGE_ACCESSED,
+                .val    = _PAGE_ACCESSED,
+                .set    = "accessed",
+                .clear  = "        ",
+        }, {
+                .mask   = _PAGE_NO_CACHE,
+                .val    = _PAGE_NO_CACHE,
+                .set    = "no cache",
+                .clear  = "        ",
+        }, {
+                .mask   = _PAGE_SPECIAL,
+                .val    = _PAGE_SPECIAL,
+                .set    = "special",
+        }
+};
+
+struct pgtable_level pg_level[5] = {
+        {
+        }, { /* pgd */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pud */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pmd */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pte */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        },
+};
diff --git a/arch/powerpc/mm/dump_linuxpagetables-book3s64.c b/arch/powerpc/mm/dump_linuxpagetables-book3s64.c
new file mode 100644
index 000000000000..ed6fcf78256e
--- /dev/null
+++ b/arch/powerpc/mm/dump_linuxpagetables-book3s64.c
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * From split of dump_linuxpagetables.c
+ * Copyright 2016, Rashmica Gupta, IBM Corp.
+ *
+ */
+#include <linux/kernel.h>
+#include <asm/pgtable.h>
+
+#include "dump_linuxpagetables.h"
+
+static const struct flag_info flag_array[] = {
+        {
+                .mask   = _PAGE_PRIVILEGED,
+                .val    = 0,
+                .set    = "user",
+                .clear  = "    ",
+        }, {
+                .mask   = _PAGE_READ,
+                .val    = _PAGE_READ,
+                .set    = "r",
+                .clear  = " ",
+        }, {
+                .mask   = _PAGE_WRITE,
+                .val    = _PAGE_WRITE,
+                .set    = "w",
+                .clear  = " ",
+        }, {
+                .mask   = _PAGE_EXEC,
+                .val    = _PAGE_EXEC,
+                .set    = " X ",
+                .clear  = "   ",
+        }, {
+                .mask   = _PAGE_PTE,
+                .val    = _PAGE_PTE,
+                .set    = "pte",
+                .clear  = "   ",
+        }, {
+                .mask   = _PAGE_PRESENT,
+                .val    = _PAGE_PRESENT,
+                .set    = "valid",
+                .clear  = "     ",
+        }, {
+                .mask   = _PAGE_PRESENT | _PAGE_INVALID,
+                .val    = 0,
+                .set    = "       ",
+                .clear  = "present",
+        }, {
+                .mask   = H_PAGE_HASHPTE,
+                .val    = H_PAGE_HASHPTE,
+                .set    = "hpte",
+                .clear  = "    ",
+        }, {
+                .mask   = _PAGE_DIRTY,
+                .val    = _PAGE_DIRTY,
+                .set    = "dirty",
+                .clear  = "     ",
+        }, {
+                .mask   = _PAGE_ACCESSED,
+                .val    = _PAGE_ACCESSED,
+                .set    = "accessed",
+                .clear  = "        ",
+        }, {
+                .mask   = _PAGE_NON_IDEMPOTENT,
+                .val    = _PAGE_NON_IDEMPOTENT,
+                .set    = "non-idempotent",
+                .clear  = "              ",
+        }, {
+                .mask   = _PAGE_TOLERANT,
+                .val    = _PAGE_TOLERANT,
+                .set    = "tolerant",
+                .clear  = "        ",
+        }, {
+                .mask   = H_PAGE_BUSY,
+                .val    = H_PAGE_BUSY,
+                .set    = "busy",
+        }, {
+#ifdef CONFIG_PPC_64K_PAGES
+                .mask   = H_PAGE_COMBO,
+                .val    = H_PAGE_COMBO,
+                .set    = "combo",
+        }, {
+                .mask   = H_PAGE_4K_PFN,
+                .val    = H_PAGE_4K_PFN,
+                .set    = "4K_pfn",
+        }, {
+#else /* CONFIG_PPC_64K_PAGES */
+                .mask   = H_PAGE_F_GIX,
+                .val    = H_PAGE_F_GIX,
+                .set    = "f_gix",
+                .is_val = true,
+                .shift  = H_PAGE_F_GIX_SHIFT,
+        }, {
+                .mask   = H_PAGE_F_SECOND,
+                .val    = H_PAGE_F_SECOND,
+                .set    = "f_second",
+        }, {
+#endif /* CONFIG_PPC_64K_PAGES */
+                .mask   = _PAGE_SPECIAL,
+                .val    = _PAGE_SPECIAL,
+                .set    = "special",
+        }
+};
+
+struct pgtable_level pg_level[5] = {
+        {
+        }, { /* pgd */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pud */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pmd */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pte */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        },
+};
diff --git a/arch/powerpc/mm/dump_linuxpagetables-generic.c b/arch/powerpc/mm/dump_linuxpagetables-generic.c
new file mode 100644
index 000000000000..1e3829ec1348
--- /dev/null
+++ b/arch/powerpc/mm/dump_linuxpagetables-generic.c
@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * From split of dump_linuxpagetables.c
+ * Copyright 2016, Rashmica Gupta, IBM Corp.
+ *
+ */
+#include <linux/kernel.h>
+#include <asm/pgtable.h>
+
+#include "dump_linuxpagetables.h"
+
+static const struct flag_info flag_array[] = {
+        {
+                .mask   = _PAGE_USER,
+                .val    = _PAGE_USER,
+                .set    = "user",
+                .clear  = "    ",
+        }, {
+                .mask   = _PAGE_RW,
+                .val    = _PAGE_RW,
+                .set    = "rw",
+                .clear  = "r ",
+        }, {
+#ifndef CONFIG_PPC_BOOK3S_32
+                .mask   = _PAGE_EXEC,
+                .val    = _PAGE_EXEC,
+                .set    = " X ",
+                .clear  = "   ",
+        }, {
+#endif
+                .mask   = _PAGE_PRESENT,
+                .val    = _PAGE_PRESENT,
+                .set    = "present",
+                .clear  = "       ",
+        }, {
+                .mask   = _PAGE_GUARDED,
+                .val    = _PAGE_GUARDED,
+                .set    = "guarded",
+                .clear  = "       ",
+        }, {
+                .mask   = _PAGE_DIRTY,
+                .val    = _PAGE_DIRTY,
+                .set    = "dirty",
+                .clear  = "     ",
+        }, {
+                .mask   = _PAGE_ACCESSED,
+                .val    = _PAGE_ACCESSED,
+                .set    = "accessed",
+                .clear  = "        ",
+        }, {
+                .mask   = _PAGE_WRITETHRU,
+                .val    = _PAGE_WRITETHRU,
+                .set    = "write through",
+                .clear  = "             ",
+        }, {
+                .mask   = _PAGE_NO_CACHE,
+                .val    = _PAGE_NO_CACHE,
+                .set    = "no cache",
+                .clear  = "        ",
+        }, {
+                .mask   = _PAGE_SPECIAL,
+                .val    = _PAGE_SPECIAL,
+                .set    = "special",
+        }
+};
+
+struct pgtable_level pg_level[5] = {
+        {
+        }, { /* pgd */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pud */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pmd */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        }, { /* pte */
+                .flag   = flag_array,
+                .num    = ARRAY_SIZE(flag_array),
+        },
+};
diff --git a/arch/powerpc/mm/dump_linuxpagetables.c b/arch/powerpc/mm/dump_linuxpagetables.c
index 876e2a3c79f2..2b74f8adf4d0 100644
--- a/arch/powerpc/mm/dump_linuxpagetables.c
+++ b/arch/powerpc/mm/dump_linuxpagetables.c
@@ -27,6 +27,8 @@
 #include <asm/page.h>
 #include <asm/pgalloc.h>
 
+#include "dump_linuxpagetables.h"
+
 #ifdef CONFIG_PPC32
 #define KERN_VIRT_START 0
 #endif
@@ -101,159 +103,6 @@ static struct addr_marker address_markers[] = {
         { -1,   NULL },
 };
 
-struct flag_info {
-        u64             mask;
-        u64             val;
-        const char      *set;
-        const char      *clear;
-        bool            is_val;
-        int             shift;
-};
-
-static const struct flag_info flag_array[] = {
-        {
-                .mask   = _PAGE_USER | _PAGE_PRIVILEGED,
-                .val    = _PAGE_USER,
-                .set    = "user",
-                .clear  = "    ",
-        }, {
-                .mask   = _PAGE_RW | _PAGE_RO | _PAGE_NA,
-                .val    = _PAGE_RW,
-                .set    = "rw",
-        }, {
-                .mask   = _PAGE_RW | _PAGE_RO | _PAGE_NA,
-                .val    = _PAGE_RO,
-                .set    = "ro",
-        }, {
-#if _PAGE_NA != 0
-                .mask   = _PAGE_RW | _PAGE_RO | _PAGE_NA,
-                .val    = _PAGE_RO,
-                .set    = "na",
-        }, {
-#endif
-                .mask   = _PAGE_EXEC,
-                .val    = _PAGE_EXEC,
-                .set    = " X ",
-                .clear  = "   ",
-        }, {
-                .mask   = _PAGE_PTE,
-                .val    = _PAGE_PTE,
-                .set    = "pte",
-                .clear  = "   ",
-        }, {
-                .mask   = _PAGE_PRESENT,
-                .val    = _PAGE_PRESENT,
-                .set    = "present",
-                .clear  = "       ",
-        }, {
-#ifdef CONFIG_PPC_BOOK3S_64
-                .mask   = H_PAGE_HASHPTE,
-                .val    = H_PAGE_HASHPTE,
-#else
-                .mask   = _PAGE_HASHPTE,
-                .val    = _PAGE_HASHPTE,
-#endif
-                .set    = "hpte",
-                .clear  = "    ",
-        }, {
-#ifndef CONFIG_PPC_BOOK3S_64
-                .mask   = _PAGE_GUARDED,
-                .val    = _PAGE_GUARDED,
-                .set    = "guarded",
-                .clear  = "       ",
-        }, {
-#endif
-                .mask   = _PAGE_DIRTY,
-                .val    = _PAGE_DIRTY,
-                .set    = "dirty",
-                .clear  = "     ",
-        }, {
-                .mask   = _PAGE_ACCESSED,
-                .val    = _PAGE_ACCESSED,
-                .set    = "accessed",
-                .clear  = "        ",
-        }, {
-#ifndef CONFIG_PPC_BOOK3S_64
-                .mask   = _PAGE_WRITETHRU,
-                .val    = _PAGE_WRITETHRU,
-                .set    = "write through",
-                .clear  = "             ",
-        }, {
-#endif
-#ifndef CONFIG_PPC_BOOK3S_64
-                .mask   = _PAGE_NO_CACHE,
-                .val    = _PAGE_NO_CACHE,
-                .set    = "no cache",
-                .clear  = "        ",
-        }, {
-#else
-                .mask   = _PAGE_NON_IDEMPOTENT,
-                .val    = _PAGE_NON_IDEMPOTENT,
-                .set    = "non-idempotent",
-                .clear  = "              ",
-        }, {
-                .mask   = _PAGE_TOLERANT,
-                .val    = _PAGE_TOLERANT,
-                .set    = "tolerant",
-                .clear  = "        ",
-        }, {
-#endif
-#ifdef CONFIG_PPC_BOOK3S_64
-                .mask   = H_PAGE_BUSY,
-                .val    = H_PAGE_BUSY,
-                .set    = "busy",
-        }, {
-#ifdef CONFIG_PPC_64K_PAGES
-                .mask   = H_PAGE_COMBO,
-                .val    = H_PAGE_COMBO,
-                .set    = "combo",
-        }, {
-                .mask   = H_PAGE_4K_PFN,
-                .val    = H_PAGE_4K_PFN,
-                .set    = "4K_pfn",
-        }, {
-#else /* CONFIG_PPC_64K_PAGES */
-                .mask   = H_PAGE_F_GIX,
-                .val    = H_PAGE_F_GIX,
-                .set    = "f_gix",
-                .is_val = true,
-                .shift  = H_PAGE_F_GIX_SHIFT,
-        }, {
-                .mask   = H_PAGE_F_SECOND,
-                .val    = H_PAGE_F_SECOND,
-                .set    = "f_second",
-        }, {
-#endif /* CONFIG_PPC_64K_PAGES */
-#endif
-                .mask   = _PAGE_SPECIAL,
-                .val    = _PAGE_SPECIAL,
-                .set    = "special",
-        }
-};
-
-struct pgtable_level {
-        const struct flag_info *flag;
-        size_t num;
-        u64 mask;
-};
-
-static struct pgtable_level pg_level[] = {
-        {
-        }, { /* pgd */
-                .flag   = flag_array,
-                .num    = ARRAY_SIZE(flag_array),
-        }, { /* pud */
-                .flag   = flag_array,
-                .num    = ARRAY_SIZE(flag_array),
-        }, { /* pmd */
-                .flag   = flag_array,
-                .num    = ARRAY_SIZE(flag_array),
-        }, { /* pte */
-                .flag   = flag_array,
-                .num    = ARRAY_SIZE(flag_array),
-        },
-};
-
 static void dump_flag_info(struct pg_state *st, const struct flag_info
                 *flag, u64 pte, int num)
 {
@@ -418,12 +267,13 @@ static void walk_pagetables(struct pg_state *st)
         unsigned int i;
         unsigned long addr;
 
+        addr = st->start_address;
+
         /*
          * Traverse the linux pagetable structure and dump pages that are in
          * the hash pagetable.
          */
-        for (i = 0; i < PTRS_PER_PGD; i++, pgd++) {
-                addr = KERN_VIRT_START + i * PGDIR_SIZE;
+        for (i = 0; i < PTRS_PER_PGD; i++, pgd++, addr += PGDIR_SIZE) {
                 if (!pgd_none(*pgd) && !pgd_huge(*pgd))
                         /* pgd exists */
                         walk_pud(st, pgd, addr);
@@ -472,9 +322,14 @@ static int ptdump_show(struct seq_file *m, void *v)
 {
         struct pg_state st = {
                 .seq = m,
-                .start_address = KERN_VIRT_START,
                 .marker = address_markers,
         };
+
+        if (radix_enabled())
+                st.start_address = PAGE_OFFSET;
+        else
+                st.start_address = KERN_VIRT_START;
+
         /* Traverse kernel page tables */
         walk_pagetables(&st);
         note_page(&st, 0, 0, 0);
diff --git a/arch/powerpc/mm/dump_linuxpagetables.h b/arch/powerpc/mm/dump_linuxpagetables.h
new file mode 100644
index 000000000000..5d513636de73
--- /dev/null
+++ b/arch/powerpc/mm/dump_linuxpagetables.h
@@ -0,0 +1,19 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <linux/types.h>
+
+struct flag_info {
+        u64             mask;
+        u64             val;
+        const char      *set;
+        const char      *clear;
+        bool            is_val;
+        int             shift;
+};
+
+struct pgtable_level {
+        const struct flag_info *flag;
+        size_t num;
+        u64 mask;
+};
+
+extern struct pgtable_level pg_level[5];
diff --git a/arch/powerpc/mm/hash_native_64.c b/arch/powerpc/mm/hash_native_64.c
index 729f02df8290..aaa28fd918fe 100644
--- a/arch/powerpc/mm/hash_native_64.c
+++ b/arch/powerpc/mm/hash_native_64.c
@@ -115,6 +115,8 @@ static void tlbiel_all_isa300(unsigned int num_sets, unsigned int is)
         tlbiel_hash_set_isa300(0, is, 0, 2, 1);
 
         asm volatile("ptesync": : :"memory");
+
+        asm volatile(PPC_INVALIDATE_ERAT "; isync" : : :"memory");
 }
 
 void hash__tlbiel_all(unsigned int action)
@@ -140,8 +142,6 @@ void hash__tlbiel_all(unsigned int action)
                 tlbiel_all_isa206(POWER7_TLB_SETS, is);
         else
                 WARN(1, "%s called on pre-POWER7 CPU\n", __func__);
-
-        asm volatile(PPC_INVALIDATE_ERAT "; isync" : : :"memory");
 }
 
 static inline unsigned long  ___tlbie(unsigned long vpn, int psize,
diff --git a/arch/powerpc/mm/hash_utils_64.c b/arch/powerpc/mm/hash_utils_64.c
index f23a89d8e4ce..0cc7fbc3bd1c 100644
--- a/arch/powerpc/mm/hash_utils_64.c
+++ b/arch/powerpc/mm/hash_utils_64.c
@@ -1001,9 +1001,9 @@ void __init hash__early_init_mmu(void)
          * 4k use hugepd format, so for hash set then to
          * zero
          */
-        __pmd_val_bits = 0;
-        __pud_val_bits = 0;
-        __pgd_val_bits = 0;
+        __pmd_val_bits = HASH_PMD_VAL_BITS;
+        __pud_val_bits = HASH_PUD_VAL_BITS;
+        __pgd_val_bits = HASH_PGD_VAL_BITS;
 
         __kernel_virt_start = H_KERN_VIRT_START;
         __kernel_virt_size = H_KERN_VIRT_SIZE;
@@ -1125,7 +1125,7 @@ void demote_segment_4k(struct mm_struct *mm, unsigned long addr)
         if ((get_paca_psize(addr) != MMU_PAGE_4K) && (current->mm == mm)) {
 
                 copy_mm_to_paca(mm);
-                slb_flush_and_rebolt();
+                slb_flush_and_restore_bolted();
         }
 }
 #endif /* CONFIG_PPC_64K_PAGES */
@@ -1197,7 +1197,7 @@ static void check_paca_psize(unsigned long ea, struct mm_struct *mm,
         if (user_region) {
                 if (psize != get_paca_psize(ea)) {
                         copy_mm_to_paca(mm);
-                        slb_flush_and_rebolt();
+                        slb_flush_and_restore_bolted();
                 }
         } else if (get_paca()->vmalloc_sllp !=
                    mmu_psize_defs[mmu_vmalloc_psize].sllp) {
@@ -1482,7 +1482,7 @@ static bool should_hash_preload(struct mm_struct *mm, unsigned long ea)
 #endif
 
 void hash_preload(struct mm_struct *mm, unsigned long ea,
-                  unsigned long access, unsigned long trap)
+                  bool is_exec, unsigned long trap)
 {
         int hugepage_shift;
         unsigned long vsid;
@@ -1490,6 +1490,7 @@ void hash_preload(struct mm_struct *mm, unsigned long ea,
         pte_t *ptep;
         unsigned long flags;
         int rc, ssize, update_flags = 0;
+        unsigned long access = _PAGE_PRESENT | _PAGE_READ | (is_exec ? _PAGE_EXEC : 0);
 
         BUG_ON(REGION_ID(ea) != USER_REGION_ID);
 
diff --git a/arch/powerpc/mm/hugepage-hash64.c b/arch/powerpc/mm/hugepage-hash64.c
index 01f213d2bcb9..dfbc3b32f09b 100644
--- a/arch/powerpc/mm/hugepage-hash64.c
+++ b/arch/powerpc/mm/hugepage-hash64.c
@@ -51,6 +51,12 @@ int __hash_page_thp(unsigned long ea, unsigned long access, unsigned long vsid,
                         new_pmd |= _PAGE_DIRTY;
         } while (!pmd_xchg(pmdp, __pmd(old_pmd), __pmd(new_pmd)));
 
+        /*
+         * Make sure this is thp or devmap entry
+         */
+        if (!(old_pmd & (H_PAGE_THP_HUGE | _PAGE_DEVMAP)))
+                return 0;
+
         rflags = htab_convert_pte_flags(new_pmd);
 
 #if 0
diff --git a/arch/powerpc/mm/hugetlbpage-hash64.c b/arch/powerpc/mm/hugetlbpage-hash64.c
index b320f5097a06..2e6a8f9345d3 100644
--- a/arch/powerpc/mm/hugetlbpage-hash64.c
+++ b/arch/powerpc/mm/hugetlbpage-hash64.c
@@ -62,6 +62,10 @@ int __hash_page_huge(unsigned long ea, unsigned long access, unsigned long vsid,
                         new_pte |= _PAGE_DIRTY;
         } while(!pte_xchg(ptep, __pte(old_pte), __pte(new_pte)));
 
+        /* Make sure this is a hugetlb entry */
+        if (old_pte & (H_PAGE_THP_HUGE | _PAGE_DEVMAP))
+                return 0;
+
         rflags = htab_convert_pte_flags(new_pte);
         if (unlikely(mmu_psize == MMU_PAGE_16G))
                 offset = PTRS_PER_PUD;
diff --git a/arch/powerpc/mm/hugetlbpage.c b/arch/powerpc/mm/hugetlbpage.c
index e87f9ef9115b..a7226ed9cae6 100644
--- a/arch/powerpc/mm/hugetlbpage.c
+++ b/arch/powerpc/mm/hugetlbpage.c
@@ -19,6 +19,7 @@
 #include <linux/moduleparam.h>
 #include <linux/swap.h>
 #include <linux/swapops.h>
+#include <linux/kmemleak.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/tlb.h>
@@ -95,7 +96,7 @@ static int __hugepte_alloc(struct mm_struct *mm, hugepd_t *hpdp,
                         break;
                 else {
 #ifdef CONFIG_PPC_BOOK3S_64
-                        *hpdp = __hugepd(__pa(new) |
+                        *hpdp = __hugepd(__pa(new) | HUGEPD_VAL_BITS |
                                          (shift_to_mmu_psize(pshift) << 2));
 #elif defined(CONFIG_PPC_8xx)
                         *hpdp = __hugepd(__pa(new) | _PMD_USER |
@@ -112,6 +113,8 @@ static int __hugepte_alloc(struct mm_struct *mm, hugepd_t *hpdp,
                 for (i = i - 1 ; i >= 0; i--, hpdp--)
                         *hpdp = __hugepd(0);
                 kmem_cache_free(cachep, new);
+        } else {
+                kmemleak_ignore(new);
         }
         spin_unlock(ptl);
         return 0;
@@ -837,8 +840,12 @@ pte_t *__find_linux_pte(pgd_t *pgdir, unsigned long ea,
                                 ret_pte = (pte_t *) pmdp;
                                 goto out;
                         }
-
-                        if (pmd_huge(pmd)) {
+                        /*
+                         * pmd_large check below will handle the swap pmd pte
+                         * we need to do both the check because they are config
+                         * dependent.
+                         */
+                        if (pmd_huge(pmd) || pmd_large(pmd)) {
                                 ret_pte = (pte_t *) pmdp;
                                 goto out;
                         } else if (is_hugepd(__hugepd(pmd_val(pmd))))
diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c
index 04ccb274a620..dd949d6649a2 100644
--- a/arch/powerpc/mm/mem.c
+++ b/arch/powerpc/mm/mem.c
@@ -309,11 +309,11 @@ void __init paging_init(void)
         unsigned long end = __fix_to_virt(FIX_HOLE);
 
         for (; v < end; v += PAGE_SIZE)
-                map_kernel_page(v, 0, 0); /* XXX gross */
+                map_kernel_page(v, 0, __pgprot(0)); /* XXX gross */
 #endif
 
 #ifdef CONFIG_HIGHMEM
-        map_kernel_page(PKMAP_BASE, 0, 0);      /* XXX gross */
+        map_kernel_page(PKMAP_BASE, 0, __pgprot(0));    /* XXX gross */
         pkmap_page_table = virt_to_kpte(PKMAP_BASE);
 
         kmap_pte = virt_to_kpte(__fix_to_virt(FIX_KMAP_BEGIN));
@@ -509,7 +509,8 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address,
          * We don't need to worry about _PAGE_PRESENT here because we are
          * called with either mm->page_table_lock held or ptl lock held
          */
-        unsigned long access, trap;
+        unsigned long trap;
+        bool is_exec;
 
         if (radix_enabled()) {
                 prefetch((void *)address);
@@ -531,16 +532,16 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address,
         trap = current->thread.regs ? TRAP(current->thread.regs) : 0UL;
         switch (trap) {
         case 0x300:
-                access = 0UL;
+                is_exec = false;
                 break;
         case 0x400:
-                access = _PAGE_EXEC;
+                is_exec = true;
                 break;
         default:
                 return;
         }
 
-        hash_preload(vma->vm_mm, address, access, trap);
+        hash_preload(vma->vm_mm, address, is_exec, trap);
 #endif /* CONFIG_PPC_STD_MMU */
 #if (defined(CONFIG_PPC_BOOK3E_64) || defined(CONFIG_PPC_FSL_BOOK3E)) \
         && defined(CONFIG_HUGETLB_PAGE)
diff --git a/arch/powerpc/mm/mmu_context_book3s64.c b/arch/powerpc/mm/mmu_context_book3s64.c
index dbd8f762140b..510f103d7813 100644
--- a/arch/powerpc/mm/mmu_context_book3s64.c
+++ b/arch/powerpc/mm/mmu_context_book3s64.c
@@ -53,6 +53,8 @@ int hash__alloc_context_id(void)
 }
 EXPORT_SYMBOL_GPL(hash__alloc_context_id);
 
+void slb_setup_new_exec(void);
+
 static int hash__init_new_context(struct mm_struct *mm)
 {
         int index;
@@ -84,6 +86,13 @@ static int hash__init_new_context(struct mm_struct *mm)
         return index;
 }
 
+void hash__setup_new_exec(void)
+{
+        slice_setup_new_exec();
+
+        slb_setup_new_exec();
+}
+
 static int radix__init_new_context(struct mm_struct *mm)
 {
         unsigned long rts_field;
diff --git a/arch/powerpc/mm/mmu_decl.h b/arch/powerpc/mm/mmu_decl.h
index e5d779eed181..8574fbbc45e0 100644
--- a/arch/powerpc/mm/mmu_decl.h
+++ b/arch/powerpc/mm/mmu_decl.h
@@ -22,6 +22,7 @@
 #include <asm/mmu.h>
 
 #ifdef CONFIG_PPC_MMU_NOHASH
+#include <asm/trace.h>
 
 /*
  * On 40x and 8xx, we directly inline tlbia and tlbivax
@@ -30,10 +31,12 @@
 static inline void _tlbil_all(void)
 {
         asm volatile ("sync; tlbia; isync" : : : "memory");
+        trace_tlbia(MMU_NO_CONTEXT);
 }
 static inline void _tlbil_pid(unsigned int pid)
 {
         asm volatile ("sync; tlbia; isync" : : : "memory");
+        trace_tlbia(pid);
 }
 #define _tlbil_pid_noind(pid)   _tlbil_pid(pid)
 
@@ -55,6 +58,7 @@ static inline void _tlbil_va(unsigned long address, unsigned int pid,
                              unsigned int tsize, unsigned int ind)
 {
         asm volatile ("tlbie %0; sync" : : "r" (address) : "memory");
+        trace_tlbie(0, 0, address, pid, 0, 0, 0);
 }
 #elif defined(CONFIG_PPC_BOOK3E)
 extern void _tlbil_va(unsigned long address, unsigned int pid,
@@ -82,7 +86,7 @@ static inline void _tlbivax_bcast(unsigned long address, unsigned int pid,
 #else /* CONFIG_PPC_MMU_NOHASH */
 
 extern void hash_preload(struct mm_struct *mm, unsigned long ea,
-                         unsigned long access, unsigned long trap);
+                         bool is_exec, unsigned long trap);
 
 
 extern void _tlbie(unsigned long address);
diff --git a/arch/powerpc/mm/numa.c b/arch/powerpc/mm/numa.c
index 055b211b7126..693ae1c1acba 100644
--- a/arch/powerpc/mm/numa.c
+++ b/arch/powerpc/mm/numa.c
@@ -1521,6 +1521,10 @@ int start_topology_update(void)
                 }
         }
 
+        pr_info("Starting topology update%s%s\n",
+                (prrn_enabled ? " prrn_enabled" : ""),
+                (vphn_enabled ? " vphn_enabled" : ""));
+
         return rc;
 }
 
@@ -1542,6 +1546,8 @@ int stop_topology_update(void)
                 rc = del_timer_sync(&topology_timer);
         }
 
+        pr_info("Stopping topology update\n");
+
         return rc;
 }
 
diff --git a/arch/powerpc/mm/pgtable-book3e.c b/arch/powerpc/mm/pgtable-book3e.c
index a2298930f990..e0ccf36714b2 100644
--- a/arch/powerpc/mm/pgtable-book3e.c
+++ b/arch/powerpc/mm/pgtable-book3e.c
@@ -42,7 +42,7 @@ int __meminit vmemmap_create_mapping(unsigned long start,
          * thus must have the low bits clear
          */
         for (i = 0; i < page_size; i += PAGE_SIZE)
-                BUG_ON(map_kernel_page(start + i, phys, flags));
+                BUG_ON(map_kernel_page(start + i, phys, __pgprot(flags)));
 
         return 0;
 }
@@ -70,7 +70,7 @@ static __ref void *early_alloc_pgtable(unsigned long size)
  * map_kernel_page adds an entry to the ioremap page table
  * and adds an entry to the HPT, possibly bolting it
  */
-int map_kernel_page(unsigned long ea, unsigned long pa, unsigned long flags)
+int map_kernel_page(unsigned long ea, unsigned long pa, pgprot_t prot)
 {
         pgd_t *pgdp;
         pud_t *pudp;
@@ -89,8 +89,6 @@ int map_kernel_page(unsigned long ea, unsigned long pa, unsigned long flags)
                 ptep = pte_alloc_kernel(pmdp, ea);
                 if (!ptep)
                         return -ENOMEM;
-                set_pte_at(&init_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT,
-                                                          __pgprot(flags)));
         } else {
                 pgdp = pgd_offset_k(ea);
 #ifndef __PAGETABLE_PUD_FOLDED
@@ -113,9 +111,8 @@ int map_kernel_page(unsigned long ea, unsigned long pa, unsigned long flags)
                         pmd_populate_kernel(&init_mm, pmdp, ptep);
                 }
                 ptep = pte_offset_kernel(pmdp, ea);
-                set_pte_at(&init_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT,
-                                                          __pgprot(flags)));
         }
+        set_pte_at(&init_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT, prot));
 
         smp_wmb();
         return 0;
diff --git a/arch/powerpc/mm/pgtable-book3s64.c b/arch/powerpc/mm/pgtable-book3s64.c
index 01d7c0f7c4f0..9f93c9f985c5 100644
--- a/arch/powerpc/mm/pgtable-book3s64.c
+++ b/arch/powerpc/mm/pgtable-book3s64.c
@@ -69,9 +69,14 @@ void set_pmd_at(struct mm_struct *mm, unsigned long addr,
                 pmd_t *pmdp, pmd_t pmd)
 {
 #ifdef CONFIG_DEBUG_VM
-        WARN_ON(pte_present(pmd_pte(*pmdp)) && !pte_protnone(pmd_pte(*pmdp)));
+        /*
+         * Make sure hardware valid bit is not set. We don't do
+         * tlb flush for this update.
+         */
+
+        WARN_ON(pte_hw_valid(pmd_pte(*pmdp)) && !pte_protnone(pmd_pte(*pmdp)));
         assert_spin_locked(pmd_lockptr(mm, pmdp));
-        WARN_ON(!(pmd_trans_huge(pmd) || pmd_devmap(pmd)));
+        WARN_ON(!(pmd_large(pmd) || pmd_devmap(pmd)));
 #endif
         trace_hugepage_set_pmd(addr, pmd_val(pmd));
         return set_pte_at(mm, addr, pmdp_ptep(pmdp), pmd_pte(pmd));
@@ -106,7 +111,7 @@ pmd_t pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
 {
         unsigned long old_pmd;
 
-        old_pmd = pmd_hugepage_update(vma->vm_mm, address, pmdp, _PAGE_PRESENT, 0);
+        old_pmd = pmd_hugepage_update(vma->vm_mm, address, pmdp, _PAGE_PRESENT, _PAGE_INVALID);
         flush_pmd_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
         /*
          * This ensures that generic code that rely on IRQ disabling
diff --git a/arch/powerpc/mm/pgtable-hash64.c b/arch/powerpc/mm/pgtable-hash64.c
index 692bfc9e372c..c08d49046a96 100644
--- a/arch/powerpc/mm/pgtable-hash64.c
+++ b/arch/powerpc/mm/pgtable-hash64.c
@@ -142,7 +142,7 @@ void hash__vmemmap_remove_mapping(unsigned long start,
  * map_kernel_page adds an entry to the ioremap page table
  * and adds an entry to the HPT, possibly bolting it
  */
-int hash__map_kernel_page(unsigned long ea, unsigned long pa, unsigned long flags)
+int hash__map_kernel_page(unsigned long ea, unsigned long pa, pgprot_t prot)
 {
         pgd_t *pgdp;
         pud_t *pudp;
@@ -161,8 +161,7 @@ int hash__map_kernel_page(unsigned long ea, unsigned long pa, unsigned long flag
                 ptep = pte_alloc_kernel(pmdp, ea);
                 if (!ptep)
                         return -ENOMEM;
-                set_pte_at(&init_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT,
-                                                          __pgprot(flags)));
+                set_pte_at(&init_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT, prot));
         } else {
                 /*
                  * If the mm subsystem is not fully up, we cannot create a
@@ -170,7 +169,7 @@ int hash__map_kernel_page(unsigned long ea, unsigned long pa, unsigned long flag
                  * entry in the hardware page table.
                  *
                  */
-                if (htab_bolt_mapping(ea, ea + PAGE_SIZE, pa, flags,
+                if (htab_bolt_mapping(ea, ea + PAGE_SIZE, pa, pgprot_val(prot),
                                       mmu_io_psize, mmu_kernel_ssize)) {
                         printk(KERN_ERR "Failed to do bolted mapping IO "
                                "memory at %016lx !\n", pa);
diff --git a/arch/powerpc/mm/pgtable-radix.c b/arch/powerpc/mm/pgtable-radix.c
index c879979faa73..931156069a81 100644
--- a/arch/powerpc/mm/pgtable-radix.c
+++ b/arch/powerpc/mm/pgtable-radix.c
@@ -241,9 +241,8 @@ void radix__mark_initmem_nx(void)
 }
 #endif /* CONFIG_STRICT_KERNEL_RWX */
 
-static inline void __meminit print_mapping(unsigned long start,
-                                           unsigned long end,
-                                           unsigned long size)
+static inline void __meminit
+print_mapping(unsigned long start, unsigned long end, unsigned long size, bool exec)
 {
         char buf[10];
 
@@ -252,7 +251,17 @@ static inline void __meminit print_mapping(unsigned long start,
 
         string_get_size(size, 1, STRING_UNITS_2, buf, sizeof(buf));
 
-        pr_info("Mapped 0x%016lx-0x%016lx with %s pages\n", start, end, buf);
+        pr_info("Mapped 0x%016lx-0x%016lx with %s pages%s\n", start, end, buf,
+                exec ? " (exec)" : "");
+}
+
+static unsigned long next_boundary(unsigned long addr, unsigned long end)
+{
+#ifdef CONFIG_STRICT_KERNEL_RWX
+        if (addr < __pa_symbol(__init_begin))
+                return __pa_symbol(__init_begin);
+#endif
+        return end;
 }
 
 static int __meminit create_physical_mapping(unsigned long start,
@@ -260,13 +269,8 @@ static int __meminit create_physical_mapping(unsigned long start,
                                              int nid)
 {
         unsigned long vaddr, addr, mapping_size = 0;
+        bool prev_exec, exec = false;
         pgprot_t prot;
-        unsigned long max_mapping_size;
-#ifdef CONFIG_STRICT_KERNEL_RWX
-        int split_text_mapping = 1;
-#else
-        int split_text_mapping = 0;
-#endif
         int psize;
 
         start = _ALIGN_UP(start, PAGE_SIZE);
@@ -274,14 +278,12 @@ static int __meminit create_physical_mapping(unsigned long start,
                 unsigned long gap, previous_size;
                 int rc;
 
-                gap = end - addr;
+                gap = next_boundary(addr, end) - addr;
                 previous_size = mapping_size;
-                max_mapping_size = PUD_SIZE;
+                prev_exec = exec;
 
-retry:
                 if (IS_ALIGNED(addr, PUD_SIZE) && gap >= PUD_SIZE &&
-                    mmu_psize_defs[MMU_PAGE_1G].shift &&
-                    PUD_SIZE <= max_mapping_size) {
+                    mmu_psize_defs[MMU_PAGE_1G].shift) {
                         mapping_size = PUD_SIZE;
                         psize = MMU_PAGE_1G;
                 } else if (IS_ALIGNED(addr, PMD_SIZE) && gap >= PMD_SIZE &&
@@ -293,32 +295,21 @@ retry:
                         psize = mmu_virtual_psize;
                 }
 
-                if (split_text_mapping && (mapping_size == PUD_SIZE) &&
-                        (addr <= __pa_symbol(__init_begin)) &&
-                        (addr + mapping_size) >= __pa_symbol(_stext)) {
-                        max_mapping_size = PMD_SIZE;
-                        goto retry;
-                }
-
-                if (split_text_mapping && (mapping_size == PMD_SIZE) &&
-                    (addr <= __pa_symbol(__init_begin)) &&
-                    (addr + mapping_size) >= __pa_symbol(_stext)) {
-                        mapping_size = PAGE_SIZE;
-                        psize = mmu_virtual_psize;
-                }
-
-                if (mapping_size != previous_size) {
-                        print_mapping(start, addr, previous_size);
-                        start = addr;
-                }
-
                 vaddr = (unsigned long)__va(addr);
 
                 if (overlaps_kernel_text(vaddr, vaddr + mapping_size) ||
-                    overlaps_interrupt_vector_text(vaddr, vaddr + mapping_size))
+                    overlaps_interrupt_vector_text(vaddr, vaddr + mapping_size)) {
                         prot = PAGE_KERNEL_X;
-                else
+                        exec = true;
+                } else {
                         prot = PAGE_KERNEL;
+                        exec = false;
+                }
+
+                if (mapping_size != previous_size || exec != prev_exec) {
+                        print_mapping(start, addr, previous_size, prev_exec);
+                        start = addr;
+                }
 
                 rc = __map_kernel_page(vaddr, addr, prot, mapping_size, nid, start, end);
                 if (rc)
@@ -327,7 +318,7 @@ retry:
                 update_page_count(psize, 1);
         }
 
-        print_mapping(start, addr, mapping_size);
+        print_mapping(start, addr, mapping_size, exec);
         return 0;
 }
 
diff --git a/arch/powerpc/mm/pgtable.c b/arch/powerpc/mm/pgtable.c
index d71c7777669c..010e1c616cb2 100644
--- a/arch/powerpc/mm/pgtable.c
+++ b/arch/powerpc/mm/pgtable.c
@@ -44,20 +44,13 @@ static inline int is_exec_fault(void)
 static inline int pte_looks_normal(pte_t pte)
 {
 
-#if defined(CONFIG_PPC_BOOK3S_64)
-        if ((pte_val(pte) & (_PAGE_PRESENT | _PAGE_SPECIAL)) == _PAGE_PRESENT) {
+        if (pte_present(pte) && !pte_special(pte)) {
                 if (pte_ci(pte))
                         return 0;
                 if (pte_user(pte))
                         return 1;
         }
         return 0;
-#else
-        return (pte_val(pte) &
-                (_PAGE_PRESENT | _PAGE_SPECIAL | _PAGE_NO_CACHE | _PAGE_USER |
-                 _PAGE_PRIVILEGED)) ==
-                (_PAGE_PRESENT | _PAGE_USER);
-#endif
 }
 
 static struct page *maybe_pte_to_page(pte_t pte)
@@ -73,7 +66,7 @@ static struct page *maybe_pte_to_page(pte_t pte)
         return page;
 }
 
-#if defined(CONFIG_PPC_STD_MMU) || _PAGE_EXEC == 0
+#ifdef CONFIG_PPC_BOOK3S
 
 /* Server-style MMU handles coherency when hashing if HW exec permission
  * is supposed per page (currently 64-bit only). If not, then, we always
@@ -106,7 +99,7 @@ static pte_t set_access_flags_filter(pte_t pte, struct vm_area_struct *vma,
         return pte;
 }
 
-#else /* defined(CONFIG_PPC_STD_MMU) || _PAGE_EXEC == 0 */
+#else /* CONFIG_PPC_BOOK3S */
 
 /* Embedded type MMU with HW exec support. This is a bit more complicated
  * as we don't have two bits to spare for _PAGE_EXEC and _PAGE_HWEXEC so
@@ -117,7 +110,7 @@ static pte_t set_pte_filter(pte_t pte)
         struct page *pg;
 
         /* No exec permission in the first place, move on */
-        if (!(pte_val(pte) & _PAGE_EXEC) || !pte_looks_normal(pte))
+        if (!pte_exec(pte) || !pte_looks_normal(pte))
                 return pte;
 
         /* If you set _PAGE_EXEC on weird pages you're on your own */
@@ -137,7 +130,7 @@ static pte_t set_pte_filter(pte_t pte)
         }
 
         /* Else, we filter out _PAGE_EXEC */
-        return __pte(pte_val(pte) & ~_PAGE_EXEC);
+        return pte_exprotect(pte);
 }
 
 static pte_t set_access_flags_filter(pte_t pte, struct vm_area_struct *vma,
@@ -150,7 +143,7 @@ static pte_t set_access_flags_filter(pte_t pte, struct vm_area_struct *vma,
          * if necessary. Also if _PAGE_EXEC is already set, same deal,
          * we just bail out
          */
-        if (dirty || (pte_val(pte) & _PAGE_EXEC) || !is_exec_fault())
+        if (dirty || pte_exec(pte) || !is_exec_fault())
                 return pte;
 
 #ifdef CONFIG_DEBUG_VM
@@ -176,10 +169,10 @@ static pte_t set_access_flags_filter(pte_t pte, struct vm_area_struct *vma,
         set_bit(PG_arch_1, &pg->flags);
 
  bail:
-        return __pte(pte_val(pte) | _PAGE_EXEC);
+        return pte_mkexec(pte);
 }
 
-#endif /* !(defined(CONFIG_PPC_STD_MMU) || _PAGE_EXEC == 0) */
+#endif /* CONFIG_PPC_BOOK3S */
 
 /*
  * set_pte stores a linux PTE into the linux page table.
@@ -188,14 +181,13 @@ void set_pte_at(struct mm_struct *mm, unsigned long addr, pte_t *ptep,
                 pte_t pte)
 {
         /*
-         * When handling numa faults, we already have the pte marked
-         * _PAGE_PRESENT, but we can be sure that it is not in hpte.
-         * Hence we can use set_pte_at for them.
+         * Make sure hardware valid bit is not set. We don't do
+         * tlb flush for this update.
          */
-        VM_WARN_ON(pte_present(*ptep) && !pte_protnone(*ptep));
+        VM_WARN_ON(pte_hw_valid(*ptep) && !pte_protnone(*ptep));
 
         /* Add the pte bit when trying to set a pte */
-        pte = __pte(pte_val(pte) | _PAGE_PTE);
+        pte = pte_mkpte(pte);
 
         /* Note: mm->context.id might not yet have been assigned as
          * this context might not have been activated yet when this
diff --git a/arch/powerpc/mm/pgtable_32.c b/arch/powerpc/mm/pgtable_32.c
index 120a49bfb9c6..5877f5aa8f5d 100644
--- a/arch/powerpc/mm/pgtable_32.c
+++ b/arch/powerpc/mm/pgtable_32.c
@@ -76,56 +76,69 @@ pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
 void __iomem *
 ioremap(phys_addr_t addr, unsigned long size)
 {
-        return __ioremap_caller(addr, size, _PAGE_NO_CACHE | _PAGE_GUARDED,
-                                __builtin_return_address(0));
+        pgprot_t prot = pgprot_noncached(PAGE_KERNEL);
+
+        return __ioremap_caller(addr, size, prot, __builtin_return_address(0));
 }
 EXPORT_SYMBOL(ioremap);
 
 void __iomem *
 ioremap_wc(phys_addr_t addr, unsigned long size)
 {
-        return __ioremap_caller(addr, size, _PAGE_NO_CACHE,
-                                __builtin_return_address(0));
+        pgprot_t prot = pgprot_noncached_wc(PAGE_KERNEL);
+
+        return __ioremap_caller(addr, size, prot, __builtin_return_address(0));
 }
 EXPORT_SYMBOL(ioremap_wc);
 
 void __iomem *
+ioremap_wt(phys_addr_t addr, unsigned long size)
+{
+        pgprot_t prot = pgprot_cached_wthru(PAGE_KERNEL);
+
+        return __ioremap_caller(addr, size, prot, __builtin_return_address(0));
+}
+EXPORT_SYMBOL(ioremap_wt);
+
+void __iomem *
+ioremap_coherent(phys_addr_t addr, unsigned long size)
+{
+        pgprot_t prot = pgprot_cached(PAGE_KERNEL);
+
+        return __ioremap_caller(addr, size, prot, __builtin_return_address(0));
+}
+EXPORT_SYMBOL(ioremap_coherent);
+
+void __iomem *
 ioremap_prot(phys_addr_t addr, unsigned long size, unsigned long flags)
 {
+        pte_t pte = __pte(flags);
+
         /* writeable implies dirty for kernel addresses */
-        if ((flags & (_PAGE_RW | _PAGE_RO)) != _PAGE_RO)
-                flags |= _PAGE_DIRTY | _PAGE_HWWRITE;
+        if (pte_write(pte))
+                pte = pte_mkdirty(pte);
 
         /* we don't want to let _PAGE_USER and _PAGE_EXEC leak out */
-        flags &= ~(_PAGE_USER | _PAGE_EXEC);
-        flags |= _PAGE_PRIVILEGED;
+        pte = pte_exprotect(pte);
+        pte = pte_mkprivileged(pte);
 
-        return __ioremap_caller(addr, size, flags, __builtin_return_address(0));
+        return __ioremap_caller(addr, size, pte_pgprot(pte), __builtin_return_address(0));
 }
 EXPORT_SYMBOL(ioremap_prot);
 
 void __iomem *
 __ioremap(phys_addr_t addr, unsigned long size, unsigned long flags)
 {
-        return __ioremap_caller(addr, size, flags, __builtin_return_address(0));
+        return __ioremap_caller(addr, size, __pgprot(flags), __builtin_return_address(0));
 }
 
 void __iomem *
-__ioremap_caller(phys_addr_t addr, unsigned long size, unsigned long flags,
-                 void *caller)
+__ioremap_caller(phys_addr_t addr, unsigned long size, pgprot_t prot, void *caller)
 {
         unsigned long v, i;
         phys_addr_t p;
         int err;
 
-        /* Make sure we have the base flags */
-        if ((flags & _PAGE_PRESENT) == 0)
-                flags |= pgprot_val(PAGE_KERNEL);
-
-        /* Non-cacheable page cannot be coherent */
-        if (flags & _PAGE_NO_CACHE)
-                flags &= ~_PAGE_COHERENT;
-
         /*
          * Choose an address to map it to.
          * Once the vmalloc system is running, we use it.
@@ -183,7 +196,7 @@ __ioremap_caller(phys_addr_t addr, unsigned long size, unsigned long flags,
 
         err = 0;
         for (i = 0; i < size && err == 0; i += PAGE_SIZE)
-                err = map_kernel_page(v+i, p+i, flags);
+                err = map_kernel_page(v + i, p + i, prot);
         if (err) {
                 if (slab_is_available())
                         vunmap((void *)v);
@@ -209,7 +222,7 @@ void iounmap(volatile void __iomem *addr)
 }
 EXPORT_SYMBOL(iounmap);
 
-int map_kernel_page(unsigned long va, phys_addr_t pa, int flags)
+int map_kernel_page(unsigned long va, phys_addr_t pa, pgprot_t prot)
 {
         pmd_t *pd;
         pte_t *pg;
@@ -224,10 +237,8 @@ int map_kernel_page(unsigned long va, phys_addr_t pa, int flags)
                 /* The PTE should never be already set nor present in the
                  * hash table
                  */
-                BUG_ON((pte_val(*pg) & (_PAGE_PRESENT | _PAGE_HASHPTE)) &&
-                       flags);
-                set_pte_at(&init_mm, va, pg, pfn_pte(pa >> PAGE_SHIFT,
-                                                     __pgprot(flags)));
+                BUG_ON((pte_present(*pg) | pte_hashpte(*pg)) && pgprot_val(prot));
+                set_pte_at(&init_mm, va, pg, pfn_pte(pa >> PAGE_SHIFT, prot));
         }
         smp_wmb();
         return err;
@@ -238,7 +249,7 @@ int map_kernel_page(unsigned long va, phys_addr_t pa, int flags)
  */
 static void __init __mapin_ram_chunk(unsigned long offset, unsigned long top)
 {
-        unsigned long v, s, f;
+        unsigned long v, s;
         phys_addr_t p;
         int ktext;
 
@@ -248,11 +259,10 @@ static void __init __mapin_ram_chunk(unsigned long offset, unsigned long top)
         for (; s < top; s += PAGE_SIZE) {
                 ktext = ((char *)v >= _stext && (char *)v < etext) ||
                         ((char *)v >= _sinittext && (char *)v < _einittext);
-                f = ktext ? pgprot_val(PAGE_KERNEL_TEXT) : pgprot_val(PAGE_KERNEL);
-                map_kernel_page(v, p, f);
+                map_kernel_page(v, p, ktext ? PAGE_KERNEL_TEXT : PAGE_KERNEL);
 #ifdef CONFIG_PPC_STD_MMU_32
                 if (ktext)
-                        hash_preload(&init_mm, v, 0, 0x300);
+                        hash_preload(&init_mm, v, false, 0x300);
 #endif
                 v += PAGE_SIZE;
                 p += PAGE_SIZE;
diff --git a/arch/powerpc/mm/pgtable_64.c b/arch/powerpc/mm/pgtable_64.c
index 53e9eeecd5d4..fb1375c07e8c 100644
--- a/arch/powerpc/mm/pgtable_64.c
+++ b/arch/powerpc/mm/pgtable_64.c
@@ -113,17 +113,12 @@ unsigned long ioremap_bot = IOREMAP_BASE;
  * __ioremap_at - Low level function to establish the page tables
  *                for an IO mapping
  */
-void __iomem * __ioremap_at(phys_addr_t pa, void *ea, unsigned long size,
-                            unsigned long flags)
+void __iomem *__ioremap_at(phys_addr_t pa, void *ea, unsigned long size, pgprot_t prot)
 {
         unsigned long i;
 
-        /* Make sure we have the base flags */
-        if ((flags & _PAGE_PRESENT) == 0)
-                flags |= pgprot_val(PAGE_KERNEL);
-
         /* We don't support the 4K PFN hack with ioremap */
-        if (flags & H_PAGE_4K_PFN)
+        if (pgprot_val(prot) & H_PAGE_4K_PFN)
                 return NULL;
 
         WARN_ON(pa & ~PAGE_MASK);
@@ -131,7 +126,7 @@ void __iomem * __ioremap_at(phys_addr_t pa, void *ea, unsigned long size,
         WARN_ON(size & ~PAGE_MASK);
 
         for (i = 0; i < size; i += PAGE_SIZE)
-                if (map_kernel_page((unsigned long)ea+i, pa+i, flags))
+                if (map_kernel_page((unsigned long)ea + i, pa + i, prot))
                         return NULL;
 
         return (void __iomem *)ea;
@@ -152,7 +147,7 @@ void __iounmap_at(void *ea, unsigned long size)
 }
 
 void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size,
-                                unsigned long flags, void *caller)
+                                pgprot_t prot, void *caller)
 {
         phys_addr_t paligned;
         void __iomem *ret;
@@ -182,11 +177,11 @@ void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size,
                         return NULL;
 
                 area->phys_addr = paligned;
-                ret = __ioremap_at(paligned, area->addr, size, flags);
+                ret = __ioremap_at(paligned, area->addr, size, prot);
                 if (!ret)
                         vunmap(area->addr);
         } else {
-                ret = __ioremap_at(paligned, (void *)ioremap_bot, size, flags);
+                ret = __ioremap_at(paligned, (void *)ioremap_bot, size, prot);
                 if (ret)
                         ioremap_bot += size;
         }
@@ -199,49 +194,59 @@ void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size,
 void __iomem * __ioremap(phys_addr_t addr, unsigned long size,
                          unsigned long flags)
 {
-        return __ioremap_caller(addr, size, flags, __builtin_return_address(0));
+        return __ioremap_caller(addr, size, __pgprot(flags), __builtin_return_address(0));
 }
 
 void __iomem * ioremap(phys_addr_t addr, unsigned long size)
 {
-        unsigned long flags = pgprot_val(pgprot_noncached(__pgprot(0)));
+        pgprot_t prot = pgprot_noncached(PAGE_KERNEL);
         void *caller = __builtin_return_address(0);
 
         if (ppc_md.ioremap)
-                return ppc_md.ioremap(addr, size, flags, caller);
-        return __ioremap_caller(addr, size, flags, caller);
+                return ppc_md.ioremap(addr, size, prot, caller);
+        return __ioremap_caller(addr, size, prot, caller);
 }
 
 void __iomem * ioremap_wc(phys_addr_t addr, unsigned long size)
 {
-        unsigned long flags = pgprot_val(pgprot_noncached_wc(__pgprot(0)));
+        pgprot_t prot = pgprot_noncached_wc(PAGE_KERNEL);
+        void *caller = __builtin_return_address(0);
+
+        if (ppc_md.ioremap)
+                return ppc_md.ioremap(addr, size, prot, caller);
+        return __ioremap_caller(addr, size, prot, caller);
+}
+
+void __iomem *ioremap_coherent(phys_addr_t addr, unsigned long size)
+{
+        pgprot_t prot = pgprot_cached(PAGE_KERNEL);
         void *caller = __builtin_return_address(0);
 
         if (ppc_md.ioremap)
-                return ppc_md.ioremap(addr, size, flags, caller);
-        return __ioremap_caller(addr, size, flags, caller);
+                return ppc_md.ioremap(addr, size, prot, caller);
+        return __ioremap_caller(addr, size, prot, caller);
 }
 
 void __iomem * ioremap_prot(phys_addr_t addr, unsigned long size,
                              unsigned long flags)
 {
+        pte_t pte = __pte(flags);
         void *caller = __builtin_return_address(0);
 
         /* writeable implies dirty for kernel addresses */
-        if (flags & _PAGE_WRITE)
-                flags |= _PAGE_DIRTY;
+        if (pte_write(pte))
+                pte = pte_mkdirty(pte);
 
         /* we don't want to let _PAGE_EXEC leak out */
-        flags &= ~_PAGE_EXEC;
+        pte = pte_exprotect(pte);
         /*
          * Force kernel mapping.
          */
-        flags &= ~_PAGE_USER;
-        flags |= _PAGE_PRIVILEGED;
+        pte = pte_mkprivileged(pte);
 
         if (ppc_md.ioremap)
-                return ppc_md.ioremap(addr, size, flags, caller);
-        return __ioremap_caller(addr, size, flags, caller);
+                return ppc_md.ioremap(addr, size, pte_pgprot(pte), caller);
+        return __ioremap_caller(addr, size, pte_pgprot(pte), caller);
 }
 
 
@@ -306,7 +311,7 @@ struct page *pud_page(pud_t pud)
  */
 struct page *pmd_page(pmd_t pmd)
 {
-        if (pmd_trans_huge(pmd) || pmd_huge(pmd) || pmd_devmap(pmd))
+        if (pmd_large(pmd) || pmd_huge(pmd) || pmd_devmap(pmd))
                 return pte_page(pmd_pte(pmd));
         return virt_to_page(pmd_page_vaddr(pmd));
 }
diff --git a/arch/powerpc/mm/ppc_mmu_32.c b/arch/powerpc/mm/ppc_mmu_32.c
index bea6c544e38f..38a793bfca37 100644
--- a/arch/powerpc/mm/ppc_mmu_32.c
+++ b/arch/powerpc/mm/ppc_mmu_32.c
@@ -163,7 +163,7 @@ void __init setbat(int index, unsigned long virt, phys_addr_t phys,
  * Preload a translation in the hash table
  */
 void hash_preload(struct mm_struct *mm, unsigned long ea,
-                  unsigned long access, unsigned long trap)
+                  bool is_exec, unsigned long trap)
 {
         pmd_t *pmd;
 
diff --git a/arch/powerpc/mm/slb.c b/arch/powerpc/mm/slb.c
index 9f574e59d178..c3fdf2969d9f 100644
--- a/arch/powerpc/mm/slb.c
+++ b/arch/powerpc/mm/slb.c
@@ -14,6 +14,7 @@
  *      2 of the License, or (at your option) any later version.
  */
 
+#include <asm/asm-prototypes.h>
 #include <asm/pgtable.h>
 #include <asm/mmu.h>
 #include <asm/mmu_context.h>
@@ -30,11 +31,10 @@
 
 enum slb_index {
         LINEAR_INDEX    = 0, /* Kernel linear map  (0xc000000000000000) */
-        VMALLOC_INDEX   = 1, /* Kernel virtual map (0xd000000000000000) */
-        KSTACK_INDEX    = 2, /* Kernel stack map */
+        KSTACK_INDEX    = 1, /* Kernel stack map */
 };
 
-extern void slb_allocate(unsigned long ea);
+static long slb_allocate_user(struct mm_struct *mm, unsigned long ea);
 
 #define slb_esid_mask(ssize)    \
         (((ssize) == MMU_SEGSIZE_256M)? ESID_MASK: ESID_MASK_1T)
@@ -45,13 +45,43 @@ static inline unsigned long mk_esid_data(unsigned long ea, int ssize,
         return (ea & slb_esid_mask(ssize)) | SLB_ESID_V | index;
 }
 
-static inline unsigned long mk_vsid_data(unsigned long ea, int ssize,
+static inline unsigned long __mk_vsid_data(unsigned long vsid, int ssize,
                                          unsigned long flags)
 {
-        return (get_kernel_vsid(ea, ssize) << slb_vsid_shift(ssize)) | flags |
+        return (vsid << slb_vsid_shift(ssize)) | flags |
                 ((unsigned long) ssize << SLB_VSID_SSIZE_SHIFT);
 }
 
+static inline unsigned long mk_vsid_data(unsigned long ea, int ssize,
+                                         unsigned long flags)
+{
+        return __mk_vsid_data(get_kernel_vsid(ea, ssize), ssize, flags);
+}
+
+static void assert_slb_exists(unsigned long ea)
+{
+#ifdef CONFIG_DEBUG_VM
+        unsigned long tmp;
+
+        WARN_ON_ONCE(mfmsr() & MSR_EE);
+
+        asm volatile("slbfee. %0, %1" : "=r"(tmp) : "r"(ea) : "cr0");
+        WARN_ON(tmp == 0);
+#endif
+}
+
+static void assert_slb_notexists(unsigned long ea)
+{
+#ifdef CONFIG_DEBUG_VM
+        unsigned long tmp;
+
+        WARN_ON_ONCE(mfmsr() & MSR_EE);
+
+        asm volatile("slbfee. %0, %1" : "=r"(tmp) : "r"(ea) : "cr0");
+        WARN_ON(tmp != 0);
+#endif
+}
+
 static inline void slb_shadow_update(unsigned long ea, int ssize,
                                      unsigned long flags,
                                      enum slb_index index)
@@ -84,6 +114,7 @@ static inline void create_shadowed_slbe(unsigned long ea, int ssize,
          */
         slb_shadow_update(ea, ssize, flags, index);
 
+        assert_slb_notexists(ea);
         asm volatile("slbmte  %0,%1" :
                      : "r" (mk_vsid_data(ea, ssize, flags)),
                        "r" (mk_esid_data(ea, ssize, index))
@@ -105,17 +136,20 @@ void __slb_restore_bolted_realmode(void)
                      : "r" (be64_to_cpu(p->save_area[index].vsid)),
                        "r" (be64_to_cpu(p->save_area[index].esid)));
         }
+
+        assert_slb_exists(local_paca->kstack);
 }
 
 /*
  * Insert the bolted entries into an empty SLB.
- * This is not the same as rebolt because the bolted segments are not
- * changed, just loaded from the shadow area.
  */
 void slb_restore_bolted_realmode(void)
 {
         __slb_restore_bolted_realmode();
         get_paca()->slb_cache_ptr = 0;
+
+        get_paca()->slb_kern_bitmap = (1U << SLB_NUM_BOLTED) - 1;
+        get_paca()->slb_used_bitmap = get_paca()->slb_kern_bitmap;
 }
 
 /*
@@ -123,113 +157,262 @@ void slb_restore_bolted_realmode(void)
  */
 void slb_flush_all_realmode(void)
 {
-        /*
-         * This flushes all SLB entries including 0, so it must be realmode.
-         */
         asm volatile("slbmte %0,%0; slbia" : : "r" (0));
 }
 
-static void __slb_flush_and_rebolt(void)
+/*
+ * This flushes non-bolted entries, it can be run in virtual mode. Must
+ * be called with interrupts disabled.
+ */
+void slb_flush_and_restore_bolted(void)
 {
-        /* If you change this make sure you change SLB_NUM_BOLTED
-         * and PR KVM appropriately too. */
-        unsigned long linear_llp, vmalloc_llp, lflags, vflags;
-        unsigned long ksp_esid_data, ksp_vsid_data;
+        struct slb_shadow *p = get_slb_shadow();
 
-        linear_llp = mmu_psize_defs[mmu_linear_psize].sllp;
-        vmalloc_llp = mmu_psize_defs[mmu_vmalloc_psize].sllp;
-        lflags = SLB_VSID_KERNEL | linear_llp;
-        vflags = SLB_VSID_KERNEL | vmalloc_llp;
+        BUILD_BUG_ON(SLB_NUM_BOLTED != 2);
 
-        ksp_esid_data = mk_esid_data(get_paca()->kstack, mmu_kernel_ssize, KSTACK_INDEX);
-        if ((ksp_esid_data & ~0xfffffffUL) <= PAGE_OFFSET) {
-                ksp_esid_data &= ~SLB_ESID_V;
-                ksp_vsid_data = 0;
-                slb_shadow_clear(KSTACK_INDEX);
-        } else {
-                /* Update stack entry; others don't change */
-                slb_shadow_update(get_paca()->kstack, mmu_kernel_ssize, lflags, KSTACK_INDEX);
-                ksp_vsid_data =
-                        be64_to_cpu(get_slb_shadow()->save_area[KSTACK_INDEX].vsid);
-        }
+        WARN_ON(!irqs_disabled());
+
+        /*
+         * We can't take a PMU exception in the following code, so hard
+         * disable interrupts.
+         */
+        hard_irq_disable();
 
-        /* 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"
                      "slbia\n"
-                     /* Slot 1 - first VMALLOC segment */
-                     "slbmte    %0,%1\n"
-                     /* Slot 2 - kernel stack */
-                     "slbmte    %2,%3\n"
-                     "isync"
-                     :: "r"(mk_vsid_data(VMALLOC_START, mmu_kernel_ssize, vflags)),
-                        "r"(mk_esid_data(VMALLOC_START, mmu_kernel_ssize, VMALLOC_INDEX)),
-                        "r"(ksp_vsid_data),
-                        "r"(ksp_esid_data)
+                     "slbmte  %0, %1\n"
+                     "isync\n"
+                     :: "r" (be64_to_cpu(p->save_area[KSTACK_INDEX].vsid)),
+                        "r" (be64_to_cpu(p->save_area[KSTACK_INDEX].esid))
                      : "memory");
+        assert_slb_exists(get_paca()->kstack);
+
+        get_paca()->slb_cache_ptr = 0;
+
+        get_paca()->slb_kern_bitmap = (1U << SLB_NUM_BOLTED) - 1;
+        get_paca()->slb_used_bitmap = get_paca()->slb_kern_bitmap;
 }
 
-void slb_flush_and_rebolt(void)
+void slb_save_contents(struct slb_entry *slb_ptr)
 {
+        int i;
+        unsigned long e, v;
 
-        WARN_ON(!irqs_disabled());
+        /* Save slb_cache_ptr value. */
+        get_paca()->slb_save_cache_ptr = get_paca()->slb_cache_ptr;
+
+        if (!slb_ptr)
+                return;
+
+        for (i = 0; i < mmu_slb_size; i++) {
+                asm volatile("slbmfee  %0,%1" : "=r" (e) : "r" (i));
+                asm volatile("slbmfev  %0,%1" : "=r" (v) : "r" (i));
+                slb_ptr->esid = e;
+                slb_ptr->vsid = v;
+                slb_ptr++;
+        }
+}
+
+void slb_dump_contents(struct slb_entry *slb_ptr)
+{
+        int i, n;
+        unsigned long e, v;
+        unsigned long llp;
+
+        if (!slb_ptr)
+                return;
+
+        pr_err("SLB contents of cpu 0x%x\n", smp_processor_id());
+        pr_err("Last SLB entry inserted at slot %d\n", get_paca()->stab_rr);
+
+        for (i = 0; i < mmu_slb_size; i++) {
+                e = slb_ptr->esid;
+                v = slb_ptr->vsid;
+                slb_ptr++;
+
+                if (!e && !v)
+                        continue;
+
+                pr_err("%02d %016lx %016lx\n", i, e, v);
+
+                if (!(e & SLB_ESID_V)) {
+                        pr_err("\n");
+                        continue;
+                }
+                llp = v & SLB_VSID_LLP;
+                if (v & SLB_VSID_B_1T) {
+                        pr_err("  1T  ESID=%9lx  VSID=%13lx LLP:%3lx\n",
+                               GET_ESID_1T(e),
+                               (v & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T, llp);
+                } else {
+                        pr_err(" 256M ESID=%9lx  VSID=%13lx LLP:%3lx\n",
+                               GET_ESID(e),
+                               (v & ~SLB_VSID_B) >> SLB_VSID_SHIFT, llp);
+                }
+        }
+        pr_err("----------------------------------\n");
+
+        /* Dump slb cache entires as well. */
+        pr_err("SLB cache ptr value = %d\n", get_paca()->slb_save_cache_ptr);
+        pr_err("Valid SLB cache entries:\n");
+        n = min_t(int, get_paca()->slb_save_cache_ptr, SLB_CACHE_ENTRIES);
+        for (i = 0; i < n; i++)
+                pr_err("%02d EA[0-35]=%9x\n", i, get_paca()->slb_cache[i]);
+        pr_err("Rest of SLB cache entries:\n");
+        for (i = n; i < SLB_CACHE_ENTRIES; i++)
+                pr_err("%02d EA[0-35]=%9x\n", i, get_paca()->slb_cache[i]);
+}
 
+void slb_vmalloc_update(void)
+{
         /*
-         * We can't take a PMU exception in the following code, so hard
-         * disable interrupts.
+         * vmalloc is not bolted, so just have to flush non-bolted.
          */
-        hard_irq_disable();
+        slb_flush_and_restore_bolted();
+}
 
-        __slb_flush_and_rebolt();
-        get_paca()->slb_cache_ptr = 0;
+static bool preload_hit(struct thread_info *ti, unsigned long esid)
+{
+        unsigned char i;
+
+        for (i = 0; i < ti->slb_preload_nr; i++) {
+                unsigned char idx;
+
+                idx = (ti->slb_preload_tail + i) % SLB_PRELOAD_NR;
+                if (esid == ti->slb_preload_esid[idx])
+                        return true;
+        }
+        return false;
 }
 
-void slb_vmalloc_update(void)
+static bool preload_add(struct thread_info *ti, unsigned long ea)
 {
-        unsigned long vflags;
+        unsigned char idx;
+        unsigned long esid;
+
+        if (mmu_has_feature(MMU_FTR_1T_SEGMENT)) {
+                /* EAs are stored >> 28 so 256MB segments don't need clearing */
+                if (ea & ESID_MASK_1T)
+                        ea &= ESID_MASK_1T;
+        }
+
+        esid = ea >> SID_SHIFT;
 
-        vflags = SLB_VSID_KERNEL | mmu_psize_defs[mmu_vmalloc_psize].sllp;
-        slb_shadow_update(VMALLOC_START, mmu_kernel_ssize, vflags, VMALLOC_INDEX);
-        slb_flush_and_rebolt();
+        if (preload_hit(ti, esid))
+                return false;
+
+        idx = (ti->slb_preload_tail + ti->slb_preload_nr) % SLB_PRELOAD_NR;
+        ti->slb_preload_esid[idx] = esid;
+        if (ti->slb_preload_nr == SLB_PRELOAD_NR)
+                ti->slb_preload_tail = (ti->slb_preload_tail + 1) % SLB_PRELOAD_NR;
+        else
+                ti->slb_preload_nr++;
+
+        return true;
 }
 
-/* Helper function to compare esids.  There are four cases to handle.
- * 1. The system is not 1T segment size capable.  Use the GET_ESID compare.
- * 2. The system is 1T capable, both addresses are < 1T, use the GET_ESID compare.
- * 3. The system is 1T capable, only one of the two addresses is > 1T.  This is not a match.
- * 4. The system is 1T capable, both addresses are > 1T, use the GET_ESID_1T macro to compare.
- */
-static inline int esids_match(unsigned long addr1, unsigned long addr2)
+static void preload_age(struct thread_info *ti)
 {
-        int esid_1t_count;
+        if (!ti->slb_preload_nr)
+                return;
+        ti->slb_preload_nr--;
+        ti->slb_preload_tail = (ti->slb_preload_tail + 1) % SLB_PRELOAD_NR;
+}
 
-        /* System is not 1T segment size capable. */
-        if (!mmu_has_feature(MMU_FTR_1T_SEGMENT))
-                return (GET_ESID(addr1) == GET_ESID(addr2));
+void slb_setup_new_exec(void)
+{
+        struct thread_info *ti = current_thread_info();
+        struct mm_struct *mm = current->mm;
+        unsigned long exec = 0x10000000;
 
-        esid_1t_count = (((addr1 >> SID_SHIFT_1T) != 0) +
-                                ((addr2 >> SID_SHIFT_1T) != 0));
+        WARN_ON(irqs_disabled());
 
-        /* both addresses are < 1T */
-        if (esid_1t_count == 0)
-                return (GET_ESID(addr1) == GET_ESID(addr2));
+        /*
+         * preload cache can only be used to determine whether a SLB
+         * entry exists if it does not start to overflow.
+         */
+        if (ti->slb_preload_nr + 2 > SLB_PRELOAD_NR)
+                return;
 
-        /* One address < 1T, the other > 1T.  Not a match */
-        if (esid_1t_count == 1)
-                return 0;
+        hard_irq_disable();
 
-        /* Both addresses are > 1T. */
-        return (GET_ESID_1T(addr1) == GET_ESID_1T(addr2));
+        /*
+         * We have no good place to clear the slb preload cache on exec,
+         * flush_thread is about the earliest arch hook but that happens
+         * after we switch to the mm and have aleady preloaded the SLBEs.
+         *
+         * For the most part that's probably okay to use entries from the
+         * previous exec, they will age out if unused. It may turn out to
+         * be an advantage to clear the cache before switching to it,
+         * however.
+         */
+
+        /*
+         * preload some userspace segments into the SLB.
+         * Almost all 32 and 64bit PowerPC executables are linked at
+         * 0x10000000 so it makes sense to preload this segment.
+         */
+        if (!is_kernel_addr(exec)) {
+                if (preload_add(ti, exec))
+                        slb_allocate_user(mm, exec);
+        }
+
+        /* Libraries and mmaps. */
+        if (!is_kernel_addr(mm->mmap_base)) {
+                if (preload_add(ti, mm->mmap_base))
+                        slb_allocate_user(mm, mm->mmap_base);
+        }
+
+        /* see switch_slb */
+        asm volatile("isync" : : : "memory");
+
+        local_irq_enable();
 }
 
+void preload_new_slb_context(unsigned long start, unsigned long sp)
+{
+        struct thread_info *ti = current_thread_info();
+        struct mm_struct *mm = current->mm;
+        unsigned long heap = mm->start_brk;
+
+        WARN_ON(irqs_disabled());
+
+        /* see above */
+        if (ti->slb_preload_nr + 3 > SLB_PRELOAD_NR)
+                return;
+
+        hard_irq_disable();
+
+        /* Userspace entry address. */
+        if (!is_kernel_addr(start)) {
+                if (preload_add(ti, start))
+                        slb_allocate_user(mm, start);
+        }
+
+        /* Top of stack, grows down. */
+        if (!is_kernel_addr(sp)) {
+                if (preload_add(ti, sp))
+                        slb_allocate_user(mm, sp);
+        }
+
+        /* Bottom of heap, grows up. */
+        if (heap && !is_kernel_addr(heap)) {
+                if (preload_add(ti, heap))
+                        slb_allocate_user(mm, heap);
+        }
+
+        /* see switch_slb */
+        asm volatile("isync" : : : "memory");
+
+        local_irq_enable();
+}
+
+
 /* Flush all user entries from the segment table of the current processor. */
 void switch_slb(struct task_struct *tsk, struct mm_struct *mm)
 {
-        unsigned long offset;
-        unsigned long slbie_data = 0;
-        unsigned long pc = KSTK_EIP(tsk);
-        unsigned long stack = KSTK_ESP(tsk);
-        unsigned long exec_base;
+        struct thread_info *ti = task_thread_info(tsk);
+        unsigned char i;
 
         /*
          * We need interrupts hard-disabled here, not just soft-disabled,
@@ -238,91 +421,107 @@ void switch_slb(struct task_struct *tsk, struct mm_struct *mm)
          * which would update the slb_cache/slb_cache_ptr fields in the PACA.
          */
         hard_irq_disable();
-        offset = get_paca()->slb_cache_ptr;
-        if (!mmu_has_feature(MMU_FTR_NO_SLBIE_B) &&
-            offset <= SLB_CACHE_ENTRIES) {
-                int i;
-                asm volatile("isync" : : : "memory");
-                for (i = 0; i < offset; i++) {
-                        slbie_data = (unsigned long)get_paca()->slb_cache[i]
-                                << SID_SHIFT; /* EA */
-                        slbie_data |= user_segment_size(slbie_data)
-                                << SLBIE_SSIZE_SHIFT;
-                        slbie_data |= SLBIE_C; /* C set for user addresses */
-                        asm volatile("slbie %0" : : "r" (slbie_data));
-                }
-                asm volatile("isync" : : : "memory");
+        asm volatile("isync" : : : "memory");
+        if (cpu_has_feature(CPU_FTR_ARCH_300)) {
+                /*
+                 * SLBIA IH=3 invalidates all Class=1 SLBEs and their
+                 * associated lookaside structures, which matches what
+                 * switch_slb wants. So ARCH_300 does not use the slb
+                 * cache.
+                 */
+                asm volatile(PPC_SLBIA(3));
         } else {
-                __slb_flush_and_rebolt();
-        }
+                unsigned long offset = get_paca()->slb_cache_ptr;
+
+                if (!mmu_has_feature(MMU_FTR_NO_SLBIE_B) &&
+                    offset <= SLB_CACHE_ENTRIES) {
+                        unsigned long slbie_data = 0;
+
+                        for (i = 0; i < offset; i++) {
+                                unsigned long ea;
+
+                                ea = (unsigned long)
+                                        get_paca()->slb_cache[i] << SID_SHIFT;
+                                /*
+                                 * Could assert_slb_exists here, but hypervisor
+                                 * or machine check could have come in and
+                                 * removed the entry at this point.
+                                 */
+
+                                slbie_data = ea;
+                                slbie_data |= user_segment_size(slbie_data)
+                                                << SLBIE_SSIZE_SHIFT;
+                                slbie_data |= SLBIE_C; /* user slbs have C=1 */
+                                asm volatile("slbie %0" : : "r" (slbie_data));
+                        }
+
+                        /* Workaround POWER5 < DD2.1 issue */
+                        if (!cpu_has_feature(CPU_FTR_ARCH_207S) && offset == 1)
+                                asm volatile("slbie %0" : : "r" (slbie_data));
+
+                } else {
+                        struct slb_shadow *p = get_slb_shadow();
+                        unsigned long ksp_esid_data =
+                                be64_to_cpu(p->save_area[KSTACK_INDEX].esid);
+                        unsigned long ksp_vsid_data =
+                                be64_to_cpu(p->save_area[KSTACK_INDEX].vsid);
+
+                        asm volatile(PPC_SLBIA(1) "\n"
+                                     "slbmte    %0,%1\n"
+                                     "isync"
+                                     :: "r"(ksp_vsid_data),
+                                        "r"(ksp_esid_data));
+
+                        get_paca()->slb_kern_bitmap = (1U << SLB_NUM_BOLTED) - 1;
+                }
 
-        /* Workaround POWER5 < DD2.1 issue */
-        if (offset == 1 || offset > SLB_CACHE_ENTRIES)
-                asm volatile("slbie %0" : : "r" (slbie_data));
+                get_paca()->slb_cache_ptr = 0;
+        }
+        get_paca()->slb_used_bitmap = get_paca()->slb_kern_bitmap;
 
-        get_paca()->slb_cache_ptr = 0;
         copy_mm_to_paca(mm);
 
         /*
-         * preload some userspace segments into the SLB.
-         * Almost all 32 and 64bit PowerPC executables are linked at
-         * 0x10000000 so it makes sense to preload this segment.
+         * We gradually age out SLBs after a number of context switches to
+         * reduce reload overhead of unused entries (like we do with FP/VEC
+         * reload). Each time we wrap 256 switches, take an entry out of the
+         * SLB preload cache.
          */
-        exec_base = 0x10000000;
-
-        if (is_kernel_addr(pc) || is_kernel_addr(stack) ||
-            is_kernel_addr(exec_base))
-                return;
+        tsk->thread.load_slb++;
+        if (!tsk->thread.load_slb) {
+                unsigned long pc = KSTK_EIP(tsk);
 
-        slb_allocate(pc);
+                preload_age(ti);
+                preload_add(ti, pc);
+        }
 
-        if (!esids_match(pc, stack))
-                slb_allocate(stack);
+        for (i = 0; i < ti->slb_preload_nr; i++) {
+                unsigned char idx;
+                unsigned long ea;
 
-        if (!esids_match(pc, exec_base) &&
-            !esids_match(stack, exec_base))
-                slb_allocate(exec_base);
-}
+                idx = (ti->slb_preload_tail + i) % SLB_PRELOAD_NR;
+                ea = (unsigned long)ti->slb_preload_esid[idx] << SID_SHIFT;
 
-static inline void patch_slb_encoding(unsigned int *insn_addr,
-                                      unsigned int immed)
-{
+                slb_allocate_user(mm, ea);
+        }
 
         /*
-         * This function patches either an li or a cmpldi instruction with
-         * a new immediate value. This relies on the fact that both li
-         * (which is actually addi) and cmpldi both take a 16-bit immediate
-         * value, and it is situated in the same location in the instruction,
-         * ie. bits 16-31 (Big endian bit order) or the lower 16 bits.
-         * The signedness of the immediate operand differs between the two
-         * instructions however this code is only ever patching a small value,
-         * much less than 1 << 15, so we can get away with it.
-         * To patch the value we read the existing instruction, clear the
-         * immediate value, and or in our new value, then write the instruction
-         * back.
+         * Synchronize slbmte preloads with possible subsequent user memory
+         * address accesses by the kernel (user mode won't happen until
+         * rfid, which is safe).
          */
-        unsigned int insn = (*insn_addr & 0xffff0000) | immed;
-        patch_instruction(insn_addr, insn);
+        asm volatile("isync" : : : "memory");
 }
 
-extern u32 slb_miss_kernel_load_linear[];
-extern u32 slb_miss_kernel_load_io[];
-extern u32 slb_compare_rr_to_size[];
-extern u32 slb_miss_kernel_load_vmemmap[];
-
 void slb_set_size(u16 size)
 {
-        if (mmu_slb_size == size)
-                return;
-
         mmu_slb_size = size;
-        patch_slb_encoding(slb_compare_rr_to_size, mmu_slb_size);
 }
 
 void slb_initialize(void)
 {
         unsigned long linear_llp, vmalloc_llp, io_llp;
-        unsigned long lflags, vflags;
+        unsigned long lflags;
         static int slb_encoding_inited;
 #ifdef CONFIG_SPARSEMEM_VMEMMAP
         unsigned long vmemmap_llp;
@@ -338,34 +537,24 @@ void slb_initialize(void)
 #endif
         if (!slb_encoding_inited) {
                 slb_encoding_inited = 1;
-                patch_slb_encoding(slb_miss_kernel_load_linear,
-                                   SLB_VSID_KERNEL | linear_llp);
-                patch_slb_encoding(slb_miss_kernel_load_io,
-                                   SLB_VSID_KERNEL | io_llp);
-                patch_slb_encoding(slb_compare_rr_to_size,
-                                   mmu_slb_size);
-
                 pr_devel("SLB: linear  LLP = %04lx\n", linear_llp);
                 pr_devel("SLB: io      LLP = %04lx\n", io_llp);
-
 #ifdef CONFIG_SPARSEMEM_VMEMMAP
-                patch_slb_encoding(slb_miss_kernel_load_vmemmap,
-                                   SLB_VSID_KERNEL | vmemmap_llp);
                 pr_devel("SLB: vmemmap LLP = %04lx\n", vmemmap_llp);
 #endif
         }
 
-        get_paca()->stab_rr = SLB_NUM_BOLTED;
+        get_paca()->stab_rr = SLB_NUM_BOLTED - 1;
+        get_paca()->slb_kern_bitmap = (1U << SLB_NUM_BOLTED) - 1;
+        get_paca()->slb_used_bitmap = get_paca()->slb_kern_bitmap;
 
         lflags = SLB_VSID_KERNEL | linear_llp;
-        vflags = SLB_VSID_KERNEL | vmalloc_llp;
 
         /* Invalidate the entire SLB (even entry 0) & all the ERATS */
         asm volatile("isync":::"memory");
         asm volatile("slbmte  %0,%0"::"r" (0) : "memory");
         asm volatile("isync; slbia; isync":::"memory");
         create_shadowed_slbe(PAGE_OFFSET, mmu_kernel_ssize, lflags, LINEAR_INDEX);
-        create_shadowed_slbe(VMALLOC_START, mmu_kernel_ssize, vflags, VMALLOC_INDEX);
 
         /* For the boot cpu, we're running on the stack in init_thread_union,
          * which is in the first segment of the linear mapping, and also
@@ -381,122 +570,259 @@ void slb_initialize(void)
         asm volatile("isync":::"memory");
 }
 
-static void insert_slb_entry(unsigned long vsid, unsigned long ea,
-                             int bpsize, int ssize)
+static void slb_cache_update(unsigned long esid_data)
 {
-        unsigned long flags, vsid_data, esid_data;
-        enum slb_index index;
         int slb_cache_index;
 
-        /*
-         * We are irq disabled, hence should be safe to access PACA.
-         */
-        VM_WARN_ON(!irqs_disabled());
-
-        /*
-         * We can't take a PMU exception in the following code, so hard
-         * disable interrupts.
-         */
-        hard_irq_disable();
-
-        index = get_paca()->stab_rr;
-
-        /*
-         * simple round-robin replacement of slb starting at SLB_NUM_BOLTED.
-         */
-        if (index < (mmu_slb_size - 1))
-                index++;
-        else
-                index = SLB_NUM_BOLTED;
-
-        get_paca()->stab_rr = index;
-
-        flags = SLB_VSID_USER | mmu_psize_defs[bpsize].sllp;
-        vsid_data = (vsid << slb_vsid_shift(ssize)) | flags |
-                    ((unsigned long) ssize << SLB_VSID_SSIZE_SHIFT);
-        esid_data = mk_esid_data(ea, ssize, index);
-
-        /*
-         * No need for an isync before or after this slbmte. The exception
-         * we enter with and the rfid we exit with are context synchronizing.
-         * Also we only handle user segments here.
-         */
-        asm volatile("slbmte %0, %1" : : "r" (vsid_data), "r" (esid_data)
-                     : "memory");
+        if (cpu_has_feature(CPU_FTR_ARCH_300))
+                return; /* ISAv3.0B and later does not use slb_cache */
 
         /*
          * Now update slb cache entries
          */
-        slb_cache_index = get_paca()->slb_cache_ptr;
+        slb_cache_index = local_paca->slb_cache_ptr;
         if (slb_cache_index < SLB_CACHE_ENTRIES) {
                 /*
                  * We have space in slb cache for optimized switch_slb().
                  * Top 36 bits from esid_data as per ISA
                  */
-                get_paca()->slb_cache[slb_cache_index++] = esid_data >> 28;
-                get_paca()->slb_cache_ptr++;
+                local_paca->slb_cache[slb_cache_index++] = esid_data >> 28;
+                local_paca->slb_cache_ptr++;
         } else {
                 /*
                  * Our cache is full and the current cache content strictly
                  * doesn't indicate the active SLB conents. Bump the ptr
                  * so that switch_slb() will ignore the cache.
                  */
-                get_paca()->slb_cache_ptr = SLB_CACHE_ENTRIES + 1;
+                local_paca->slb_cache_ptr = SLB_CACHE_ENTRIES + 1;
         }
 }
 
-static void handle_multi_context_slb_miss(int context_id, unsigned long ea)
+static enum slb_index alloc_slb_index(bool kernel)
 {
-        struct mm_struct *mm = current->mm;
-        unsigned long vsid;
-        int bpsize;
+        enum slb_index index;
 
         /*
-         * We are always above 1TB, hence use high user segment size.
+         * The allocation bitmaps can become out of synch with the SLB
+         * when the _switch code does slbie when bolting a new stack
+         * segment and it must not be anywhere else in the SLB. This leaves
+         * a kernel allocated entry that is unused in the SLB. With very
+         * large systems or small segment sizes, the bitmaps could slowly
+         * fill with these entries. They will eventually be cleared out
+         * by the round robin allocator in that case, so it's probably not
+         * worth accounting for.
          */
-        vsid = get_vsid(context_id, ea, mmu_highuser_ssize);
-        bpsize = get_slice_psize(mm, ea);
-        insert_slb_entry(vsid, ea, bpsize, mmu_highuser_ssize);
+
+        /*
+         * SLBs beyond 32 entries are allocated with stab_rr only
+         * POWER7/8/9 have 32 SLB entries, this could be expanded if a
+         * future CPU has more.
+         */
+        if (local_paca->slb_used_bitmap != U32_MAX) {
+                index = ffz(local_paca->slb_used_bitmap);
+                local_paca->slb_used_bitmap |= 1U << index;
+                if (kernel)
+                        local_paca->slb_kern_bitmap |= 1U << index;
+        } else {
+                /* round-robin replacement of slb starting at SLB_NUM_BOLTED. */
+                index = local_paca->stab_rr;
+                if (index < (mmu_slb_size - 1))
+                        index++;
+                else
+                        index = SLB_NUM_BOLTED;
+                local_paca->stab_rr = index;
+                if (index < 32) {
+                        if (kernel)
+                                local_paca->slb_kern_bitmap |= 1U << index;
+                        else
+                                local_paca->slb_kern_bitmap &= ~(1U << index);
+                }
+        }
+        BUG_ON(index < SLB_NUM_BOLTED);
+
+        return index;
 }
 
-void slb_miss_large_addr(struct pt_regs *regs)
+static long slb_insert_entry(unsigned long ea, unsigned long context,
+                                unsigned long flags, int ssize, bool kernel)
 {
-        enum ctx_state prev_state = exception_enter();
-        unsigned long ea = regs->dar;
-        int context;
+        unsigned long vsid;
+        unsigned long vsid_data, esid_data;
+        enum slb_index index;
 
-        if (REGION_ID(ea) != USER_REGION_ID)
-                goto slb_bad_addr;
+        vsid = get_vsid(context, ea, ssize);
+        if (!vsid)
+                return -EFAULT;
 
         /*
-         * Are we beyound what the page table layout supports ?
+         * There must not be a kernel SLB fault in alloc_slb_index or before
+         * slbmte here or the allocation bitmaps could get out of whack with
+         * the SLB.
+         *
+         * User SLB faults or preloads take this path which might get inlined
+         * into the caller, so add compiler barriers here to ensure unsafe
+         * memory accesses do not come between.
          */
-        if ((ea & ~REGION_MASK) >= H_PGTABLE_RANGE)
-                goto slb_bad_addr;
+        barrier();
 
-        /* Lower address should have been handled by asm code */
-        if (ea < (1UL << MAX_EA_BITS_PER_CONTEXT))
-                goto slb_bad_addr;
+        index = alloc_slb_index(kernel);
+
+        vsid_data = __mk_vsid_data(vsid, ssize, flags);
+        esid_data = mk_esid_data(ea, ssize, index);
+
+        /*
+         * No need for an isync before or after this slbmte. The exception
+         * we enter with and the rfid we exit with are context synchronizing.
+         * User preloads should add isync afterwards in case the kernel
+         * accesses user memory before it returns to userspace with rfid.
+         */
+        assert_slb_notexists(ea);
+        asm volatile("slbmte %0, %1" : : "r" (vsid_data), "r" (esid_data));
+
+        barrier();
+
+        if (!kernel)
+                slb_cache_update(esid_data);
+
+        return 0;
+}
+
+static long slb_allocate_kernel(unsigned long ea, unsigned long id)
+{
+        unsigned long context;
+        unsigned long flags;
+        int ssize;
+
+        if (id == KERNEL_REGION_ID) {
+
+                /* We only support upto MAX_PHYSMEM_BITS */
+                if ((ea & ~REGION_MASK) > (1UL << MAX_PHYSMEM_BITS))
+                        return -EFAULT;
+
+                flags = SLB_VSID_KERNEL | mmu_psize_defs[mmu_linear_psize].sllp;
+
+#ifdef CONFIG_SPARSEMEM_VMEMMAP
+        } else if (id == VMEMMAP_REGION_ID) {
+
+                if ((ea & ~REGION_MASK) >= (1ULL << MAX_EA_BITS_PER_CONTEXT))
+                        return -EFAULT;
+
+                flags = SLB_VSID_KERNEL | mmu_psize_defs[mmu_vmemmap_psize].sllp;
+#endif
+        } else if (id == VMALLOC_REGION_ID) {
+
+                if ((ea & ~REGION_MASK) >= (1ULL << MAX_EA_BITS_PER_CONTEXT))
+                        return -EFAULT;
+
+                if (ea < H_VMALLOC_END)
+                        flags = get_paca()->vmalloc_sllp;
+                else
+                        flags = SLB_VSID_KERNEL | mmu_psize_defs[mmu_io_psize].sllp;
+        } else {
+                return -EFAULT;
+        }
+
+        ssize = MMU_SEGSIZE_1T;
+        if (!mmu_has_feature(MMU_FTR_1T_SEGMENT))
+                ssize = MMU_SEGSIZE_256M;
+
+        context = get_kernel_context(ea);
+        return slb_insert_entry(ea, context, flags, ssize, true);
+}
+
+static long slb_allocate_user(struct mm_struct *mm, unsigned long ea)
+{
+        unsigned long context;
+        unsigned long flags;
+        int bpsize;
+        int ssize;
 
         /*
          * consider this as bad access if we take a SLB miss
          * on an address above addr limit.
          */
-        if (ea >= current->mm->context.slb_addr_limit)
-                goto slb_bad_addr;
+        if (ea >= mm->context.slb_addr_limit)
+                return -EFAULT;
 
-        context = get_ea_context(&current->mm->context, ea);
+        context = get_user_context(&mm->context, ea);
         if (!context)
-                goto slb_bad_addr;
+                return -EFAULT;
+
+        if (unlikely(ea >= H_PGTABLE_RANGE)) {
+                WARN_ON(1);
+                return -EFAULT;
+        }
 
-        handle_multi_context_slb_miss(context, ea);
-        exception_exit(prev_state);
-        return;
+        ssize = user_segment_size(ea);
 
-slb_bad_addr:
-        if (user_mode(regs))
-                _exception(SIGSEGV, regs, SEGV_BNDERR, ea);
-        else
-                bad_page_fault(regs, ea, SIGSEGV);
-        exception_exit(prev_state);
+        bpsize = get_slice_psize(mm, ea);
+        flags = SLB_VSID_USER | mmu_psize_defs[bpsize].sllp;
+
+        return slb_insert_entry(ea, context, flags, ssize, false);
+}
+
+long do_slb_fault(struct pt_regs *regs, unsigned long ea)
+{
+        unsigned long id = REGION_ID(ea);
+
+        /* IRQs are not reconciled here, so can't check irqs_disabled */
+        VM_WARN_ON(mfmsr() & MSR_EE);
+
+        if (unlikely(!(regs->msr & MSR_RI)))
+                return -EINVAL;
+
+        /*
+         * SLB kernel faults must be very careful not to touch anything
+         * that is not bolted. E.g., PACA and global variables are okay,
+         * mm->context stuff is not.
+         *
+         * SLB user faults can access all of kernel memory, but must be
+         * careful not to touch things like IRQ state because it is not
+         * "reconciled" here. The difficulty is that we must use
+         * fast_exception_return to return from kernel SLB faults without
+         * looking at possible non-bolted memory. We could test user vs
+         * kernel faults in the interrupt handler asm and do a full fault,
+         * reconcile, ret_from_except for user faults which would make them
+         * first class kernel code. But for performance it's probably nicer
+         * if they go via fast_exception_return too.
+         */
+        if (id >= KERNEL_REGION_ID) {
+                long err;
+#ifdef CONFIG_DEBUG_VM
+                /* Catch recursive kernel SLB faults. */
+                BUG_ON(local_paca->in_kernel_slb_handler);
+                local_paca->in_kernel_slb_handler = 1;
+#endif
+                err = slb_allocate_kernel(ea, id);
+#ifdef CONFIG_DEBUG_VM
+                local_paca->in_kernel_slb_handler = 0;
+#endif
+                return err;
+        } else {
+                struct mm_struct *mm = current->mm;
+                long err;
+
+                if (unlikely(!mm))
+                        return -EFAULT;
+
+                err = slb_allocate_user(mm, ea);
+                if (!err)
+                        preload_add(current_thread_info(), ea);
+
+                return err;
+        }
+}
+
+void do_bad_slb_fault(struct pt_regs *regs, unsigned long ea, long err)
+{
+        if (err == -EFAULT) {
+                if (user_mode(regs))
+                        _exception(SIGSEGV, regs, SEGV_BNDERR, ea);
+                else
+                        bad_page_fault(regs, ea, SIGSEGV);
+        } else if (err == -EINVAL) {
+                unrecoverable_exception(regs);
+        } else {
+                BUG();
+        }
 }
diff --git a/arch/powerpc/mm/slb_low.S b/arch/powerpc/mm/slb_low.S
deleted file mode 100644
index 4ac5057ad439..000000000000
--- a/arch/powerpc/mm/slb_low.S
+++ /dev/null
@@ -1,335 +0,0 @@
-/*
- * Low-level SLB routines
- *
- * Copyright (C) 2004 David Gibson <dwg@au.ibm.com>, IBM
- *
- * Based on earlier C version:
- * Dave Engebretsen and Mike Corrigan {engebret|mikejc}@us.ibm.com
- *    Copyright (c) 2001 Dave Engebretsen
- * Copyright (C) 2002 Anton Blanchard <anton@au.ibm.com>, IBM
- *
- *  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 <asm/processor.h>
-#include <asm/ppc_asm.h>
-#include <asm/asm-offsets.h>
-#include <asm/cputable.h>
-#include <asm/page.h>
-#include <asm/mmu.h>
-#include <asm/pgtable.h>
-#include <asm/firmware.h>
-#include <asm/feature-fixups.h>
-
-/*
- * This macro generates asm code to compute the VSID scramble
- * function.  Used in slb_allocate() and do_stab_bolted.  The function
- * computed is: (protovsid*VSID_MULTIPLIER) % VSID_MODULUS
- *
- *      rt = register containing the proto-VSID and into which the
- *              VSID will be stored
- *      rx = scratch register (clobbered)
- *      rf = flags
- *
- *      - rt and rx must be different registers
- *      - The answer will end up in the low VSID_BITS bits of rt.  The higher
- *        bits may contain other garbage, so you may need to mask the
- *        result.
- */
-#define ASM_VSID_SCRAMBLE(rt, rx, rf, size)                             \
-        lis     rx,VSID_MULTIPLIER_##size@h;                            \
-        ori     rx,rx,VSID_MULTIPLIER_##size@l;                         \
-        mulld   rt,rt,rx;               /* rt = rt * MULTIPLIER */      \
-/*                                                                      \
- * powermac get slb fault before feature fixup, so make 65 bit part     \
- * the default part of feature fixup                                    \
- */                                                                     \
-BEGIN_MMU_FTR_SECTION                                                   \
-        srdi    rx,rt,VSID_BITS_65_##size;                              \
-        clrldi  rt,rt,(64-VSID_BITS_65_##size);                         \
-        add     rt,rt,rx;                                               \
-        addi    rx,rt,1;                                                \
-        srdi    rx,rx,VSID_BITS_65_##size;                              \
-        add     rt,rt,rx;                                               \
-        rldimi  rf,rt,SLB_VSID_SHIFT_##size,(64 - (SLB_VSID_SHIFT_##size + VSID_BITS_65_##size)); \
-MMU_FTR_SECTION_ELSE                                                    \
-        srdi    rx,rt,VSID_BITS_##size;                                 \
-        clrldi  rt,rt,(64-VSID_BITS_##size);                            \
-        add     rt,rt,rx;               /* add high and low bits */     \
-        addi    rx,rt,1;                                                \
-        srdi    rx,rx,VSID_BITS_##size; /* extract 2^VSID_BITS bit */   \
-        add     rt,rt,rx;                                               \
-        rldimi  rf,rt,SLB_VSID_SHIFT_##size,(64 - (SLB_VSID_SHIFT_##size + VSID_BITS_##size)); \
-ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_68_BIT_VA)
-
-
-/* void slb_allocate(unsigned long ea);
- *
- * Create an SLB entry for the given EA (user or kernel).
- *      r3 = faulting address, r13 = PACA
- *      r9, r10, r11 are clobbered by this function
- *      r3 is preserved.
- * No other registers are examined or changed.
- */
-_GLOBAL(slb_allocate)
-        /*
-         * Check if the address falls within the range of the first context, or
-         * if we may need to handle multi context. For the first context we
-         * allocate the slb entry via the fast path below. For large address we
-         * branch out to C-code and see if additional contexts have been
-         * allocated.
-         * The test here is:
-         *   (ea & ~REGION_MASK) >= (1ull << MAX_EA_BITS_PER_CONTEXT)
-         */
-        rldicr. r9,r3,4,(63 - MAX_EA_BITS_PER_CONTEXT - 4)
-        bne-    8f
-
-        srdi    r9,r3,60                /* get region */
-        srdi    r10,r3,SID_SHIFT        /* get esid */
-        cmpldi  cr7,r9,0xc              /* cmp PAGE_OFFSET for later use */
-
-        /* r3 = address, r10 = esid, cr7 = <> PAGE_OFFSET */
-        blt     cr7,0f                  /* user or kernel? */
-
-        /* Check if hitting the linear mapping or some other kernel space
-        */
-        bne     cr7,1f
-
-        /* Linear mapping encoding bits, the "li" instruction below will
-         * be patched by the kernel at boot
-         */
-.globl slb_miss_kernel_load_linear
-slb_miss_kernel_load_linear:
-        li      r11,0
-        /*
-         * context = (ea >> 60) - (0xc - 1)
-         * r9 = region id.
-         */
-        subi    r9,r9,KERNEL_REGION_CONTEXT_OFFSET
-
-BEGIN_FTR_SECTION
-        b       .Lslb_finish_load
-END_MMU_FTR_SECTION_IFCLR(MMU_FTR_1T_SEGMENT)
-        b       .Lslb_finish_load_1T
-
-1:
-#ifdef CONFIG_SPARSEMEM_VMEMMAP
-        cmpldi  cr0,r9,0xf
-        bne     1f
-/* Check virtual memmap region. To be patched at kernel boot */
-.globl slb_miss_kernel_load_vmemmap
-slb_miss_kernel_load_vmemmap:
-        li      r11,0
-        b       6f
-1:
-#endif /* CONFIG_SPARSEMEM_VMEMMAP */
-
-        /*
-         * r10 contains the ESID, which is the original faulting EA shifted
-         * right by 28 bits. We need to compare that with (H_VMALLOC_END >> 28)
-         * which is 0xd00038000. That can't be used as an immediate, even if we
-         * ignored the 0xd, so we have to load it into a register, and we only
-         * have one register free. So we must load all of (H_VMALLOC_END >> 28)
-         * into a register and compare ESID against that.
-         */
-        lis     r11,(H_VMALLOC_END >> 32)@h     // r11 = 0xffffffffd0000000
-        ori     r11,r11,(H_VMALLOC_END >> 32)@l // r11 = 0xffffffffd0003800
-        // Rotate left 4, then mask with 0xffffffff0
-        rldic   r11,r11,4,28                    // r11 = 0xd00038000
-        cmpld   r10,r11                         // if r10 >= r11
-        bge     5f                              //   goto io_mapping
-
-        /*
-         * vmalloc mapping gets the encoding from the PACA as the mapping
-         * can be demoted from 64K -> 4K dynamically on some machines.
-         */
-        lhz     r11,PACAVMALLOCSLLP(r13)
-        b       6f
-5:
-        /* IO mapping */
-.globl slb_miss_kernel_load_io
-slb_miss_kernel_load_io:
-        li      r11,0
-6:
-        /*
-         * context = (ea >> 60) - (0xc - 1)
-         * r9 = region id.
-         */
-        subi    r9,r9,KERNEL_REGION_CONTEXT_OFFSET
-
-BEGIN_FTR_SECTION
-        b       .Lslb_finish_load
-END_MMU_FTR_SECTION_IFCLR(MMU_FTR_1T_SEGMENT)
-        b       .Lslb_finish_load_1T
-
-0:      /*
-         * For userspace addresses, make sure this is region 0.
-         */
-        cmpdi   r9, 0
-        bne-    8f
-        /*
-         * user space make sure we are within the allowed limit
-         */
-        ld      r11,PACA_SLB_ADDR_LIMIT(r13)
-        cmpld   r3,r11
-        bge-    8f
-
-        /* when using slices, we extract the psize off the slice bitmaps
-         * and then we need to get the sllp encoding off the mmu_psize_defs
-         * array.
-         *
-         * XXX This is a bit inefficient especially for the normal case,
-         * so we should try to implement a fast path for the standard page
-         * size using the old sllp value so we avoid the array. We cannot
-         * really do dynamic patching unfortunately as processes might flip
-         * between 4k and 64k standard page size
-         */
-#ifdef CONFIG_PPC_MM_SLICES
-        /* r10 have esid */
-        cmpldi  r10,16
-        /* below SLICE_LOW_TOP */
-        blt     5f
-        /*
-         * Handle hpsizes,
-         * r9 is get_paca()->context.high_slices_psize[index], r11 is mask_index
-         */
-        srdi    r11,r10,(SLICE_HIGH_SHIFT - SLICE_LOW_SHIFT + 1) /* index */
-        addi    r9,r11,PACAHIGHSLICEPSIZE
-        lbzx    r9,r13,r9               /* r9 is hpsizes[r11] */
-        /* r11 = (r10 >> (SLICE_HIGH_SHIFT - SLICE_LOW_SHIFT)) & 0x1 */
-        rldicl  r11,r10,(64 - (SLICE_HIGH_SHIFT - SLICE_LOW_SHIFT)),63
-        b       6f
-
-5:
-        /*
-         * Handle lpsizes
-         * r9 is get_paca()->context.low_slices_psize[index], r11 is mask_index
-         */
-        srdi    r11,r10,1 /* index */
-        addi    r9,r11,PACALOWSLICESPSIZE
-        lbzx    r9,r13,r9               /* r9 is lpsizes[r11] */
-        rldicl  r11,r10,0,63            /* r11 = r10 & 0x1 */
-6:
-        sldi    r11,r11,2  /* index * 4 */
-        /* Extract the psize and multiply to get an array offset */
-        srd     r9,r9,r11
-        andi.   r9,r9,0xf
-        mulli   r9,r9,MMUPSIZEDEFSIZE
-
-        /* Now get to the array and obtain the sllp
-         */
-        ld      r11,PACATOC(r13)
-        ld      r11,mmu_psize_defs@got(r11)
-        add     r11,r11,r9
-        ld      r11,MMUPSIZESLLP(r11)
-        ori     r11,r11,SLB_VSID_USER
-#else
-        /* paca context sllp already contains the SLB_VSID_USER bits */
-        lhz     r11,PACACONTEXTSLLP(r13)
-#endif /* CONFIG_PPC_MM_SLICES */
-
-        ld      r9,PACACONTEXTID(r13)
-BEGIN_FTR_SECTION
-        cmpldi  r10,0x1000
-        bge     .Lslb_finish_load_1T
-END_MMU_FTR_SECTION_IFSET(MMU_FTR_1T_SEGMENT)
-        b       .Lslb_finish_load
-
-8:      /* invalid EA - return an error indication */
-        crset   4*cr0+eq                /* indicate failure */
-        blr
-
-/*
- * Finish loading of an SLB entry and return
- *
- * r3 = EA, r9 = context, r10 = ESID, r11 = flags, clobbers r9, cr7 = <> PAGE_OFFSET
- */
-.Lslb_finish_load:
-        rldimi  r10,r9,ESID_BITS,0
-        ASM_VSID_SCRAMBLE(r10,r9,r11,256M)
-        /* r3 = EA, r11 = VSID data */
-        /*
-         * Find a slot, round robin. Previously we tried to find a
-         * free slot first but that took too long. Unfortunately we
-         * dont have any LRU information to help us choose a slot.
-         */
-
-        mr      r9,r3
-
-        /* slb_finish_load_1T continues here. r9=EA with non-ESID bits clear */
-7:      ld      r10,PACASTABRR(r13)
-        addi    r10,r10,1
-        /* This gets soft patched on boot. */
-.globl slb_compare_rr_to_size
-slb_compare_rr_to_size:
-        cmpldi  r10,0
-
-        blt+    4f
-        li      r10,SLB_NUM_BOLTED
-
-4:
-        std     r10,PACASTABRR(r13)
-
-3:
-        rldimi  r9,r10,0,36             /* r9  = EA[0:35] | entry */
-        oris    r10,r9,SLB_ESID_V@h     /* r10 = r9 | SLB_ESID_V */
-
-        /* r9 = ESID data, r11 = VSID data */
-
-        /*
-         * No need for an isync before or after this slbmte. The exception
-         * we enter with and the rfid we exit with are context synchronizing.
-         */
-        slbmte  r11,r10
-
-        /* we're done for kernel addresses */
-        crclr   4*cr0+eq                /* set result to "success" */
-        bgelr   cr7
-
-        /* Update the slb cache */
-        lhz     r9,PACASLBCACHEPTR(r13) /* offset = paca->slb_cache_ptr */
-        cmpldi  r9,SLB_CACHE_ENTRIES
-        bge     1f
-
-        /* still room in the slb cache */
-        sldi    r11,r9,2                /* r11 = offset * sizeof(u32) */
-        srdi    r10,r10,28              /* get the 36 bits of the ESID */
-        add     r11,r11,r13             /* r11 = (u32 *)paca + offset */
-        stw     r10,PACASLBCACHE(r11)   /* paca->slb_cache[offset] = esid */
-        addi    r9,r9,1                 /* offset++ */
-        b       2f
-1:                                      /* offset >= SLB_CACHE_ENTRIES */
-        li      r9,SLB_CACHE_ENTRIES+1
-2:
-        sth     r9,PACASLBCACHEPTR(r13) /* paca->slb_cache_ptr = offset */
-        crclr   4*cr0+eq                /* set result to "success" */
-        blr
-
-/*
- * Finish loading of a 1T SLB entry (for the kernel linear mapping) and return.
- *
- * r3 = EA, r9 = context, r10 = ESID(256MB), r11 = flags, clobbers r9
- */
-.Lslb_finish_load_1T:
-        srdi    r10,r10,(SID_SHIFT_1T - SID_SHIFT)      /* get 1T ESID */
-        rldimi  r10,r9,ESID_BITS_1T,0
-        ASM_VSID_SCRAMBLE(r10,r9,r11,1T)
-
-        li      r10,MMU_SEGSIZE_1T
-        rldimi  r11,r10,SLB_VSID_SSIZE_SHIFT,0  /* insert segment size */
-
-        /* r3 = EA, r11 = VSID data */
-        clrrdi  r9,r3,SID_SHIFT_1T      /* clear out non-ESID bits */
-        b       7b
-
-
-_ASM_NOKPROBE_SYMBOL(slb_allocate)
-_ASM_NOKPROBE_SYMBOL(slb_miss_kernel_load_linear)
-_ASM_NOKPROBE_SYMBOL(slb_miss_kernel_load_io)
-_ASM_NOKPROBE_SYMBOL(slb_compare_rr_to_size)
-#ifdef CONFIG_SPARSEMEM_VMEMMAP
-_ASM_NOKPROBE_SYMBOL(slb_miss_kernel_load_vmemmap)
-#endif
diff --git a/arch/powerpc/mm/slice.c b/arch/powerpc/mm/slice.c
index 205fe557ca10..06898c13901d 100644
--- a/arch/powerpc/mm/slice.c
+++ b/arch/powerpc/mm/slice.c
@@ -31,6 +31,7 @@
 #include <linux/spinlock.h>
 #include <linux/export.h>
 #include <linux/hugetlb.h>
+#include <linux/sched/mm.h>
 #include <asm/mman.h>
 #include <asm/mmu.h>
 #include <asm/copro.h>
@@ -61,6 +62,13 @@ static void slice_print_mask(const char *label, const struct slice_mask *mask) {
 
 #endif
 
+static inline bool slice_addr_is_low(unsigned long addr)
+{
+        u64 tmp = (u64)addr;
+
+        return tmp < SLICE_LOW_TOP;
+}
+
 static void slice_range_to_mask(unsigned long start, unsigned long len,
                                 struct slice_mask *ret)
 {
@@ -70,7 +78,7 @@ static void slice_range_to_mask(unsigned long start, unsigned long len,
         if (SLICE_NUM_HIGH)
                 bitmap_zero(ret->high_slices, SLICE_NUM_HIGH);
 
-        if (start < SLICE_LOW_TOP) {
+        if (slice_addr_is_low(start)) {
                 unsigned long mend = min(end,
                                          (unsigned long)(SLICE_LOW_TOP - 1));
 
@@ -78,7 +86,7 @@ static void slice_range_to_mask(unsigned long start, unsigned long len,
                         - (1u << GET_LOW_SLICE_INDEX(start));
         }
 
-        if ((start + len) > SLICE_LOW_TOP) {
+        if (SLICE_NUM_HIGH && !slice_addr_is_low(end)) {
                 unsigned long start_index = GET_HIGH_SLICE_INDEX(start);
                 unsigned long align_end = ALIGN(end, (1UL << SLICE_HIGH_SHIFT));
                 unsigned long count = GET_HIGH_SLICE_INDEX(align_end) - start_index;
@@ -133,7 +141,7 @@ static void slice_mask_for_free(struct mm_struct *mm, struct slice_mask *ret,
                 if (!slice_low_has_vma(mm, i))
                         ret->low_slices |= 1u << i;
 
-        if (high_limit <= SLICE_LOW_TOP)
+        if (slice_addr_is_low(high_limit - 1))
                 return;
 
         for (i = 0; i < GET_HIGH_SLICE_INDEX(high_limit); i++)
@@ -182,7 +190,7 @@ static bool slice_check_range_fits(struct mm_struct *mm,
         unsigned long end = start + len - 1;
         u64 low_slices = 0;
 
-        if (start < SLICE_LOW_TOP) {
+        if (slice_addr_is_low(start)) {
                 unsigned long mend = min(end,
                                          (unsigned long)(SLICE_LOW_TOP - 1));
 
@@ -192,7 +200,7 @@ static bool slice_check_range_fits(struct mm_struct *mm,
         if ((low_slices & available->low_slices) != low_slices)
                 return false;
 
-        if (SLICE_NUM_HIGH && ((start + len) > SLICE_LOW_TOP)) {
+        if (SLICE_NUM_HIGH && !slice_addr_is_low(end)) {
                 unsigned long start_index = GET_HIGH_SLICE_INDEX(start);
                 unsigned long align_end = ALIGN(end, (1UL << SLICE_HIGH_SHIFT));
                 unsigned long count = GET_HIGH_SLICE_INDEX(align_end) - start_index;
@@ -219,7 +227,7 @@ static void slice_flush_segments(void *parm)
         copy_mm_to_paca(current->active_mm);
 
         local_irq_save(flags);
-        slb_flush_and_rebolt();
+        slb_flush_and_restore_bolted();
         local_irq_restore(flags);
 #endif
 }
@@ -303,7 +311,7 @@ static bool slice_scan_available(unsigned long addr,
                                  int end, unsigned long *boundary_addr)
 {
         unsigned long slice;
-        if (addr < SLICE_LOW_TOP) {
+        if (slice_addr_is_low(addr)) {
                 slice = GET_LOW_SLICE_INDEX(addr);
                 *boundary_addr = (slice + end) << SLICE_LOW_SHIFT;
                 return !!(available->low_slices & (1u << slice));
@@ -706,7 +714,7 @@ unsigned int get_slice_psize(struct mm_struct *mm, unsigned long addr)
 
         VM_BUG_ON(radix_enabled());
 
-        if (addr < SLICE_LOW_TOP) {
+        if (slice_addr_is_low(addr)) {
                 psizes = mm->context.low_slices_psize;
                 index = GET_LOW_SLICE_INDEX(addr);
         } else {
@@ -757,6 +765,20 @@ void slice_init_new_context_exec(struct mm_struct *mm)
                 bitmap_fill(mask->high_slices, SLICE_NUM_HIGH);
 }
 
+#ifdef CONFIG_PPC_BOOK3S_64
+void slice_setup_new_exec(void)
+{
+        struct mm_struct *mm = current->mm;
+
+        slice_dbg("slice_setup_new_exec(mm=%p)\n", mm);
+
+        if (!is_32bit_task())
+                return;
+
+        mm->context.slb_addr_limit = DEFAULT_MAP_WINDOW;
+}
+#endif
+
 void slice_set_range_psize(struct mm_struct *mm, unsigned long start,
                            unsigned long len, unsigned int psize)
 {
diff --git a/arch/powerpc/mm/tlb-radix.c b/arch/powerpc/mm/tlb-radix.c
index 4c4dfc473800..6a23b9ebd2a1 100644
--- a/arch/powerpc/mm/tlb-radix.c
+++ b/arch/powerpc/mm/tlb-radix.c
@@ -366,6 +366,7 @@ static inline void _tlbiel_lpid_guest(unsigned long lpid, unsigned long ric)
                 __tlbiel_lpid_guest(lpid, set, RIC_FLUSH_TLB);
 
         asm volatile("ptesync": : :"memory");
+        asm volatile(PPC_INVALIDATE_ERAT : : :"memory");
 }
 
 
@@ -1016,7 +1017,6 @@ void radix__flush_tlb_collapsed_pmd(struct mm_struct *mm, unsigned long addr)
                         goto local;
                 }
                 _tlbie_va_range(addr, end, pid, PAGE_SIZE, mmu_virtual_psize, true);
-                goto local;
         } else {
 local:
                 _tlbiel_va_range(addr, end, pid, PAGE_SIZE, mmu_virtual_psize, true);
diff --git a/arch/powerpc/mm/tlb_nohash.c b/arch/powerpc/mm/tlb_nohash.c
index 15fe5f0c8665..ae5d568e267f 100644
--- a/arch/powerpc/mm/tlb_nohash.c
+++ b/arch/powerpc/mm/tlb_nohash.c
@@ -503,6 +503,9 @@ static void setup_page_sizes(void)
                 for (psize = 0; psize < MMU_PAGE_COUNT; ++psize) {
                         struct mmu_psize_def *def = &mmu_psize_defs[psize];
 
+                        if (!def->shift)
+                                continue;
+
                         if (tlb1ps & (1U << (def->shift - 10))) {
                                 def->flags |= MMU_PAGE_SIZE_DIRECT;
 
diff --git a/arch/powerpc/oprofile/Makefile b/arch/powerpc/oprofile/Makefile
index 7a7834c39f64..8d26d7416481 100644
--- a/arch/powerpc/oprofile/Makefile
+++ b/arch/powerpc/oprofile/Makefile
@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: GPL-2.0
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
 
 ccflags-$(CONFIG_PPC64) := $(NO_MINIMAL_TOC)
 
diff --git a/arch/powerpc/perf/Makefile b/arch/powerpc/perf/Makefile
index 82986d2acd9b..ab26df5bacb9 100644
--- a/arch/powerpc/perf/Makefile
+++ b/arch/powerpc/perf/Makefile
@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: GPL-2.0
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
 
 obj-$(CONFIG_PERF_EVENTS)       += callchain.o perf_regs.o
 
diff --git a/arch/powerpc/perf/imc-pmu.c b/arch/powerpc/perf/imc-pmu.c
index 1fafc32b12a0..6954636b16d1 100644
--- a/arch/powerpc/perf/imc-pmu.c
+++ b/arch/powerpc/perf/imc-pmu.c
@@ -1392,7 +1392,7 @@ int init_imc_pmu(struct device_node *parent, struct imc_pmu *pmu_ptr, int pmu_id
         if (ret)
                 goto err_free_cpuhp_mem;
 
-        pr_info("%s performance monitor hardware support registered\n",
+        pr_debug("%s performance monitor hardware support registered\n",
                                                         pmu_ptr->pmu.name);
 
         return 0;
diff --git a/arch/powerpc/perf/power7-pmu.c b/arch/powerpc/perf/power7-pmu.c
index 7963658dbc22..6dbae9884ec4 100644
--- a/arch/powerpc/perf/power7-pmu.c
+++ b/arch/powerpc/perf/power7-pmu.c
@@ -238,6 +238,7 @@ static int power7_marked_instr_event(u64 event)
         case 6:
                 if (psel == 0x64)
                         return pmc >= 3;
+                break;
         case 8:
                 return unit == 0xd;
         }
diff --git a/arch/powerpc/platforms/40x/Kconfig b/arch/powerpc/platforms/40x/Kconfig
index 60254a321a91..2a9d66254ffc 100644
--- a/arch/powerpc/platforms/40x/Kconfig
+++ b/arch/powerpc/platforms/40x/Kconfig
@@ -2,7 +2,6 @@
 config ACADIA
         bool "Acadia"
         depends on 40x
-        default n
         select PPC40x_SIMPLE
         select 405EZ
         help
@@ -11,7 +10,6 @@ config ACADIA
 config EP405
         bool "EP405/EP405PC"
         depends on 40x
-        default n
         select 405GP
         select PCI
         help
@@ -20,7 +18,6 @@ config EP405
 config HOTFOOT
         bool "Hotfoot"
         depends on 40x
-        default n
         select PPC40x_SIMPLE
         select PCI
         help
@@ -29,7 +26,6 @@ config HOTFOOT
 config KILAUEA
         bool "Kilauea"
         depends on 40x
-        default n
         select 405EX
         select PPC40x_SIMPLE
         select PPC4xx_PCI_EXPRESS
@@ -41,7 +37,6 @@ config KILAUEA
 config MAKALU
         bool "Makalu"
         depends on 40x
-        default n
         select 405EX
         select PCI
         select PPC4xx_PCI_EXPRESS
@@ -62,7 +57,6 @@ config WALNUT
 config XILINX_VIRTEX_GENERIC_BOARD
         bool "Generic Xilinx Virtex board"
         depends on 40x
-        default n
         select XILINX_VIRTEX_II_PRO
         select XILINX_VIRTEX_4_FX
         select XILINX_INTC
@@ -80,7 +74,6 @@ config XILINX_VIRTEX_GENERIC_BOARD
 config OBS600
         bool "OpenBlockS 600"
         depends on 40x
-        default n
         select 405EX
         select PPC40x_SIMPLE
         help
@@ -90,7 +83,6 @@ config OBS600
 config PPC40x_SIMPLE
         bool "Simple PowerPC 40x board support"
         depends on 40x
-        default n
         help
           This option enables the simple PowerPC 40x platform support.
 
@@ -156,7 +148,6 @@ config IBM405_ERR51
 config APM8018X
         bool "APM8018X"
         depends on 40x
-        default n
         select PPC40x_SIMPLE
         help
           This option enables support for the AppliedMicro APM8018X evaluation
diff --git a/arch/powerpc/platforms/44x/Kconfig b/arch/powerpc/platforms/44x/Kconfig
index a6011422b861..f024efd5a4c2 100644
--- a/arch/powerpc/platforms/44x/Kconfig
+++ b/arch/powerpc/platforms/44x/Kconfig
@@ -2,7 +2,6 @@
 config PPC_47x
         bool "Support for 47x variant"
         depends on 44x
-        default n
         select MPIC
         help
           This option enables support for the 47x family of processors and is
@@ -11,7 +10,6 @@ config PPC_47x
 config BAMBOO
         bool "Bamboo"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 440EP
         select PCI
@@ -21,7 +19,6 @@ config BAMBOO
 config BLUESTONE
         bool "Bluestone"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select APM821xx
         select PCI_MSI
@@ -44,7 +41,6 @@ config EBONY
 config SAM440EP
         bool "Sam440ep"
         depends on 44x
-        default n
         select 440EP
         select PCI
         help
@@ -53,7 +49,6 @@ config SAM440EP
 config SEQUOIA
         bool "Sequoia"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 440EPX
         help
@@ -62,7 +57,6 @@ config SEQUOIA
 config TAISHAN
         bool "Taishan"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 440GX
         select PCI
@@ -73,7 +67,6 @@ config TAISHAN
 config KATMAI
         bool "Katmai"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 440SPe
         select PCI
@@ -86,7 +79,6 @@ config KATMAI
 config RAINIER
         bool "Rainier"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 440GRX
         select PCI
@@ -96,7 +88,6 @@ config RAINIER
 config WARP
         bool "PIKA Warp"
         depends on 44x
-        default n
         select 440EP
         help
           This option enables support for the PIKA Warp(tm) Appliance. The Warp
@@ -109,7 +100,6 @@ config WARP
 config ARCHES
         bool "Arches"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 460EX # Odd since it uses 460GT but the effects are the same
         select PCI
@@ -120,7 +110,6 @@ config ARCHES
 config CANYONLANDS
         bool "Canyonlands"
         depends on 44x
-        default n
         select 460EX
         select PCI
         select PPC4xx_PCI_EXPRESS
@@ -134,7 +123,6 @@ config CANYONLANDS
 config GLACIER
         bool "Glacier"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 460EX # Odd since it uses 460GT but the effects are the same
         select PCI
@@ -147,7 +135,6 @@ config GLACIER
 config REDWOOD
         bool "Redwood"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 460SX
         select PCI
@@ -160,7 +147,6 @@ config REDWOOD
 config EIGER
         bool "Eiger"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 460SX
         select PCI
@@ -172,7 +158,6 @@ config EIGER
 config YOSEMITE
         bool "Yosemite"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 440EP
         select PCI
@@ -182,7 +167,6 @@ config YOSEMITE
 config ISS4xx
         bool "ISS 4xx Simulator"
         depends on (44x || 40x)
-        default n
         select 405GP if 40x
         select 440GP if 44x && !PPC_47x
         select PPC_FPU
@@ -193,7 +177,6 @@ config ISS4xx
 config CURRITUCK
         bool "IBM Currituck (476fpe) Support"
         depends on PPC_47x
-        default n
         select SWIOTLB
         select 476FPE
         select PPC4xx_PCI_EXPRESS
@@ -203,7 +186,6 @@ config CURRITUCK
 config FSP2
         bool "IBM FSP2 (476fpe) Support"
         depends on PPC_47x
-        default n
         select 476FPE
         select IBM_EMAC_EMAC4 if IBM_EMAC
         select IBM_EMAC_RGMII if IBM_EMAC
@@ -215,7 +197,6 @@ config FSP2
 config AKEBONO
         bool "IBM Akebono (476gtr) Support"
         depends on PPC_47x
-        default n
         select SWIOTLB
         select 476FPE
         select PPC4xx_PCI_EXPRESS
@@ -241,7 +222,6 @@ config AKEBONO
 config ICON
         bool "Icon"
         depends on 44x
-        default n
         select PPC44x_SIMPLE
         select 440SPe
         select PCI
@@ -252,7 +232,6 @@ config ICON
 config XILINX_VIRTEX440_GENERIC_BOARD
         bool "Generic Xilinx Virtex 5 FXT board support"
         depends on 44x
-        default n
         select XILINX_VIRTEX_5_FXT
         select XILINX_INTC
         help
@@ -280,7 +259,6 @@ config XILINX_ML510
 config PPC44x_SIMPLE
         bool "Simple PowerPC 44x board support"
         depends on 44x
-        default n
         help
           This option enables the simple PowerPC 44x platform support.
 
diff --git a/arch/powerpc/platforms/44x/fsp2.c b/arch/powerpc/platforms/44x/fsp2.c
index 04f0c73a9b4f..7a507f775308 100644
--- a/arch/powerpc/platforms/44x/fsp2.c
+++ b/arch/powerpc/platforms/44x/fsp2.c
@@ -210,15 +210,15 @@ static void node_irq_request(const char *compat, irq_handler_t errirq_handler)
         for_each_compatible_node(np, NULL, compat) {
                 irq = irq_of_parse_and_map(np, 0);
                 if (irq == NO_IRQ) {
-                        pr_err("device tree node %s is missing a interrupt",
-                              np->name);
+                        pr_err("device tree node %pOFn is missing a interrupt",
+                              np);
                         return;
                 }
 
                 rc = request_irq(irq, errirq_handler, 0, np->name, np);
                 if (rc) {
-                        pr_err("fsp_of_probe: request_irq failed: np=%s rc=%d",
-                              np->full_name, rc);
+                        pr_err("fsp_of_probe: request_irq failed: np=%pOF rc=%d",
+                              np, rc);
                         return;
                 }
         }
diff --git a/arch/powerpc/platforms/4xx/ocm.c b/arch/powerpc/platforms/4xx/ocm.c
index 69d9f60d9fe5..f5bbd4563342 100644
--- a/arch/powerpc/platforms/4xx/ocm.c
+++ b/arch/powerpc/platforms/4xx/ocm.c
@@ -113,7 +113,6 @@ static void __init ocm_init_node(int count, struct device_node *node)
         int len;
 
         struct resource rsrc;
-        int ioflags;
 
         ocm = ocm_get_node(count);
 
@@ -179,9 +178,8 @@ static void __init ocm_init_node(int count, struct device_node *node)
 
         /* ioremap the non-cached region */
         if (ocm->nc.memtotal) {
-                ioflags = _PAGE_NO_CACHE | _PAGE_GUARDED | _PAGE_EXEC;
                 ocm->nc.virt = __ioremap(ocm->nc.phys, ocm->nc.memtotal,
-                                          ioflags);
+                                         _PAGE_EXEC | PAGE_KERNEL_NCG);
 
                 if (!ocm->nc.virt) {
                         printk(KERN_ERR
@@ -195,9 +193,8 @@ static void __init ocm_init_node(int count, struct device_node *node)
         /* ioremap the cached region */
 
         if (ocm->c.memtotal) {
-                ioflags = _PAGE_EXEC;
                 ocm->c.virt = __ioremap(ocm->c.phys, ocm->c.memtotal,
-                                         ioflags);
+                                        _PAGE_EXEC | PAGE_KERNEL);
 
                 if (!ocm->c.virt) {
                         printk(KERN_ERR
diff --git a/arch/powerpc/platforms/82xx/Kconfig b/arch/powerpc/platforms/82xx/Kconfig
index 6e04099361b9..1947a88bc69f 100644
--- a/arch/powerpc/platforms/82xx/Kconfig
+++ b/arch/powerpc/platforms/82xx/Kconfig
@@ -51,7 +51,6 @@ endif
 
 config PQ2ADS
         bool
-        default n
 
 config 8260
         bool
diff --git a/arch/powerpc/platforms/85xx/smp.c b/arch/powerpc/platforms/85xx/smp.c
index 7e966f4cf19a..fff72425727a 100644
--- a/arch/powerpc/platforms/85xx/smp.c
+++ b/arch/powerpc/platforms/85xx/smp.c
@@ -216,8 +216,8 @@ static int smp_85xx_start_cpu(int cpu)
 
         /* Map the spin table */
         if (ioremappable)
-                spin_table = ioremap_prot(*cpu_rel_addr,
-                        sizeof(struct epapr_spin_table), _PAGE_COHERENT);
+                spin_table = ioremap_coherent(*cpu_rel_addr,
+                                              sizeof(struct epapr_spin_table));
         else
                 spin_table = phys_to_virt(*cpu_rel_addr);
 
diff --git a/arch/powerpc/platforms/8xx/machine_check.c b/arch/powerpc/platforms/8xx/machine_check.c
index 402016705a39..9944fc303df0 100644
--- a/arch/powerpc/platforms/8xx/machine_check.c
+++ b/arch/powerpc/platforms/8xx/machine_check.c
@@ -18,9 +18,9 @@ int machine_check_8xx(struct pt_regs *regs)
         pr_err("Machine check in kernel mode.\n");
         pr_err("Caused by (from SRR1=%lx): ", reason);
         if (reason & 0x40000000)
-                pr_err("Fetch error at address %lx\n", regs->nip);
+                pr_cont("Fetch error at address %lx\n", regs->nip);
         else
-                pr_err("Data access error at address %lx\n", regs->dar);
+                pr_cont("Data access error at address %lx\n", regs->dar);
 
 #ifdef CONFIG_PCI
         /* the qspan pci read routines can cause machine checks -- Cort
diff --git a/arch/powerpc/platforms/Kconfig b/arch/powerpc/platforms/Kconfig
index 14ef17e10ec9..260a56b7602d 100644
--- a/arch/powerpc/platforms/Kconfig
+++ b/arch/powerpc/platforms/Kconfig
@@ -23,7 +23,6 @@ source "arch/powerpc/platforms/amigaone/Kconfig"
 
 config KVM_GUEST
         bool "KVM Guest support"
-        default n
         select EPAPR_PARAVIRT
         ---help---
           This option enables various optimizations for running under the KVM
@@ -34,7 +33,6 @@ config KVM_GUEST
 
 config EPAPR_PARAVIRT
         bool "ePAPR para-virtualization support"
-        default n
         help
           Enables ePAPR para-virtualization support for guests.
 
@@ -74,7 +72,6 @@ config PPC_DT_CPU_FTRS
 config UDBG_RTAS_CONSOLE
         bool "RTAS based debug console"
         depends on PPC_RTAS
-        default n
 
 config PPC_SMP_MUXED_IPI
         bool
@@ -86,16 +83,13 @@ config PPC_SMP_MUXED_IPI
 
 config IPIC
         bool
-        default n
 
 config MPIC
         bool
-        default n
 
 config MPIC_TIMER
         bool "MPIC Global Timer"
         depends on MPIC && FSL_SOC
-        default n
         help
           The MPIC global timer is a hardware timer inside the
           Freescale PIC complying with OpenPIC standard. When the
@@ -107,7 +101,6 @@ config MPIC_TIMER
 config FSL_MPIC_TIMER_WAKEUP
         tristate "Freescale MPIC global timer wakeup driver"
         depends on FSL_SOC &&  MPIC_TIMER && PM
-        default n
         help
           The driver provides a way to wake up the system by MPIC
           timer.
@@ -115,43 +108,35 @@ config FSL_MPIC_TIMER_WAKEUP
 
 config PPC_EPAPR_HV_PIC
         bool
-        default n
         select EPAPR_PARAVIRT
 
 config MPIC_WEIRD
         bool
-        default n
 
 config MPIC_MSGR
         bool "MPIC message register support"
         depends on MPIC
-        default n
         help
           Enables support for the MPIC message registers.  These
           registers are used for inter-processor communication.
 
 config PPC_I8259
         bool
-        default n
 
 config U3_DART
         bool
         depends on PPC64
-        default n
 
 config PPC_RTAS
         bool
-        default n
 
 config RTAS_ERROR_LOGGING
         bool
         depends on PPC_RTAS
-        default n
 
 config PPC_RTAS_DAEMON
         bool
         depends on PPC_RTAS
-        default n
 
 config RTAS_PROC
         bool "Proc interface to RTAS"
@@ -164,11 +149,9 @@ config RTAS_FLASH
 
 config MMIO_NVRAM
         bool
-        default n
 
 config MPIC_U3_HT_IRQS
         bool
-        default n
 
 config MPIC_BROKEN_REGREAD
         bool
@@ -187,15 +170,12 @@ config EEH
 
 config PPC_MPC106
         bool
-        default n
 
 config PPC_970_NAP
         bool
-        default n
 
 config PPC_P7_NAP
         bool
-        default n
 
 config PPC_INDIRECT_PIO
         bool
@@ -295,7 +275,6 @@ config CPM2
 
 config FSL_ULI1575
         bool
-        default n
         select GENERIC_ISA_DMA
         help
           Supports for the ULI1575 PCIe south bridge that exists on some
diff --git a/arch/powerpc/platforms/Kconfig.cputype b/arch/powerpc/platforms/Kconfig.cputype
index 6c6a7c72cae4..f4e2c5729374 100644
--- a/arch/powerpc/platforms/Kconfig.cputype
+++ b/arch/powerpc/platforms/Kconfig.cputype
@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: GPL-2.0
 config PPC64
         bool "64-bit kernel"
-        default n
         select ZLIB_DEFLATE
         help
           This option selects whether a 32-bit or a 64-bit kernel
@@ -72,6 +71,7 @@ config PPC_BOOK3S_64
         select PPC_HAVE_PMU_SUPPORT
         select SYS_SUPPORTS_HUGETLBFS
         select HAVE_ARCH_TRANSPARENT_HUGEPAGE
+        select ARCH_ENABLE_THP_MIGRATION if TRANSPARENT_HUGEPAGE
         select ARCH_SUPPORTS_NUMA_BALANCING
         select IRQ_WORK
 
@@ -368,7 +368,6 @@ config PPC_MM_SLICES
         bool
         default y if PPC_BOOK3S_64
         default y if PPC_8xx && HUGETLB_PAGE
-        default n
 
 config PPC_HAVE_PMU_SUPPORT
        bool
@@ -382,7 +381,6 @@ config PPC_PERF_CTRS
 config FORCE_SMP
         # Allow platforms to force SMP=y by selecting this
         bool
-        default n
         select SMP
 
 config SMP
@@ -423,7 +421,6 @@ config CHECK_CACHE_COHERENCY
 
 config PPC_DOORBELL
         bool
-        default n
 
 endmenu
 
diff --git a/arch/powerpc/platforms/Makefile b/arch/powerpc/platforms/Makefile
index e46bb7ea710f..143d4417f6cc 100644
--- a/arch/powerpc/platforms/Makefile
+++ b/arch/powerpc/platforms/Makefile
@@ -1,7 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0
 
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
-
 obj-$(CONFIG_FSL_ULI1575)       += fsl_uli1575.o
 
 obj-$(CONFIG_PPC_PMAC)          += powermac/
diff --git a/arch/powerpc/platforms/cell/Kconfig b/arch/powerpc/platforms/cell/Kconfig
index 9f5958f16923..4b2f114f3116 100644
--- a/arch/powerpc/platforms/cell/Kconfig
+++ b/arch/powerpc/platforms/cell/Kconfig
@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: GPL-2.0
 config PPC_CELL
         bool
-        default n
 
 config PPC_CELL_COMMON
         bool
@@ -22,7 +21,6 @@ config PPC_CELL_NATIVE
         select IBM_EMAC_RGMII if IBM_EMAC
         select IBM_EMAC_ZMII if IBM_EMAC #test only
         select IBM_EMAC_TAH if IBM_EMAC  #test only
-        default n
 
 config PPC_IBM_CELL_BLADE
         bool "IBM Cell Blade"
@@ -54,7 +52,6 @@ config SPU_FS
 
 config SPU_BASE
         bool
-        default n
         select PPC_COPRO_BASE
 
 config CBE_RAS
diff --git a/arch/powerpc/platforms/cell/spu_manage.c b/arch/powerpc/platforms/cell/spu_manage.c
index 5c409c98cca8..f7e36373f6e0 100644
--- a/arch/powerpc/platforms/cell/spu_manage.c
+++ b/arch/powerpc/platforms/cell/spu_manage.c
@@ -180,35 +180,22 @@ out:
 
 static int __init spu_map_interrupts(struct spu *spu, struct device_node *np)
 {
-        struct of_phandle_args oirq;
-        int ret;
         int i;
 
         for (i=0; i < 3; i++) {
-                ret = of_irq_parse_one(np, i, &oirq);
-                if (ret) {
-                        pr_debug("spu_new: failed to get irq %d\n", i);
-                        goto err;
-                }
-                ret = -EINVAL;
-                pr_debug("  irq %d no 0x%x on %pOF\n", i, oirq.args[0],
-                         oirq.np);
-                spu->irqs[i] = irq_create_of_mapping(&oirq);
-                if (!spu->irqs[i]) {
-                        pr_debug("spu_new: failed to map it !\n");
+                spu->irqs[i] = irq_of_parse_and_map(np, i);
+                if (!spu->irqs[i])
                         goto err;
-                }
         }
         return 0;
 
 err:
-        pr_debug("failed to map irq %x for spu %s\n", *oirq.args,
-                spu->name);
+        pr_debug("failed to map irq %x for spu %s\n", i, spu->name);
         for (; i >= 0; i--) {
                 if (spu->irqs[i])
                         irq_dispose_mapping(spu->irqs[i]);
         }
-        return ret;
+        return -EINVAL;
 }
 
 static int spu_map_resource(struct spu *spu, int nr,
@@ -295,8 +282,8 @@ static int __init of_enumerate_spus(int (*fn)(void *data))
         for_each_node_by_type(node, "spe") {
                 ret = fn(node);
                 if (ret) {
-                        printk(KERN_WARNING "%s: Error initializing %s\n",
-                                __func__, node->name);
+                        printk(KERN_WARNING "%s: Error initializing %pOFn\n",
+                                __func__, node);
                         of_node_put(node);
                         break;
                 }
diff --git a/arch/powerpc/platforms/embedded6xx/wii.c b/arch/powerpc/platforms/embedded6xx/wii.c
index 403523c061ba..ecf703ee3a76 100644
--- a/arch/powerpc/platforms/embedded6xx/wii.c
+++ b/arch/powerpc/platforms/embedded6xx/wii.c
@@ -112,7 +112,7 @@ static void __iomem *wii_ioremap_hw_regs(char *name, char *compatible)
         }
         error = of_address_to_resource(np, 0, &res);
         if (error) {
-                pr_err("no valid reg found for %s\n", np->name);
+                pr_err("no valid reg found for %pOFn\n", np);
                 goto out_put;
         }
 
diff --git a/arch/powerpc/platforms/maple/Kconfig b/arch/powerpc/platforms/maple/Kconfig
index 376d0be36b66..2601fac50354 100644
--- a/arch/powerpc/platforms/maple/Kconfig
+++ b/arch/powerpc/platforms/maple/Kconfig
@@ -13,7 +13,6 @@ config PPC_MAPLE
         select PPC_RTAS
         select MMIO_NVRAM
         select ATA_NONSTANDARD if ATA
-        default n
         help
           This option enables support for the Maple 970FX Evaluation Board.
           For more information, refer to <http://www.970eval.com>
diff --git a/arch/powerpc/platforms/pasemi/Kconfig b/arch/powerpc/platforms/pasemi/Kconfig
index d458a791d35b..98e3bc22bebc 100644
--- a/arch/powerpc/platforms/pasemi/Kconfig
+++ b/arch/powerpc/platforms/pasemi/Kconfig
@@ -2,7 +2,6 @@
 config PPC_PASEMI
         depends on PPC64 && PPC_BOOK3S && CPU_BIG_ENDIAN
         bool "PA Semi SoC-based platforms"
-        default n
         select MPIC
         select PCI
         select PPC_UDBG_16550
diff --git a/arch/powerpc/platforms/pasemi/dma_lib.c b/arch/powerpc/platforms/pasemi/dma_lib.c
index c80f72c370ae..53384eb42a76 100644
--- a/arch/powerpc/platforms/pasemi/dma_lib.c
+++ b/arch/powerpc/platforms/pasemi/dma_lib.c
@@ -576,7 +576,7 @@ int pasemi_dma_init(void)
                 res.start = 0xfd800000;
                 res.end = res.start + 0x1000;
         }
-        dma_status = __ioremap(res.start, resource_size(&res), 0);
+        dma_status = ioremap_cache(res.start, resource_size(&res));
         pci_dev_put(iob_pdev);
 
         for (i = 0; i < MAX_TXCH; i++)
diff --git a/arch/powerpc/platforms/powermac/Makefile b/arch/powerpc/platforms/powermac/Makefile
index f2839eed0f89..923bfb340433 100644
--- a/arch/powerpc/platforms/powermac/Makefile
+++ b/arch/powerpc/platforms/powermac/Makefile
@@ -1,9 +1,10 @@
 # SPDX-License-Identifier: GPL-2.0
 CFLAGS_bootx_init.o             += -fPIC
+CFLAGS_bootx_init.o             += $(call cc-option, -fno-stack-protector)
 
 ifdef CONFIG_FUNCTION_TRACER
 # Do not trace early boot code
-CFLAGS_REMOVE_bootx_init.o = -mno-sched-epilog $(CC_FLAGS_FTRACE)
+CFLAGS_REMOVE_bootx_init.o = $(CC_FLAGS_FTRACE)
 endif
 
 obj-y                           += pic.o setup.o time.o feature.o pci.o \
diff --git a/arch/powerpc/platforms/powermac/time.c b/arch/powerpc/platforms/powermac/time.c
index f92c1918fb56..f157e3d071f2 100644
--- a/arch/powerpc/platforms/powermac/time.c
+++ b/arch/powerpc/platforms/powermac/time.c
@@ -45,13 +45,6 @@
 #endif
 
 /*
- * Offset between Unix time (1970-based) and Mac time (1904-based). Cuda and PMU
- * times wrap in 2040. If we need to handle later times, the read_time functions
- * need to be changed to interpret wrapped times as post-2040.
- */
-#define RTC_OFFSET      2082844800
-
-/*
  * Calibrate the decrementer frequency with the VIA timer 1.
  */
 #define VIA_TIMER_FREQ_6        4700000 /* time 1 frequency * 6 */
@@ -90,98 +83,6 @@ long __init pmac_time_init(void)
         return delta;
 }
 
-#ifdef CONFIG_ADB_CUDA
-static time64_t cuda_get_time(void)
-{
-        struct adb_request req;
-        time64_t now;
-
-        if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME) < 0)
-                return 0;
-        while (!req.complete)
-                cuda_poll();
-        if (req.reply_len != 7)
-                printk(KERN_ERR "cuda_get_time: got %d byte reply\n",
-                       req.reply_len);
-        now = (u32)((req.reply[3] << 24) + (req.reply[4] << 16) +
-                    (req.reply[5] << 8) + req.reply[6]);
-        /* it's either after year 2040, or the RTC has gone backwards */
-        WARN_ON(now < RTC_OFFSET);
-
-        return now - RTC_OFFSET;
-}
-
-#define cuda_get_rtc_time(tm)   rtc_time64_to_tm(cuda_get_time(), (tm))
-
-static int cuda_set_rtc_time(struct rtc_time *tm)
-{
-        u32 nowtime;
-        struct adb_request req;
-
-        nowtime = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
-        if (cuda_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME,
-                         nowtime >> 24, nowtime >> 16, nowtime >> 8,
-                         nowtime) < 0)
-                return -ENXIO;
-        while (!req.complete)
-                cuda_poll();
-        if ((req.reply_len != 3) && (req.reply_len != 7))
-                printk(KERN_ERR "cuda_set_rtc_time: got %d byte reply\n",
-                       req.reply_len);
-        return 0;
-}
-
-#else
-#define cuda_get_time()         0
-#define cuda_get_rtc_time(tm)
-#define cuda_set_rtc_time(tm)   0
-#endif
-
-#ifdef CONFIG_ADB_PMU
-static time64_t pmu_get_time(void)
-{
-        struct adb_request req;
-        time64_t now;
-
-        if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)
-                return 0;
-        pmu_wait_complete(&req);
-        if (req.reply_len != 4)
-                printk(KERN_ERR "pmu_get_time: got %d byte reply from PMU\n",
-                       req.reply_len);
-        now = (u32)((req.reply[0] << 24) + (req.reply[1] << 16) +
-                    (req.reply[2] << 8) + req.reply[3]);
-
-        /* it's either after year 2040, or the RTC has gone backwards */
-        WARN_ON(now < RTC_OFFSET);
-
-        return now - RTC_OFFSET;
-}
-
-#define pmu_get_rtc_time(tm)    rtc_time64_to_tm(pmu_get_time(), (tm))
-
-static int pmu_set_rtc_time(struct rtc_time *tm)
-{
-        u32 nowtime;
-        struct adb_request req;
-
-        nowtime = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
-        if (pmu_request(&req, NULL, 5, PMU_SET_RTC, nowtime >> 24,
-                        nowtime >> 16, nowtime >> 8, nowtime) < 0)
-                return -ENXIO;
-        pmu_wait_complete(&req);
-        if (req.reply_len != 0)
-                printk(KERN_ERR "pmu_set_rtc_time: %d byte reply from PMU\n",
-                       req.reply_len);
-        return 0;
-}
-
-#else
-#define pmu_get_time()          0
-#define pmu_get_rtc_time(tm)
-#define pmu_set_rtc_time(tm)    0
-#endif
-
 #ifdef CONFIG_PMAC_SMU
 static time64_t smu_get_time(void)
 {
@@ -191,11 +92,6 @@ static time64_t smu_get_time(void)
                 return 0;
         return rtc_tm_to_time64(&tm);
 }
-
-#else
-#define smu_get_time()                  0
-#define smu_get_rtc_time(tm, spin)
-#define smu_set_rtc_time(tm, spin)      0
 #endif
 
 /* Can't be __init, it's called when suspending and resuming */
@@ -203,12 +99,18 @@ time64_t pmac_get_boot_time(void)
 {
         /* Get the time from the RTC, used only at boot time */
         switch (sys_ctrler) {
+#ifdef CONFIG_ADB_CUDA
         case SYS_CTRLER_CUDA:
                 return cuda_get_time();
+#endif
+#ifdef CONFIG_ADB_PMU
         case SYS_CTRLER_PMU:
                 return pmu_get_time();
+#endif
+#ifdef CONFIG_PMAC_SMU
         case SYS_CTRLER_SMU:
                 return smu_get_time();
+#endif
         default:
                 return 0;
         }
@@ -218,15 +120,21 @@ void pmac_get_rtc_time(struct rtc_time *tm)
 {
         /* Get the time from the RTC, used only at boot time */
         switch (sys_ctrler) {
+#ifdef CONFIG_ADB_CUDA
         case SYS_CTRLER_CUDA:
-                cuda_get_rtc_time(tm);
+                rtc_time64_to_tm(cuda_get_time(), tm);
                 break;
+#endif
+#ifdef CONFIG_ADB_PMU
         case SYS_CTRLER_PMU:
-                pmu_get_rtc_time(tm);
+                rtc_time64_to_tm(pmu_get_time(), tm);
                 break;
+#endif
+#ifdef CONFIG_PMAC_SMU
         case SYS_CTRLER_SMU:
                 smu_get_rtc_time(tm, 1);
                 break;
+#endif
         default:
                 ;
         }
@@ -235,12 +143,18 @@ void pmac_get_rtc_time(struct rtc_time *tm)
 int pmac_set_rtc_time(struct rtc_time *tm)
 {
         switch (sys_ctrler) {
+#ifdef CONFIG_ADB_CUDA
         case SYS_CTRLER_CUDA:
                 return cuda_set_rtc_time(tm);
+#endif
+#ifdef CONFIG_ADB_PMU
         case SYS_CTRLER_PMU:
                 return pmu_set_rtc_time(tm);
+#endif
+#ifdef CONFIG_PMAC_SMU
         case SYS_CTRLER_SMU:
                 return smu_set_rtc_time(tm, 1);
+#endif
         default:
                 return -ENODEV;
         }
diff --git a/arch/powerpc/platforms/powernv/Kconfig b/arch/powerpc/platforms/powernv/Kconfig
index f8dc98d3dc01..99083fe992d5 100644
--- a/arch/powerpc/platforms/powernv/Kconfig
+++ b/arch/powerpc/platforms/powernv/Kconfig
@@ -15,11 +15,6 @@ config PPC_POWERNV
         select PPC_SCOM
         select ARCH_RANDOM
         select CPU_FREQ
-        select CPU_FREQ_GOV_PERFORMANCE
-        select CPU_FREQ_GOV_POWERSAVE
-        select CPU_FREQ_GOV_USERSPACE
-        select CPU_FREQ_GOV_ONDEMAND
-        select CPU_FREQ_GOV_CONSERVATIVE
         select PPC_DOORBELL
         select MMU_NOTIFIER
         select FORCE_SMP
@@ -35,7 +30,6 @@ config OPAL_PRD
 config PPC_MEMTRACE
         bool "Enable removal of RAM from kernel mappings for tracing"
         depends on PPC_POWERNV && MEMORY_HOTREMOVE
-        default n
         help
           Enabling this option allows for the removal of memory (RAM)
           from the kernel mappings to be used for hardware tracing.
diff --git a/arch/powerpc/platforms/powernv/eeh-powernv.c b/arch/powerpc/platforms/powernv/eeh-powernv.c
index 3c1beae29f2d..abc0be7507c8 100644
--- a/arch/powerpc/platforms/powernv/eeh-powernv.c
+++ b/arch/powerpc/platforms/powernv/eeh-powernv.c
@@ -223,14 +223,6 @@ int pnv_eeh_post_init(void)
         eeh_probe_devices();
         eeh_addr_cache_build();
 
-        if (eeh_has_flag(EEH_POSTPONED_PROBE)) {
-                eeh_clear_flag(EEH_POSTPONED_PROBE);
-                if (eeh_enabled())
-                        pr_info("EEH: PCI Enhanced I/O Error Handling Enabled\n");
-                else
-                        pr_info("EEH: No capable adapters found\n");
-        }
-
         /* Register OPAL event notifier */
         eeh_event_irq = opal_event_request(ilog2(OPAL_EVENT_PCI_ERROR));
         if (eeh_event_irq < 0) {
@@ -391,12 +383,6 @@ static void *pnv_eeh_probe(struct pci_dn *pdn, void *data)
         if ((pdn->class_code >> 8) == PCI_CLASS_BRIDGE_ISA)
                 return NULL;
 
-        /* Skip if we haven't probed yet */
-        if (phb->ioda.pe_rmap[config_addr] == IODA_INVALID_PE) {
-                eeh_add_flag(EEH_POSTPONED_PROBE);
-                return NULL;
-        }
-
         /* Initialize eeh device */
         edev->class_code = pdn->class_code;
         edev->mode      &= 0xFFFFFF00;
@@ -604,7 +590,7 @@ static int pnv_eeh_get_phb_state(struct eeh_pe *pe)
                           EEH_STATE_MMIO_ENABLED |
                           EEH_STATE_DMA_ENABLED);
         } else if (!(pe->state & EEH_PE_ISOLATED)) {
-                eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
+                eeh_pe_mark_isolated(pe);
                 pnv_eeh_get_phb_diag(pe);
 
                 if (eeh_has_flag(EEH_EARLY_DUMP_LOG))
@@ -706,7 +692,7 @@ static int pnv_eeh_get_pe_state(struct eeh_pe *pe)
                 if (phb->freeze_pe)
                         phb->freeze_pe(phb, pe->addr);
 
-                eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
+                eeh_pe_mark_isolated(pe);
                 pnv_eeh_get_phb_diag(pe);
 
                 if (eeh_has_flag(EEH_EARLY_DUMP_LOG))
@@ -1054,7 +1040,7 @@ static int pnv_eeh_reset_vf_pe(struct eeh_pe *pe, int option)
         int ret;
 
         /* The VF PE should have only one child device */
-        edev = list_first_entry_or_null(&pe->edevs, struct eeh_dev, list);
+        edev = list_first_entry_or_null(&pe->edevs, struct eeh_dev, entry);
         pdn = eeh_dev_to_pdn(edev);
         if (!pdn)
                 return -ENXIO;
@@ -1148,43 +1134,6 @@ static int pnv_eeh_reset(struct eeh_pe *pe, int option)
 }
 
 /**
- * pnv_eeh_wait_state - Wait for PE state
- * @pe: EEH PE
- * @max_wait: maximal period in millisecond
- *
- * Wait for the state of associated PE. It might take some time
- * to retrieve the PE's state.
- */
-static int pnv_eeh_wait_state(struct eeh_pe *pe, int max_wait)
-{
-        int ret;
-        int mwait;
-
-        while (1) {
-                ret = pnv_eeh_get_state(pe, &mwait);
-
-                /*
-                 * If the PE's state is temporarily unavailable,
-                 * we have to wait for the specified time. Otherwise,
-                 * the PE's state will be returned immediately.
-                 */
-                if (ret != EEH_STATE_UNAVAILABLE)
-                        return ret;
-
-                if (max_wait <= 0) {
-                        pr_warn("%s: Timeout getting PE#%x's state (%d)\n",
-                                __func__, pe->addr, max_wait);
-                        return EEH_STATE_NOT_SUPPORT;
-                }
-
-                max_wait -= mwait;
-                msleep(mwait);
-        }
-
-        return EEH_STATE_NOT_SUPPORT;
-}
-
-/**
  * pnv_eeh_get_log - Retrieve error log
  * @pe: EEH PE
  * @severity: temporary or permanent error log
@@ -1611,7 +1560,7 @@ static int pnv_eeh_next_error(struct eeh_pe **pe)
                 if ((ret == EEH_NEXT_ERR_FROZEN_PE  ||
                     ret == EEH_NEXT_ERR_FENCED_PHB) &&
                     !((*pe)->state & EEH_PE_ISOLATED)) {
-                        eeh_pe_state_mark(*pe, EEH_PE_ISOLATED);
+                        eeh_pe_mark_isolated(*pe);
                         pnv_eeh_get_phb_diag(*pe);
 
                         if (eeh_has_flag(EEH_EARLY_DUMP_LOG))
@@ -1640,7 +1589,7 @@ static int pnv_eeh_next_error(struct eeh_pe **pe)
                         }
 
                         /* We possibly migrate to another PE */
-                        eeh_pe_state_mark(*pe, EEH_PE_ISOLATED);
+                        eeh_pe_mark_isolated(*pe);
                 }
 
                 /*
@@ -1702,7 +1651,6 @@ static struct eeh_ops pnv_eeh_ops = {
         .get_pe_addr            = pnv_eeh_get_pe_addr,
         .get_state              = pnv_eeh_get_state,
         .reset                  = pnv_eeh_reset,
-        .wait_state             = pnv_eeh_wait_state,
         .get_log                = pnv_eeh_get_log,
         .configure_bridge       = pnv_eeh_configure_bridge,
         .err_inject             = pnv_eeh_err_inject,
diff --git a/arch/powerpc/platforms/powernv/memtrace.c b/arch/powerpc/platforms/powernv/memtrace.c
index 51dc398ae3f7..a29fdf8a2e56 100644
--- a/arch/powerpc/platforms/powernv/memtrace.c
+++ b/arch/powerpc/platforms/powernv/memtrace.c
@@ -90,17 +90,15 @@ static bool memtrace_offline_pages(u32 nid, u64 start_pfn, u64 nr_pages)
         walk_memory_range(start_pfn, end_pfn, (void *)MEM_OFFLINE,
                           change_memblock_state);
 
-        lock_device_hotplug();
-        remove_memory(nid, start_pfn << PAGE_SHIFT, nr_pages << PAGE_SHIFT);
-        unlock_device_hotplug();
 
         return true;
 }
 
 static u64 memtrace_alloc_node(u32 nid, u64 size)
 {
-        u64 start_pfn, end_pfn, nr_pages;
+        u64 start_pfn, end_pfn, nr_pages, pfn;
         u64 base_pfn;
+        u64 bytes = memory_block_size_bytes();
 
         if (!node_spanned_pages(nid))
                 return 0;
@@ -113,8 +111,21 @@ static u64 memtrace_alloc_node(u32 nid, u64 size)
         end_pfn = round_down(end_pfn - nr_pages, nr_pages);
 
         for (base_pfn = end_pfn; base_pfn > start_pfn; base_pfn -= nr_pages) {
-                if (memtrace_offline_pages(nid, base_pfn, nr_pages) == true)
+                if (memtrace_offline_pages(nid, base_pfn, nr_pages) == true) {
+                        /*
+                         * Remove memory in memory block size chunks so that
+                         * iomem resources are always split to the same size and
+                         * we never try to remove memory that spans two iomem
+                         * resources.
+                         */
+                        lock_device_hotplug();
+                        end_pfn = base_pfn + nr_pages;
+                        for (pfn = base_pfn; pfn < end_pfn; pfn += bytes>> PAGE_SHIFT) {
+                                remove_memory(nid, pfn << PAGE_SHIFT, bytes);
+                        }
+                        unlock_device_hotplug();
                         return base_pfn << PAGE_SHIFT;
+                }
         }
 
         return 0;
diff --git a/arch/powerpc/platforms/powernv/npu-dma.c b/arch/powerpc/platforms/powernv/npu-dma.c
index 8006c54a91e3..6f60e0931922 100644
--- a/arch/powerpc/platforms/powernv/npu-dma.c
+++ b/arch/powerpc/platforms/powernv/npu-dma.c
@@ -17,7 +17,7 @@
 #include <linux/pci.h>
 #include <linux/memblock.h>
 #include <linux/iommu.h>
-#include <linux/debugfs.h>
+#include <linux/sizes.h>
 
 #include <asm/debugfs.h>
 #include <asm/tlb.h>
@@ -42,14 +42,6 @@
 static DEFINE_SPINLOCK(npu_context_lock);
 
 /*
- * When an address shootdown range exceeds this threshold we invalidate the
- * entire TLB on the GPU for the given PID rather than each specific address in
- * the range.
- */
-static uint64_t atsd_threshold = 2 * 1024 * 1024;
-static struct dentry *atsd_threshold_dentry;
-
-/*
  * Other types of TCE cache invalidation are not functional in the
  * hardware.
  */
@@ -454,79 +446,73 @@ static void put_mmio_atsd_reg(struct npu *npu, int reg)
 }
 
 /* MMIO ATSD register offsets */
-#define XTS_ATSD_AVA  1
-#define XTS_ATSD_STAT 2
-
-static void mmio_launch_invalidate(struct mmio_atsd_reg *mmio_atsd_reg,
-                                unsigned long launch, unsigned long va)
-{
-        struct npu *npu = mmio_atsd_reg->npu;
-        int reg = mmio_atsd_reg->reg;
-
-        __raw_writeq_be(va, npu->mmio_atsd_regs[reg] + XTS_ATSD_AVA);
-        eieio();
-        __raw_writeq_be(launch, npu->mmio_atsd_regs[reg]);
-}
+#define XTS_ATSD_LAUNCH 0
+#define XTS_ATSD_AVA    1
+#define XTS_ATSD_STAT   2
 
-static void mmio_invalidate_pid(struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS],
-                                unsigned long pid, bool flush)
+static unsigned long get_atsd_launch_val(unsigned long pid, unsigned long psize)
 {
-        int i;
-        unsigned long launch;
-
-        for (i = 0; i <= max_npu2_index; i++) {
-                if (mmio_atsd_reg[i].reg < 0)
-                        continue;
+        unsigned long launch = 0;
 
-                /* IS set to invalidate matching PID */
-                launch = PPC_BIT(12);
-
-                /* PRS set to process-scoped */
-                launch |= PPC_BIT(13);
+        if (psize == MMU_PAGE_COUNT) {
+                /* IS set to invalidate entire matching PID */
+                launch |= PPC_BIT(12);
+        } else {
+                /* AP set to invalidate region of psize */
+                launch |= (u64)mmu_get_ap(psize) << PPC_BITLSHIFT(17);
+        }
 
-                /* AP */
-                launch |= (u64)
-                        mmu_get_ap(mmu_virtual_psize) << PPC_BITLSHIFT(17);
+        /* PRS set to process-scoped */
+        launch |= PPC_BIT(13);
 
-                /* PID */
-                launch |= pid << PPC_BITLSHIFT(38);
+        /* PID */
+        launch |= pid << PPC_BITLSHIFT(38);
 
-                /* No flush */
-                launch |= !flush << PPC_BITLSHIFT(39);
+        /* Leave "No flush" (bit 39) 0 so every ATSD performs a flush */
 
-                /* Invalidating the entire process doesn't use a va */
-                mmio_launch_invalidate(&mmio_atsd_reg[i], launch, 0);
-        }
+        return launch;
 }
 
-static void mmio_invalidate_va(struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS],
-                        unsigned long va, unsigned long pid, bool flush)
+static void mmio_atsd_regs_write(struct mmio_atsd_reg
+                        mmio_atsd_reg[NV_MAX_NPUS], unsigned long offset,
+                        unsigned long val)
 {
-        int i;
-        unsigned long launch;
+        struct npu *npu;
+        int i, reg;
 
         for (i = 0; i <= max_npu2_index; i++) {
-                if (mmio_atsd_reg[i].reg < 0)
+                reg = mmio_atsd_reg[i].reg;
+                if (reg < 0)
                         continue;
 
-                /* IS set to invalidate target VA */
-                launch = 0;
+                npu = mmio_atsd_reg[i].npu;
+                __raw_writeq_be(val, npu->mmio_atsd_regs[reg] + offset);
+        }
+}
+
+static void mmio_invalidate_pid(struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS],
+                                unsigned long pid)
+{
+        unsigned long launch = get_atsd_launch_val(pid, MMU_PAGE_COUNT);
 
-                /* PRS set to process scoped */
-                launch |= PPC_BIT(13);
+        /* Invalidating the entire process doesn't use a va */
+        mmio_atsd_regs_write(mmio_atsd_reg, XTS_ATSD_LAUNCH, launch);
+}
 
-                /* AP */
-                launch |= (u64)
-                        mmu_get_ap(mmu_virtual_psize) << PPC_BITLSHIFT(17);
+static void mmio_invalidate_range(struct mmio_atsd_reg
+                        mmio_atsd_reg[NV_MAX_NPUS], unsigned long pid,
+                        unsigned long start, unsigned long psize)
+{
+        unsigned long launch = get_atsd_launch_val(pid, psize);
 
-                /* PID */
-                launch |= pid << PPC_BITLSHIFT(38);
+        /* Write all VAs first */
+        mmio_atsd_regs_write(mmio_atsd_reg, XTS_ATSD_AVA, start);
 
-                /* No flush */
-                launch |= !flush << PPC_BITLSHIFT(39);
+        /* Issue one barrier for all address writes */
+        eieio();
 
-                mmio_launch_invalidate(&mmio_atsd_reg[i], launch, va);
-        }
+        /* Launch */
+        mmio_atsd_regs_write(mmio_atsd_reg, XTS_ATSD_LAUNCH, launch);
 }
 
 #define mn_to_npu_context(x) container_of(x, struct npu_context, mn)
@@ -612,14 +598,36 @@ static void release_atsd_reg(struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS])
 }
 
 /*
- * Invalidate either a single address or an entire PID depending on
- * the value of va.
+ * Invalidate a virtual address range
  */
-static void mmio_invalidate(struct npu_context *npu_context, int va,
-                        unsigned long address, bool flush)
+static void mmio_invalidate(struct npu_context *npu_context,
+                        unsigned long start, unsigned long size)
 {
         struct mmio_atsd_reg mmio_atsd_reg[NV_MAX_NPUS];
         unsigned long pid = npu_context->mm->context.id;
+        unsigned long atsd_start = 0;
+        unsigned long end = start + size - 1;
+        int atsd_psize = MMU_PAGE_COUNT;
+
+        /*
+         * Convert the input range into one of the supported sizes. If the range
+         * doesn't fit, use the next larger supported size. Invalidation latency
+         * is high, so over-invalidation is preferred to issuing multiple
+         * invalidates.
+         *
+         * A 4K page size isn't supported by NPU/GPU ATS, so that case is
+         * ignored.
+         */
+        if (size == SZ_64K) {
+                atsd_start = start;
+                atsd_psize = MMU_PAGE_64K;
+        } else if (ALIGN_DOWN(start, SZ_2M) == ALIGN_DOWN(end, SZ_2M)) {
+                atsd_start = ALIGN_DOWN(start, SZ_2M);
+                atsd_psize = MMU_PAGE_2M;
+        } else if (ALIGN_DOWN(start, SZ_1G) == ALIGN_DOWN(end, SZ_1G)) {
+                atsd_start = ALIGN_DOWN(start, SZ_1G);
+                atsd_psize = MMU_PAGE_1G;
+        }
 
         if (npu_context->nmmu_flush)
                 /*
@@ -634,23 +642,25 @@ static void mmio_invalidate(struct npu_context *npu_context, int va,
          * an invalidate.
          */
         acquire_atsd_reg(npu_context, mmio_atsd_reg);
-        if (va)
-                mmio_invalidate_va(mmio_atsd_reg, address, pid, flush);
+
+        if (atsd_psize == MMU_PAGE_COUNT)
+                mmio_invalidate_pid(mmio_atsd_reg, pid);
         else
-                mmio_invalidate_pid(mmio_atsd_reg, pid, flush);
+                mmio_invalidate_range(mmio_atsd_reg, pid, atsd_start,
+                                        atsd_psize);
 
         mmio_invalidate_wait(mmio_atsd_reg);
-        if (flush) {
-                /*
-                 * The GPU requires two flush ATSDs to ensure all entries have
-                 * been flushed. We use PID 0 as it will never be used for a
-                 * process on the GPU.
-                 */
-                mmio_invalidate_pid(mmio_atsd_reg, 0, true);
-                mmio_invalidate_wait(mmio_atsd_reg);
-                mmio_invalidate_pid(mmio_atsd_reg, 0, true);
-                mmio_invalidate_wait(mmio_atsd_reg);
-        }
+
+        /*
+         * The GPU requires two flush ATSDs to ensure all entries have been
+         * flushed. We use PID 0 as it will never be used for a process on the
+         * GPU.
+         */
+        mmio_invalidate_pid(mmio_atsd_reg, 0);
+        mmio_invalidate_wait(mmio_atsd_reg);
+        mmio_invalidate_pid(mmio_atsd_reg, 0);
+        mmio_invalidate_wait(mmio_atsd_reg);
+
         release_atsd_reg(mmio_atsd_reg);
 }
 
@@ -667,7 +677,7 @@ static void pnv_npu2_mn_release(struct mmu_notifier *mn,
          * There should be no more translation requests for this PID, but we
          * need to ensure any entries for it are removed from the TLB.
          */
-        mmio_invalidate(npu_context, 0, 0, true);
+        mmio_invalidate(npu_context, 0, ~0UL);
 }
 
 static void pnv_npu2_mn_change_pte(struct mmu_notifier *mn,
@@ -676,8 +686,7 @@ static void pnv_npu2_mn_change_pte(struct mmu_notifier *mn,
                                 pte_t pte)
 {
         struct npu_context *npu_context = mn_to_npu_context(mn);
-
-        mmio_invalidate(npu_context, 1, address, true);
+        mmio_invalidate(npu_context, address, PAGE_SIZE);
 }
 
 static void pnv_npu2_mn_invalidate_range(struct mmu_notifier *mn,
@@ -685,21 +694,7 @@ static void pnv_npu2_mn_invalidate_range(struct mmu_notifier *mn,
                                         unsigned long start, unsigned long end)
 {
         struct npu_context *npu_context = mn_to_npu_context(mn);
-        unsigned long address;
-
-        if (end - start > atsd_threshold) {
-                /*
-                 * Just invalidate the entire PID if the address range is too
-                 * large.
-                 */
-                mmio_invalidate(npu_context, 0, 0, true);
-        } else {
-                for (address = start; address < end; address += PAGE_SIZE)
-                        mmio_invalidate(npu_context, 1, address, false);
-
-                /* Do the flush only on the final addess == end */
-                mmio_invalidate(npu_context, 1, address, true);
-        }
+        mmio_invalidate(npu_context, start, end - start);
 }
 
 static const struct mmu_notifier_ops nv_nmmu_notifier_ops = {
@@ -962,11 +957,6 @@ int pnv_npu2_init(struct pnv_phb *phb)
         static int npu_index;
         uint64_t rc = 0;
 
-        if (!atsd_threshold_dentry) {
-                atsd_threshold_dentry = debugfs_create_x64("atsd_threshold",
-                                   0600, powerpc_debugfs_root, &atsd_threshold);
-        }
-
         phb->npu.nmmu_flush =
                 of_property_read_bool(phb->hose->dn, "ibm,nmmu-flush");
         for_each_child_of_node(phb->hose->dn, dn) {
diff --git a/arch/powerpc/platforms/powernv/opal-powercap.c b/arch/powerpc/platforms/powernv/opal-powercap.c
index badb29bde93f..d90ee4fc2c6a 100644
--- a/arch/powerpc/platforms/powernv/opal-powercap.c
+++ b/arch/powerpc/platforms/powernv/opal-powercap.c
@@ -199,7 +199,7 @@ void __init opal_powercap_init(void)
                 }
 
                 j = 0;
-                pcaps[i].pg.name = node->name;
+                pcaps[i].pg.name = kasprintf(GFP_KERNEL, "%pOFn", node);
                 if (has_min) {
                         powercap_add_attr(min, "powercap-min",
                                           &pcaps[i].pattrs[j]);
@@ -237,6 +237,7 @@ out_pcaps_pattrs:
         while (--i >= 0) {
                 kfree(pcaps[i].pattrs);
                 kfree(pcaps[i].pg.attrs);
+                kfree(pcaps[i].pg.name);
         }
         kobject_put(powercap_kobj);
 out_pcaps:
diff --git a/arch/powerpc/platforms/powernv/opal-sensor-groups.c b/arch/powerpc/platforms/powernv/opal-sensor-groups.c
index f7d04b6a2d7a..179609220e6f 100644
--- a/arch/powerpc/platforms/powernv/opal-sensor-groups.c
+++ b/arch/powerpc/platforms/powernv/opal-sensor-groups.c
@@ -214,9 +214,9 @@ void __init opal_sensor_groups_init(void)
                 }
 
                 if (!of_property_read_u32(node, "ibm,chip-id", &chipid))
-                        sprintf(sgs[i].name, "%s%d", node->name, chipid);
+                        sprintf(sgs[i].name, "%pOFn%d", node, chipid);
                 else
-                        sprintf(sgs[i].name, "%s", node->name);
+                        sprintf(sgs[i].name, "%pOFn", node);
 
                 sgs[i].sg.name = sgs[i].name;
                 if (add_attr_group(ops, len, &sgs[i], sgid)) {
diff --git a/arch/powerpc/platforms/powernv/opal-sysparam.c b/arch/powerpc/platforms/powernv/opal-sysparam.c
index 9aa87df114fd..916a4b7b1bb5 100644
--- a/arch/powerpc/platforms/powernv/opal-sysparam.c
+++ b/arch/powerpc/platforms/powernv/opal-sysparam.c
@@ -194,7 +194,7 @@ void __init opal_sys_param_init(void)
         count = of_property_count_strings(sysparam, "param-name");
         if (count < 0) {
                 pr_err("SYSPARAM: No string found of property param-name in "
-                                "the node %s\n", sysparam->name);
+                                "the node %pOFn\n", sysparam);
                 goto out_param_buf;
         }
 
diff --git a/arch/powerpc/platforms/powernv/opal.c b/arch/powerpc/platforms/powernv/opal.c
index 38fe4087484a..a4641515956f 100644
--- a/arch/powerpc/platforms/powernv/opal.c
+++ b/arch/powerpc/platforms/powernv/opal.c
@@ -535,7 +535,7 @@ static int opal_recover_mce(struct pt_regs *regs,
         return recovered;
 }
 
-void pnv_platform_error_reboot(struct pt_regs *regs, const char *msg)
+void __noreturn pnv_platform_error_reboot(struct pt_regs *regs, const char *msg)
 {
         panic_flush_kmsg_start();
 
diff --git a/arch/powerpc/platforms/powernv/setup.c b/arch/powerpc/platforms/powernv/setup.c
index adddde023622..14befee4b3f1 100644
--- a/arch/powerpc/platforms/powernv/setup.c
+++ b/arch/powerpc/platforms/powernv/setup.c
@@ -219,17 +219,41 @@ static void pnv_prepare_going_down(void)
 
 static void  __noreturn pnv_restart(char *cmd)
 {
-        long rc = OPAL_BUSY;
+        long rc;
 
         pnv_prepare_going_down();
 
-        while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
-                rc = opal_cec_reboot();
-                if (rc == OPAL_BUSY_EVENT)
-                        opal_poll_events(NULL);
+        do {
+                if (!cmd)
+                        rc = opal_cec_reboot();
+                else if (strcmp(cmd, "full") == 0)
+                        rc = opal_cec_reboot2(OPAL_REBOOT_FULL_IPL, NULL);
                 else
+                        rc = OPAL_UNSUPPORTED;
+
+                if (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT) {
+                        /* Opal is busy wait for some time and retry */
+                        opal_poll_events(NULL);
                         mdelay(10);
-        }
+
+                } else  if (cmd && rc) {
+                        /* Unknown error while issuing reboot */
+                        if (rc == OPAL_UNSUPPORTED)
+                                pr_err("Unsupported '%s' reboot.\n", cmd);
+                        else
+                                pr_err("Unable to issue '%s' reboot. Err=%ld\n",
+                                       cmd, rc);
+                        pr_info("Forcing a cec-reboot\n");
+                        cmd = NULL;
+                        rc = OPAL_BUSY;
+
+                } else if (rc != OPAL_SUCCESS) {
+                        /* Unknown error while issuing cec-reboot */
+                        pr_err("Unable to reboot. Err=%ld\n", rc);
+                }
+
+        } while (rc == OPAL_BUSY || rc == OPAL_BUSY_EVENT);
+
         for (;;)
                 opal_poll_events(NULL);
 }
@@ -437,6 +461,16 @@ static unsigned long pnv_get_proc_freq(unsigned int cpu)
         return ret_freq;
 }
 
+static long pnv_machine_check_early(struct pt_regs *regs)
+{
+        long handled = 0;
+
+        if (cur_cpu_spec && cur_cpu_spec->machine_check_early)
+                handled = cur_cpu_spec->machine_check_early(regs);
+
+        return handled;
+}
+
 define_machine(powernv) {
         .name                   = "PowerNV",
         .probe                  = pnv_probe,
@@ -448,6 +482,7 @@ define_machine(powernv) {
         .machine_shutdown       = pnv_shutdown,
         .power_save             = NULL,
         .calibrate_decr         = generic_calibrate_decr,
+        .machine_check_early    = pnv_machine_check_early,
 #ifdef CONFIG_KEXEC_CORE
         .kexec_cpu_down         = pnv_kexec_cpu_down,
 #endif
diff --git a/arch/powerpc/platforms/ps3/Kconfig b/arch/powerpc/platforms/ps3/Kconfig
index 6f7525555b19..24864b8aaf5d 100644
--- a/arch/powerpc/platforms/ps3/Kconfig
+++ b/arch/powerpc/platforms/ps3/Kconfig
@@ -49,7 +49,6 @@ config PS3_HTAB_SIZE
 config PS3_DYNAMIC_DMA
         depends on PPC_PS3
         bool "PS3 Platform dynamic DMA page table management"
-        default n
         help
           This option will enable kernel support to take advantage of the
           per device dynamic DMA page table management provided by the Cell
@@ -89,7 +88,6 @@ config PS3_SYS_MANAGER
 config PS3_REPOSITORY_WRITE
         bool "PS3 Repository write support" if PS3_ADVANCED
         depends on PPC_PS3
-        default n
         help
           Enables support for writing to the PS3 System Repository.
 
diff --git a/arch/powerpc/platforms/ps3/os-area.c b/arch/powerpc/platforms/ps3/os-area.c
index cdbfc5cfd6f3..f5387ad82279 100644
--- a/arch/powerpc/platforms/ps3/os-area.c
+++ b/arch/powerpc/platforms/ps3/os-area.c
@@ -664,7 +664,7 @@ static int update_flash_db(void)
         db_set_64(db, &os_area_db_id_rtc_diff, saved_params.rtc_diff);
 
         count = os_area_flash_write(db, sizeof(struct os_area_db), pos);
-        if (count < sizeof(struct os_area_db)) {
+        if (count < 0 || count < sizeof(struct os_area_db)) {
                 pr_debug("%s: os_area_flash_write failed %zd\n", __func__,
                          count);
                 error = count < 0 ? count : -EIO;
diff --git a/arch/powerpc/platforms/ps3/spu.c b/arch/powerpc/platforms/ps3/spu.c
index b54850845466..7746c2a3c509 100644
--- a/arch/powerpc/platforms/ps3/spu.c
+++ b/arch/powerpc/platforms/ps3/spu.c
@@ -215,8 +215,7 @@ static int __init setup_areas(struct spu *spu)
                 goto fail_ioremap;
         }
 
-        spu->local_store = (__force void *)ioremap_prot(spu->local_store_phys,
-                LS_SIZE, pgprot_val(pgprot_noncached_wc(__pgprot(0))));
+        spu->local_store = (__force void *)ioremap_wc(spu->local_store_phys, LS_SIZE);
 
         if (!spu->local_store) {
                 pr_debug("%s:%d: ioremap local_store failed\n",
diff --git a/arch/powerpc/platforms/pseries/Kconfig b/arch/powerpc/platforms/pseries/Kconfig
index 0c698fd6d491..2e4bd32154b5 100644
--- a/arch/powerpc/platforms/pseries/Kconfig
+++ b/arch/powerpc/platforms/pseries/Kconfig
@@ -28,7 +28,6 @@ config PPC_PSERIES
 config PPC_SPLPAR
         depends on PPC_PSERIES
         bool "Support for shared-processor logical partitions"
-        default n
         help
           Enabling this option will make the kernel run more efficiently
           on logically-partitioned pSeries systems which use shared
@@ -99,7 +98,6 @@ config PPC_SMLPAR
         bool "Support for shared-memory logical partitions"
         depends on PPC_PSERIES
         select LPARCFG
-        default n
         help
           Select this option to enable shared memory partition support.
           With this option a system running in an LPAR can be given more
@@ -140,3 +138,10 @@ config IBMEBUS
         bool "Support for GX bus based adapters"
         help
           Bus device driver for GX bus based adapters.
+
+config PAPR_SCM
+        depends on PPC_PSERIES && MEMORY_HOTPLUG
+        select LIBNVDIMM
+        tristate "Support for the PAPR Storage Class Memory interface"
+        help
+          Enable access to hypervisor provided storage class memory.
diff --git a/arch/powerpc/platforms/pseries/Makefile b/arch/powerpc/platforms/pseries/Makefile
index 7e89d5c47068..a43ec843c8e2 100644
--- a/arch/powerpc/platforms/pseries/Makefile
+++ b/arch/powerpc/platforms/pseries/Makefile
@@ -13,7 +13,7 @@ obj-$(CONFIG_KEXEC_CORE)	+= kexec.o
 obj-$(CONFIG_PSERIES_ENERGY)    += pseries_energy.o
 
 obj-$(CONFIG_HOTPLUG_CPU)       += hotplug-cpu.o
-obj-$(CONFIG_MEMORY_HOTPLUG)    += hotplug-memory.o
+obj-$(CONFIG_MEMORY_HOTPLUG)    += hotplug-memory.o pmem.o
 
 obj-$(CONFIG_HVC_CONSOLE)       += hvconsole.o
 obj-$(CONFIG_HVCS)              += hvcserver.o
@@ -24,6 +24,7 @@ obj-$(CONFIG_IO_EVENT_IRQ)	+= io_event_irq.o
 obj-$(CONFIG_LPARCFG)           += lparcfg.o
 obj-$(CONFIG_IBMVIO)            += vio.o
 obj-$(CONFIG_IBMEBUS)           += ibmebus.o
+obj-$(CONFIG_PAPR_SCM)          += papr_scm.o
 
 ifdef CONFIG_PPC_PSERIES
 obj-$(CONFIG_SUSPEND)           += suspend.o
diff --git a/arch/powerpc/platforms/pseries/dlpar.c b/arch/powerpc/platforms/pseries/dlpar.c
index a0b20c03f078..7625546caefd 100644
--- a/arch/powerpc/platforms/pseries/dlpar.c
+++ b/arch/powerpc/platforms/pseries/dlpar.c
@@ -32,8 +32,6 @@ static struct workqueue_struct *pseries_hp_wq;
 struct pseries_hp_work {
         struct work_struct work;
         struct pseries_hp_errorlog *errlog;
-        struct completion *hp_completion;
-        int *rc;
 };
 
 struct cc_workarea {
@@ -329,7 +327,7 @@ int dlpar_release_drc(u32 drc_index)
         return 0;
 }
 
-static int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog)
+int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog)
 {
         int rc;
 
@@ -357,6 +355,10 @@ static int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_elog)
         case PSERIES_HP_ELOG_RESOURCE_CPU:
                 rc = dlpar_cpu(hp_elog);
                 break;
+        case PSERIES_HP_ELOG_RESOURCE_PMEM:
+                rc = dlpar_hp_pmem(hp_elog);
+                break;
+
         default:
                 pr_warn_ratelimited("Invalid resource (%d) specified\n",
                                     hp_elog->resource);
@@ -371,20 +373,13 @@ static void pseries_hp_work_fn(struct work_struct *work)
         struct pseries_hp_work *hp_work =
                         container_of(work, struct pseries_hp_work, work);
 
-        if (hp_work->rc)
-                *(hp_work->rc) = handle_dlpar_errorlog(hp_work->errlog);
-        else
-                handle_dlpar_errorlog(hp_work->errlog);
-
-        if (hp_work->hp_completion)
-                complete(hp_work->hp_completion);
+        handle_dlpar_errorlog(hp_work->errlog);
 
         kfree(hp_work->errlog);
         kfree((void *)work);
 }
 
-void queue_hotplug_event(struct pseries_hp_errorlog *hp_errlog,
-                         struct completion *hotplug_done, int *rc)
+void queue_hotplug_event(struct pseries_hp_errorlog *hp_errlog)
 {
         struct pseries_hp_work *work;
         struct pseries_hp_errorlog *hp_errlog_copy;
@@ -397,13 +392,9 @@ void queue_hotplug_event(struct pseries_hp_errorlog *hp_errlog,
         if (work) {
                 INIT_WORK((struct work_struct *)work, pseries_hp_work_fn);
                 work->errlog = hp_errlog_copy;
-                work->hp_completion = hotplug_done;
-                work->rc = rc;
                 queue_work(pseries_hp_wq, (struct work_struct *)work);
         } else {
-                *rc = -ENOMEM;
                 kfree(hp_errlog_copy);
-                complete(hotplug_done);
         }
 }
 
@@ -521,18 +512,15 @@ static int dlpar_parse_id_type(char **cmd, struct pseries_hp_errorlog *hp_elog)
 static ssize_t dlpar_store(struct class *class, struct class_attribute *attr,
                            const char *buf, size_t count)
 {
-        struct pseries_hp_errorlog *hp_elog;
-        struct completion hotplug_done;
+        struct pseries_hp_errorlog hp_elog;
         char *argbuf;
         char *args;
         int rc;
 
         args = argbuf = kstrdup(buf, GFP_KERNEL);
-        hp_elog = kzalloc(sizeof(*hp_elog), GFP_KERNEL);
-        if (!hp_elog || !argbuf) {
+        if (!argbuf) {
                 pr_info("Could not allocate resources for DLPAR operation\n");
                 kfree(argbuf);
-                kfree(hp_elog);
                 return -ENOMEM;
         }
 
@@ -540,25 +528,22 @@ static ssize_t dlpar_store(struct class *class, struct class_attribute *attr,
          * Parse out the request from the user, this will be in the form:
          * <resource> <action> <id_type> <id>
          */
-        rc = dlpar_parse_resource(&args, hp_elog);
+        rc = dlpar_parse_resource(&args, &hp_elog);
         if (rc)
                 goto dlpar_store_out;
 
-        rc = dlpar_parse_action(&args, hp_elog);
+        rc = dlpar_parse_action(&args, &hp_elog);
         if (rc)
                 goto dlpar_store_out;
 
-        rc = dlpar_parse_id_type(&args, hp_elog);
+        rc = dlpar_parse_id_type(&args, &hp_elog);
         if (rc)
                 goto dlpar_store_out;
 
-        init_completion(&hotplug_done);
-        queue_hotplug_event(hp_elog, &hotplug_done, &rc);
-        wait_for_completion(&hotplug_done);
+        rc = handle_dlpar_errorlog(&hp_elog);
 
 dlpar_store_out:
         kfree(argbuf);
-        kfree(hp_elog);
 
         if (rc)
                 pr_err("Could not handle DLPAR request \"%s\"\n", buf);
diff --git a/arch/powerpc/platforms/pseries/dtl.c b/arch/powerpc/platforms/pseries/dtl.c
index 18014cdeb590..ef6595153642 100644
--- a/arch/powerpc/platforms/pseries/dtl.c
+++ b/arch/powerpc/platforms/pseries/dtl.c
@@ -149,7 +149,7 @@ static int dtl_start(struct dtl *dtl)
 
         /* Register our dtl buffer with the hypervisor. The HV expects the
          * buffer size to be passed in the second word of the buffer */
-        ((u32 *)dtl->buf)[1] = DISPATCH_LOG_BYTES;
+        ((u32 *)dtl->buf)[1] = cpu_to_be32(DISPATCH_LOG_BYTES);
 
         hwcpu = get_hard_smp_processor_id(dtl->cpu);
         addr = __pa(dtl->buf);
@@ -184,7 +184,7 @@ static void dtl_stop(struct dtl *dtl)
 
 static u64 dtl_current_index(struct dtl *dtl)
 {
-        return lppaca_of(dtl->cpu).dtl_idx;
+        return be64_to_cpu(lppaca_of(dtl->cpu).dtl_idx);
 }
 #endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
 
diff --git a/arch/powerpc/platforms/pseries/eeh_pseries.c b/arch/powerpc/platforms/pseries/eeh_pseries.c
index 823cb27efa8b..c9e5ca4afb26 100644
--- a/arch/powerpc/platforms/pseries/eeh_pseries.c
+++ b/arch/powerpc/platforms/pseries/eeh_pseries.c
@@ -438,7 +438,7 @@ static int pseries_eeh_get_pe_addr(struct eeh_pe *pe)
 /**
  * pseries_eeh_get_state - Retrieve PE state
  * @pe: EEH PE
- * @state: return value
+ * @delay: suggested time to wait if state is unavailable
  *
  * Retrieve the state of the specified PE. On RTAS compliant
  * pseries platform, there already has one dedicated RTAS function
@@ -448,7 +448,7 @@ static int pseries_eeh_get_pe_addr(struct eeh_pe *pe)
  * RTAS calls for the purpose, we need to try the new one and back
  * to the old one if the new one couldn't work properly.
  */
-static int pseries_eeh_get_state(struct eeh_pe *pe, int *state)
+static int pseries_eeh_get_state(struct eeh_pe *pe, int *delay)
 {
         int config_addr;
         int ret;
@@ -499,7 +499,8 @@ static int pseries_eeh_get_state(struct eeh_pe *pe, int *state)
                 break;
         case 5:
                 if (rets[2]) {
-                        if (state) *state = rets[2];
+                        if (delay)
+                                *delay = rets[2];
                         result = EEH_STATE_UNAVAILABLE;
                 } else {
                         result = EEH_STATE_NOT_SUPPORT;
@@ -554,64 +555,6 @@ static int pseries_eeh_reset(struct eeh_pe *pe, int option)
 }
 
 /**
- * pseries_eeh_wait_state - Wait for PE state
- * @pe: EEH PE
- * @max_wait: maximal period in millisecond
- *
- * Wait for the state of associated PE. It might take some time
- * to retrieve the PE's state.
- */
-static int pseries_eeh_wait_state(struct eeh_pe *pe, int max_wait)
-{
-        int ret;
-        int mwait;
-
-        /*
-         * According to PAPR, the state of PE might be temporarily
-         * unavailable. Under the circumstance, we have to wait
-         * for indicated time determined by firmware. The maximal
-         * wait time is 5 minutes, which is acquired from the original
-         * EEH implementation. Also, the original implementation
-         * also defined the minimal wait time as 1 second.
-         */
-#define EEH_STATE_MIN_WAIT_TIME (1000)
-#define EEH_STATE_MAX_WAIT_TIME (300 * 1000)
-
-        while (1) {
-                ret = pseries_eeh_get_state(pe, &mwait);
-
-                /*
-                 * If the PE's state is temporarily unavailable,
-                 * we have to wait for the specified time. Otherwise,
-                 * the PE's state will be returned immediately.
-                 */
-                if (ret != EEH_STATE_UNAVAILABLE)
-                        return ret;
-
-                if (max_wait <= 0) {
-                        pr_warn("%s: Timeout when getting PE's state (%d)\n",
-                                __func__, max_wait);
-                        return EEH_STATE_NOT_SUPPORT;
-                }
-
-                if (mwait <= 0) {
-                        pr_warn("%s: Firmware returned bad wait value %d\n",
-                                __func__, mwait);
-                        mwait = EEH_STATE_MIN_WAIT_TIME;
-                } else if (mwait > EEH_STATE_MAX_WAIT_TIME) {
-                        pr_warn("%s: Firmware returned too long wait value %d\n",
-                                __func__, mwait);
-                        mwait = EEH_STATE_MAX_WAIT_TIME;
-                }
-
-                max_wait -= mwait;
-                msleep(mwait);
-        }
-
-        return EEH_STATE_NOT_SUPPORT;
-}
-
-/**
  * pseries_eeh_get_log - Retrieve error log
  * @pe: EEH PE
  * @severity: temporary or permanent error log
@@ -849,7 +792,6 @@ static struct eeh_ops pseries_eeh_ops = {
         .get_pe_addr            = pseries_eeh_get_pe_addr,
         .get_state              = pseries_eeh_get_state,
         .reset                  = pseries_eeh_reset,
-        .wait_state             = pseries_eeh_wait_state,
         .get_log                = pseries_eeh_get_log,
         .configure_bridge       = pseries_eeh_configure_bridge,
         .err_inject             = NULL,
diff --git a/arch/powerpc/platforms/pseries/event_sources.c b/arch/powerpc/platforms/pseries/event_sources.c
index 6eeb0d4bab61..446ef104fb3a 100644
--- a/arch/powerpc/platforms/pseries/event_sources.c
+++ b/arch/powerpc/platforms/pseries/event_sources.c
@@ -16,7 +16,8 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-#include <asm/prom.h>
+#include <linux/interrupt.h>
+#include <linux/of_irq.h>
 
 #include "pseries.h"
 
@@ -24,34 +25,19 @@ void request_event_sources_irqs(struct device_node *np,
                                 irq_handler_t handler,
                                 const char *name)
 {
-        int i, index, count = 0;
-        struct of_phandle_args oirq;
-        unsigned int virqs[16];
+        int i, virq, rc;
 
-        /* First try to do a proper OF tree parsing */
-        for (index = 0; of_irq_parse_one(np, index, &oirq) == 0;
-             index++) {
-                if (count > 15)
-                        break;
-                virqs[count] = irq_create_of_mapping(&oirq);
-                if (!virqs[count]) {
-                        pr_err("event-sources: Unable to allocate "
-                               "interrupt number for %pOF\n",
-                               np);
-                        WARN_ON(1);
-                } else {
-                        count++;
-                }
-        }
+        for (i = 0; i < 16; i++) {
+                virq = of_irq_get(np, i);
+                if (virq < 0)
+                        return;
+                if (WARN(!virq, "event-sources: Unable to allocate "
+                                "interrupt number for %pOF\n", np))
+                        continue;
 
-        /* Now request them */
-        for (i = 0; i < count; i++) {
-                if (request_irq(virqs[i], handler, 0, name, NULL)) {
-                        pr_err("event-sources: Unable to request interrupt "
-                               "%d for %pOF\n", virqs[i], np);
-                        WARN_ON(1);
+                rc = request_irq(virq, handler, 0, name, NULL);
+                if (WARN(rc, "event-sources: Unable to request interrupt %d for %pOF\n",
+                    virq, np))
                         return;
-                }
         }
 }
-
diff --git a/arch/powerpc/platforms/pseries/firmware.c b/arch/powerpc/platforms/pseries/firmware.c
index a3bbeb43689e..608ecad0178f 100644
--- a/arch/powerpc/platforms/pseries/firmware.c
+++ b/arch/powerpc/platforms/pseries/firmware.c
@@ -65,6 +65,8 @@ hypertas_fw_features_table[] = {
         {FW_FEATURE_SET_MODE,           "hcall-set-mode"},
         {FW_FEATURE_BEST_ENERGY,        "hcall-best-energy-1*"},
         {FW_FEATURE_HPT_RESIZE,         "hcall-hpt-resize"},
+        {FW_FEATURE_BLOCK_REMOVE,       "hcall-block-remove"},
+        {FW_FEATURE_PAPR_SCM,           "hcall-scm"},
 };
 
 /* Build up the firmware features bitmask using the contents of
diff --git a/arch/powerpc/platforms/pseries/hotplug-cpu.c b/arch/powerpc/platforms/pseries/hotplug-cpu.c
index 6ef77caf7bcf..2f8e62163602 100644
--- a/arch/powerpc/platforms/pseries/hotplug-cpu.c
+++ b/arch/powerpc/platforms/pseries/hotplug-cpu.c
@@ -287,7 +287,7 @@ static int pseries_add_processor(struct device_node *np)
 
         if (cpumask_empty(tmp)) {
                 printk(KERN_ERR "Unable to find space in cpu_present_mask for"
-                       " processor %s with %d thread(s)\n", np->name,
+                       " processor %pOFn with %d thread(s)\n", np,
                        nthreads);
                 goto out_unlock;
         }
@@ -481,8 +481,8 @@ static ssize_t dlpar_cpu_add(u32 drc_index)
 
         if (rc) {
                 saved_rc = rc;
-                pr_warn("Failed to attach node %s, rc: %d, drc index: %x\n",
-                        dn->name, rc, drc_index);
+                pr_warn("Failed to attach node %pOFn, rc: %d, drc index: %x\n",
+                        dn, rc, drc_index);
 
                 rc = dlpar_release_drc(drc_index);
                 if (!rc)
@@ -494,8 +494,8 @@ static ssize_t dlpar_cpu_add(u32 drc_index)
         rc = dlpar_online_cpu(dn);
         if (rc) {
                 saved_rc = rc;
-                pr_warn("Failed to online cpu %s, rc: %d, drc index: %x\n",
-                        dn->name, rc, drc_index);
+                pr_warn("Failed to online cpu %pOFn, rc: %d, drc index: %x\n",
+                        dn, rc, drc_index);
 
                 rc = dlpar_detach_node(dn);
                 if (!rc)
@@ -504,7 +504,7 @@ static ssize_t dlpar_cpu_add(u32 drc_index)
                 return saved_rc;
         }
 
-        pr_debug("Successfully added CPU %s, drc index: %x\n", dn->name,
+        pr_debug("Successfully added CPU %pOFn, drc index: %x\n", dn,
                  drc_index);
         return rc;
 }
@@ -570,19 +570,19 @@ static ssize_t dlpar_cpu_remove(struct device_node *dn, u32 drc_index)
 {
         int rc;
 
-        pr_debug("Attempting to remove CPU %s, drc index: %x\n",
-                 dn->name, drc_index);
+        pr_debug("Attempting to remove CPU %pOFn, drc index: %x\n",
+                 dn, drc_index);
 
         rc = dlpar_offline_cpu(dn);
         if (rc) {
-                pr_warn("Failed to offline CPU %s, rc: %d\n", dn->name, rc);
+                pr_warn("Failed to offline CPU %pOFn, rc: %d\n", dn, rc);
                 return -EINVAL;
         }
 
         rc = dlpar_release_drc(drc_index);
         if (rc) {
-                pr_warn("Failed to release drc (%x) for CPU %s, rc: %d\n",
-                        drc_index, dn->name, rc);
+                pr_warn("Failed to release drc (%x) for CPU %pOFn, rc: %d\n",
+                        drc_index, dn, rc);
                 dlpar_online_cpu(dn);
                 return rc;
         }
@@ -591,7 +591,7 @@ static ssize_t dlpar_cpu_remove(struct device_node *dn, u32 drc_index)
         if (rc) {
                 int saved_rc = rc;
 
-                pr_warn("Failed to detach CPU %s, rc: %d", dn->name, rc);
+                pr_warn("Failed to detach CPU %pOFn, rc: %d", dn, rc);
 
                 rc = dlpar_acquire_drc(drc_index);
                 if (!rc)
@@ -662,8 +662,8 @@ static int find_dlpar_cpus_to_remove(u32 *cpu_drcs, int cpus_to_remove)
                 rc = of_property_read_u32(dn, "ibm,my-drc-index",
                                           &cpu_drcs[cpus_found - 1]);
                 if (rc) {
-                        pr_warn("Error occurred getting drc-index for %s\n",
-                                dn->name);
+                        pr_warn("Error occurred getting drc-index for %pOFn\n",
+                                dn);
                         of_node_put(dn);
                         return -1;
                 }
diff --git a/arch/powerpc/platforms/pseries/hotplug-memory.c b/arch/powerpc/platforms/pseries/hotplug-memory.c
index c1578f54c626..2b796da822c2 100644
--- a/arch/powerpc/platforms/pseries/hotplug-memory.c
+++ b/arch/powerpc/platforms/pseries/hotplug-memory.c
@@ -101,11 +101,12 @@ static struct property *dlpar_clone_property(struct property *prop,
         return new_prop;
 }
 
-static u32 find_aa_index(struct device_node *dr_node,
-                         struct property *ala_prop, const u32 *lmb_assoc)
+static bool find_aa_index(struct device_node *dr_node,
+                         struct property *ala_prop,
+                         const u32 *lmb_assoc, u32 *aa_index)
 {
-        u32 *assoc_arrays;
-        u32 aa_index;
+        u32 *assoc_arrays, new_prop_size;
+        struct property *new_prop;
         int aa_arrays, aa_array_entries, aa_array_sz;
         int i, index;
 
@@ -121,54 +122,48 @@ static u32 find_aa_index(struct device_node *dr_node,
         aa_array_entries = be32_to_cpu(assoc_arrays[1]);
         aa_array_sz = aa_array_entries * sizeof(u32);
 
-        aa_index = -1;
         for (i = 0; i < aa_arrays; i++) {
                 index = (i * aa_array_entries) + 2;
 
                 if (memcmp(&assoc_arrays[index], &lmb_assoc[1], aa_array_sz))
                         continue;
 
-                aa_index = i;
-                break;
+                *aa_index = i;
+                return true;
         }
 
-        if (aa_index == -1) {
-                struct property *new_prop;
-                u32 new_prop_size;
-
-                new_prop_size = ala_prop->length + aa_array_sz;
-                new_prop = dlpar_clone_property(ala_prop, new_prop_size);
-                if (!new_prop)
-                        return -1;
-
-                assoc_arrays = new_prop->value;
+        new_prop_size = ala_prop->length + aa_array_sz;
+        new_prop = dlpar_clone_property(ala_prop, new_prop_size);
+        if (!new_prop)
+                return false;
 
-                /* increment the number of entries in the lookup array */
-                assoc_arrays[0] = cpu_to_be32(aa_arrays + 1);
+        assoc_arrays = new_prop->value;
 
-                /* copy the new associativity into the lookup array */
-                index = aa_arrays * aa_array_entries + 2;
-                memcpy(&assoc_arrays[index], &lmb_assoc[1], aa_array_sz);
+        /* increment the number of entries in the lookup array */
+        assoc_arrays[0] = cpu_to_be32(aa_arrays + 1);
 
-                of_update_property(dr_node, new_prop);
+        /* copy the new associativity into the lookup array */
+        index = aa_arrays * aa_array_entries + 2;
+        memcpy(&assoc_arrays[index], &lmb_assoc[1], aa_array_sz);
 
-                /*
-                 * The associativity lookup array index for this lmb is
-                 * number of entries - 1 since we added its associativity
-                 * to the end of the lookup array.
-                 */
-                aa_index = be32_to_cpu(assoc_arrays[0]) - 1;
-        }
+        of_update_property(dr_node, new_prop);
 
-        return aa_index;
+        /*
+         * The associativity lookup array index for this lmb is
+         * number of entries - 1 since we added its associativity
+         * to the end of the lookup array.
+         */
+        *aa_index = be32_to_cpu(assoc_arrays[0]) - 1;
+        return true;
 }
 
-static u32 lookup_lmb_associativity_index(struct drmem_lmb *lmb)
+static int update_lmb_associativity_index(struct drmem_lmb *lmb)
 {
         struct device_node *parent, *lmb_node, *dr_node;
         struct property *ala_prop;
         const u32 *lmb_assoc;
         u32 aa_index;
+        bool found;
 
         parent = of_find_node_by_path("/");
         if (!parent)
@@ -200,46 +195,17 @@ static u32 lookup_lmb_associativity_index(struct drmem_lmb *lmb)
                 return -ENODEV;
         }
 
-        aa_index = find_aa_index(dr_node, ala_prop, lmb_assoc);
+        found = find_aa_index(dr_node, ala_prop, lmb_assoc, &aa_index);
 
         dlpar_free_cc_nodes(lmb_node);
-        return aa_index;
-}
 
-static int dlpar_add_device_tree_lmb(struct drmem_lmb *lmb)
-{
-        int rc, aa_index;
-
-        lmb->flags |= DRCONF_MEM_ASSIGNED;
-
-        aa_index = lookup_lmb_associativity_index(lmb);
-        if (aa_index < 0) {
-                pr_err("Couldn't find associativity index for drc index %x\n",
-                       lmb->drc_index);
-                return aa_index;
+        if (!found) {
+                pr_err("Could not find LMB associativity\n");
+                return -1;
         }
 
         lmb->aa_index = aa_index;
-
-        rtas_hp_event = true;
-        rc = drmem_update_dt();
-        rtas_hp_event = false;
-
-        return rc;
-}
-
-static int dlpar_remove_device_tree_lmb(struct drmem_lmb *lmb)
-{
-        int rc;
-
-        lmb->flags &= ~DRCONF_MEM_ASSIGNED;
-        lmb->aa_index = 0xffffffff;
-
-        rtas_hp_event = true;
-        rc = drmem_update_dt();
-        rtas_hp_event = false;
-
-        return rc;
+        return 0;
 }
 
 static struct memory_block *lmb_to_memblock(struct drmem_lmb *lmb)
@@ -428,7 +394,9 @@ static int dlpar_remove_lmb(struct drmem_lmb *lmb)
         /* Update memory regions for memory remove */
         memblock_remove(lmb->base_addr, block_sz);
 
-        dlpar_remove_device_tree_lmb(lmb);
+        invalidate_lmb_associativity_index(lmb);
+        lmb->flags &= ~DRCONF_MEM_ASSIGNED;
+
         return 0;
 }
 
@@ -688,10 +656,8 @@ static int dlpar_add_lmb(struct drmem_lmb *lmb)
         if (lmb->flags & DRCONF_MEM_ASSIGNED)
                 return -EINVAL;
 
-        rc = dlpar_add_device_tree_lmb(lmb);
+        rc = update_lmb_associativity_index(lmb);
         if (rc) {
-                pr_err("Couldn't update device tree for drc index %x\n",
-                       lmb->drc_index);
                 dlpar_release_drc(lmb->drc_index);
                 return rc;
         }
@@ -704,14 +670,14 @@ static int dlpar_add_lmb(struct drmem_lmb *lmb)
         /* Add the memory */
         rc = add_memory(nid, lmb->base_addr, block_sz);
         if (rc) {
-                dlpar_remove_device_tree_lmb(lmb);
+                invalidate_lmb_associativity_index(lmb);
                 return rc;
         }
 
         rc = dlpar_online_lmb(lmb);
         if (rc) {
                 remove_memory(nid, lmb->base_addr, block_sz);
-                dlpar_remove_device_tree_lmb(lmb);
+                invalidate_lmb_associativity_index(lmb);
         } else {
                 lmb->flags |= DRCONF_MEM_ASSIGNED;
         }
@@ -958,6 +924,12 @@ int dlpar_memory(struct pseries_hp_errorlog *hp_elog)
                 break;
         }
 
+        if (!rc) {
+                rtas_hp_event = true;
+                rc = drmem_update_dt();
+                rtas_hp_event = false;
+        }
+
         unlock_device_hotplug();
         return rc;
 }
diff --git a/arch/powerpc/platforms/pseries/ibmebus.c b/arch/powerpc/platforms/pseries/ibmebus.c
index c7c1140c13b6..5b4a56131904 100644
--- a/arch/powerpc/platforms/pseries/ibmebus.c
+++ b/arch/powerpc/platforms/pseries/ibmebus.c
@@ -404,7 +404,7 @@ static ssize_t name_show(struct device *dev,
         struct platform_device *ofdev;
 
         ofdev = to_platform_device(dev);
-        return sprintf(buf, "%s\n", ofdev->dev.of_node->name);
+        return sprintf(buf, "%pOFn\n", ofdev->dev.of_node);
 }
 static DEVICE_ATTR_RO(name);
 
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index d3992ced0782..32d4452973e7 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -48,6 +48,7 @@
 #include <asm/kexec.h>
 #include <asm/fadump.h>
 #include <asm/asm-prototypes.h>
+#include <asm/debugfs.h>
 
 #include "pseries.h"
 
@@ -417,6 +418,79 @@ static void pSeries_lpar_hpte_invalidate(unsigned long slot, unsigned long vpn,
         BUG_ON(lpar_rc != H_SUCCESS);
 }
 
+
+/*
+ * As defined in the PAPR's section 14.5.4.1.8
+ * The control mask doesn't include the returned reference and change bit from
+ * the processed PTE.
+ */
+#define HBLKR_AVPN              0x0100000000000000UL
+#define HBLKR_CTRL_MASK         0xf800000000000000UL
+#define HBLKR_CTRL_SUCCESS      0x8000000000000000UL
+#define HBLKR_CTRL_ERRNOTFOUND  0x8800000000000000UL
+#define HBLKR_CTRL_ERRBUSY      0xa000000000000000UL
+
+/**
+ * H_BLOCK_REMOVE caller.
+ * @idx should point to the latest @param entry set with a PTEX.
+ * If PTE cannot be processed because another CPUs has already locked that
+ * group, those entries are put back in @param starting at index 1.
+ * If entries has to be retried and @retry_busy is set to true, these entries
+ * are retried until success. If @retry_busy is set to false, the returned
+ * is the number of entries yet to process.
+ */
+static unsigned long call_block_remove(unsigned long idx, unsigned long *param,
+                                       bool retry_busy)
+{
+        unsigned long i, rc, new_idx;
+        unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
+
+        if (idx < 2) {
+                pr_warn("Unexpected empty call to H_BLOCK_REMOVE");
+                return 0;
+        }
+again:
+        new_idx = 0;
+        if (idx > PLPAR_HCALL9_BUFSIZE) {
+                pr_err("Too many PTEs (%lu) for H_BLOCK_REMOVE", idx);
+                idx = PLPAR_HCALL9_BUFSIZE;
+        } else if (idx < PLPAR_HCALL9_BUFSIZE)
+                param[idx] = HBR_END;
+
+        rc = plpar_hcall9(H_BLOCK_REMOVE, retbuf,
+                          param[0], /* AVA */
+                          param[1],  param[2],  param[3],  param[4], /* TS0-7 */
+                          param[5],  param[6],  param[7],  param[8]);
+        if (rc == H_SUCCESS)
+                return 0;
+
+        BUG_ON(rc != H_PARTIAL);
+
+        /* Check that the unprocessed entries were 'not found' or 'busy' */
+        for (i = 0; i < idx-1; i++) {
+                unsigned long ctrl = retbuf[i] & HBLKR_CTRL_MASK;
+
+                if (ctrl == HBLKR_CTRL_ERRBUSY) {
+                        param[++new_idx] = param[i+1];
+                        continue;
+                }
+
+                BUG_ON(ctrl != HBLKR_CTRL_SUCCESS
+                       && ctrl != HBLKR_CTRL_ERRNOTFOUND);
+        }
+
+        /*
+         * If there were entries found busy, retry these entries if requested,
+         * of if all the entries have to be retried.
+         */
+        if (new_idx && (retry_busy || new_idx == (PLPAR_HCALL9_BUFSIZE-1))) {
+                idx = new_idx + 1;
+                goto again;
+        }
+
+        return new_idx;
+}
+
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 /*
  * Limit iterations holding pSeries_lpar_tlbie_lock to 3. We also need
@@ -424,17 +498,57 @@ static void pSeries_lpar_hpte_invalidate(unsigned long slot, unsigned long vpn,
  */
 #define PPC64_HUGE_HPTE_BATCH 12
 
-static void __pSeries_lpar_hugepage_invalidate(unsigned long *slot,
-                                             unsigned long *vpn, int count,
-                                             int psize, int ssize)
+static void hugepage_block_invalidate(unsigned long *slot, unsigned long *vpn,
+                                      int count, int psize, int ssize)
 {
         unsigned long param[PLPAR_HCALL9_BUFSIZE];
-        int i = 0, pix = 0, rc;
-        unsigned long flags = 0;
-        int lock_tlbie = !mmu_has_feature(MMU_FTR_LOCKLESS_TLBIE);
+        unsigned long shift, current_vpgb, vpgb;
+        int i, pix = 0;
 
-        if (lock_tlbie)
-                spin_lock_irqsave(&pSeries_lpar_tlbie_lock, flags);
+        shift = mmu_psize_defs[psize].shift;
+
+        for (i = 0; i < count; i++) {
+                /*
+                 * Shifting 3 bits more on the right to get a
+                 * 8 pages aligned virtual addresse.
+                 */
+                vpgb = (vpn[i] >> (shift - VPN_SHIFT + 3));
+                if (!pix || vpgb != current_vpgb) {
+                        /*
+                         * Need to start a new 8 pages block, flush
+                         * the current one if needed.
+                         */
+                        if (pix)
+                                (void)call_block_remove(pix, param, true);
+                        current_vpgb = vpgb;
+                        param[0] = hpte_encode_avpn(vpn[i], psize, ssize);
+                        pix = 1;
+                }
+
+                param[pix++] = HBR_REQUEST | HBLKR_AVPN | slot[i];
+                if (pix == PLPAR_HCALL9_BUFSIZE) {
+                        pix = call_block_remove(pix, param, false);
+                        /*
+                         * pix = 0 means that all the entries were
+                         * removed, we can start a new block.
+                         * Otherwise, this means that there are entries
+                         * to retry, and pix points to latest one, so
+                         * we should increment it and try to continue
+                         * the same block.
+                         */
+                        if (pix)
+                                pix++;
+                }
+        }
+        if (pix)
+                (void)call_block_remove(pix, param, true);
+}
+
+static void hugepage_bulk_invalidate(unsigned long *slot, unsigned long *vpn,
+                                     int count, int psize, int ssize)
+{
+        unsigned long param[PLPAR_HCALL9_BUFSIZE];
+        int i = 0, pix = 0, rc;
 
         for (i = 0; i < count; i++) {
 
@@ -462,6 +576,23 @@ static void __pSeries_lpar_hugepage_invalidate(unsigned long *slot,
                                   param[6], param[7]);
                 BUG_ON(rc != H_SUCCESS);
         }
+}
+
+static inline void __pSeries_lpar_hugepage_invalidate(unsigned long *slot,
+                                                      unsigned long *vpn,
+                                                      int count, int psize,
+                                                      int ssize)
+{
+        unsigned long flags = 0;
+        int lock_tlbie = !mmu_has_feature(MMU_FTR_LOCKLESS_TLBIE);
+
+        if (lock_tlbie)
+                spin_lock_irqsave(&pSeries_lpar_tlbie_lock, flags);
+
+        if (firmware_has_feature(FW_FEATURE_BLOCK_REMOVE))
+                hugepage_block_invalidate(slot, vpn, count, psize, ssize);
+        else
+                hugepage_bulk_invalidate(slot, vpn, count, psize, ssize);
 
         if (lock_tlbie)
                 spin_unlock_irqrestore(&pSeries_lpar_tlbie_lock, flags);
@@ -546,6 +677,86 @@ static int pSeries_lpar_hpte_removebolted(unsigned long ea,
         return 0;
 }
 
+
+static inline unsigned long compute_slot(real_pte_t pte,
+                                         unsigned long vpn,
+                                         unsigned long index,
+                                         unsigned long shift,
+                                         int ssize)
+{
+        unsigned long slot, hash, hidx;
+
+        hash = hpt_hash(vpn, shift, ssize);
+        hidx = __rpte_to_hidx(pte, index);
+        if (hidx & _PTEIDX_SECONDARY)
+                hash = ~hash;
+        slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
+        slot += hidx & _PTEIDX_GROUP_IX;
+        return slot;
+}
+
+/**
+ * The hcall H_BLOCK_REMOVE implies that the virtual pages to processed are
+ * "all within the same naturally aligned 8 page virtual address block".
+ */
+static void do_block_remove(unsigned long number, struct ppc64_tlb_batch *batch,
+                            unsigned long *param)
+{
+        unsigned long vpn;
+        unsigned long i, pix = 0;
+        unsigned long index, shift, slot, current_vpgb, vpgb;
+        real_pte_t pte;
+        int psize, ssize;
+
+        psize = batch->psize;
+        ssize = batch->ssize;
+
+        for (i = 0; i < number; i++) {
+                vpn = batch->vpn[i];
+                pte = batch->pte[i];
+                pte_iterate_hashed_subpages(pte, psize, vpn, index, shift) {
+                        /*
+                         * Shifting 3 bits more on the right to get a
+                         * 8 pages aligned virtual addresse.
+                         */
+                        vpgb = (vpn >> (shift - VPN_SHIFT + 3));
+                        if (!pix || vpgb != current_vpgb) {
+                                /*
+                                 * Need to start a new 8 pages block, flush
+                                 * the current one if needed.
+                                 */
+                                if (pix)
+                                        (void)call_block_remove(pix, param,
+                                                                true);
+                                current_vpgb = vpgb;
+                                param[0] = hpte_encode_avpn(vpn, psize,
+                                                            ssize);
+                                pix = 1;
+                        }
+
+                        slot = compute_slot(pte, vpn, index, shift, ssize);
+                        param[pix++] = HBR_REQUEST | HBLKR_AVPN | slot;
+
+                        if (pix == PLPAR_HCALL9_BUFSIZE) {
+                                pix = call_block_remove(pix, param, false);
+                                /*
+                                 * pix = 0 means that all the entries were
+                                 * removed, we can start a new block.
+                                 * Otherwise, this means that there are entries
+                                 * to retry, and pix points to latest one, so
+                                 * we should increment it and try to continue
+                                 * the same block.
+                                 */
+                                if (pix)
+                                        pix++;
+                        }
+                } pte_iterate_hashed_end();
+        }
+
+        if (pix)
+                (void)call_block_remove(pix, param, true);
+}
+
 /*
  * Take a spinlock around flushes to avoid bouncing the hypervisor tlbie
  * lock.
@@ -558,13 +769,18 @@ static void pSeries_lpar_flush_hash_range(unsigned long number, int local)
         struct ppc64_tlb_batch *batch = this_cpu_ptr(&ppc64_tlb_batch);
         int lock_tlbie = !mmu_has_feature(MMU_FTR_LOCKLESS_TLBIE);
         unsigned long param[PLPAR_HCALL9_BUFSIZE];
-        unsigned long hash, index, shift, hidx, slot;
+        unsigned long index, shift, slot;
         real_pte_t pte;
         int psize, ssize;
 
         if (lock_tlbie)
                 spin_lock_irqsave(&pSeries_lpar_tlbie_lock, flags);
 
+        if (firmware_has_feature(FW_FEATURE_BLOCK_REMOVE)) {
+                do_block_remove(number, batch, param);
+                goto out;
+        }
+
         psize = batch->psize;
         ssize = batch->ssize;
         pix = 0;
@@ -572,12 +788,7 @@ static void pSeries_lpar_flush_hash_range(unsigned long number, int local)
                 vpn = batch->vpn[i];
                 pte = batch->pte[i];
                 pte_iterate_hashed_subpages(pte, psize, vpn, index, shift) {
-                        hash = hpt_hash(vpn, shift, ssize);
-                        hidx = __rpte_to_hidx(pte, index);
-                        if (hidx & _PTEIDX_SECONDARY)
-                                hash = ~hash;
-                        slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
-                        slot += hidx & _PTEIDX_GROUP_IX;
+                        slot = compute_slot(pte, vpn, index, shift, ssize);
                         if (!firmware_has_feature(FW_FEATURE_BULK_REMOVE)) {
                                 /*
                                  * lpar doesn't use the passed actual page size
@@ -608,6 +819,7 @@ static void pSeries_lpar_flush_hash_range(unsigned long number, int local)
                 BUG_ON(rc != H_SUCCESS);
         }
 
+out:
         if (lock_tlbie)
                 spin_unlock_irqrestore(&pSeries_lpar_tlbie_lock, flags);
 }
@@ -1028,3 +1240,56 @@ static int __init reserve_vrma_context_id(void)
         return 0;
 }
 machine_device_initcall(pseries, reserve_vrma_context_id);
+
+#ifdef CONFIG_DEBUG_FS
+/* debugfs file interface for vpa data */
+static ssize_t vpa_file_read(struct file *filp, char __user *buf, size_t len,
+                              loff_t *pos)
+{
+        int cpu = (long)filp->private_data;
+        struct lppaca *lppaca = &lppaca_of(cpu);
+
+        return simple_read_from_buffer(buf, len, pos, lppaca,
+                                sizeof(struct lppaca));
+}
+
+static const struct file_operations vpa_fops = {
+        .open           = simple_open,
+        .read           = vpa_file_read,
+        .llseek         = default_llseek,
+};
+
+static int __init vpa_debugfs_init(void)
+{
+        char name[16];
+        long i;
+        static struct dentry *vpa_dir;
+
+        if (!firmware_has_feature(FW_FEATURE_SPLPAR))
+                return 0;
+
+        vpa_dir = debugfs_create_dir("vpa", powerpc_debugfs_root);
+        if (!vpa_dir) {
+                pr_warn("%s: can't create vpa root dir\n", __func__);
+                return -ENOMEM;
+        }
+
+        /* set up the per-cpu vpa file*/
+        for_each_possible_cpu(i) {
+                struct dentry *d;
+
+                sprintf(name, "cpu-%ld", i);
+
+                d = debugfs_create_file(name, 0400, vpa_dir, (void *)i,
+                                        &vpa_fops);
+                if (!d) {
+                        pr_warn("%s: can't create per-cpu vpa file\n",
+                                        __func__);
+                        return -ENOMEM;
+                }
+        }
+
+        return 0;
+}
+machine_arch_initcall(pseries, vpa_debugfs_init);
+#endif /* CONFIG_DEBUG_FS */
diff --git a/arch/powerpc/platforms/pseries/lparcfg.c b/arch/powerpc/platforms/pseries/lparcfg.c
index 7c872dc01bdb..8bd590af488a 100644
--- a/arch/powerpc/platforms/pseries/lparcfg.c
+++ b/arch/powerpc/platforms/pseries/lparcfg.c
@@ -585,8 +585,7 @@ static ssize_t update_mpp(u64 *entitlement, u8 *weight)
 static ssize_t lparcfg_write(struct file *file, const char __user * buf,
                              size_t count, loff_t * off)
 {
-        int kbuf_sz = 64;
-        char kbuf[kbuf_sz];
+        char kbuf[64];
         char *tmp;
         u64 new_entitled, *new_entitled_ptr = &new_entitled;
         u8 new_weight, *new_weight_ptr = &new_weight;
@@ -595,7 +594,7 @@ static ssize_t lparcfg_write(struct file *file, const char __user * buf,
         if (!firmware_has_feature(FW_FEATURE_SPLPAR))
                 return -EINVAL;
 
-        if (count > kbuf_sz)
+        if (count > sizeof(kbuf))
                 return -EINVAL;
 
         if (copy_from_user(kbuf, buf, count))
diff --git a/arch/powerpc/platforms/pseries/mobility.c b/arch/powerpc/platforms/pseries/mobility.c
index f0e30dc94988..88925f8ca8a0 100644
--- a/arch/powerpc/platforms/pseries/mobility.c
+++ b/arch/powerpc/platforms/pseries/mobility.c
@@ -242,7 +242,7 @@ static int add_dt_node(__be32 parent_phandle, __be32 drc_index)
 
 static void prrn_update_node(__be32 phandle)
 {
-        struct pseries_hp_errorlog *hp_elog;
+        struct pseries_hp_errorlog hp_elog;
         struct device_node *dn;
 
         /*
@@ -255,18 +255,12 @@ static void prrn_update_node(__be32 phandle)
                 return;
         }
 
-        hp_elog = kzalloc(sizeof(*hp_elog), GFP_KERNEL);
-        if(!hp_elog)
-                return;
-
-        hp_elog->resource = PSERIES_HP_ELOG_RESOURCE_MEM;
-        hp_elog->action = PSERIES_HP_ELOG_ACTION_READD;
-        hp_elog->id_type = PSERIES_HP_ELOG_ID_DRC_INDEX;
-        hp_elog->_drc_u.drc_index = phandle;
-
-        queue_hotplug_event(hp_elog, NULL, NULL);
+        hp_elog.resource = PSERIES_HP_ELOG_RESOURCE_MEM;
+        hp_elog.action = PSERIES_HP_ELOG_ACTION_READD;
+        hp_elog.id_type = PSERIES_HP_ELOG_ID_DRC_INDEX;
+        hp_elog._drc_u.drc_index = phandle;
 
-        kfree(hp_elog);
+        handle_dlpar_errorlog(&hp_elog);
 }
 
 int pseries_devicetree_update(s32 scope)
@@ -366,6 +360,8 @@ static ssize_t migration_store(struct class *class,
         if (rc)
                 return rc;
 
+        stop_topology_update();
+
         do {
                 rc = rtas_ibm_suspend_me(streamid);
                 if (rc == -EAGAIN)
@@ -376,6 +372,9 @@ static ssize_t migration_store(struct class *class,
                 return rc;
 
         post_mobility_fixup();
+
+        start_topology_update();
+
         return count;
 }
 
diff --git a/arch/powerpc/platforms/pseries/msi.c b/arch/powerpc/platforms/pseries/msi.c
index b7496948129e..8011b4129e3a 100644
--- a/arch/powerpc/platforms/pseries/msi.c
+++ b/arch/powerpc/platforms/pseries/msi.c
@@ -203,7 +203,8 @@ static struct device_node *find_pe_dn(struct pci_dev *dev, int *total)
         /* Get the top level device in the PE */
         edev = pdn_to_eeh_dev(PCI_DN(dn));
         if (edev->pe)
-                edev = list_first_entry(&edev->pe->edevs, struct eeh_dev, list);
+                edev = list_first_entry(&edev->pe->edevs, struct eeh_dev,
+                                        entry);
         dn = pci_device_to_OF_node(edev->pdev);
         if (!dn)
                 return NULL;
diff --git a/arch/powerpc/platforms/pseries/papr_scm.c b/arch/powerpc/platforms/pseries/papr_scm.c
new file mode 100644
index 000000000000..ee9372b65ca5
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/papr_scm.c
@@ -0,0 +1,345 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#define pr_fmt(fmt)     "papr-scm: " fmt
+
+#include <linux/of.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/ndctl.h>
+#include <linux/sched.h>
+#include <linux/libnvdimm.h>
+#include <linux/platform_device.h>
+
+#include <asm/plpar_wrappers.h>
+
+#define BIND_ANY_ADDR (~0ul)
+
+#define PAPR_SCM_DIMM_CMD_MASK \
+        ((1ul << ND_CMD_GET_CONFIG_SIZE) | \
+         (1ul << ND_CMD_GET_CONFIG_DATA) | \
+         (1ul << ND_CMD_SET_CONFIG_DATA))
+
+struct papr_scm_priv {
+        struct platform_device *pdev;
+        struct device_node *dn;
+        uint32_t drc_index;
+        uint64_t blocks;
+        uint64_t block_size;
+        int metadata_size;
+
+        uint64_t bound_addr;
+
+        struct nvdimm_bus_descriptor bus_desc;
+        struct nvdimm_bus *bus;
+        struct nvdimm *nvdimm;
+        struct resource res;
+        struct nd_region *region;
+        struct nd_interleave_set nd_set;
+};
+
+static int drc_pmem_bind(struct papr_scm_priv *p)
+{
+        unsigned long ret[PLPAR_HCALL_BUFSIZE];
+        uint64_t rc, token;
+
+        /*
+         * When the hypervisor cannot map all the requested memory in a single
+         * hcall it returns H_BUSY and we call again with the token until
+         * we get H_SUCCESS. Aborting the retry loop before getting H_SUCCESS
+         * leave the system in an undefined state, so we wait.
+         */
+        token = 0;
+
+        do {
+                rc = plpar_hcall(H_SCM_BIND_MEM, ret, p->drc_index, 0,
+                                p->blocks, BIND_ANY_ADDR, token);
+                token = be64_to_cpu(ret[0]);
+                cond_resched();
+        } while (rc == H_BUSY);
+
+        if (rc) {
+                dev_err(&p->pdev->dev, "bind err: %lld\n", rc);
+                return -ENXIO;
+        }
+
+        p->bound_addr = be64_to_cpu(ret[1]);
+
+        dev_dbg(&p->pdev->dev, "bound drc %x to %pR\n", p->drc_index, &p->res);
+
+        return 0;
+}
+
+static int drc_pmem_unbind(struct papr_scm_priv *p)
+{
+        unsigned long ret[PLPAR_HCALL_BUFSIZE];
+        uint64_t rc, token;
+
+        token = 0;
+
+        /* NB: unbind has the same retry requirements mentioned above */
+        do {
+                rc = plpar_hcall(H_SCM_UNBIND_MEM, ret, p->drc_index,
+                                p->bound_addr, p->blocks, token);
+                token = be64_to_cpu(ret);
+                cond_resched();
+        } while (rc == H_BUSY);
+
+        if (rc)
+                dev_err(&p->pdev->dev, "unbind error: %lld\n", rc);
+
+        return !!rc;
+}
+
+static int papr_scm_meta_get(struct papr_scm_priv *p,
+                        struct nd_cmd_get_config_data_hdr *hdr)
+{
+        unsigned long data[PLPAR_HCALL_BUFSIZE];
+        int64_t ret;
+
+        if (hdr->in_offset >= p->metadata_size || hdr->in_length != 1)
+                return -EINVAL;
+
+        ret = plpar_hcall(H_SCM_READ_METADATA, data, p->drc_index,
+                        hdr->in_offset, 1);
+
+        if (ret == H_PARAMETER) /* bad DRC index */
+                return -ENODEV;
+        if (ret)
+                return -EINVAL; /* other invalid parameter */
+
+        hdr->out_buf[0] = data[0] & 0xff;
+
+        return 0;
+}
+
+static int papr_scm_meta_set(struct papr_scm_priv *p,
+                        struct nd_cmd_set_config_hdr *hdr)
+{
+        int64_t ret;
+
+        if (hdr->in_offset >= p->metadata_size || hdr->in_length != 1)
+                return -EINVAL;
+
+        ret = plpar_hcall_norets(H_SCM_WRITE_METADATA,
+                        p->drc_index, hdr->in_offset, hdr->in_buf[0], 1);
+
+        if (ret == H_PARAMETER) /* bad DRC index */
+                return -ENODEV;
+        if (ret)
+                return -EINVAL; /* other invalid parameter */
+
+        return 0;
+}
+
+int papr_scm_ndctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
+                unsigned int cmd, void *buf, unsigned int buf_len, int *cmd_rc)
+{
+        struct nd_cmd_get_config_size *get_size_hdr;
+        struct papr_scm_priv *p;
+
+        /* Only dimm-specific calls are supported atm */
+        if (!nvdimm)
+                return -EINVAL;
+
+        p = nvdimm_provider_data(nvdimm);
+
+        switch (cmd) {
+        case ND_CMD_GET_CONFIG_SIZE:
+                get_size_hdr = buf;
+
+                get_size_hdr->status = 0;
+                get_size_hdr->max_xfer = 1;
+                get_size_hdr->config_size = p->metadata_size;
+                *cmd_rc = 0;
+                break;
+
+        case ND_CMD_GET_CONFIG_DATA:
+                *cmd_rc = papr_scm_meta_get(p, buf);
+                break;
+
+        case ND_CMD_SET_CONFIG_DATA:
+                *cmd_rc = papr_scm_meta_set(p, buf);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        dev_dbg(&p->pdev->dev, "returned with cmd_rc = %d\n", *cmd_rc);
+
+        return 0;
+}
+
+static const struct attribute_group *region_attr_groups[] = {
+        &nd_region_attribute_group,
+        &nd_device_attribute_group,
+        &nd_mapping_attribute_group,
+        &nd_numa_attribute_group,
+        NULL,
+};
+
+static const struct attribute_group *bus_attr_groups[] = {
+        &nvdimm_bus_attribute_group,
+        NULL,
+};
+
+static const struct attribute_group *papr_scm_dimm_groups[] = {
+        &nvdimm_attribute_group,
+        &nd_device_attribute_group,
+        NULL,
+};
+
+static int papr_scm_nvdimm_init(struct papr_scm_priv *p)
+{
+        struct device *dev = &p->pdev->dev;
+        struct nd_mapping_desc mapping;
+        struct nd_region_desc ndr_desc;
+        unsigned long dimm_flags;
+
+        p->bus_desc.ndctl = papr_scm_ndctl;
+        p->bus_desc.module = THIS_MODULE;
+        p->bus_desc.of_node = p->pdev->dev.of_node;
+        p->bus_desc.attr_groups = bus_attr_groups;
+        p->bus_desc.provider_name = kstrdup(p->pdev->name, GFP_KERNEL);
+
+        if (!p->bus_desc.provider_name)
+                return -ENOMEM;
+
+        p->bus = nvdimm_bus_register(NULL, &p->bus_desc);
+        if (!p->bus) {
+                dev_err(dev, "Error creating nvdimm bus %pOF\n", p->dn);
+                return -ENXIO;
+        }
+
+        dimm_flags = 0;
+        set_bit(NDD_ALIASING, &dimm_flags);
+
+        p->nvdimm = nvdimm_create(p->bus, p, papr_scm_dimm_groups,
+                                dimm_flags, PAPR_SCM_DIMM_CMD_MASK, 0, NULL);
+        if (!p->nvdimm) {
+                dev_err(dev, "Error creating DIMM object for %pOF\n", p->dn);
+                goto err;
+        }
+
+        /* now add the region */
+
+        memset(&mapping, 0, sizeof(mapping));
+        mapping.nvdimm = p->nvdimm;
+        mapping.start = 0;
+        mapping.size = p->blocks * p->block_size; // XXX: potential overflow?
+
+        memset(&ndr_desc, 0, sizeof(ndr_desc));
+        ndr_desc.attr_groups = region_attr_groups;
+        ndr_desc.numa_node = dev_to_node(&p->pdev->dev);
+        ndr_desc.res = &p->res;
+        ndr_desc.of_node = p->dn;
+        ndr_desc.provider_data = p;
+        ndr_desc.mapping = &mapping;
+        ndr_desc.num_mappings = 1;
+        ndr_desc.nd_set = &p->nd_set;
+        set_bit(ND_REGION_PAGEMAP, &ndr_desc.flags);
+
+        p->region = nvdimm_pmem_region_create(p->bus, &ndr_desc);
+        if (!p->region) {
+                dev_err(dev, "Error registering region %pR from %pOF\n",
+                                ndr_desc.res, p->dn);
+                goto err;
+        }
+
+        return 0;
+
+err:    nvdimm_bus_unregister(p->bus);
+        kfree(p->bus_desc.provider_name);
+        return -ENXIO;
+}
+
+static int papr_scm_probe(struct platform_device *pdev)
+{
+        uint32_t drc_index, metadata_size, unit_cap[2];
+        struct device_node *dn = pdev->dev.of_node;
+        struct papr_scm_priv *p;
+        int rc;
+
+        /* check we have all the required DT properties */
+        if (of_property_read_u32(dn, "ibm,my-drc-index", &drc_index)) {
+                dev_err(&pdev->dev, "%pOF: missing drc-index!\n", dn);
+                return -ENODEV;
+        }
+
+        if (of_property_read_u32_array(dn, "ibm,unit-capacity", unit_cap, 2)) {
+                dev_err(&pdev->dev, "%pOF: missing unit-capacity!\n", dn);
+                return -ENODEV;
+        }
+
+        p = kzalloc(sizeof(*p), GFP_KERNEL);
+        if (!p)
+                return -ENOMEM;
+
+        /* optional DT properties */
+        of_property_read_u32(dn, "ibm,metadata-size", &metadata_size);
+
+        p->dn = dn;
+        p->drc_index = drc_index;
+        p->block_size = unit_cap[0];
+        p->blocks     = unit_cap[1];
+
+        /* might be zero */
+        p->metadata_size = metadata_size;
+        p->pdev = pdev;
+
+        /* request the hypervisor to bind this region to somewhere in memory */
+        rc = drc_pmem_bind(p);
+        if (rc)
+                goto err;
+
+        /* setup the resource for the newly bound range */
+        p->res.start = p->bound_addr;
+        p->res.end   = p->bound_addr + p->blocks * p->block_size;
+        p->res.name  = pdev->name;
+        p->res.flags = IORESOURCE_MEM;
+
+        rc = papr_scm_nvdimm_init(p);
+        if (rc)
+                goto err2;
+
+        platform_set_drvdata(pdev, p);
+
+        return 0;
+
+err2:   drc_pmem_unbind(p);
+err:    kfree(p);
+        return rc;
+}
+
+static int papr_scm_remove(struct platform_device *pdev)
+{
+        struct papr_scm_priv *p = platform_get_drvdata(pdev);
+
+        nvdimm_bus_unregister(p->bus);
+        drc_pmem_unbind(p);
+        kfree(p);
+
+        return 0;
+}
+
+static const struct of_device_id papr_scm_match[] = {
+        { .compatible = "ibm,pmemory" },
+        { },
+};
+
+static struct platform_driver papr_scm_driver = {
+        .probe = papr_scm_probe,
+        .remove = papr_scm_remove,
+        .driver = {
+                .name = "papr_scm",
+                .owner = THIS_MODULE,
+                .of_match_table = papr_scm_match,
+        },
+};
+
+module_platform_driver(papr_scm_driver);
+MODULE_DEVICE_TABLE(of, papr_scm_match);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("IBM Corporation");
diff --git a/arch/powerpc/platforms/pseries/pci.c b/arch/powerpc/platforms/pseries/pci.c
index eab96637d6cf..41d8a4d1d02e 100644
--- a/arch/powerpc/platforms/pseries/pci.c
+++ b/arch/powerpc/platforms/pseries/pci.c
@@ -239,6 +239,7 @@ void __init pSeries_final_fixup(void)
 {
         pSeries_request_regions();
 
+        eeh_probe_devices();
         eeh_addr_cache_build();
 
 #ifdef CONFIG_PCI_IOV
diff --git a/arch/powerpc/platforms/pseries/pmem.c b/arch/powerpc/platforms/pseries/pmem.c
new file mode 100644
index 000000000000..a27f40eb57b1
--- /dev/null
+++ b/arch/powerpc/platforms/pseries/pmem.c
@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/*
+ * Handles hot and cold plug of persistent memory regions on pseries.
+ */
+
+#define pr_fmt(fmt)     "pseries-pmem: " fmt
+
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/sched.h>        /* for idle_task_exit */
+#include <linux/sched/hotplug.h>
+#include <linux/cpu.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/slab.h>
+#include <asm/prom.h>
+#include <asm/rtas.h>
+#include <asm/firmware.h>
+#include <asm/machdep.h>
+#include <asm/vdso_datapage.h>
+#include <asm/plpar_wrappers.h>
+#include <asm/topology.h>
+
+#include "pseries.h"
+#include "offline_states.h"
+
+static struct device_node *pmem_node;
+
+static ssize_t pmem_drc_add_node(u32 drc_index)
+{
+        struct device_node *dn;
+        int rc;
+
+        pr_debug("Attempting to add pmem node, drc index: %x\n", drc_index);
+
+        rc = dlpar_acquire_drc(drc_index);
+        if (rc) {
+                pr_err("Failed to acquire DRC, rc: %d, drc index: %x\n",
+                        rc, drc_index);
+                return -EINVAL;
+        }
+
+        dn = dlpar_configure_connector(cpu_to_be32(drc_index), pmem_node);
+        if (!dn) {
+                pr_err("configure-connector failed for drc %x\n", drc_index);
+                dlpar_release_drc(drc_index);
+                return -EINVAL;
+        }
+
+        /* NB: The of reconfig notifier creates platform device from the node */
+        rc = dlpar_attach_node(dn, pmem_node);
+        if (rc) {
+                pr_err("Failed to attach node %s, rc: %d, drc index: %x\n",
+                        dn->name, rc, drc_index);
+
+                if (dlpar_release_drc(drc_index))
+                        dlpar_free_cc_nodes(dn);
+
+                return rc;
+        }
+
+        pr_info("Successfully added %pOF, drc index: %x\n", dn, drc_index);
+
+        return 0;
+}
+
+static ssize_t pmem_drc_remove_node(u32 drc_index)
+{
+        struct device_node *dn;
+        uint32_t index;
+        int rc;
+
+        for_each_child_of_node(pmem_node, dn) {
+                if (of_property_read_u32(dn, "ibm,my-drc-index", &index))
+                        continue;
+                if (index == drc_index)
+                        break;
+        }
+
+        if (!dn) {
+                pr_err("Attempting to remove unused DRC index %x\n", drc_index);
+                return -ENODEV;
+        }
+
+        pr_debug("Attempting to remove %pOF, drc index: %x\n", dn, drc_index);
+
+        /* * NB: tears down the ibm,pmemory device as a side-effect */
+        rc = dlpar_detach_node(dn);
+        if (rc)
+                return rc;
+
+        rc = dlpar_release_drc(drc_index);
+        if (rc) {
+                pr_err("Failed to release drc (%x) for CPU %s, rc: %d\n",
+                        drc_index, dn->name, rc);
+                dlpar_attach_node(dn, pmem_node);
+                return rc;
+        }
+
+        pr_info("Successfully removed PMEM with drc index: %x\n", drc_index);
+
+        return 0;
+}
+
+int dlpar_hp_pmem(struct pseries_hp_errorlog *hp_elog)
+{
+        u32 count, drc_index;
+        int rc;
+
+        /* slim chance, but we might get a hotplug event while booting */
+        if (!pmem_node)
+                pmem_node = of_find_node_by_type(NULL, "ibm,persistent-memory");
+        if (!pmem_node) {
+                pr_err("Hotplug event for a pmem device, but none exists\n");
+                return -ENODEV;
+        }
+
+        if (hp_elog->id_type != PSERIES_HP_ELOG_ID_DRC_INDEX) {
+                pr_err("Unsupported hotplug event type %d\n",
+                                hp_elog->id_type);
+                return -EINVAL;
+        }
+
+        count = hp_elog->_drc_u.drc_count;
+        drc_index = hp_elog->_drc_u.drc_index;
+
+        lock_device_hotplug();
+
+        if (hp_elog->action == PSERIES_HP_ELOG_ACTION_ADD) {
+                rc = pmem_drc_add_node(drc_index);
+        } else if (hp_elog->action == PSERIES_HP_ELOG_ACTION_REMOVE) {
+                rc = pmem_drc_remove_node(drc_index);
+        } else {
+                pr_err("Unsupported hotplug action (%d)\n", hp_elog->action);
+                rc = -EINVAL;
+        }
+
+        unlock_device_hotplug();
+        return rc;
+}
+
+const struct of_device_id drc_pmem_match[] = {
+        { .type = "ibm,persistent-memory", },
+        {}
+};
+
+static int pseries_pmem_init(void)
+{
+        pmem_node = of_find_node_by_type(NULL, "ibm,persistent-memory");
+        if (!pmem_node)
+                return 0;
+
+        /*
+         * The generic OF bus probe/populate handles creating platform devices
+         * from the child (ibm,pmemory) nodes. The generic code registers an of
+         * reconfig notifier to handle the hot-add/remove cases too.
+         */
+        of_platform_bus_probe(pmem_node, drc_pmem_match, NULL);
+
+        return 0;
+}
+machine_arch_initcall(pseries, pseries_pmem_init);
diff --git a/arch/powerpc/platforms/pseries/pseries.h b/arch/powerpc/platforms/pseries/pseries.h
index 60db2ee511fb..7dee8c5d3363 100644
--- a/arch/powerpc/platforms/pseries/pseries.h
+++ b/arch/powerpc/platforms/pseries/pseries.h
@@ -24,6 +24,7 @@ struct pt_regs;
 
 extern int pSeries_system_reset_exception(struct pt_regs *regs);
 extern int pSeries_machine_check_exception(struct pt_regs *regs);
+extern long pseries_machine_check_realmode(struct pt_regs *regs);
 
 #ifdef CONFIG_SMP
 extern void smp_init_pseries(void);
@@ -59,15 +60,21 @@ extern int dlpar_detach_node(struct device_node *);
 extern int dlpar_acquire_drc(u32 drc_index);
 extern int dlpar_release_drc(u32 drc_index);
 
-void queue_hotplug_event(struct pseries_hp_errorlog *hp_errlog,
-                         struct completion *hotplug_done, int *rc);
+void queue_hotplug_event(struct pseries_hp_errorlog *hp_errlog);
+int handle_dlpar_errorlog(struct pseries_hp_errorlog *hp_errlog);
+
 #ifdef CONFIG_MEMORY_HOTPLUG
 int dlpar_memory(struct pseries_hp_errorlog *hp_elog);
+int dlpar_hp_pmem(struct pseries_hp_errorlog *hp_elog);
 #else
 static inline int dlpar_memory(struct pseries_hp_errorlog *hp_elog)
 {
         return -EOPNOTSUPP;
 }
+static inline int dlpar_hp_pmem(struct pseries_hp_errorlog *hp_elog)
+{
+        return -EOPNOTSUPP;
+}
 #endif
 
 #ifdef CONFIG_HOTPLUG_CPU
diff --git a/arch/powerpc/platforms/pseries/ras.c b/arch/powerpc/platforms/pseries/ras.c
index 851ce326874a..d97d52772789 100644
--- a/arch/powerpc/platforms/pseries/ras.c
+++ b/arch/powerpc/platforms/pseries/ras.c
@@ -27,6 +27,7 @@
 #include <asm/machdep.h>
 #include <asm/rtas.h>
 #include <asm/firmware.h>
+#include <asm/mce.h>
 
 #include "pseries.h"
 
@@ -50,6 +51,101 @@ static irqreturn_t ras_hotplug_interrupt(int irq, void *dev_id);
 static irqreturn_t ras_epow_interrupt(int irq, void *dev_id);
 static irqreturn_t ras_error_interrupt(int irq, void *dev_id);
 
+/* RTAS pseries MCE errorlog section. */
+struct pseries_mc_errorlog {
+        __be32  fru_id;
+        __be32  proc_id;
+        u8      error_type;
+        /*
+         * sub_err_type (1 byte). Bit fields depends on error_type
+         *
+         *   MSB0
+         *   |
+         *   V
+         *   01234567
+         *   XXXXXXXX
+         *
+         * For error_type == MC_ERROR_TYPE_UE
+         *   XXXXXXXX
+         *   X          1: Permanent or Transient UE.
+         *    X         1: Effective address provided.
+         *     X        1: Logical address provided.
+         *      XX      2: Reserved.
+         *        XXX   3: Type of UE error.
+         *
+         * For error_type != MC_ERROR_TYPE_UE
+         *   XXXXXXXX
+         *   X          1: Effective address provided.
+         *    XXXXX     5: Reserved.
+         *         XX   2: Type of SLB/ERAT/TLB error.
+         */
+        u8      sub_err_type;
+        u8      reserved_1[6];
+        __be64  effective_address;
+        __be64  logical_address;
+} __packed;
+
+/* RTAS pseries MCE error types */
+#define MC_ERROR_TYPE_UE                0x00
+#define MC_ERROR_TYPE_SLB               0x01
+#define MC_ERROR_TYPE_ERAT              0x02
+#define MC_ERROR_TYPE_TLB               0x04
+#define MC_ERROR_TYPE_D_CACHE           0x05
+#define MC_ERROR_TYPE_I_CACHE           0x07
+
+/* RTAS pseries MCE error sub types */
+#define MC_ERROR_UE_INDETERMINATE               0
+#define MC_ERROR_UE_IFETCH                      1
+#define MC_ERROR_UE_PAGE_TABLE_WALK_IFETCH      2
+#define MC_ERROR_UE_LOAD_STORE                  3
+#define MC_ERROR_UE_PAGE_TABLE_WALK_LOAD_STORE  4
+
+#define MC_ERROR_SLB_PARITY             0
+#define MC_ERROR_SLB_MULTIHIT           1
+#define MC_ERROR_SLB_INDETERMINATE      2
+
+#define MC_ERROR_ERAT_PARITY            1
+#define MC_ERROR_ERAT_MULTIHIT          2
+#define MC_ERROR_ERAT_INDETERMINATE     3
+
+#define MC_ERROR_TLB_PARITY             1
+#define MC_ERROR_TLB_MULTIHIT           2
+#define MC_ERROR_TLB_INDETERMINATE      3
+
+static inline u8 rtas_mc_error_sub_type(const struct pseries_mc_errorlog *mlog)
+{
+        switch (mlog->error_type) {
+        case    MC_ERROR_TYPE_UE:
+                return (mlog->sub_err_type & 0x07);
+        case    MC_ERROR_TYPE_SLB:
+        case    MC_ERROR_TYPE_ERAT:
+        case    MC_ERROR_TYPE_TLB:
+                return (mlog->sub_err_type & 0x03);
+        default:
+                return 0;
+        }
+}
+
+static
+inline u64 rtas_mc_get_effective_addr(const struct pseries_mc_errorlog *mlog)
+{
+        __be64 addr = 0;
+
+        switch (mlog->error_type) {
+        case    MC_ERROR_TYPE_UE:
+                if (mlog->sub_err_type & 0x40)
+                        addr = mlog->effective_address;
+                break;
+        case    MC_ERROR_TYPE_SLB:
+        case    MC_ERROR_TYPE_ERAT:
+        case    MC_ERROR_TYPE_TLB:
+                if (mlog->sub_err_type & 0x80)
+                        addr = mlog->effective_address;
+        default:
+                break;
+        }
+        return be64_to_cpu(addr);
+}
 
 /*
  * Enable the hotplug interrupt late because processing them may touch other
@@ -237,8 +333,9 @@ static irqreturn_t ras_hotplug_interrupt(int irq, void *dev_id)
          * hotplug events on the ras_log_buf to be handled by rtas_errd.
          */
         if (hp_elog->resource == PSERIES_HP_ELOG_RESOURCE_MEM ||
-            hp_elog->resource == PSERIES_HP_ELOG_RESOURCE_CPU)
-                queue_hotplug_event(hp_elog, NULL, NULL);
+            hp_elog->resource == PSERIES_HP_ELOG_RESOURCE_CPU ||
+            hp_elog->resource == PSERIES_HP_ELOG_RESOURCE_PMEM)
+                queue_hotplug_event(hp_elog);
         else
                 log_error(ras_log_buf, ERR_TYPE_RTAS_LOG, 0);
 
@@ -427,6 +524,188 @@ int pSeries_system_reset_exception(struct pt_regs *regs)
         return 0; /* need to perform reset */
 }
 
+#define VAL_TO_STRING(ar, val)  \
+        (((val) < ARRAY_SIZE(ar)) ? ar[(val)] : "Unknown")
+
+static void pseries_print_mce_info(struct pt_regs *regs,
+                                   struct rtas_error_log *errp)
+{
+        const char *level, *sevstr;
+        struct pseries_errorlog *pseries_log;
+        struct pseries_mc_errorlog *mce_log;
+        u8 error_type, err_sub_type;
+        u64 addr;
+        u8 initiator = rtas_error_initiator(errp);
+        int disposition = rtas_error_disposition(errp);
+
+        static const char * const initiators[] = {
+                "Unknown",
+                "CPU",
+                "PCI",
+                "ISA",
+                "Memory",
+                "Power Mgmt",
+        };
+        static const char * const mc_err_types[] = {
+                "UE",
+                "SLB",
+                "ERAT",
+                "TLB",
+                "D-Cache",
+                "Unknown",
+                "I-Cache",
+        };
+        static const char * const mc_ue_types[] = {
+                "Indeterminate",
+                "Instruction fetch",
+                "Page table walk ifetch",
+                "Load/Store",
+                "Page table walk Load/Store",
+        };
+
+        /* SLB sub errors valid values are 0x0, 0x1, 0x2 */
+        static const char * const mc_slb_types[] = {
+                "Parity",
+                "Multihit",
+                "Indeterminate",
+        };
+
+        /* TLB and ERAT sub errors valid values are 0x1, 0x2, 0x3 */
+        static const char * const mc_soft_types[] = {
+                "Unknown",
+                "Parity",
+                "Multihit",
+                "Indeterminate",
+        };
+
+        if (!rtas_error_extended(errp)) {
+                pr_err("Machine check interrupt: Missing extended error log\n");
+                return;
+        }
+
+        pseries_log = get_pseries_errorlog(errp, PSERIES_ELOG_SECT_ID_MCE);
+        if (pseries_log == NULL)
+                return;
+
+        mce_log = (struct pseries_mc_errorlog *)pseries_log->data;
+
+        error_type = mce_log->error_type;
+        err_sub_type = rtas_mc_error_sub_type(mce_log);
+
+        switch (rtas_error_severity(errp)) {
+        case RTAS_SEVERITY_NO_ERROR:
+                level = KERN_INFO;
+                sevstr = "Harmless";
+                break;
+        case RTAS_SEVERITY_WARNING:
+                level = KERN_WARNING;
+                sevstr = "";
+                break;
+        case RTAS_SEVERITY_ERROR:
+        case RTAS_SEVERITY_ERROR_SYNC:
+                level = KERN_ERR;
+                sevstr = "Severe";
+                break;
+        case RTAS_SEVERITY_FATAL:
+        default:
+                level = KERN_ERR;
+                sevstr = "Fatal";
+                break;
+        }
+
+#ifdef CONFIG_PPC_BOOK3S_64
+        /* Display faulty slb contents for SLB errors. */
+        if (error_type == MC_ERROR_TYPE_SLB)
+                slb_dump_contents(local_paca->mce_faulty_slbs);
+#endif
+
+        printk("%s%s Machine check interrupt [%s]\n", level, sevstr,
+               disposition == RTAS_DISP_FULLY_RECOVERED ?
+               "Recovered" : "Not recovered");
+        if (user_mode(regs)) {
+                printk("%s  NIP: [%016lx] PID: %d Comm: %s\n", level,
+                       regs->nip, current->pid, current->comm);
+        } else {
+                printk("%s  NIP [%016lx]: %pS\n", level, regs->nip,
+                       (void *)regs->nip);
+        }
+        printk("%s  Initiator: %s\n", level,
+               VAL_TO_STRING(initiators, initiator));
+
+        switch (error_type) {
+        case MC_ERROR_TYPE_UE:
+                printk("%s  Error type: %s [%s]\n", level,
+                       VAL_TO_STRING(mc_err_types, error_type),
+                       VAL_TO_STRING(mc_ue_types, err_sub_type));
+                break;
+        case MC_ERROR_TYPE_SLB:
+                printk("%s  Error type: %s [%s]\n", level,
+                       VAL_TO_STRING(mc_err_types, error_type),
+                       VAL_TO_STRING(mc_slb_types, err_sub_type));
+                break;
+        case MC_ERROR_TYPE_ERAT:
+        case MC_ERROR_TYPE_TLB:
+                printk("%s  Error type: %s [%s]\n", level,
+                       VAL_TO_STRING(mc_err_types, error_type),
+                       VAL_TO_STRING(mc_soft_types, err_sub_type));
+                break;
+        default:
+                printk("%s  Error type: %s\n", level,
+                       VAL_TO_STRING(mc_err_types, error_type));
+                break;
+        }
+
+        addr = rtas_mc_get_effective_addr(mce_log);
+        if (addr)
+                printk("%s    Effective address: %016llx\n", level, addr);
+}
+
+static int mce_handle_error(struct rtas_error_log *errp)
+{
+        struct pseries_errorlog *pseries_log;
+        struct pseries_mc_errorlog *mce_log;
+        int disposition = rtas_error_disposition(errp);
+        u8 error_type;
+
+        if (!rtas_error_extended(errp))
+                goto out;
+
+        pseries_log = get_pseries_errorlog(errp, PSERIES_ELOG_SECT_ID_MCE);
+        if (pseries_log == NULL)
+                goto out;
+
+        mce_log = (struct pseries_mc_errorlog *)pseries_log->data;
+        error_type = mce_log->error_type;
+
+#ifdef CONFIG_PPC_BOOK3S_64
+        if (disposition == RTAS_DISP_NOT_RECOVERED) {
+                switch (error_type) {
+                case    MC_ERROR_TYPE_SLB:
+                case    MC_ERROR_TYPE_ERAT:
+                        /*
+                         * Store the old slb content in paca before flushing.
+                         * Print this when we go to virtual mode.
+                         * There are chances that we may hit MCE again if there
+                         * is a parity error on the SLB entry we trying to read
+                         * for saving. Hence limit the slb saving to single
+                         * level of recursion.
+                         */
+                        if (local_paca->in_mce == 1)
+                                slb_save_contents(local_paca->mce_faulty_slbs);
+                        flush_and_reload_slb();
+                        disposition = RTAS_DISP_FULLY_RECOVERED;
+                        rtas_set_disposition_recovered(errp);
+                        break;
+                default:
+                        break;
+                }
+        }
+#endif
+
+out:
+        return disposition;
+}
+
 /*
  * Process MCE rtas errlog event.
  */
@@ -452,8 +731,11 @@ static int recover_mce(struct pt_regs *regs, struct rtas_error_log *err)
         int recovered = 0;
         int disposition = rtas_error_disposition(err);
 
+        pseries_print_mce_info(regs, err);
+
         if (!(regs->msr & MSR_RI)) {
                 /* If MSR_RI isn't set, we cannot recover */
+                pr_err("Machine check interrupt unrecoverable: MSR(RI=0)\n");
                 recovered = 0;
 
         } else if (disposition == RTAS_DISP_FULLY_RECOVERED) {
@@ -503,11 +785,31 @@ int pSeries_machine_check_exception(struct pt_regs *regs)
         struct rtas_error_log *errp;
 
         if (fwnmi_active) {
-                errp = fwnmi_get_errinfo(regs);
                 fwnmi_release_errinfo();
+                errp = fwnmi_get_errlog();
                 if (errp && recover_mce(regs, errp))
                         return 1;
         }
 
         return 0;
 }
+
+long pseries_machine_check_realmode(struct pt_regs *regs)
+{
+        struct rtas_error_log *errp;
+        int disposition;
+
+        if (fwnmi_active) {
+                errp = fwnmi_get_errinfo(regs);
+                /*
+                 * Call to fwnmi_release_errinfo() in real mode causes kernel
+                 * to panic. Hence we will call it as soon as we go into
+                 * virtual mode.
+                 */
+                disposition = mce_handle_error(errp);
+                if (disposition == RTAS_DISP_FULLY_RECOVERED)
+                        return 1;
+        }
+
+        return 0;
+}
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index ba1791fd3234..0f553dcfa548 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -107,6 +107,10 @@ static void __init fwnmi_init(void)
         u8 *mce_data_buf;
         unsigned int i;
         int nr_cpus = num_possible_cpus();
+#ifdef CONFIG_PPC_BOOK3S_64
+        struct slb_entry *slb_ptr;
+        size_t size;
+#endif
 
         int ibm_nmi_register = rtas_token("ibm,nmi-register");
         if (ibm_nmi_register == RTAS_UNKNOWN_SERVICE)
@@ -132,6 +136,15 @@ static void __init fwnmi_init(void)
                 paca_ptrs[i]->mce_data_buf = mce_data_buf +
                                                 (RTAS_ERROR_LOG_MAX * i);
         }
+
+#ifdef CONFIG_PPC_BOOK3S_64
+        /* Allocate per cpu slb area to save old slb contents during MCE */
+        size = sizeof(struct slb_entry) * mmu_slb_size * nr_cpus;
+        slb_ptr = __va(memblock_alloc_base(size, sizeof(struct slb_entry),
+                                           ppc64_rma_size));
+        for_each_possible_cpu(i)
+                paca_ptrs[i]->mce_faulty_slbs = slb_ptr + (mmu_slb_size * i);
+#endif
 }
 
 static void pseries_8259_cascade(struct irq_desc *desc)
@@ -1017,6 +1030,7 @@ define_machine(pseries) {
         .calibrate_decr         = generic_calibrate_decr,
         .progress               = rtas_progress,
         .system_reset_exception = pSeries_system_reset_exception,
+        .machine_check_early    = pseries_machine_check_realmode,
         .machine_check_exception = pSeries_machine_check_exception,
 #ifdef CONFIG_KEXEC_CORE
         .machine_kexec          = pSeries_machine_kexec,
diff --git a/arch/powerpc/platforms/pseries/vio.c b/arch/powerpc/platforms/pseries/vio.c
index 49e04ec19238..88f1ad1d6309 100644
--- a/arch/powerpc/platforms/pseries/vio.c
+++ b/arch/powerpc/platforms/pseries/vio.c
@@ -1349,7 +1349,6 @@ struct vio_dev *vio_register_device_node(struct device_node *of_node)
         struct device_node *parent_node;
         const __be32 *prop;
         enum vio_dev_family family;
-        const char *of_node_name = of_node->name ? of_node->name : "<unknown>";
 
         /*
          * Determine if this node is a under the /vdevice node or under the
@@ -1362,24 +1361,24 @@ struct vio_dev *vio_register_device_node(struct device_node *of_node)
                 else if (!strcmp(parent_node->type, "vdevice"))
                         family = VDEVICE;
                 else {
-                        pr_warn("%s: parent(%pOF) of %s not recognized.\n",
+                        pr_warn("%s: parent(%pOF) of %pOFn not recognized.\n",
                                         __func__,
                                         parent_node,
-                                        of_node_name);
+                                        of_node);
                         of_node_put(parent_node);
                         return NULL;
                 }
                 of_node_put(parent_node);
         } else {
-                pr_warn("%s: could not determine the parent of node %s.\n",
-                                __func__, of_node_name);
+                pr_warn("%s: could not determine the parent of node %pOFn.\n",
+                                __func__, of_node);
                 return NULL;
         }
 
         if (family == PFO) {
                 if (of_get_property(of_node, "interrupt-controller", NULL)) {
-                        pr_debug("%s: Skipping the interrupt controller %s.\n",
-                                        __func__, of_node_name);
+                        pr_debug("%s: Skipping the interrupt controller %pOFn.\n",
+                                        __func__, of_node);
                         return NULL;
                 }
         }
@@ -1399,15 +1398,15 @@ struct vio_dev *vio_register_device_node(struct device_node *of_node)
                 if (of_node->type != NULL)
                         viodev->type = of_node->type;
                 else {
-                        pr_warn("%s: node %s is missing the 'device_type' "
-                                        "property.\n", __func__, of_node_name);
+                        pr_warn("%s: node %pOFn is missing the 'device_type' "
+                                        "property.\n", __func__, of_node);
                         goto out;
                 }
 
                 prop = of_get_property(of_node, "reg", NULL);
                 if (prop == NULL) {
-                        pr_warn("%s: node %s missing 'reg'\n",
-                                        __func__, of_node_name);
+                        pr_warn("%s: node %pOFn missing 'reg'\n",
+                                        __func__, of_node);
                         goto out;
                 }
                 unit_address = of_read_number(prop, 1);
@@ -1422,8 +1421,8 @@ struct vio_dev *vio_register_device_node(struct device_node *of_node)
                 if (prop != NULL)
                         viodev->resource_id = of_read_number(prop, 1);
 
-                dev_set_name(&viodev->dev, "%s", of_node_name);
-                viodev->type = of_node_name;
+                dev_set_name(&viodev->dev, "%pOFn", of_node);
+                viodev->type = dev_name(&viodev->dev);
                 viodev->irq = 0;
         }
 
@@ -1694,7 +1693,7 @@ struct vio_dev *vio_find_node(struct device_node *vnode)
                 snprintf(kobj_name, sizeof(kobj_name), "%x",
                          (uint32_t)of_read_number(prop, 1));
         } else if (!strcmp(dev_type, "ibm,platform-facilities"))
-                snprintf(kobj_name, sizeof(kobj_name), "%s", vnode->name);
+                snprintf(kobj_name, sizeof(kobj_name), "%pOFn", vnode);
         else
                 return NULL;
 
diff --git a/arch/powerpc/sysdev/Kconfig b/arch/powerpc/sysdev/Kconfig
index bcef2ac56479..e0dbec780fe9 100644
--- a/arch/powerpc/sysdev/Kconfig
+++ b/arch/powerpc/sysdev/Kconfig
@@ -6,19 +6,16 @@
 config PPC4xx_PCI_EXPRESS
         bool
         depends on PCI && 4xx
-        default n
 
 config PPC4xx_HSTA_MSI
         bool
         depends on PCI_MSI
         depends on PCI && 4xx
-        default n
 
 config PPC4xx_MSI
         bool
         depends on PCI_MSI
         depends on PCI && 4xx
-        default n
 
 config PPC_MSI_BITMAP
         bool
@@ -37,11 +34,9 @@ config PPC_SCOM
 config SCOM_DEBUGFS
         bool "Expose SCOM controllers via debugfs"
         depends on PPC_SCOM && DEBUG_FS
-        default n
 
 config GE_FPGA
         bool
-        default n
 
 config FSL_CORENET_RCPM
         bool
diff --git a/arch/powerpc/sysdev/Makefile b/arch/powerpc/sysdev/Makefile
index f730539074c4..2caa4defdfb6 100644
--- a/arch/powerpc/sysdev/Makefile
+++ b/arch/powerpc/sysdev/Makefile
@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: GPL-2.0
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
 
 ccflags-$(CONFIG_PPC64)         := $(NO_MINIMAL_TOC)
 
@@ -56,8 +55,6 @@ obj-$(CONFIG_PPC_SCOM)		+= scom.o
 
 obj-$(CONFIG_PPC_EARLY_DEBUG_MEMCONS)   += udbg_memcons.o
 
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
-
 obj-$(CONFIG_PPC_XICS)          += xics/
 obj-$(CONFIG_PPC_XIVE)          += xive/
 
diff --git a/arch/powerpc/sysdev/fsl_85xx_cache_sram.c b/arch/powerpc/sysdev/fsl_85xx_cache_sram.c
index 00ccf3e4fcb4..15cbdd4fde06 100644
--- a/arch/powerpc/sysdev/fsl_85xx_cache_sram.c
+++ b/arch/powerpc/sysdev/fsl_85xx_cache_sram.c
@@ -107,11 +107,11 @@ int __init instantiate_cache_sram(struct platform_device *dev,
                 goto out_free;
         }
 
-        cache_sram->base_virt = ioremap_prot(cache_sram->base_phys,
-                                cache_sram->size, _PAGE_COHERENT | PAGE_KERNEL);
+        cache_sram->base_virt = ioremap_coherent(cache_sram->base_phys,
+                                                 cache_sram->size);
         if (!cache_sram->base_virt) {
-                dev_err(&dev->dev, "%pOF: ioremap_prot failed\n",
-                                dev->dev.of_node);
+                dev_err(&dev->dev, "%pOF: ioremap_coherent failed\n",
+                        dev->dev.of_node);
                 ret = -ENOMEM;
                 goto out_release;
         }
diff --git a/arch/powerpc/sysdev/ipic.c b/arch/powerpc/sysdev/ipic.c
index 535cf1f6941c..6300123ce965 100644
--- a/arch/powerpc/sysdev/ipic.c
+++ b/arch/powerpc/sysdev/ipic.c
@@ -846,7 +846,7 @@ void ipic_disable_mcp(enum ipic_mcp_irq mcp_irq)
 
 u32 ipic_get_mcp_status(void)
 {
-        return ipic_read(primary_ipic->regs, IPIC_SERSR);
+        return primary_ipic ? ipic_read(primary_ipic->regs, IPIC_SERSR) : 0;
 }
 
 void ipic_clear_mcp_status(u32 mask)
diff --git a/arch/powerpc/sysdev/xics/Makefile b/arch/powerpc/sysdev/xics/Makefile
index 5d438d92472b..ba1e3117b1c0 100644
--- a/arch/powerpc/sysdev/xics/Makefile
+++ b/arch/powerpc/sysdev/xics/Makefile
@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: GPL-2.0
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
 
 obj-y                           += xics-common.o
 obj-$(CONFIG_PPC_ICP_NATIVE)    += icp-native.o
diff --git a/arch/powerpc/sysdev/xive/Kconfig b/arch/powerpc/sysdev/xive/Kconfig
index 70ee976e1de0..785c292d104b 100644
--- a/arch/powerpc/sysdev/xive/Kconfig
+++ b/arch/powerpc/sysdev/xive/Kconfig
@@ -1,17 +1,14 @@
 # SPDX-License-Identifier: GPL-2.0
 config PPC_XIVE
         bool
-        default n
         select PPC_SMP_MUXED_IPI
         select HARDIRQS_SW_RESEND
 
 config PPC_XIVE_NATIVE
         bool
-        default n
         select PPC_XIVE
         depends on PPC_POWERNV
 
 config PPC_XIVE_SPAPR
         bool
-        default n
         select PPC_XIVE
diff --git a/arch/powerpc/sysdev/xive/Makefile b/arch/powerpc/sysdev/xive/Makefile
index 536d6e5706e3..dea2abc23f4d 100644
--- a/arch/powerpc/sysdev/xive/Makefile
+++ b/arch/powerpc/sysdev/xive/Makefile
@@ -1,4 +1,3 @@
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
 
 obj-y                           += common.o
 obj-$(CONFIG_PPC_XIVE_NATIVE)   += native.o
diff --git a/arch/powerpc/sysdev/xive/common.c b/arch/powerpc/sysdev/xive/common.c
index 959a2a62f233..9824074ec1b5 100644
--- a/arch/powerpc/sysdev/xive/common.c
+++ b/arch/powerpc/sysdev/xive/common.c
@@ -1010,12 +1010,13 @@ static void xive_ipi_eoi(struct irq_data *d)
 {
         struct xive_cpu *xc = __this_cpu_read(xive_cpu);
 
-        DBG_VERBOSE("IPI eoi: irq=%d [0x%lx] (HW IRQ 0x%x) pending=%02x\n",
-                    d->irq, irqd_to_hwirq(d), xc->hw_ipi, xc->pending_prio);
-
         /* Handle possible race with unplug and drop stale IPIs */
         if (!xc)
                 return;
+
+        DBG_VERBOSE("IPI eoi: irq=%d [0x%lx] (HW IRQ 0x%x) pending=%02x\n",
+                    d->irq, irqd_to_hwirq(d), xc->hw_ipi, xc->pending_prio);
+
         xive_do_source_eoi(xc->hw_ipi, &xc->ipi_data);
         xive_do_queue_eoi(xc);
 }
diff --git a/arch/powerpc/sysdev/xive/native.c b/arch/powerpc/sysdev/xive/native.c
index 5b20a678d755..1ca127d052a6 100644
--- a/arch/powerpc/sysdev/xive/native.c
+++ b/arch/powerpc/sysdev/xive/native.c
@@ -238,20 +238,11 @@ static bool xive_native_match(struct device_node *node)
 #ifdef CONFIG_SMP
 static int xive_native_get_ipi(unsigned int cpu, struct xive_cpu *xc)
 {
-        struct device_node *np;
-        unsigned int chip_id;
         s64 irq;
 
-        /* Find the chip ID */
-        np = of_get_cpu_node(cpu, NULL);
-        if (np) {
-                if (of_property_read_u32(np, "ibm,chip-id", &chip_id) < 0)
-                        chip_id = 0;
-        }
-
         /* Allocate an IPI and populate info about it */
         for (;;) {
-                irq = opal_xive_allocate_irq(chip_id);
+                irq = opal_xive_allocate_irq(xc->chip_id);
                 if (irq == OPAL_BUSY) {
                         msleep(OPAL_BUSY_DELAY_MS);
                         continue;
diff --git a/arch/powerpc/xmon/Makefile b/arch/powerpc/xmon/Makefile
index 1bc3abb237cd..69e7fb47bcaa 100644
--- a/arch/powerpc/xmon/Makefile
+++ b/arch/powerpc/xmon/Makefile
@@ -1,14 +1,15 @@
 # SPDX-License-Identifier: GPL-2.0
 # Makefile for xmon
 
-subdir-ccflags-$(CONFIG_PPC_WERROR) := -Werror
+# Disable clang warning for using setjmp without setjmp.h header
+subdir-ccflags-y := $(call cc-disable-warning, builtin-requires-header)
 
 GCOV_PROFILE := n
 UBSAN_SANITIZE := n
 
 # Disable ftrace for the entire directory
 ORIG_CFLAGS := $(KBUILD_CFLAGS)
-KBUILD_CFLAGS = $(subst -mno-sched-epilog,,$(subst $(CC_FLAGS_FTRACE),,$(ORIG_CFLAGS)))
+KBUILD_CFLAGS = $(subst $(CC_FLAGS_FTRACE),,$(ORIG_CFLAGS))
 
 ccflags-$(CONFIG_PPC64) := $(NO_MINIMAL_TOC)
 
diff --git a/arch/powerpc/xmon/xmon.c b/arch/powerpc/xmon/xmon.c
index 4264aedc7775..36b8dc47a3c3 100644
--- a/arch/powerpc/xmon/xmon.c
+++ b/arch/powerpc/xmon/xmon.c
@@ -2378,25 +2378,33 @@ static void dump_one_paca(int cpu)
         DUMP(p, cpu_start, "%#-*x");
         DUMP(p, kexec_state, "%#-*x");
 #ifdef CONFIG_PPC_BOOK3S_64
-        for (i = 0; i < SLB_NUM_BOLTED; i++) {
-                u64 esid, vsid;
+        if (!early_radix_enabled()) {
+                for (i = 0; i < SLB_NUM_BOLTED; i++) {
+                        u64 esid, vsid;
 
-                if (!p->slb_shadow_ptr)
-                        continue;
+                        if (!p->slb_shadow_ptr)
+                                continue;
+
+                        esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
+                        vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
 
-                esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
-                vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
+                        if (esid || vsid) {
+                                printf(" %-*s[%d] = 0x%016llx 0x%016llx\n",
+                                       22, "slb_shadow", i, esid, vsid);
+                        }
+                }
+                DUMP(p, vmalloc_sllp, "%#-*x");
+                DUMP(p, stab_rr, "%#-*x");
+                DUMP(p, slb_used_bitmap, "%#-*x");
+                DUMP(p, slb_kern_bitmap, "%#-*x");
 
-                if (esid || vsid) {
-                        printf(" %-*s[%d] = 0x%016llx 0x%016llx\n",
-                               22, "slb_shadow", i, esid, vsid);
+                if (!early_cpu_has_feature(CPU_FTR_ARCH_300)) {
+                        DUMP(p, slb_cache_ptr, "%#-*x");
+                        for (i = 0; i < SLB_CACHE_ENTRIES; i++)
+                                printf(" %-*s[%d] = 0x%016x\n",
+                                       22, "slb_cache", i, p->slb_cache[i]);
                 }
         }
-        DUMP(p, vmalloc_sllp, "%#-*x");
-        DUMP(p, slb_cache_ptr, "%#-*x");
-        for (i = 0; i < SLB_CACHE_ENTRIES; i++)
-                printf(" %-*s[%d] = 0x%016x\n",
-                       22, "slb_cache", i, p->slb_cache[i]);
 
         DUMP(p, rfi_flush_fallback_area, "%-*px");
 #endif
@@ -2412,7 +2420,9 @@ static void dump_one_paca(int cpu)
         DUMP(p, __current, "%-*px");
         DUMP(p, kstack, "%#-*llx");
         printf(" %-*s = 0x%016llx\n", 25, "kstack_base", p->kstack & ~(THREAD_SIZE - 1));
-        DUMP(p, stab_rr, "%#-*llx");
+#ifdef CONFIG_STACKPROTECTOR
+        DUMP(p, canary, "%#-*lx");
+#endif
         DUMP(p, saved_r1, "%#-*llx");
         DUMP(p, trap_save, "%#-*x");
         DUMP(p, irq_soft_mask, "%#-*x");
@@ -2444,11 +2454,15 @@ static void dump_one_paca(int cpu)
 
         DUMP(p, accounting.utime, "%#-*lx");
         DUMP(p, accounting.stime, "%#-*lx");
+#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
         DUMP(p, accounting.utime_scaled, "%#-*lx");
+#endif
         DUMP(p, accounting.starttime, "%#-*lx");
         DUMP(p, accounting.starttime_user, "%#-*lx");
+#ifdef CONFIG_ARCH_HAS_SCALED_CPUTIME
         DUMP(p, accounting.startspurr, "%#-*lx");
         DUMP(p, accounting.utime_sspurr, "%#-*lx");
+#endif
         DUMP(p, accounting.steal_time, "%#-*lx");
 #undef DUMP
 
@@ -2988,15 +3002,17 @@ static void show_task(struct task_struct *tsk)
 #ifdef CONFIG_PPC_BOOK3S_64
 void format_pte(void *ptep, unsigned long pte)
 {
+        pte_t entry = __pte(pte);
+
         printf("ptep @ 0x%016lx = 0x%016lx\n", (unsigned long)ptep, pte);
         printf("Maps physical address = 0x%016lx\n", pte & PTE_RPN_MASK);
 
         printf("Flags = %s%s%s%s%s\n",
-               (pte & _PAGE_ACCESSED) ? "Accessed " : "",
-               (pte & _PAGE_DIRTY)    ? "Dirty " : "",
-               (pte & _PAGE_READ)     ? "Read " : "",
-               (pte & _PAGE_WRITE)    ? "Write " : "",
-               (pte & _PAGE_EXEC)     ? "Exec " : "");
+               pte_young(entry) ? "Accessed " : "",
+               pte_dirty(entry) ? "Dirty " : "",
+               pte_read(entry)  ? "Read " : "",
+               pte_write(entry) ? "Write " : "",
+               pte_exec(entry)  ? "Exec " : "");
 }
 
 static void show_pte(unsigned long addr)
diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index 1106c076fa4b..600430685e28 100644
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -191,8 +191,7 @@ static int z2_open(struct block_device *bdev, fmode_t mode)
                         vfree(vmalloc (size));
                 }
 
-                vaddr = (unsigned long) __ioremap (paddr, size, 
-                                                   _PAGE_WRITETHRU);
+                vaddr = (unsigned long)ioremap_wt(paddr, size);
 
 #else
                 vaddr = (unsigned long)z_remap_nocache_nonser(paddr, size);
diff --git a/drivers/macintosh/adb-iop.c b/drivers/macintosh/adb-iop.c
index ca623e6446e4..fca31640e3ef 100644
--- a/drivers/macintosh/adb-iop.c
+++ b/drivers/macintosh/adb-iop.c
@@ -20,13 +20,13 @@
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 
-#include <asm/macintosh.h> 
-#include <asm/macints.h> 
+#include <asm/macintosh.h>
+#include <asm/macints.h>
 #include <asm/mac_iop.h>
 #include <asm/mac_oss.h>
 #include <asm/adb_iop.h>
 
-#include <linux/adb.h> 
+#include <linux/adb.h>
 
 /*#define DEBUG_ADB_IOP*/
 
@@ -38,9 +38,9 @@ static unsigned char *reply_ptr;
 #endif
 
 static enum adb_iop_state {
-    idle,
-    sending,
-    awaiting_reply
+        idle,
+        sending,
+        awaiting_reply
 } adb_iop_state;
 
 static void adb_iop_start(void);
@@ -66,7 +66,8 @@ static void adb_iop_end_req(struct adb_request *req, int state)
 {
         req->complete = 1;
         current_req = req->next;
-        if (req->done) (*req->done)(req);
+        if (req->done)
+                (*req->done)(req);
         adb_iop_state = state;
 }
 
@@ -100,7 +101,7 @@ static void adb_iop_complete(struct iop_msg *msg)
 
 static void adb_iop_listen(struct iop_msg *msg)
 {
-        struct adb_iopmsg *amsg = (struct adb_iopmsg *) msg->message;
+        struct adb_iopmsg *amsg = (struct adb_iopmsg *)msg->message;
         struct adb_request *req;
         unsigned long flags;
 #ifdef DEBUG_ADB_IOP
@@ -113,9 +114,9 @@ static void adb_iop_listen(struct iop_msg *msg)
 
 #ifdef DEBUG_ADB_IOP
         printk("adb_iop_listen %p: rcvd packet, %d bytes: %02X %02X", req,
-                (uint) amsg->count + 2, (uint) amsg->flags, (uint) amsg->cmd);
+               (uint)amsg->count + 2, (uint)amsg->flags, (uint)amsg->cmd);
         for (i = 0; i < amsg->count; i++)
-                printk(" %02X", (uint) amsg->data[i]);
+                printk(" %02X", (uint)amsg->data[i]);
         printk("\n");
 #endif
 
@@ -168,14 +169,15 @@ static void adb_iop_start(void)
 
         /* get the packet to send */
         req = current_req;
-        if (!req) return;
+        if (!req)
+                return;
 
         local_irq_save(flags);
 
 #ifdef DEBUG_ADB_IOP
         printk("adb_iop_start %p: sending packet, %d bytes:", req, req->nbytes);
-        for (i = 0 ; i < req->nbytes ; i++)
-                printk(" %02X", (uint) req->data[i]);
+        for (i = 0; i < req->nbytes; i++)
+                printk(" %02X", (uint)req->data[i]);
         printk("\n");
 #endif
 
@@ -196,19 +198,20 @@ static void adb_iop_start(void)
         /* Now send it. The IOP manager will call adb_iop_complete */
         /* when the packet has been sent.                          */
 
-        iop_send_message(ADB_IOP, ADB_CHAN, req,
-                         sizeof(amsg), (__u8 *) &amsg, adb_iop_complete);
+        iop_send_message(ADB_IOP, ADB_CHAN, req, sizeof(amsg), (__u8 *)&amsg,
+                         adb_iop_complete);
 }
 
 int adb_iop_probe(void)
 {
-        if (!iop_ism_present) return -ENODEV;
+        if (!iop_ism_present)
+                return -ENODEV;
         return 0;
 }
 
 int adb_iop_init(void)
 {
-        printk("adb: IOP ISM driver v0.4 for Unified ADB.\n");
+        pr_info("adb: IOP ISM driver v0.4 for Unified ADB\n");
         iop_listen(ADB_IOP, ADB_CHAN, adb_iop_listen, "ADB");
         return 0;
 }
@@ -218,10 +221,12 @@ int adb_iop_send_request(struct adb_request *req, int sync)
         int err;
 
         err = adb_iop_write(req);
-        if (err) return err;
+        if (err)
+                return err;
 
         if (sync) {
-                while (!req->complete) adb_iop_poll();
+                while (!req->complete)
+                        adb_iop_poll();
         }
         return 0;
 }
@@ -251,7 +256,9 @@ static int adb_iop_write(struct adb_request *req)
         }
 
         local_irq_restore(flags);
-        if (adb_iop_state == idle) adb_iop_start();
+
+        if (adb_iop_state == idle)
+                adb_iop_start();
         return 0;
 }
 
@@ -263,7 +270,8 @@ int adb_iop_autopoll(int devs)
 
 void adb_iop_poll(void)
 {
-        if (adb_iop_state == idle) adb_iop_start();
+        if (adb_iop_state == idle)
+                adb_iop_start();
         iop_ism_irq_poll(ADB_IOP);
 }
 
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 76e98f0f7a3e..e49d1f287a17 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -203,15 +203,15 @@ static int adb_scan_bus(void)
         }
 
         /* Now fill in the handler_id field of the adb_handler entries. */
-        pr_debug("adb devices:\n");
         for (i = 1; i < 16; i++) {
                 if (adb_handler[i].original_address == 0)
                         continue;
                 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
                             (i << 4) | 0xf);
                 adb_handler[i].handler_id = req.reply[2];
-                pr_debug(" [%d]: %d %x\n", i, adb_handler[i].original_address,
-                         adb_handler[i].handler_id);
+                printk(KERN_DEBUG "adb device [%d]: %d 0x%X\n", i,
+                       adb_handler[i].original_address,
+                       adb_handler[i].handler_id);
                 devmask |= 1 << i;
         }
         return devmask;
@@ -579,6 +579,8 @@ adb_try_handler_change(int address, int new_id)
         mutex_lock(&adb_handler_mutex);
         ret = try_handler_change(address, new_id);
         mutex_unlock(&adb_handler_mutex);
+        if (ret)
+                pr_debug("adb handler change: [%d] 0x%X\n", address, new_id);
         return ret;
 }
 EXPORT_SYMBOL(adb_try_handler_change);
diff --git a/drivers/macintosh/adbhid.c b/drivers/macintosh/adbhid.c
index a261892c03b3..75482eeab2c4 100644
--- a/drivers/macintosh/adbhid.c
+++ b/drivers/macintosh/adbhid.c
@@ -757,6 +757,7 @@ adbhid_input_register(int id, int default_id, int original_handler_id,
         struct input_dev *input_dev;
         int err;
         int i;
+        char *keyboard_type;
 
         if (adbhid[id]) {
                 pr_err("Trying to reregister ADB HID on ID %d\n", id);
@@ -798,24 +799,23 @@ adbhid_input_register(int id, int default_id, int original_handler_id,
 
                 memcpy(hid->keycode, adb_to_linux_keycodes, sizeof(adb_to_linux_keycodes));
 
-                pr_info("Detected ADB keyboard, type ");
                 switch (original_handler_id) {
                 default:
-                        pr_cont("<unknown>.\n");
+                        keyboard_type = "<unknown>";
                         input_dev->id.version = ADB_KEYBOARD_UNKNOWN;
                         break;
 
                 case 0x01: case 0x02: case 0x03: case 0x06: case 0x08:
                 case 0x0C: case 0x10: case 0x18: case 0x1B: case 0x1C:
                 case 0xC0: case 0xC3: case 0xC6:
-                        pr_cont("ANSI.\n");
+                        keyboard_type = "ANSI";
                         input_dev->id.version = ADB_KEYBOARD_ANSI;
                         break;
 
                 case 0x04: case 0x05: case 0x07: case 0x09: case 0x0D:
                 case 0x11: case 0x14: case 0x19: case 0x1D: case 0xC1:
                 case 0xC4: case 0xC7:
-                        pr_cont("ISO, swapping keys.\n");
+                        keyboard_type = "ISO, swapping keys";
                         input_dev->id.version = ADB_KEYBOARD_ISO;
                         i = hid->keycode[10];
                         hid->keycode[10] = hid->keycode[50];
@@ -824,10 +824,11 @@ adbhid_input_register(int id, int default_id, int original_handler_id,
 
                 case 0x12: case 0x15: case 0x16: case 0x17: case 0x1A:
                 case 0x1E: case 0xC2: case 0xC5: case 0xC8: case 0xC9:
-                        pr_cont("JIS.\n");
+                        keyboard_type = "JIS";
                         input_dev->id.version = ADB_KEYBOARD_JIS;
                         break;
                 }
+                pr_info("Detected ADB keyboard, type %s.\n", keyboard_type);
 
                 for (i = 0; i < 128; i++)
                         if (hid->keycode[i])
@@ -972,16 +973,13 @@ adbhid_probe(void)
                    ->get it to send separate codes for left and right shift,
                    control, option keys */
 #if 0           /* handler 5 doesn't send separate codes for R modifiers */
-                if (adb_try_handler_change(id, 5))
-                        printk("ADB keyboard at %d, handler set to 5\n", id);
-                else
+                if (!adb_try_handler_change(id, 5))
 #endif
-                if (adb_try_handler_change(id, 3))
-                        printk("ADB keyboard at %d, handler set to 3\n", id);
-                else
-                        printk("ADB keyboard at %d, handler 1\n", id);
+                adb_try_handler_change(id, 3);
 
                 adb_get_infos(id, &default_id, &cur_handler_id);
+                printk(KERN_DEBUG "ADB keyboard at %d has handler 0x%X\n",
+                       id, cur_handler_id);
                 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
                                                cur_handler_id, 0);
         }
@@ -999,48 +997,44 @@ adbhid_probe(void)
         for (i = 0; i < mouse_ids.nids; i++) {
                 int id = mouse_ids.id[i];
                 int mouse_kind;
+                char *desc = "standard";
 
                 adb_get_infos(id, &default_id, &org_handler_id);
 
                 if (adb_try_handler_change(id, 4)) {
-                        printk("ADB mouse at %d, handler set to 4", id);
                         mouse_kind = ADBMOUSE_EXTENDED;
                 }
                 else if (adb_try_handler_change(id, 0x2F)) {
-                        printk("ADB mouse at %d, handler set to 0x2F", id);
                         mouse_kind = ADBMOUSE_MICROSPEED;
                 }
                 else if (adb_try_handler_change(id, 0x42)) {
-                        printk("ADB mouse at %d, handler set to 0x42", id);
                         mouse_kind = ADBMOUSE_TRACKBALLPRO;
                 }
                 else if (adb_try_handler_change(id, 0x66)) {
-                        printk("ADB mouse at %d, handler set to 0x66", id);
                         mouse_kind = ADBMOUSE_MICROSPEED;
                 }
                 else if (adb_try_handler_change(id, 0x5F)) {
-                        printk("ADB mouse at %d, handler set to 0x5F", id);
                         mouse_kind = ADBMOUSE_MICROSPEED;
                 }
                 else if (adb_try_handler_change(id, 3)) {
-                        printk("ADB mouse at %d, handler set to 3", id);
                         mouse_kind = ADBMOUSE_MS_A3;
                 }
                 else if (adb_try_handler_change(id, 2)) {
-                        printk("ADB mouse at %d, handler set to 2", id);
                         mouse_kind = ADBMOUSE_STANDARD_200;
                 }
                 else {
-                        printk("ADB mouse at %d, handler 1", id);
                         mouse_kind = ADBMOUSE_STANDARD_100;
                 }
 
                 if ((mouse_kind == ADBMOUSE_TRACKBALLPRO)
                     || (mouse_kind == ADBMOUSE_MICROSPEED)) {
+                        desc = "Microspeed/MacPoint or compatible";
                         init_microspeed(id);
                 } else if (mouse_kind == ADBMOUSE_MS_A3) {
+                        desc = "Mouse Systems A3 Mouse or compatible";
                         init_ms_a3(id);
                 } else if (mouse_kind ==  ADBMOUSE_EXTENDED) {
+                        desc = "extended";
                         /*
                          * Register 1 is usually used for device
                          * identification.  Here, we try to identify
@@ -1054,32 +1048,36 @@ adbhid_probe(void)
                             (req.reply[1] == 0x9a) && ((req.reply[2] == 0x21)
                                 || (req.reply[2] == 0x20))) {
                                 mouse_kind = ADBMOUSE_TRACKBALL;
+                                desc = "trackman/mouseman";
                                 init_trackball(id);
                         }
                         else if ((req.reply_len >= 4) &&
                             (req.reply[1] == 0x74) && (req.reply[2] == 0x70) &&
                             (req.reply[3] == 0x61) && (req.reply[4] == 0x64)) {
                                 mouse_kind = ADBMOUSE_TRACKPAD;
+                                desc = "trackpad";
                                 init_trackpad(id);
                         }
                         else if ((req.reply_len >= 4) &&
                             (req.reply[1] == 0x4b) && (req.reply[2] == 0x4d) &&
                             (req.reply[3] == 0x4c) && (req.reply[4] == 0x31)) {
                                 mouse_kind = ADBMOUSE_TURBOMOUSE5;
+                                desc = "TurboMouse 5";
                                 init_turbomouse(id);
                         }
                         else if ((req.reply_len == 9) &&
                             (req.reply[1] == 0x4b) && (req.reply[2] == 0x4f) &&
                             (req.reply[3] == 0x49) && (req.reply[4] == 0x54)) {
                                 if (adb_try_handler_change(id, 0x42)) {
-                                        pr_cont("\nADB MacAlly 2-button mouse at %d, handler set to 0x42", id);
                                         mouse_kind = ADBMOUSE_MACALLY2;
+                                        desc = "MacAlly 2-button";
                                 }
                         }
                 }
-                pr_cont("\n");
 
                 adb_get_infos(id, &default_id, &cur_handler_id);
+                printk(KERN_DEBUG "ADB mouse (%s) at %d has handler 0x%X\n",
+                       desc, id, cur_handler_id);
                 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
                                                cur_handler_id, mouse_kind);
         }
@@ -1092,12 +1090,10 @@ init_trackpad(int id)
         struct adb_request req;
         unsigned char r1_buffer[8];
 
-        pr_cont(" (trackpad)");
-
         adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
                     ADB_READREG(id,1));
         if (req.reply_len < 8)
-            pr_cont("bad length for reg. 1\n");
+                pr_err("%s: bad length for reg. 1\n", __func__);
         else
         {
             memcpy(r1_buffer, &req.reply[1], 8);
@@ -1145,8 +1141,6 @@ init_trackball(int id)
 {
         struct adb_request req;
 
-        pr_cont(" (trackman/mouseman)");
-
         adb_request(&req, NULL, ADBREQ_SYNC, 3,
         ADB_WRITEREG(id,1), 00,0x81);
 
@@ -1177,8 +1171,6 @@ init_turbomouse(int id)
 {
         struct adb_request req;
 
-        pr_cont(" (TurboMouse 5)");
-
         adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
 
         adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
@@ -1213,8 +1205,6 @@ init_microspeed(int id)
 {
         struct adb_request req;
 
-        pr_cont(" (Microspeed/MacPoint or compatible)");
-
         adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
 
         /* This will initialize mice using the Microspeed, MacPoint and
@@ -1253,7 +1243,6 @@ init_ms_a3(int id)
 {
         struct adb_request req;
 
-        pr_cont(" (Mouse Systems A3 Mouse, or compatible)");
         adb_request(&req, NULL, ADBREQ_SYNC, 3,
         ADB_WRITEREG(id, 0x2),
             0x00,
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 07074820a167..17d3bc917562 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -360,9 +360,10 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
                                                struct macio_dev *in_bay,
                                                struct resource *parent_res)
 {
+        char name[MAX_NODE_NAME_SIZE + 1];
         struct macio_dev *dev;
         const u32 *reg;
-        
+
         if (np == NULL)
                 return NULL;
 
@@ -402,6 +403,7 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
 #endif
 
         /* MacIO itself has a different reg, we use it's PCI base */
+        snprintf(name, sizeof(name), "%pOFn", np);
         if (np == chip->of_node) {
                 dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s",
                              chip->lbus.index,
@@ -410,12 +412,12 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
 #else
                         0, /* NuBus may want to do something better here */
 #endif
-                        MAX_NODE_NAME_SIZE, np->name);
+                        MAX_NODE_NAME_SIZE, name);
         } else {
                 reg = of_get_property(np, "reg", NULL);
                 dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s",
                              chip->lbus.index,
-                             reg ? *reg : 0, MAX_NODE_NAME_SIZE, np->name);
+                             reg ? *reg : 0, MAX_NODE_NAME_SIZE, name);
         }
 
         /* Setup interrupts & resources */
diff --git a/drivers/macintosh/macio_sysfs.c b/drivers/macintosh/macio_sysfs.c
index ca4fcffe454b..d2451e58acb9 100644
--- a/drivers/macintosh/macio_sysfs.c
+++ b/drivers/macintosh/macio_sysfs.c
@@ -58,7 +58,13 @@ static ssize_t devspec_show(struct device *dev,
 static DEVICE_ATTR_RO(modalias);
 static DEVICE_ATTR_RO(devspec);
 
-macio_config_of_attr (name, "%s\n");
+static ssize_t name_show(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%pOFn\n", dev->of_node);
+}
+static DEVICE_ATTR_RO(name);
+
 macio_config_of_attr (type, "%s\n");
 
 static struct attribute *macio_dev_attrs[] = {
diff --git a/drivers/macintosh/via-cuda.c b/drivers/macintosh/via-cuda.c
index 98dd702eb867..bbec6ac0a966 100644
--- a/drivers/macintosh/via-cuda.c
+++ b/drivers/macintosh/via-cuda.c
@@ -766,3 +766,38 @@ cuda_input(unsigned char *buf, int nb)
                        buf, nb, false);
     }
 }
+
+/* Offset between Unix time (1970-based) and Mac time (1904-based) */
+#define RTC_OFFSET      2082844800
+
+time64_t cuda_get_time(void)
+{
+        struct adb_request req;
+        u32 now;
+
+        if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME) < 0)
+                return 0;
+        while (!req.complete)
+                cuda_poll();
+        if (req.reply_len != 7)
+                pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
+        now = (req.reply[3] << 24) + (req.reply[4] << 16) +
+              (req.reply[5] << 8) + req.reply[6];
+        return (time64_t)now - RTC_OFFSET;
+}
+
+int cuda_set_rtc_time(struct rtc_time *tm)
+{
+        u32 now;
+        struct adb_request req;
+
+        now = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
+        if (cuda_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME,
+                         now >> 24, now >> 16, now >> 8, now) < 0)
+                return -ENXIO;
+        while (!req.complete)
+                cuda_poll();
+        if ((req.reply_len != 3) && (req.reply_len != 7))
+                pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
+        return 0;
+}
diff --git a/drivers/macintosh/via-macii.c b/drivers/macintosh/via-macii.c
index cf6f7d52d6be..ac824d7b2dcf 100644
--- a/drivers/macintosh/via-macii.c
+++ b/drivers/macintosh/via-macii.c
@@ -12,7 +12,7 @@
  *
  * 1999-08-02 (jmt) - Initial rewrite for Unified ADB.
  * 2000-03-29 Tony Mantler <tonym@mac.linux-m68k.org>
- *                              - Big overhaul, should actually work now.
+ *            - Big overhaul, should actually work now.
  * 2006-12-31 Finn Thain - Another overhaul.
  *
  * Suggested reading:
@@ -23,7 +23,7 @@
  * Apple's "ADB Analyzer" bus sniffer is invaluable:
  *   ftp://ftp.apple.com/developer/Tool_Chest/Devices_-_Hardware/Apple_Desktop_Bus/
  */
- 
+
 #include <stdarg.h>
 #include <linux/types.h>
 #include <linux/errno.h>
@@ -77,7 +77,7 @@ static volatile unsigned char *via;
 #define ST_ODD          0x20            /* ADB state: odd data byte */
 #define ST_IDLE         0x30            /* ADB state: idle, nothing to send */
 
-static int  macii_init_via(void);
+static int macii_init_via(void);
 static void macii_start(void);
 static irqreturn_t macii_interrupt(int irq, void *arg);
 static void macii_queue_poll(void);
@@ -120,31 +120,15 @@ static int srq_asserted;     /* have to poll for the device that asserted it */
 static int command_byte;         /* the most recent command byte transmitted */
 static int autopoll_devs;      /* bits set are device addresses to be polled */
 
-/* Sanity check for request queue. Doesn't check for cycles. */
-static int request_is_queued(struct adb_request *req) {
-        struct adb_request *cur;
-        unsigned long flags;
-        local_irq_save(flags);
-        cur = current_req;
-        while (cur) {
-                if (cur == req) {
-                        local_irq_restore(flags);
-                        return 1;
-                }
-                cur = cur->next;
-        }
-        local_irq_restore(flags);
-        return 0;
-}
-
 /* Check for MacII style ADB */
 static int macii_probe(void)
 {
-        if (macintosh_config->adb_type != MAC_ADB_II) return -ENODEV;
+        if (macintosh_config->adb_type != MAC_ADB_II)
+                return -ENODEV;
 
         via = via1;
 
-        printk("adb: Mac II ADB Driver v1.0 for Unified ADB\n");
+        pr_info("adb: Mac II ADB Driver v1.0 for Unified ADB\n");
         return 0;
 }
 
@@ -153,15 +137,17 @@ int macii_init(void)
 {
         unsigned long flags;
         int err;
-        
+
         local_irq_save(flags);
-        
+
         err = macii_init_via();
-        if (err) goto out;
+        if (err)
+                goto out;
 
         err = request_irq(IRQ_MAC_ADB, macii_interrupt, 0, "ADB",
                           macii_interrupt);
-        if (err) goto out;
+        if (err)
+                goto out;
 
         macii_state = idle;
 out:
@@ -169,7 +155,7 @@ out:
         return err;
 }
 
-/* initialize the hardware */   
+/* initialize the hardware */
 static int macii_init_via(void)
 {
         unsigned char x;
@@ -179,7 +165,7 @@ static int macii_init_via(void)
 
         /* Set up state: idle */
         via[B] |= ST_IDLE;
-        last_status = via[B] & (ST_MASK|CTLR_IRQ);
+        last_status = via[B] & (ST_MASK | CTLR_IRQ);
 
         /* Shift register on input */
         via[ACR] = (via[ACR] & ~SR_CTRL) | SR_EXT;
@@ -205,7 +191,8 @@ static void macii_queue_poll(void)
         int next_device;
         static struct adb_request req;
 
-        if (!autopoll_devs) return;
+        if (!autopoll_devs)
+                return;
 
         device_mask = (1 << (((command_byte & 0xF0) >> 4) + 1)) - 1;
         if (autopoll_devs & ~device_mask)
@@ -213,10 +200,7 @@ static void macii_queue_poll(void)
         else
                 next_device = ffs(autopoll_devs) - 1;
 
-        BUG_ON(request_is_queued(&req));
-
-        adb_request(&req, NULL, ADBREQ_NOSEND, 1,
-                    ADB_READREG(next_device, 0));
+        adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_READREG(next_device, 0));
 
         req.sent = 0;
         req.complete = 0;
@@ -235,45 +219,47 @@ static void macii_queue_poll(void)
 static int macii_send_request(struct adb_request *req, int sync)
 {
         int err;
-        unsigned long flags;
 
-        BUG_ON(request_is_queued(req));
-
-        local_irq_save(flags);
         err = macii_write(req);
-        local_irq_restore(flags);
+        if (err)
+                return err;
 
-        if (!err && sync) {
-                while (!req->complete) {
+        if (sync)
+                while (!req->complete)
                         macii_poll();
-                }
-                BUG_ON(request_is_queued(req));
-        }
 
-        return err;
+        return 0;
 }
 
 /* Send an ADB request (append to request queue) */
 static int macii_write(struct adb_request *req)
 {
+        unsigned long flags;
+
         if (req->nbytes < 2 || req->data[0] != ADB_PACKET || req->nbytes > 15) {
                 req->complete = 1;
                 return -EINVAL;
         }
-        
+
         req->next = NULL;
         req->sent = 0;
         req->complete = 0;
         req->reply_len = 0;
 
+        local_irq_save(flags);
+
         if (current_req != NULL) {
                 last_req->next = req;
                 last_req = req;
         } else {
                 current_req = req;
                 last_req = req;
-                if (macii_state == idle) macii_start();
+                if (macii_state == idle)
+                        macii_start();
         }
+
+        local_irq_restore(flags);
+
         return 0;
 }
 
@@ -287,7 +273,8 @@ static int macii_autopoll(int devs)
         /* bit 1 == device 1, and so on. */
         autopoll_devs = devs & 0xFFFE;
 
-        if (!autopoll_devs) return 0;
+        if (!autopoll_devs)
+                return 0;
 
         local_irq_save(flags);
 
@@ -304,7 +291,8 @@ static int macii_autopoll(int devs)
         return err;
 }
 
-static inline int need_autopoll(void) {
+static inline int need_autopoll(void)
+{
         /* Was the last command Talk Reg 0
          * and is the target on the autopoll list?
          */
@@ -317,21 +305,17 @@ static inline int need_autopoll(void) {
 /* Prod the chip without interrupts */
 static void macii_poll(void)
 {
-        disable_irq(IRQ_MAC_ADB);
         macii_interrupt(0, NULL);
-        enable_irq(IRQ_MAC_ADB);
 }
 
 /* Reset the bus */
 static int macii_reset_bus(void)
 {
         static struct adb_request req;
-        
-        if (request_is_queued(&req))
-                return 0;
 
         /* Command = 0, Address = ignored */
-        adb_request(&req, NULL, 0, 1, ADB_BUSRESET);
+        adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_BUSRESET);
+        macii_send_request(&req, 1);
 
         /* Don't want any more requests during the Global Reset low time. */
         udelay(3000);
@@ -346,10 +330,6 @@ static void macii_start(void)
 
         req = current_req;
 
-        BUG_ON(req == NULL);
-
-        BUG_ON(macii_state != idle);
-
         /* Now send it. Be careful though, that first byte of the request
          * is actually ADB_PACKET; the real data begins at index 1!
          * And req->nbytes is the number of bytes of real data plus one.
@@ -375,7 +355,7 @@ static void macii_start(void)
  * to be activity on the ADB bus. The chip will poll to achieve this.
  *
  * The basic ADB state machine was left unchanged from the original MacII code
- * by Alan Cox, which was based on the CUDA driver for PowerMac. 
+ * by Alan Cox, which was based on the CUDA driver for PowerMac.
  * The syntax of the ADB status lines is totally different on MacII,
  * though. MacII uses the states Command -> Even -> Odd -> Even ->...-> Idle
  * for sending and Idle -> Even -> Odd -> Even ->...-> Idle for receiving.
@@ -387,164 +367,166 @@ static void macii_start(void)
 static irqreturn_t macii_interrupt(int irq, void *arg)
 {
         int x;
-        static int entered;
         struct adb_request *req;
+        unsigned long flags;
+
+        local_irq_save(flags);
 
         if (!arg) {
                 /* Clear the SR IRQ flag when polling. */
                 if (via[IFR] & SR_INT)
                         via[IFR] = SR_INT;
-                else
+                else {
+                        local_irq_restore(flags);
                         return IRQ_NONE;
+                }
         }
 
-        BUG_ON(entered++);
-
         last_status = status;
-        status = via[B] & (ST_MASK|CTLR_IRQ);
+        status = via[B] & (ST_MASK | CTLR_IRQ);
 
         switch (macii_state) {
-                case idle:
-                        if (reading_reply) {
-                                reply_ptr = current_req->reply;
-                        } else {
-                                BUG_ON(current_req != NULL);
-                                reply_ptr = reply_buf;
-                        }
+        case idle:
+                if (reading_reply) {
+                        reply_ptr = current_req->reply;
+                } else {
+                        WARN_ON(current_req);
+                        reply_ptr = reply_buf;
+                }
 
-                        x = via[SR];
+                x = via[SR];
 
-                        if ((status & CTLR_IRQ) && (x == 0xFF)) {
-                                /* Bus timeout without SRQ sequence:
-                                 *     data is "FF" while CTLR_IRQ is "H"
-                                 */
-                                reply_len = 0;
-                                srq_asserted = 0;
-                                macii_state = read_done;
-                        } else {
-                                macii_state = reading;
-                                *reply_ptr = x;
-                                reply_len = 1;
-                        }
+                if ((status & CTLR_IRQ) && (x == 0xFF)) {
+                        /* Bus timeout without SRQ sequence:
+                         *     data is "FF" while CTLR_IRQ is "H"
+                         */
+                        reply_len = 0;
+                        srq_asserted = 0;
+                        macii_state = read_done;
+                } else {
+                        macii_state = reading;
+                        *reply_ptr = x;
+                        reply_len = 1;
+                }
 
-                        /* set ADB state = even for first data byte */
-                        via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
-                        break;
+                /* set ADB state = even for first data byte */
+                via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
+                break;
 
-                case sending:
-                        req = current_req;
-                        if (data_index >= req->nbytes) {
-                                req->sent = 1;
-                                macii_state = idle;
-
-                                if (req->reply_expected) {
-                                        reading_reply = 1;
-                                } else {
-                                        req->complete = 1;
-                                        current_req = req->next;
-                                        if (req->done) (*req->done)(req);
-
-                                        if (current_req)
-                                                macii_start();
-                                        else
-                                                if (need_autopoll())
-                                                        macii_autopoll(autopoll_devs);
-                                }
+        case sending:
+                req = current_req;
+                if (data_index >= req->nbytes) {
+                        req->sent = 1;
+                        macii_state = idle;
 
-                                if (macii_state == idle) {
-                                        /* reset to shift in */
-                                        via[ACR] &= ~SR_OUT;
-                                        x = via[SR];
-                                        /* set ADB state idle - might get SRQ */
-                                        via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
-                                }
+                        if (req->reply_expected) {
+                                reading_reply = 1;
                         } else {
-                                via[SR] = req->data[data_index++];
-
-                                if ( (via[B] & ST_MASK) == ST_CMD ) {
-                                        /* just sent the command byte, set to EVEN */
-                                        via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
-                                } else {
-                                        /* invert state bits, toggle ODD/EVEN */
-                                        via[B] ^= ST_MASK;
-                                }
-                        }
-                        break;
-
-                case reading:
-                        x = via[SR];
-                        BUG_ON((status & ST_MASK) == ST_CMD ||
-                               (status & ST_MASK) == ST_IDLE);
-
-                        /* Bus timeout with SRQ sequence:
-                         *     data is "XX FF"      while CTLR_IRQ is "L L"
-                         * End of packet without SRQ sequence:
-                         *     data is "XX...YY 00" while CTLR_IRQ is "L...H L"
-                         * End of packet SRQ sequence:
-                         *     data is "XX...YY 00" while CTLR_IRQ is "L...L L"
-                         * (where XX is the first response byte and
-                         * YY is the last byte of valid response data.)
-                         */
+                                req->complete = 1;
+                                current_req = req->next;
+                                if (req->done)
+                                        (*req->done)(req);
 
-                        srq_asserted = 0;
-                        if (!(status & CTLR_IRQ)) {
-                                if (x == 0xFF) {
-                                        if (!(last_status & CTLR_IRQ)) {
-                                                macii_state = read_done;
-                                                reply_len = 0;
-                                                srq_asserted = 1;
-                                        }
-                                } else if (x == 0x00) {
-                                        macii_state = read_done;
-                                        if (!(last_status & CTLR_IRQ))
-                                                srq_asserted = 1;
-                                }
+                                if (current_req)
+                                        macii_start();
+                                else if (need_autopoll())
+                                        macii_autopoll(autopoll_devs);
                         }
 
-                        if (macii_state == reading) {
-                                BUG_ON(reply_len > 15);
-                                reply_ptr++;
-                                *reply_ptr = x;
-                                reply_len++;
+                        if (macii_state == idle) {
+                                /* reset to shift in */
+                                via[ACR] &= ~SR_OUT;
+                                x = via[SR];
+                                /* set ADB state idle - might get SRQ */
+                                via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
                         }
+                } else {
+                        via[SR] = req->data[data_index++];
 
-                        /* invert state bits, toggle ODD/EVEN */
-                        via[B] ^= ST_MASK;
-                        break;
+                        if ((via[B] & ST_MASK) == ST_CMD) {
+                                /* just sent the command byte, set to EVEN */
+                                via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
+                        } else {
+                                /* invert state bits, toggle ODD/EVEN */
+                                via[B] ^= ST_MASK;
+                        }
+                }
+                break;
 
-                case read_done:
-                        x = via[SR];
+        case reading:
+                x = via[SR];
+                WARN_ON((status & ST_MASK) == ST_CMD ||
+                        (status & ST_MASK) == ST_IDLE);
+
+                /* Bus timeout with SRQ sequence:
+                 *     data is "XX FF"      while CTLR_IRQ is "L L"
+                 * End of packet without SRQ sequence:
+                 *     data is "XX...YY 00" while CTLR_IRQ is "L...H L"
+                 * End of packet SRQ sequence:
+                 *     data is "XX...YY 00" while CTLR_IRQ is "L...L L"
+                 * (where XX is the first response byte and
+                 * YY is the last byte of valid response data.)
+                 */
 
-                        if (reading_reply) {
-                                reading_reply = 0;
-                                req = current_req;
-                                req->reply_len = reply_len;
-                                req->complete = 1;
-                                current_req = req->next;
-                                if (req->done) (*req->done)(req);
-                        } else if (reply_len && autopoll_devs)
-                                adb_input(reply_buf, reply_len, 0);
+                srq_asserted = 0;
+                if (!(status & CTLR_IRQ)) {
+                        if (x == 0xFF) {
+                                if (!(last_status & CTLR_IRQ)) {
+                                        macii_state = read_done;
+                                        reply_len = 0;
+                                        srq_asserted = 1;
+                                }
+                        } else if (x == 0x00) {
+                                macii_state = read_done;
+                                if (!(last_status & CTLR_IRQ))
+                                        srq_asserted = 1;
+                        }
+                }
 
-                        macii_state = idle;
+                if (macii_state == reading &&
+                    reply_len < ARRAY_SIZE(reply_buf)) {
+                        reply_ptr++;
+                        *reply_ptr = x;
+                        reply_len++;
+                }
 
-                        /* SRQ seen before, initiate poll now */
-                        if (srq_asserted)
-                                macii_queue_poll();
+                /* invert state bits, toggle ODD/EVEN */
+                via[B] ^= ST_MASK;
+                break;
 
-                        if (current_req)
-                                macii_start();
-                        else
-                                if (need_autopoll())
-                                        macii_autopoll(autopoll_devs);
+        case read_done:
+                x = via[SR];
 
-                        if (macii_state == idle)
-                                via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
-                        break;
+                if (reading_reply) {
+                        reading_reply = 0;
+                        req = current_req;
+                        req->reply_len = reply_len;
+                        req->complete = 1;
+                        current_req = req->next;
+                        if (req->done)
+                                (*req->done)(req);
+                } else if (reply_len && autopoll_devs)
+                        adb_input(reply_buf, reply_len, 0);
+
+                macii_state = idle;
+
+                /* SRQ seen before, initiate poll now */
+                if (srq_asserted)
+                        macii_queue_poll();
+
+                if (current_req)
+                        macii_start();
+                else if (need_autopoll())
+                        macii_autopoll(autopoll_devs);
+
+                if (macii_state == idle)
+                        via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
+                break;
 
-                default:
+        default:
                 break;
         }
 
-        entered--;
+        local_irq_restore(flags);
         return IRQ_HANDLED;
 }
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index d72c450aebe5..60f57e2abf21 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -1737,6 +1737,39 @@ pmu_enable_irled(int on)
         pmu_wait_complete(&req);
 }
 
+/* Offset between Unix time (1970-based) and Mac time (1904-based) */
+#define RTC_OFFSET      2082844800
+
+time64_t pmu_get_time(void)
+{
+        struct adb_request req;
+        u32 now;
+
+        if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)
+                return 0;
+        pmu_wait_complete(&req);
+        if (req.reply_len != 4)
+                pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
+        now = (req.reply[0] << 24) + (req.reply[1] << 16) +
+              (req.reply[2] << 8) + req.reply[3];
+        return (time64_t)now - RTC_OFFSET;
+}
+
+int pmu_set_rtc_time(struct rtc_time *tm)
+{
+        u32 now;
+        struct adb_request req;
+
+        now = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
+        if (pmu_request(&req, NULL, 5, PMU_SET_RTC,
+                        now >> 24, now >> 16, now >> 8, now) < 0)
+                return -ENXIO;
+        pmu_wait_complete(&req);
+        if (req.reply_len != 0)
+                pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
+        return 0;
+}
+
 void
 pmu_restart(void)
 {
diff --git a/drivers/macintosh/windfarm_smu_controls.c b/drivers/macintosh/windfarm_smu_controls.c
index d174c7437337..86d65462a61c 100644
--- a/drivers/macintosh/windfarm_smu_controls.c
+++ b/drivers/macintosh/windfarm_smu_controls.c
@@ -277,7 +277,7 @@ static int __init smu_controls_init(void)
                 fct = smu_fan_create(fan, 0);
                 if (fct == NULL) {
                         printk(KERN_WARNING "windfarm: Failed to create SMU "
-                               "RPM fan %s\n", fan->name);
+                               "RPM fan %pOFn\n", fan);
                         continue;
                 }
                 list_add(&fct->link, &smu_fans);
@@ -296,7 +296,7 @@ static int __init smu_controls_init(void)
                 fct = smu_fan_create(fan, 1);
                 if (fct == NULL) {
                         printk(KERN_WARNING "windfarm: Failed to create SMU "
-                               "PWM fan %s\n", fan->name);
+                               "PWM fan %pOFn\n", fan);
                         continue;
                 }
                 list_add(&fct->link, &smu_fans);
diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c
index da7f4fc1a51d..a0f61eb853c5 100644
--- a/drivers/macintosh/windfarm_smu_sat.c
+++ b/drivers/macintosh/windfarm_smu_sat.c
@@ -22,14 +22,6 @@
 
 #define VERSION "1.0"
 
-#define DEBUG
-
-#ifdef DEBUG
-#define DBG(args...)    printk(args)
-#else
-#define DBG(args...)    do { } while(0)
-#endif
-
 /* If the cache is older than 800ms we'll refetch it */
 #define MAX_AGE         msecs_to_jiffies(800)
 
@@ -106,13 +98,10 @@ struct smu_sdbp_header *smu_sat_get_sdb_partition(unsigned int sat_id, int id,
                 buf[i+2] = data[3];
                 buf[i+3] = data[2];
         }
-#ifdef DEBUG
-        DBG(KERN_DEBUG "sat %d partition %x:", sat_id, id);
-        for (i = 0; i < len; ++i)
-                DBG(" %x", buf[i]);
-        DBG("\n");
-#endif
 
+        printk(KERN_DEBUG "sat %d partition %x:", sat_id, id);
+        print_hex_dump(KERN_DEBUG, "  ", DUMP_PREFIX_OFFSET,
+                       16, 1, buf, len, false);
         if (size)
                 *size = len;
         return (struct smu_sdbp_header *) buf;
@@ -132,13 +121,13 @@ static int wf_sat_read_cache(struct wf_sat *sat)
         if (err < 0)
                 return err;
         sat->last_read = jiffies;
+
 #ifdef LOTSA_DEBUG
         {
                 int i;
-                DBG(KERN_DEBUG "wf_sat_get: data is");
-                for (i = 0; i < 16; ++i)
-                        DBG(" %.2x", sat->cache[i]);
-                DBG("\n");
+                printk(KERN_DEBUG "wf_sat_get: data is");
+                print_hex_dump(KERN_DEBUG, "  ", DUMP_PREFIX_OFFSET,
+                               16, 1, sat->cache, 16, false);
         }
 #endif
         return 0;
diff --git a/drivers/misc/ocxl/config.c b/drivers/misc/ocxl/config.c
index 2e30de9c694a..57a6bb1fd3c9 100644
--- a/drivers/misc/ocxl/config.c
+++ b/drivers/misc/ocxl/config.c
@@ -280,7 +280,9 @@ int ocxl_config_check_afu_index(struct pci_dev *dev,
         u32 val;
         int rc, templ_major, templ_minor, len;
 
-        pci_write_config_word(dev, fn->dvsec_afu_info_pos, afu_idx);
+        pci_write_config_byte(dev,
+                        fn->dvsec_afu_info_pos + OCXL_DVSEC_AFU_INFO_AFU_IDX,
+                        afu_idx);
         rc = read_afu_info(dev, fn, OCXL_DVSEC_TEMPL_VERSION, &val);
         if (rc)
                 return rc;
diff --git a/drivers/pci/hotplug/pnv_php.c b/drivers/pci/hotplug/pnv_php.c
index ee54f5bacad1..6758fd7c382e 100644
--- a/drivers/pci/hotplug/pnv_php.c
+++ b/drivers/pci/hotplug/pnv_php.c
@@ -746,7 +746,7 @@ static irqreturn_t pnv_php_interrupt(int irq, void *data)
                 pe = edev ? edev->pe : NULL;
                 if (pe) {
                         eeh_serialize_lock(&flags);
-                        eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
+                        eeh_pe_mark_isolated(pe);
                         eeh_serialize_unlock(flags);
                         eeh_pe_set_option(pe, EEH_OPT_FREEZE_PE);
                 }
diff --git a/drivers/pcmcia/electra_cf.c b/drivers/pcmcia/electra_cf.c
index 9671ded549f0..b31abe35ed2c 100644
--- a/drivers/pcmcia/electra_cf.c
+++ b/drivers/pcmcia/electra_cf.c
@@ -230,7 +230,7 @@ static int electra_cf_probe(struct platform_device *ofdev)
 
         if (!cf->mem_base || !cf->io_virt || !cf->gpio_base ||
             (__ioremap_at(io.start, cf->io_virt, cf->io_size,
-                  pgprot_val(pgprot_noncached(__pgprot(0)))) == NULL)) {
+                          pgprot_noncached(PAGE_KERNEL)) == NULL)) {
                 dev_err(device, "can't ioremap ranges\n");
                 status = -ENOMEM;
                 goto fail1;
diff --git a/drivers/soc/fsl/qbman/qman_ccsr.c b/drivers/soc/fsl/qbman/qman_ccsr.c
index 6fd5fef5f39b..109b38de3176 100644
--- a/drivers/soc/fsl/qbman/qman_ccsr.c
+++ b/drivers/soc/fsl/qbman/qman_ccsr.c
@@ -419,7 +419,7 @@ static size_t fqd_sz, pfdr_sz;
 static int zero_priv_mem(phys_addr_t addr, size_t sz)
 {
         /* map as cacheable, non-guarded */
-        void __iomem *tmpp = ioremap_prot(addr, sz, 0);
+        void __iomem *tmpp = ioremap_cache(addr, sz);
 
         if (!tmpp)
                 return -ENOMEM;
diff --git a/drivers/video/fbdev/chipsfb.c b/drivers/video/fbdev/chipsfb.c
index f103665cad43..40182ed85648 100644
--- a/drivers/video/fbdev/chipsfb.c
+++ b/drivers/video/fbdev/chipsfb.c
@@ -27,7 +27,6 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/console.h>
-#include <asm/io.h>
 
 #ifdef CONFIG_PMAC_BACKLIGHT
 #include <asm/backlight.h>
@@ -401,7 +400,7 @@ static int chipsfb_pci_init(struct pci_dev *dp, const struct pci_device_id *ent)
 #endif /* CONFIG_PMAC_BACKLIGHT */
 
 #ifdef CONFIG_PPC
-        p->screen_base = __ioremap(addr, 0x200000, _PAGE_NO_CACHE);
+        p->screen_base = ioremap_wc(addr, 0x200000);
 #else
         p->screen_base = ioremap(addr, 0x200000);
 #endif
diff --git a/drivers/video/fbdev/controlfb.c b/drivers/video/fbdev/controlfb.c
index 8d14b29aafea..9cb0ef7ac29e 100644
--- a/drivers/video/fbdev/controlfb.c
+++ b/drivers/video/fbdev/controlfb.c
@@ -48,9 +48,7 @@
 #include <linux/nvram.h>
 #include <linux/adb.h>
 #include <linux/cuda.h>
-#include <asm/io.h>
 #include <asm/prom.h>
-#include <asm/pgtable.h>
 #include <asm/btext.h>
 
 #include "macmodes.h"
@@ -715,8 +713,7 @@ static int __init control_of_init(struct device_node *dp)
                 goto error_out;
         }
         /* map at most 8MB for the frame buffer */
-        p->frame_buffer = __ioremap(p->frame_buffer_phys, 0x800000,
-                                    _PAGE_WRITETHRU);
+        p->frame_buffer = ioremap_wt(p->frame_buffer_phys, 0x800000);
 
         if (!p->control_regs_phys ||
             !request_mem_region(p->control_regs_phys, p->control_regs_size,
diff --git a/drivers/video/fbdev/platinumfb.c b/drivers/video/fbdev/platinumfb.c
index 377d3399a3ad..bf6b7fb83cf4 100644
--- a/drivers/video/fbdev/platinumfb.c
+++ b/drivers/video/fbdev/platinumfb.c
@@ -32,9 +32,7 @@
 #include <linux/nvram.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
-#include <asm/io.h>
 #include <asm/prom.h>
-#include <asm/pgtable.h>
 
 #include "macmodes.h"
 #include "platinumfb.h"
@@ -577,8 +575,7 @@ static int platinumfb_probe(struct platform_device* odev)
 
         /* frame buffer - map only 4MB */
         pinfo->frame_buffer_phys = pinfo->rsrc_fb.start;
-        pinfo->frame_buffer = __ioremap(pinfo->rsrc_fb.start, 0x400000,
-                                        _PAGE_WRITETHRU);
+        pinfo->frame_buffer = ioremap_wt(pinfo->rsrc_fb.start, 0x400000);
         pinfo->base_frame_buffer = pinfo->frame_buffer;
 
         /* registers */
diff --git a/drivers/video/fbdev/valkyriefb.c b/drivers/video/fbdev/valkyriefb.c
index 275fb98236d3..d51c3a8009cb 100644
--- a/drivers/video/fbdev/valkyriefb.c
+++ b/drivers/video/fbdev/valkyriefb.c
@@ -54,13 +54,11 @@
 #include <linux/nvram.h>
 #include <linux/adb.h>
 #include <linux/cuda.h>
-#include <asm/io.h>
 #ifdef CONFIG_MAC
 #include <asm/macintosh.h>
 #else
 #include <asm/prom.h>
 #endif
-#include <asm/pgtable.h>
 
 #include "macmodes.h"
 #include "valkyriefb.h"
@@ -318,7 +316,7 @@ static void __init valkyrie_choose_mode(struct fb_info_valkyrie *p)
 int __init valkyriefb_init(void)
 {
         struct fb_info_valkyrie *p;
-        unsigned long frame_buffer_phys, cmap_regs_phys, flags;
+        unsigned long frame_buffer_phys, cmap_regs_phys;
         int err;
         char *option = NULL;
 
@@ -337,7 +335,6 @@ int __init valkyriefb_init(void)
         /* Hardcoded addresses... welcome to 68k Macintosh country :-) */
         frame_buffer_phys = 0xf9000000;
         cmap_regs_phys = 0x50f24000;
-        flags = IOMAP_NOCACHE_SER; /* IOMAP_WRITETHROUGH?? */
 #else /* ppc (!CONFIG_MAC) */
         {
                 struct device_node *dp;
@@ -354,7 +351,6 @@ int __init valkyriefb_init(void)
 
                 frame_buffer_phys = r.start;
                 cmap_regs_phys = r.start + 0x304000;
-                flags = _PAGE_WRITETHRU;
         }
 #endif /* ppc (!CONFIG_MAC) */
 
@@ -369,7 +365,11 @@ int __init valkyriefb_init(void)
         }
         p->total_vram = 0x100000;
         p->frame_buffer_phys = frame_buffer_phys;
-        p->frame_buffer = __ioremap(frame_buffer_phys, p->total_vram, flags);
+#ifdef CONFIG_MAC
+        p->frame_buffer = ioremap_nocache(frame_buffer_phys, p->total_vram);
+#else
+        p->frame_buffer = ioremap_wt(frame_buffer_phys, p->total_vram);
+#endif
         p->cmap_regs_phys = cmap_regs_phys;
         p->cmap_regs = ioremap(p->cmap_regs_phys, 0x1000);
         p->valkyrie_regs_phys = cmap_regs_phys+0x6000;
diff --git a/include/linux/cuda.h b/include/linux/cuda.h
index 056867f09a01..45bfe9d61271 100644
--- a/include/linux/cuda.h
+++ b/include/linux/cuda.h
@@ -8,6 +8,7 @@
 #ifndef _LINUX_CUDA_H
 #define _LINUX_CUDA_H
 
+#include <linux/rtc.h>
 #include <uapi/linux/cuda.h>
 
 
@@ -16,4 +17,7 @@ extern int cuda_request(struct adb_request *req,
                         void (*done)(struct adb_request *), int nbytes, ...);
 extern void cuda_poll(void);
 
+extern time64_t cuda_get_time(void);
+extern int cuda_set_rtc_time(struct rtc_time *tm);
+
 #endif /* _LINUX_CUDA_H */
diff --git a/include/linux/pmu.h b/include/linux/pmu.h
index 9ac8fc60ad49..52453a24a24f 100644
--- a/include/linux/pmu.h
+++ b/include/linux/pmu.h
@@ -9,6 +9,7 @@
 #ifndef _LINUX_PMU_H
 #define _LINUX_PMU_H
 
+#include <linux/rtc.h>
 #include <uapi/linux/pmu.h>
 
 
@@ -36,6 +37,9 @@ static inline void pmu_resume(void)
 
 extern void pmu_enable_irled(int on);
 
+extern time64_t pmu_get_time(void);
+extern int pmu_set_rtc_time(struct rtc_time *tm);
+
 extern void pmu_restart(void);
 extern void pmu_shutdown(void);
 extern void pmu_unlock(void);
diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
index 201b598558b9..b3ad909aefbc 100644
--- a/tools/testing/selftests/powerpc/Makefile
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -28,7 +28,8 @@ SUB_DIRS = alignment		\
            tm                   \
            vphn         \
            math         \
-           ptrace
+           ptrace       \
+           security
 
 endif
 
diff --git a/tools/testing/selftests/powerpc/include/reg.h b/tools/testing/selftests/powerpc/include/reg.h
index 7f348c059bc2..52b4710469d2 100644
--- a/tools/testing/selftests/powerpc/include/reg.h
+++ b/tools/testing/selftests/powerpc/include/reg.h
@@ -17,6 +17,7 @@
                                     : "memory")
 
 #define mb()            asm volatile("sync" : : : "memory");
+#define barrier()       asm volatile("" : : : "memory");
 
 #define SPRN_MMCR2     769
 #define SPRN_MMCRA     770
diff --git a/tools/testing/selftests/powerpc/include/utils.h b/tools/testing/selftests/powerpc/include/utils.h
index c58c370828b4..49621822d7c3 100644
--- a/tools/testing/selftests/powerpc/include/utils.h
+++ b/tools/testing/selftests/powerpc/include/utils.h
@@ -11,6 +11,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <linux/auxvec.h>
+#include <linux/perf_event.h>
 #include "reg.h"
 
 /* Avoid headaches with PRI?64 - just use %ll? always */
@@ -31,6 +32,15 @@ void *get_auxv_entry(int type);
 
 int pick_online_cpu(void);
 
+int read_debugfs_file(char *debugfs_file, int *result);
+int write_debugfs_file(char *debugfs_file, int result);
+void set_dscr(unsigned long val);
+int perf_event_open_counter(unsigned int type,
+                            unsigned long config, int group_fd);
+int perf_event_enable(int fd);
+int perf_event_disable(int fd);
+int perf_event_reset(int fd);
+
 static inline bool have_hwcap(unsigned long ftr)
 {
         return ((unsigned long)get_auxv_entry(AT_HWCAP) & ftr) == ftr;
@@ -80,4 +90,12 @@ do {								\
 #define PPC_FEATURE2_ARCH_3_00 0x00800000
 #endif
 
+#if defined(__powerpc64__)
+#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.gp_regs[PT_NIP]
+#elif defined(__powerpc__)
+#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.uc_regs->gregs[PT_NIP]
+#else
+#error implement UCONTEXT_NIA
+#endif
+
 #endif /* _SELFTESTS_POWERPC_UTILS_H */
diff --git a/tools/testing/selftests/powerpc/mm/.gitignore b/tools/testing/selftests/powerpc/mm/.gitignore
index 7d7c42ed6de9..ba919308fe30 100644
--- a/tools/testing/selftests/powerpc/mm/.gitignore
+++ b/tools/testing/selftests/powerpc/mm/.gitignore
@@ -2,4 +2,5 @@ hugetlb_vs_thp_test
 subpage_prot
 tempfile
 prot_sao
-segv_errors
\ No newline at end of file
+segv_errors
+wild_bctr
\ No newline at end of file
diff --git a/tools/testing/selftests/powerpc/mm/Makefile b/tools/testing/selftests/powerpc/mm/Makefile
index 33ced6e0ad25..43d68420e363 100644
--- a/tools/testing/selftests/powerpc/mm/Makefile
+++ b/tools/testing/selftests/powerpc/mm/Makefile
@@ -2,7 +2,7 @@
 noarg:
         $(MAKE) -C ../
 
-TEST_GEN_PROGS := hugetlb_vs_thp_test subpage_prot prot_sao segv_errors
+TEST_GEN_PROGS := hugetlb_vs_thp_test subpage_prot prot_sao segv_errors wild_bctr
 TEST_GEN_FILES := tempfile
 
 top_srcdir = ../../../../..
@@ -12,6 +12,8 @@ $(TEST_GEN_PROGS): ../harness.c
 
 $(OUTPUT)/prot_sao: ../utils.c
 
+$(OUTPUT)/wild_bctr: CFLAGS += -m64
+
 $(OUTPUT)/tempfile:
         dd if=/dev/zero of=$@ bs=64k count=1
 
diff --git a/tools/testing/selftests/powerpc/mm/wild_bctr.c b/tools/testing/selftests/powerpc/mm/wild_bctr.c
new file mode 100644
index 000000000000..1b0e9e9a2ddc
--- /dev/null
+++ b/tools/testing/selftests/powerpc/mm/wild_bctr.c
@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright 2018, Michael Ellerman, IBM Corp.
+ *
+ * Test that an out-of-bounds branch to counter behaves as expected.
+ */
+
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <ucontext.h>
+#include <unistd.h>
+
+#include "utils.h"
+
+
+#define BAD_NIP 0x788c545a18000000ull
+
+static struct pt_regs signal_regs;
+static jmp_buf setjmp_env;
+
+static void save_regs(ucontext_t *ctxt)
+{
+        struct pt_regs *regs = ctxt->uc_mcontext.regs;
+
+        memcpy(&signal_regs, regs, sizeof(signal_regs));
+}
+
+static void segv_handler(int signum, siginfo_t *info, void *ctxt_v)
+{
+        save_regs(ctxt_v);
+        longjmp(setjmp_env, 1);
+}
+
+static void usr2_handler(int signum, siginfo_t *info, void *ctxt_v)
+{
+        save_regs(ctxt_v);
+}
+
+static int ok(void)
+{
+        printf("Everything is OK in here.\n");
+        return 0;
+}
+
+#define REG_POISON      0x5a5aUL
+#define POISONED_REG(n) ((REG_POISON << 48) | ((n) << 32) | (REG_POISON << 16) | (n))
+
+static inline void poison_regs(void)
+{
+        #define POISON_REG(n)   \
+          "lis  " __stringify(n) "," __stringify(REG_POISON) ";" \
+          "addi " __stringify(n) "," __stringify(n) "," __stringify(n) ";" \
+          "sldi " __stringify(n) "," __stringify(n) ", 32 ;" \
+          "oris " __stringify(n) "," __stringify(n) "," __stringify(REG_POISON) ";" \
+          "addi " __stringify(n) "," __stringify(n) "," __stringify(n) ";"
+
+        asm (POISON_REG(15)
+             POISON_REG(16)
+             POISON_REG(17)
+             POISON_REG(18)
+             POISON_REG(19)
+             POISON_REG(20)
+             POISON_REG(21)
+             POISON_REG(22)
+             POISON_REG(23)
+             POISON_REG(24)
+             POISON_REG(25)
+             POISON_REG(26)
+             POISON_REG(27)
+             POISON_REG(28)
+             POISON_REG(29)
+             : // inputs
+             : // outputs
+             : "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25",
+               "26", "27", "28", "29"
+        );
+        #undef POISON_REG
+}
+
+static int check_regs(void)
+{
+        unsigned long i;
+
+        for (i = 15; i <= 29; i++)
+                FAIL_IF(signal_regs.gpr[i] != POISONED_REG(i));
+
+        printf("Regs OK\n");
+        return 0;
+}
+
+static void dump_regs(void)
+{
+        for (int i = 0; i < 32; i += 4) {
+                printf("r%02d 0x%016lx  r%02d 0x%016lx  " \
+                       "r%02d 0x%016lx  r%02d 0x%016lx\n",
+                       i, signal_regs.gpr[i],
+                       i+1, signal_regs.gpr[i+1],
+                       i+2, signal_regs.gpr[i+2],
+                       i+3, signal_regs.gpr[i+3]);
+        }
+}
+
+int test_wild_bctr(void)
+{
+        int (*func_ptr)(void);
+        struct sigaction segv = {
+                .sa_sigaction = segv_handler,
+                .sa_flags = SA_SIGINFO
+        };
+        struct sigaction usr2 = {
+                .sa_sigaction = usr2_handler,
+                .sa_flags = SA_SIGINFO
+        };
+
+        FAIL_IF(sigaction(SIGSEGV, &segv, NULL));
+        FAIL_IF(sigaction(SIGUSR2, &usr2, NULL));
+
+        bzero(&signal_regs, sizeof(signal_regs));
+
+        if (setjmp(setjmp_env) == 0) {
+                func_ptr = ok;
+                func_ptr();
+
+                kill(getpid(), SIGUSR2);
+                printf("Regs before:\n");
+                dump_regs();
+                bzero(&signal_regs, sizeof(signal_regs));
+
+                poison_regs();
+
+                func_ptr = (int (*)(void))BAD_NIP;
+                func_ptr();
+
+                FAIL_IF(1); /* we didn't segv? */
+        }
+
+        FAIL_IF(signal_regs.nip != BAD_NIP);
+
+        printf("All good - took SEGV as expected branching to 0x%llx\n", BAD_NIP);
+
+        dump_regs();
+        FAIL_IF(check_regs());
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(test_wild_bctr, "wild_bctr");
+}
diff --git a/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c b/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c
index ed3239bbfae2..ee1e9ca22f0d 100644
--- a/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c
+++ b/tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c
@@ -65,14 +65,6 @@ static int unprotect_region(void)
 extern char __start___ex_table[];
 extern char __stop___ex_table[];
 
-#if defined(__powerpc64__)
-#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.gp_regs[PT_NIP]
-#elif defined(__powerpc__)
-#define UCONTEXT_NIA(UC)        (UC)->uc_mcontext.uc_regs->gregs[PT_NIP]
-#else
-#error implement UCONTEXT_NIA
-#endif
-
 struct extbl_entry {
         int insn;
         int fixup;
diff --git a/tools/testing/selftests/powerpc/ptrace/Makefile b/tools/testing/selftests/powerpc/ptrace/Makefile
index 923d531265f8..9b35ca8e8f13 100644
--- a/tools/testing/selftests/powerpc/ptrace/Makefile
+++ b/tools/testing/selftests/powerpc/ptrace/Makefile
@@ -2,7 +2,7 @@
 TEST_PROGS := ptrace-gpr ptrace-tm-gpr ptrace-tm-spd-gpr \
               ptrace-tar ptrace-tm-tar ptrace-tm-spd-tar ptrace-vsx ptrace-tm-vsx \
               ptrace-tm-spd-vsx ptrace-tm-spr ptrace-hwbreak ptrace-pkey core-pkey \
-              perf-hwbreak
+              perf-hwbreak ptrace-syscall
 
 top_srcdir = ../../../../..
 include ../../lib.mk
diff --git a/tools/testing/selftests/powerpc/ptrace/ptrace-syscall.c b/tools/testing/selftests/powerpc/ptrace/ptrace-syscall.c
new file mode 100644
index 000000000000..3353210dcdbd
--- /dev/null
+++ b/tools/testing/selftests/powerpc/ptrace/ptrace-syscall.c
@@ -0,0 +1,228 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * A ptrace test for testing PTRACE_SYSEMU, PTRACE_SETREGS and
+ * PTRACE_GETREG.  This test basically create a child process that executes
+ * syscalls and the parent process check if it is being traced appropriated.
+ *
+ * This test is heavily based on tools/testing/selftests/x86/ptrace_syscall.c
+ * test, and it was adapted to run on Powerpc by
+ * Breno Leitao <leitao@debian.org>
+ */
+#define _GNU_SOURCE
+
+#include <sys/ptrace.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/syscall.h>
+#include <sys/user.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <err.h>
+#include <string.h>
+#include <sys/auxv.h>
+#include "utils.h"
+
+/* Bitness-agnostic defines for user_regs_struct fields. */
+#define user_syscall_nr gpr[0]
+#define user_arg0               gpr[3]
+#define user_arg1               gpr[4]
+#define user_arg2               gpr[5]
+#define user_arg3               gpr[6]
+#define user_arg4               gpr[7]
+#define user_arg5               gpr[8]
+#define user_ip         nip
+
+#define PTRACE_SYSEMU           0x1d
+
+static int nerrs;
+
+static void wait_trap(pid_t chld)
+{
+        siginfo_t si;
+
+        if (waitid(P_PID, chld, &si, WEXITED|WSTOPPED) != 0)
+                err(1, "waitid");
+        if (si.si_pid != chld)
+                errx(1, "got unexpected pid in event\n");
+        if (si.si_code != CLD_TRAPPED)
+                errx(1, "got unexpected event type %d\n", si.si_code);
+}
+
+static void test_ptrace_syscall_restart(void)
+{
+        int status;
+        struct pt_regs regs;
+        pid_t chld;
+
+        printf("[RUN]\tptrace-induced syscall restart\n");
+
+        chld = fork();
+        if (chld < 0)
+                err(1, "fork");
+
+        /*
+         * Child process is running 4 syscalls after ptrace.
+         *
+         * 1) getpid()
+         * 2) gettid()
+         * 3) tgkill() -> Send SIGSTOP
+         * 4) gettid() -> Where the tests will happen essentially
+         */
+        if (chld == 0) {
+                if (ptrace(PTRACE_TRACEME, 0, 0, 0) != 0)
+                        err(1, "PTRACE_TRACEME");
+
+                pid_t pid = getpid(), tid = syscall(SYS_gettid);
+
+                printf("\tChild will make one syscall\n");
+                syscall(SYS_tgkill, pid, tid, SIGSTOP);
+
+                syscall(SYS_gettid, 10, 11, 12, 13, 14, 15);
+                _exit(0);
+        }
+        /* Parent process below */
+
+        /* Wait for SIGSTOP sent by tgkill above. */
+        if (waitpid(chld, &status, 0) != chld || !WIFSTOPPED(status))
+                err(1, "waitpid");
+
+        printf("[RUN]\tSYSEMU\n");
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSEMU");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        /*
+         * Ptrace trapped prior to executing the syscall, thus r3 still has
+         * the syscall number instead of the sys_gettid() result
+         */
+        if (regs.user_syscall_nr != SYS_gettid ||
+            regs.user_arg0 != 10 || regs.user_arg1 != 11 ||
+            regs.user_arg2 != 12 || regs.user_arg3 != 13 ||
+            regs.user_arg4 != 14 || regs.user_arg5 != 15) {
+                printf("[FAIL]\tInitial args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n",
+                        (unsigned long)regs.user_syscall_nr,
+                        (unsigned long)regs.user_arg0,
+                        (unsigned long)regs.user_arg1,
+                        (unsigned long)regs.user_arg2,
+                        (unsigned long)regs.user_arg3,
+                        (unsigned long)regs.user_arg4,
+                        (unsigned long)regs.user_arg5);
+                 nerrs++;
+        } else {
+                printf("[OK]\tInitial nr and args are correct\n"); }
+
+        printf("[RUN]\tRestart the syscall (ip = 0x%lx)\n",
+               (unsigned long)regs.user_ip);
+
+        /*
+         * Rewind to retry the same syscall again. This will basically test
+         * the rewind process together with PTRACE_SETREGS and PTRACE_GETREGS.
+         */
+        regs.user_ip -= 4;
+        if (ptrace(PTRACE_SETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_SETREGS");
+
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSEMU");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        if (regs.user_syscall_nr != SYS_gettid ||
+            regs.user_arg0 != 10 || regs.user_arg1 != 11 ||
+            regs.user_arg2 != 12 || regs.user_arg3 != 13 ||
+            regs.user_arg4 != 14 || regs.user_arg5 != 15) {
+                printf("[FAIL]\tRestart nr or args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n",
+                        (unsigned long)regs.user_syscall_nr,
+                        (unsigned long)regs.user_arg0,
+                        (unsigned long)regs.user_arg1,
+                        (unsigned long)regs.user_arg2,
+                        (unsigned long)regs.user_arg3,
+                        (unsigned long)regs.user_arg4,
+                        (unsigned long)regs.user_arg5);
+                nerrs++;
+        } else {
+                printf("[OK]\tRestarted nr and args are correct\n");
+        }
+
+        printf("[RUN]\tChange nr and args and restart the syscall (ip = 0x%lx)\n",
+               (unsigned long)regs.user_ip);
+
+        /*
+         * Inject a new syscall (getpid) in the same place the previous
+         * syscall (gettid), rewind and re-execute.
+         */
+        regs.user_syscall_nr = SYS_getpid;
+        regs.user_arg0 = 20;
+        regs.user_arg1 = 21;
+        regs.user_arg2 = 22;
+        regs.user_arg3 = 23;
+        regs.user_arg4 = 24;
+        regs.user_arg5 = 25;
+        regs.user_ip -= 4;
+
+        if (ptrace(PTRACE_SETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_SETREGS");
+
+        if (ptrace(PTRACE_SYSEMU, chld, 0, 0) != 0)
+                err(1, "PTRACE_SYSEMU");
+        wait_trap(chld);
+
+        if (ptrace(PTRACE_GETREGS, chld, 0, &regs) != 0)
+                err(1, "PTRACE_GETREGS");
+
+        /* Check that ptrace stopped at the new syscall that was
+         * injected, and guarantee that it haven't executed, i.e, user_args
+         * contain the arguments and not the syscall return value, for
+         * instance.
+         */
+        if (regs.user_syscall_nr != SYS_getpid
+                || regs.user_arg0 != 20 || regs.user_arg1 != 21
+                || regs.user_arg2 != 22 || regs.user_arg3 != 23
+                || regs.user_arg4 != 24 || regs.user_arg5 != 25) {
+
+                printf("[FAIL]\tRestart nr or args are wrong (nr=%lu, args=%lu %lu %lu %lu %lu %lu)\n",
+                        (unsigned long)regs.user_syscall_nr,
+                        (unsigned long)regs.user_arg0,
+                        (unsigned long)regs.user_arg1,
+                        (unsigned long)regs.user_arg2,
+                        (unsigned long)regs.user_arg3,
+                        (unsigned long)regs.user_arg4,
+                        (unsigned long)regs.user_arg5);
+                nerrs++;
+        } else {
+                printf("[OK]\tReplacement nr and args are correct\n");
+        }
+
+        if (ptrace(PTRACE_CONT, chld, 0, 0) != 0)
+                err(1, "PTRACE_CONT");
+
+        if (waitpid(chld, &status, 0) != chld)
+                err(1, "waitpid");
+
+        /* Guarantee that the process executed properly, returning 0 */
+        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+                printf("[FAIL]\tChild failed\n");
+                nerrs++;
+        } else {
+                printf("[OK]\tChild exited cleanly\n");
+        }
+}
+
+int ptrace_syscall(void)
+{
+        test_ptrace_syscall_restart();
+
+        return nerrs;
+}
+
+int main(void)
+{
+        return test_harness(ptrace_syscall, "ptrace_syscall");
+}
diff --git a/tools/testing/selftests/powerpc/security/Makefile b/tools/testing/selftests/powerpc/security/Makefile
new file mode 100644
index 000000000000..44690f1bb26a
--- /dev/null
+++ b/tools/testing/selftests/powerpc/security/Makefile
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-2.0+
+
+TEST_GEN_PROGS := rfi_flush
+
+CFLAGS += -I../../../../../usr/include
+
+include ../../lib.mk
+
+$(TEST_GEN_PROGS): ../harness.c ../utils.c
diff --git a/tools/testing/selftests/powerpc/security/rfi_flush.c b/tools/testing/selftests/powerpc/security/rfi_flush.c
new file mode 100644
index 000000000000..564ed45bbf73
--- /dev/null
+++ b/tools/testing/selftests/powerpc/security/rfi_flush.c
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: GPL-2.0+
+
+/*
+ * Copyright 2018 IBM Corporation.
+ */
+
+#define __SANE_USERSPACE_TYPES__
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <malloc.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "utils.h"
+
+#define CACHELINE_SIZE 128
+
+struct perf_event_read {
+        __u64 nr;
+        __u64 l1d_misses;
+};
+
+static inline __u64 load(void *addr)
+{
+        __u64 tmp;
+
+        asm volatile("ld %0,0(%1)" : "=r"(tmp) : "b"(addr));
+
+        return tmp;
+}
+
+static void syscall_loop(char *p, unsigned long iterations,
+                         unsigned long zero_size)
+{
+        for (unsigned long i = 0; i < iterations; i++) {
+                for (unsigned long j = 0; j < zero_size; j += CACHELINE_SIZE)
+                        load(p + j);
+                getppid();
+        }
+}
+
+int rfi_flush_test(void)
+{
+        char *p;
+        int repetitions = 10;
+        int fd, passes = 0, iter, rc = 0;
+        struct perf_event_read v;
+        __u64 l1d_misses_total = 0;
+        unsigned long iterations = 100000, zero_size = 24 * 1024;
+        int rfi_flush_org, rfi_flush;
+
+        SKIP_IF(geteuid() != 0);
+
+        if (read_debugfs_file("powerpc/rfi_flush", &rfi_flush_org)) {
+                perror("Unable to read powerpc/rfi_flush debugfs file");
+                SKIP_IF(1);
+        }
+
+        rfi_flush = rfi_flush_org;
+
+        fd = perf_event_open_counter(PERF_TYPE_RAW, /* L1d miss */ 0x400f0, -1);
+        FAIL_IF(fd < 0);
+
+        p = (char *)memalign(zero_size, CACHELINE_SIZE);
+
+        FAIL_IF(perf_event_enable(fd));
+
+        set_dscr(1);
+
+        iter = repetitions;
+
+again:
+        FAIL_IF(perf_event_reset(fd));
+
+        syscall_loop(p, iterations, zero_size);
+
+        FAIL_IF(read(fd, &v, sizeof(v)) != sizeof(v));
+
+        /* Expect at least zero_size/CACHELINE_SIZE misses per iteration */
+        if (v.l1d_misses >= (iterations * zero_size / CACHELINE_SIZE) && rfi_flush)
+                passes++;
+        else if (v.l1d_misses < iterations && !rfi_flush)
+                passes++;
+
+        l1d_misses_total += v.l1d_misses;
+
+        while (--iter)
+                goto again;
+
+        if (passes < repetitions) {
+                printf("FAIL (L1D misses with rfi_flush=%d: %llu %c %lu) [%d/%d failures]\n",
+                       rfi_flush, l1d_misses_total, rfi_flush ? '<' : '>',
+                       rfi_flush ? (repetitions * iterations * zero_size / CACHELINE_SIZE) : iterations,
+                       repetitions - passes, repetitions);
+                rc = 1;
+        } else
+                printf("PASS (L1D misses with rfi_flush=%d: %llu %c %lu) [%d/%d pass]\n",
+                       rfi_flush, l1d_misses_total, rfi_flush ? '>' : '<',
+                       rfi_flush ? (repetitions * iterations * zero_size / CACHELINE_SIZE) : iterations,
+                       passes, repetitions);
+
+        if (rfi_flush == rfi_flush_org) {
+                rfi_flush = !rfi_flush_org;
+                if (write_debugfs_file("powerpc/rfi_flush", rfi_flush) < 0) {
+                        perror("error writing to powerpc/rfi_flush debugfs file");
+                        return 1;
+                }
+                iter = repetitions;
+                l1d_misses_total = 0;
+                passes = 0;
+                goto again;
+        }
+
+        perf_event_disable(fd);
+        close(fd);
+
+        set_dscr(0);
+
+        if (write_debugfs_file("powerpc/rfi_flush", rfi_flush_org) < 0) {
+                perror("unable to restore original value of powerpc/rfi_flush debugfs file");
+                return 1;
+        }
+
+        return rc;
+}
+
+int main(int argc, char *argv[])
+{
+        return test_harness(rfi_flush_test, "rfi_flush_test");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-tmspr.c b/tools/testing/selftests/powerpc/tm/tm-tmspr.c
index 2bda81c7bf23..df1d7d4b1c89 100644
--- a/tools/testing/selftests/powerpc/tm/tm-tmspr.c
+++ b/tools/testing/selftests/powerpc/tm/tm-tmspr.c
@@ -98,7 +98,7 @@ void texasr(void *in)
 
 int test_tmspr()
 {
-        pthread_t       thread;
+        pthread_t       *thread;
         int             thread_num;
         unsigned long   i;
 
@@ -107,21 +107,28 @@ int test_tmspr()
         /* To cause some context switching */
         thread_num = 10 * sysconf(_SC_NPROCESSORS_ONLN);
 
+        thread = malloc(thread_num * sizeof(pthread_t));
+        if (thread == NULL)
+                return EXIT_FAILURE;
+
         /* Test TFIAR and TFHAR */
-        for (i = 0 ; i < thread_num ; i += 2){
-                if (pthread_create(&thread, NULL, (void*)tfiar_tfhar, (void *)i))
+        for (i = 0; i < thread_num; i += 2) {
+                if (pthread_create(&thread[i], NULL, (void *)tfiar_tfhar,
+                                   (void *)i))
                         return EXIT_FAILURE;
         }
-        if (pthread_join(thread, NULL) != 0)
-                return EXIT_FAILURE;
-
         /* Test TEXASR */
-        for (i = 0 ; i < thread_num ; i++){
-                if (pthread_create(&thread, NULL, (void*)texasr, (void *)i))
+        for (i = 1; i < thread_num; i += 2) {
+                if (pthread_create(&thread[i], NULL, (void *)texasr, (void *)i))
                         return EXIT_FAILURE;
         }
-        if (pthread_join(thread, NULL) != 0)
-                return EXIT_FAILURE;
+
+        for (i = 0; i < thread_num; i++) {
+                if (pthread_join(thread[i], NULL) != 0)
+                        return EXIT_FAILURE;
+        }
+
+        free(thread);
 
         if (passed)
                 return 0;
diff --git a/tools/testing/selftests/powerpc/tm/tm-unavailable.c b/tools/testing/selftests/powerpc/tm/tm-unavailable.c
index 156c8e750259..09894f4ff62e 100644
--- a/tools/testing/selftests/powerpc/tm/tm-unavailable.c
+++ b/tools/testing/selftests/powerpc/tm/tm-unavailable.c
@@ -236,7 +236,8 @@ void *tm_una_ping(void *input)
         }
 
         /* Check if we were not expecting a failure and a it occurred. */
-        if (!expecting_failure() && is_failure(cr_)) {
+        if (!expecting_failure() && is_failure(cr_) &&
+            !failure_is_reschedule()) {
                 printf("\n\tUnexpected transaction failure 0x%02lx\n\t",
                         failure_code());
                 return (void *) -1;
@@ -244,9 +245,11 @@ void *tm_una_ping(void *input)
 
         /*
          * Check if TM failed due to the cause we were expecting. 0xda is a
-         * TM_CAUSE_FAC_UNAV cause, otherwise it's an unexpected cause.
+         * TM_CAUSE_FAC_UNAV cause, otherwise it's an unexpected cause, unless
+         * it was caused by a reschedule.
          */
-        if (is_failure(cr_) && !failure_is_unavailable()) {
+        if (is_failure(cr_) && !failure_is_unavailable() &&
+            !failure_is_reschedule()) {
                 printf("\n\tUnexpected failure cause 0x%02lx\n\t",
                         failure_code());
                 return (void *) -1;
diff --git a/tools/testing/selftests/powerpc/tm/tm.h b/tools/testing/selftests/powerpc/tm/tm.h
index df4204247d45..5518b1d4ef8b 100644
--- a/tools/testing/selftests/powerpc/tm/tm.h
+++ b/tools/testing/selftests/powerpc/tm/tm.h
@@ -52,6 +52,15 @@ static inline bool failure_is_unavailable(void)
         return (failure_code() & TM_CAUSE_FAC_UNAV) == TM_CAUSE_FAC_UNAV;
 }
 
+static inline bool failure_is_reschedule(void)
+{
+        if ((failure_code() & TM_CAUSE_RESCHED) == TM_CAUSE_RESCHED ||
+            (failure_code() & TM_CAUSE_KVM_RESCHED) == TM_CAUSE_KVM_RESCHED)
+                return true;
+
+        return false;
+}
+
 static inline bool failure_is_nesting(void)
 {
         return (__builtin_get_texasru() & 0x400000);
diff --git a/tools/testing/selftests/powerpc/utils.c b/tools/testing/selftests/powerpc/utils.c
index aa8fc1e6365b..43c342845be0 100644
--- a/tools/testing/selftests/powerpc/utils.c
+++ b/tools/testing/selftests/powerpc/utils.c
@@ -10,16 +10,22 @@
 #include <fcntl.h>
 #include <link.h>
 #include <sched.h>
+#include <signal.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <unistd.h>
+#include <asm/unistd.h>
+#include <linux/limits.h>
 
 #include "utils.h"
 
 static char auxv[4096];
+extern unsigned int dscr_insn[];
 
 int read_auxv(char *buf, ssize_t buf_size)
 {
@@ -121,3 +127,149 @@ bool is_ppc64le(void)
 
         return strcmp(uts.machine, "ppc64le") == 0;
 }
+
+int read_debugfs_file(char *debugfs_file, int *result)
+{
+        int rc = -1, fd;
+        char path[PATH_MAX];
+        char value[16];
+
+        strcpy(path, "/sys/kernel/debug/");
+        strncat(path, debugfs_file, PATH_MAX - strlen(path) - 1);
+
+        if ((fd = open(path, O_RDONLY)) < 0)
+                return rc;
+
+        if ((rc = read(fd, value, sizeof(value))) < 0)
+                return rc;
+
+        value[15] = 0;
+        *result = atoi(value);
+        close(fd);
+
+        return 0;
+}
+
+int write_debugfs_file(char *debugfs_file, int result)
+{
+        int rc = -1, fd;
+        char path[PATH_MAX];
+        char value[16];
+
+        strcpy(path, "/sys/kernel/debug/");
+        strncat(path, debugfs_file, PATH_MAX - strlen(path) - 1);
+
+        if ((fd = open(path, O_WRONLY)) < 0)
+                return rc;
+
+        snprintf(value, 16, "%d", result);
+
+        if ((rc = write(fd, value, strlen(value))) < 0)
+                return rc;
+
+        close(fd);
+
+        return 0;
+}
+
+static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
+                int cpu, int group_fd, unsigned long flags)
+{
+        return syscall(__NR_perf_event_open, hw_event, pid, cpu,
+                      group_fd, flags);
+}
+
+static void perf_event_attr_init(struct perf_event_attr *event_attr,
+                                        unsigned int type,
+                                        unsigned long config)
+{
+        memset(event_attr, 0, sizeof(*event_attr));
+
+        event_attr->type = type;
+        event_attr->size = sizeof(struct perf_event_attr);
+        event_attr->config = config;
+        event_attr->read_format = PERF_FORMAT_GROUP;
+        event_attr->disabled = 1;
+        event_attr->exclude_kernel = 1;
+        event_attr->exclude_hv = 1;
+        event_attr->exclude_guest = 1;
+}
+
+int perf_event_open_counter(unsigned int type,
+                            unsigned long config, int group_fd)
+{
+        int fd;
+        struct perf_event_attr event_attr;
+
+        perf_event_attr_init(&event_attr, type, config);
+
+        fd = perf_event_open(&event_attr, 0, -1, group_fd, 0);
+
+        if (fd < 0)
+                perror("perf_event_open() failed");
+
+        return fd;
+}
+
+int perf_event_enable(int fd)
+{
+        if (ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) == -1) {
+                perror("error while enabling perf events");
+                return -1;
+        }
+
+        return 0;
+}
+
+int perf_event_disable(int fd)
+{
+        if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1) {
+                perror("error disabling perf events");
+                return -1;
+        }
+
+        return 0;
+}
+
+int perf_event_reset(int fd)
+{
+        if (ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP) == -1) {
+                perror("error resetting perf events");
+                return -1;
+        }
+
+        return 0;
+}
+
+static void sigill_handler(int signr, siginfo_t *info, void *unused)
+{
+        static int warned = 0;
+        ucontext_t *ctx = (ucontext_t *)unused;
+        unsigned long *pc = &UCONTEXT_NIA(ctx);
+
+        if (*pc == (unsigned long)&dscr_insn) {
+                if (!warned++)
+                        printf("WARNING: Skipping over dscr setup. Consider running 'ppc64_cpu --dscr=1' manually.\n");
+                *pc += 4;
+        } else {
+                printf("SIGILL at %p\n", pc);
+                abort();
+        }
+}
+
+void set_dscr(unsigned long val)
+{
+        static int init = 0;
+        struct sigaction sa;
+
+        if (!init) {
+                memset(&sa, 0, sizeof(sa));
+                sa.sa_sigaction = sigill_handler;
+                sa.sa_flags = SA_SIGINFO;
+                if (sigaction(SIGILL, &sa, NULL))
+                        perror("sigill_handler");
+                init = 1;
+        }
+
+        asm volatile("dscr_insn: mtspr %1,%0" : : "r" (val), "i" (SPRN_DSCR));
+}