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

Pull powerpc updates from Michael Ellerman:
 "Highlights:
   - PowerNV PCI hotplug support.
   - Lots more Power9 support.
   - eBPF JIT support on ppc64le.
   - Lots of cxl updates.
   - Boot code consolidation.

  Bug fixes:
   - Fix spin_unlock_wait() from Boqun Feng
   - Fix stack pointer corruption in __tm_recheckpoint() from Michael
     Neuling
   - Fix multiple bugs in memory_hotplug_max() from Bharata B Rao
   - mm: Ensure "special" zones are empty from Oliver O'Halloran
   - ftrace: Separate the heuristics for checking call sites from
     Michael Ellerman
   - modules: Never restore r2 for a mprofile-kernel style mcount() call
     from Michael Ellerman
   - Fix endianness when reading TCEs from Alexey Kardashevskiy
   - start rtasd before PCI probing from Greg Kurz
   - PCI: rpaphp: Fix slot registration for multiple slots under a PHB
     from Tyrel Datwyler
   - powerpc/mm: Add memory barrier in __hugepte_alloc() from Sukadev
     Bhattiprolu

  Cleanups & fixes:
   - Drop support for MPIC in pseries from Rashmica Gupta
   - Define and use PPC64_ELF_ABI_v2/v1 from Michael Ellerman
   - Remove unused symbols in asm-offsets.c from Rashmica Gupta
   - Fix SRIOV not building without EEH enabled from Russell Currey
   - Remove kretprobe_trampoline_holder from Thiago Jung Bauermann
   - Reduce log level of PCI I/O space warning from Benjamin
     Herrenschmidt
   - Add array bounds checking to crash_shutdown_handlers from Suraj
     Jitindar Singh
   - Avoid -maltivec when using clang integrated assembler from Anton
     Blanchard
   - Fix array overrun in ppc_rtas() syscall from Andrew Donnellan
   - Fix error return value in cmm_mem_going_offline() from Rasmus
     Villemoes
   - export cpu_to_core_id() from Mauricio Faria de Oliveira
   - Remove old symbols from defconfigs from Andrew Donnellan
   - Update obsolete comments in setup_32.c about entry conditions from
     Benjamin Herrenschmidt
   - Add comment explaining the purpose of setup_kdump_trampoline() from
     Benjamin Herrenschmidt
   - Merge the RELOCATABLE config entries for ppc32 and ppc64 from Kevin
     Hao
   - Remove RELOCATABLE_PPC32 from Kevin Hao
   - Fix .long's in tlb-radix.c to more meaningful from Balbir Singh

  Minor cleanups & fixes:
   - Andrew Donnellan, Anna-Maria Gleixner, Anton Blanchard, Benjamin
     Herrenschmidt, Bharata B Rao, Christophe Leroy, Colin Ian King,
     Geliang Tang, Greg Kurz, Madhavan Srinivasan, Michael Ellerman,
     Michael Ellerman, Stephen Rothwell, Stewart Smith.

  Freescale updates from Scott:
   - "Highlights include more 8xx optimizations, device tree updates,
     and MVME7100 support."

  PowerNV PCI hotplug from Gavin Shan:
   - PCI: Add pcibios_setup_bridge()
   - Override pcibios_setup_bridge()
   - Remove PCI_RESET_DELAY_US
   - Move pnv_pci_ioda_setup_opal_tce_kill() around
   - Increase PE# capacity
   - Allocate PE# in reverse order
   - Create PEs in pcibios_setup_bridge()
   - Setup PE for root bus
   - Extend PCI bridge resources
   - Make pnv_ioda_deconfigure_pe() visible
   - Dynamically release PE
   - Update bridge windows on PCI plug
   - Delay populating pdn
   - Support PCI slot ID
   - Use PCI slot reset infrastructure
   - Introduce pnv_pci_get_slot_id()
   - Functions to get/set PCI slot state
   - PCI/hotplug: PowerPC PowerNV PCI hotplug driver
   - Print correct PHB type names

  Power9 idle support from Shreyas B. Prabhu:
   - set power_save func after the idle states are initialized
   - Use PNV_THREAD_WINKLE macro while requesting for winkle
   - make hypervisor state restore a function
   - Rename idle_power7.S to idle_book3s.S
   - Rename reusable idle functions to hardware agnostic names
   - Make pnv_powersave_common more generic
   - abstraction for saving SPRs before entering deep idle states
   - Add platform support for stop instruction
   - cpuidle/powernv: Use CPUIDLE_STATE_MAX instead of MAX_POWERNV_IDLE_STATES
   - cpuidle/powernv: cleanup cpuidle-powernv.c
   - cpuidle/powernv: Add support for POWER ISA v3 idle states
   - Use deepest stop state when cpu is offlined

  Power9 PMU from Madhavan Srinivasan:
   - factor out power8 pmu macros and defines
   - factor out power8 pmu functions
   - factor out power8 __init_pmu code
   - Add power9 event list macros for generic and cache events
   - Power9 PMU support
   - Export Power9 generic and cache events to sysfs

  Power9 preliminary interrupt & PCI support from Benjamin Herrenschmidt:
   - Add XICS emulation APIs
   - Move a few exception common handlers to make room
   - Add support for HV virtualization interrupts
   - Add mechanism to force a replay of interrupts
   - Add ICP OPAL backend
   - Discover IODA3 PHBs
   - pci: Remove obsolete SW invalidate
   - opal: Add real mode call wrappers
   - Rename TCE invalidation calls
   - Remove SWINV constants and obsolete TCE code
   - Rework accessing the TCE invalidate register
   - Fallback to OPAL for TCE invalidations
   - Use the device-tree to get available range of M64's
   - Check status of a PHB before using it
   - pci: Don't try to allocate resources that will be reassigned

  Other Power9:
   - Send SIGBUS on unaligned copy and paste from Chris Smart
   - Large Decrementer support from Oliver O'Halloran
   - Load Monitor Register Support from Jack Miller

  Performance improvements from Anton Blanchard:
   - Avoid load hit store in __giveup_fpu() and __giveup_altivec()
   - Avoid load hit store in setup_sigcontext()
   - Remove assembly versions of strcpy, strcat, strlen and strcmp
   - Align hot loops of some string functions

  eBPF JIT from Naveen N. Rao:
   - Fix/enhance 32-bit Load Immediate implementation
   - Optimize 64-bit Immediate loads
   - Introduce rotate immediate instructions
   - A few cleanups
   - Isolate classic BPF JIT specifics into a separate header
   - Implement JIT compiler for extended BPF

  Operator Panel driver from Suraj Jitindar Singh:
   - devicetree/bindings: Add binding for operator panel on FSP machines
   - Add inline function to get rc from an ASYNC_COMP opal_msg
   - Add driver for operator panel on FSP machines

  Sparse fixes from Daniel Axtens:
   - make some things static
   - Introduce asm-prototypes.h
   - Include headers containing prototypes
   - Use #ifdef __BIG_ENDIAN__ #else for REG_BYTE
   - kvm: Clarify __user annotations
   - Pass endianness to sparse
   - Make ppc_md.{halt, restart} __noreturn

  MM fixes & cleanups from Aneesh Kumar K.V:
   - radix: Update LPCR HR bit as per ISA
   - use _raw variant of page table accessors
   - Compile out radix related functions if RADIX_MMU is disabled
   - Clear top 16 bits of va only on older cpus
   - Print formation regarding the the MMU mode
   - hash: Update SDR1 size encoding as documented in ISA 3.0
   - radix: Update PID switch sequence
   - radix: Update machine call back to support new HCALL.
   - radix: Add LPID based tlb flush helpers
   - radix: Add a kernel command line to disable radix
   - Cleanup LPCR defines

  Boot code consolidation from Benjamin Herrenschmidt:
   - Move epapr_paravirt_early_init() to early_init_devtree()
   - cell: Don't use flat device-tree after boot
   - ge_imp3a: Don't use the flat device-tree after boot
   - mpc85xx_ds: Don't use the flat device-tree after boot
   - mpc85xx_rdb: Don't use the flat device-tree after boot
   - Don't test for machine type in rtas_initialize()
   - Don't test for machine type in smp_setup_cpu_maps()
   - dt: Add of_device_compatible_match()
   - Factor do_feature_fixup calls
   - Move 64-bit feature fixup earlier
   - Move 64-bit memory reserves to setup_arch()
   - Use a cachable DART
   - Move FW feature probing out of pseries probe()
   - Put exception configuration in a common place
   - Remove early allocation of the SMU command buffer
   - Move MMU backend selection out of platform code
   - pasemi: Remove IOBMAP allocation from platform probe()
   - mm/hash: Don't use machine_is() early during boot
   - Don't test for machine type to detect HEA special case
   - pmac: Remove spurrious machine type test
   - Move hash table ops to a separate structure
   - Ensure that ppc_md is empty before probing for machine type
   - Move 64-bit probe_machine() to later in the boot process
   - Move 32-bit probe() machine to later in the boot process
   - Get rid of ppc_md.init_early()
   - Move the boot time info banner to a separate function
   - Move setting of {i,d}cache_bsize to initialize_cache_info()
   - Move the content of setup_system() to setup_arch()
   - Move cache info inits to a separate function
   - Re-order the call to smp_setup_cpu_maps()
   - Re-order setup_panic()
   - Make a few boot functions __init
   - Merge 32-bit and 64-bit setup_arch()

  Other new features:
   - tty/hvc: Use IRQF_SHARED for OPAL hvc consoles from Sam Mendoza-Jonas
   - tty/hvc: Use opal irqchip interface if available from Sam Mendoza-Jonas
   - powerpc: Add module autoloading based on CPU features from Alastair D'Silva
   - crypto: vmx - Convert to CPU feature based module autoloading from Alastair D'Silva
   - Wake up kopald polling thread before waiting for events from Benjamin Herrenschmidt
   - xmon: Dump ISA 2.06 SPRs from Michael Ellerman
   - xmon: Dump ISA 2.07 SPRs from Michael Ellerman
   - Add a parameter to disable 1TB segs from Oliver O'Halloran
   - powerpc/boot: Add OPAL console to epapr wrappers from Oliver O'Halloran
   - Assign fixed PHB number based on device-tree properties from Guilherme G. Piccoli
   - pseries: Add pseries hotplug workqueue from John Allen
   - pseries: Add support for hotplug interrupt source from John Allen
   - pseries: Use kernel hotplug queue for PowerVM hotplug events from John Allen
   - pseries: Move property cloning into its own routine from Nathan Fontenot
   - pseries: Dynamic add entires to associativity lookup array from Nathan Fontenot
   - pseries: Auto-online hotplugged memory from Nathan Fontenot
   - pseries: Remove call to memblock_add() from Nathan Fontenot

  cxl:
   - Add set and get private data to context struct from Michael Neuling
   - make base more explicitly non-modular from Paul Gortmaker
   - Use for_each_compatible_node() macro from Wei Yongjun
   - Frederic Barrat
   - Abstract the differences between the PSL and XSL
   - Make vPHB device node match adapter's
   - Philippe Bergheaud
   - Add mechanism for delivering AFU driver specific events
   - Ignore CAPI adapters misplaced in switched slots
   - Refine slice error debug messages
   - Andrew Donnellan
   - static-ify variables to fix sparse warnings
   - PCI/hotplug: pnv_php: export symbols and move struct types needed by cxl
   - PCI/hotplug: pnv_php: handle OPAL_PCI_SLOT_OFFLINE power state
   - Add cxl_check_and_switch_mode() API to switch bi-modal cards
   - remove dead Kconfig options
   - fix potential NULL dereference in free_adapter()
   - Ian Munsie
   - Update process element after allocating interrupts
   - Add support for CAPP DMA mode
   - Fix allowing bogus AFU descriptors with 0 maximum processes
   - Fix allocating a minimum of 2 pages for the SPA
   - Fix bug where AFU disable operation had no effect
   - Workaround XSL bug that does not clear the RA bit after a reset
   - Fix NULL pointer dereference on kernel contexts with no AFU interrupts
   - powerpc/powernv: Split cxl code out into a separate file
   - Add cxl_slot_is_supported API
   - Enable bus mastering for devices using CAPP DMA mode
   - Move cxl_afu_get / cxl_afu_put to base
   - Allow a default context to be associated with an external pci_dev
   - Do not create vPHB if there are no AFU configuration records
   - powerpc/powernv: Add support for the cxl kernel api on the real phb
   - Add support for using the kernel API with a real PHB
   - Add kernel APIs to get & set the max irqs per context
   - Add preliminary workaround for CX4 interrupt limitation
   - Add support for interrupts on the Mellanox CX4
   - Workaround PE=0 hardware limitation in Mellanox CX4
   - powerpc/powernv: Fix pci-cxl.c build when CONFIG_MODULES=n

  selftests:
   - Test unaligned copy and paste from Chris Smart
   - Load Monitor Register Tests from Jack Miller
   - Cyril Bur
   - exec() with suspended transaction
   - Use signed long to read perf_event_paranoid
   - Fix usage message in context_switch
   - Fix generation of vector instructions/types in context_switch
   - Michael Ellerman
   - Use "Delta" rather than "Error" in normal output
   - Import Anton's mmap & futex micro benchmarks
   - Add a test for PROT_SAO"

* tag 'powerpc-4.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux: (263 commits)
  powerpc/mm: Parenthesise IS_ENABLED() in if condition
  tty/hvc: Use opal irqchip interface if available
  tty/hvc: Use IRQF_SHARED for OPAL hvc consoles
  selftests/powerpc: exec() with suspended transaction
  powerpc: Improve comment explaining why we modify VRSAVE
  powerpc/mm: Drop unused externs for hpte_init_beat[_v3]()
  powerpc/mm: Rename hpte_init_lpar() and move the fallback to a header
  powerpc/mm: Fix build break when PPC_NATIVE=n
  crypto: vmx - Convert to CPU feature based module autoloading
  powerpc: Add module autoloading based on CPU features
  powerpc/powernv/ioda: Fix endianness when reading TCEs
  powerpc/mm: Add memory barrier in __hugepte_alloc()
  powerpc/modules: Never restore r2 for a mprofile-kernel style mcount() call
  powerpc/ftrace: Separate the heuristics for checking call sites
  powerpc: Merge 32-bit and 64-bit setup_arch()
  powerpc/64: Make a few boot functions __init
  powerpc: Re-order setup_panic()
  powerpc: Re-order the call to smp_setup_cpu_maps()
  powerpc/32: Move cache info inits to a separate function
  powerpc/64: Move the content of setup_system() to setup_arch()
  ...

4 files changed, 739 insertions, 5 deletions

diff --git a/drivers/pci/hotplug/Kconfig b/drivers/pci/hotplug/Kconfig
index df8caec59789..aadce45a9b4a 100644
--- a/drivers/pci/hotplug/Kconfig
+++ b/drivers/pci/hotplug/Kconfig
@@ -113,6 +113,19 @@ config HOTPLUG_PCI_SHPC
 
           When in doubt, say N.
 
+config HOTPLUG_PCI_POWERNV
+        tristate "PowerPC PowerNV PCI Hotplug driver"
+        depends on PPC_POWERNV && EEH
+        select OF_DYNAMIC
+        help
+          Say Y here if you run PowerPC PowerNV platform that supports
+          PCI Hotplug
+
+          To compile this driver as a module, choose M here: the
+          module will be called pnv-php.
+
+          When in doubt, say N.
+
 config HOTPLUG_PCI_RPA
         tristate "RPA PCI Hotplug driver"
         depends on PPC_PSERIES && EEH
diff --git a/drivers/pci/hotplug/Makefile b/drivers/pci/hotplug/Makefile
index b616e7588ff4..e33cdda45a4d 100644
--- a/drivers/pci/hotplug/Makefile
+++ b/drivers/pci/hotplug/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_HOTPLUG_PCI_PCIE)		+= pciehp.o
 obj-$(CONFIG_HOTPLUG_PCI_CPCI_ZT5550)   += cpcihp_zt5550.o
 obj-$(CONFIG_HOTPLUG_PCI_CPCI_GENERIC)  += cpcihp_generic.o
 obj-$(CONFIG_HOTPLUG_PCI_SHPC)          += shpchp.o
+obj-$(CONFIG_HOTPLUG_PCI_POWERNV)       += pnv-php.o
 obj-$(CONFIG_HOTPLUG_PCI_RPA)           += rpaphp.o
 obj-$(CONFIG_HOTPLUG_PCI_RPA_DLPAR)     += rpadlpar_io.o
 obj-$(CONFIG_HOTPLUG_PCI_SGI)           += sgi_hotplug.o
@@ -50,6 +51,8 @@ ibmphp-objs		:=	ibmphp_core.o	\
 acpiphp-objs            :=      acpiphp_core.o  \
                                 acpiphp_glue.o
 
+pnv-php-objs            :=      pnv_php.o
+
 rpaphp-objs             :=      rpaphp_core.o   \
                                 rpaphp_pci.o    \
                                 rpaphp_slot.o
diff --git a/drivers/pci/hotplug/pnv_php.c b/drivers/pci/hotplug/pnv_php.c
new file mode 100644
index 000000000000..e6245b03f0a1
--- /dev/null
+++ b/drivers/pci/hotplug/pnv_php.c
@@ -0,0 +1,711 @@
+/*
+ * PCI Hotplug Driver for PowerPC PowerNV platform.
+ *
+ * Copyright Gavin Shan, IBM Corporation 2016.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/libfdt.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/pci_hotplug.h>
+
+#include <asm/opal.h>
+#include <asm/pnv-pci.h>
+#include <asm/ppc-pci.h>
+
+#define DRIVER_VERSION  "0.1"
+#define DRIVER_AUTHOR   "Gavin Shan, IBM Corporation"
+#define DRIVER_DESC     "PowerPC PowerNV PCI Hotplug Driver"
+
+static LIST_HEAD(pnv_php_slot_list);
+static DEFINE_SPINLOCK(pnv_php_lock);
+
+static void pnv_php_register(struct device_node *dn);
+static void pnv_php_unregister_one(struct device_node *dn);
+static void pnv_php_unregister(struct device_node *dn);
+
+static void pnv_php_free_slot(struct kref *kref)
+{
+        struct pnv_php_slot *php_slot = container_of(kref,
+                                        struct pnv_php_slot, kref);
+
+        WARN_ON(!list_empty(&php_slot->children));
+        kfree(php_slot->name);
+        kfree(php_slot);
+}
+
+static inline void pnv_php_put_slot(struct pnv_php_slot *php_slot)
+{
+
+        if (WARN_ON(!php_slot))
+                return;
+
+        kref_put(&php_slot->kref, pnv_php_free_slot);
+}
+
+static struct pnv_php_slot *pnv_php_match(struct device_node *dn,
+                                          struct pnv_php_slot *php_slot)
+{
+        struct pnv_php_slot *target, *tmp;
+
+        if (php_slot->dn == dn) {
+                kref_get(&php_slot->kref);
+                return php_slot;
+        }
+
+        list_for_each_entry(tmp, &php_slot->children, link) {
+                target = pnv_php_match(dn, tmp);
+                if (target)
+                        return target;
+        }
+
+        return NULL;
+}
+
+struct pnv_php_slot *pnv_php_find_slot(struct device_node *dn)
+{
+        struct pnv_php_slot *php_slot, *tmp;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pnv_php_lock, flags);
+        list_for_each_entry(tmp, &pnv_php_slot_list, link) {
+                php_slot = pnv_php_match(dn, tmp);
+                if (php_slot) {
+                        spin_unlock_irqrestore(&pnv_php_lock, flags);
+                        return php_slot;
+                }
+        }
+        spin_unlock_irqrestore(&pnv_php_lock, flags);
+
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(pnv_php_find_slot);
+
+/*
+ * Remove pdn for all children of the indicated device node.
+ * The function should remove pdn in a depth-first manner.
+ */
+static void pnv_php_rmv_pdns(struct device_node *dn)
+{
+        struct device_node *child;
+
+        for_each_child_of_node(dn, child) {
+                pnv_php_rmv_pdns(child);
+
+                pci_remove_device_node_info(child);
+        }
+}
+
+/*
+ * Detach all child nodes of the indicated device nodes. The
+ * function should handle device nodes in depth-first manner.
+ *
+ * We should not invoke of_node_release() as the memory for
+ * individual device node is part of large memory block. The
+ * large block is allocated from memblock (system bootup) or
+ * kmalloc() when unflattening the device tree by OF changeset.
+ * We can not free the large block allocated from memblock. For
+ * later case, it should be released at once.
+ */
+static void pnv_php_detach_device_nodes(struct device_node *parent)
+{
+        struct device_node *dn;
+        int refcount;
+
+        for_each_child_of_node(parent, dn) {
+                pnv_php_detach_device_nodes(dn);
+
+                of_node_put(dn);
+                refcount = atomic_read(&dn->kobj.kref.refcount);
+                if (unlikely(refcount != 1))
+                        pr_warn("Invalid refcount %d on <%s>\n",
+                                refcount, of_node_full_name(dn));
+
+                of_detach_node(dn);
+        }
+}
+
+static void pnv_php_rmv_devtree(struct pnv_php_slot *php_slot)
+{
+        pnv_php_rmv_pdns(php_slot->dn);
+
+        /*
+         * Decrease the refcount if the device nodes were created
+         * through OF changeset before detaching them.
+         */
+        if (php_slot->fdt)
+                of_changeset_destroy(&php_slot->ocs);
+        pnv_php_detach_device_nodes(php_slot->dn);
+
+        if (php_slot->fdt) {
+                kfree(php_slot->dt);
+                kfree(php_slot->fdt);
+                php_slot->dt        = NULL;
+                php_slot->dn->child = NULL;
+                php_slot->fdt       = NULL;
+        }
+}
+
+/*
+ * As the nodes in OF changeset are applied in reverse order, we
+ * need revert the nodes in advance so that we have correct node
+ * order after the changeset is applied.
+ */
+static void pnv_php_reverse_nodes(struct device_node *parent)
+{
+        struct device_node *child, *next;
+
+        /* In-depth first */
+        for_each_child_of_node(parent, child)
+                pnv_php_reverse_nodes(child);
+
+        /* Reverse the nodes in the child list */
+        child = parent->child;
+        parent->child = NULL;
+        while (child) {
+                next = child->sibling;
+
+                child->sibling = parent->child;
+                parent->child = child;
+                child = next;
+        }
+}
+
+static int pnv_php_populate_changeset(struct of_changeset *ocs,
+                                      struct device_node *dn)
+{
+        struct device_node *child;
+        int ret = 0;
+
+        for_each_child_of_node(dn, child) {
+                ret = of_changeset_attach_node(ocs, child);
+                if (unlikely(ret))
+                        break;
+
+                ret = pnv_php_populate_changeset(ocs, child);
+                if (unlikely(ret))
+                        break;
+        }
+
+        return ret;
+}
+
+static void *pnv_php_add_one_pdn(struct device_node *dn, void *data)
+{
+        struct pci_controller *hose = (struct pci_controller *)data;
+        struct pci_dn *pdn;
+
+        pdn = pci_add_device_node_info(hose, dn);
+        if (unlikely(!pdn))
+                return ERR_PTR(-ENOMEM);
+
+        return NULL;
+}
+
+static void pnv_php_add_pdns(struct pnv_php_slot *slot)
+{
+        struct pci_controller *hose = pci_bus_to_host(slot->bus);
+
+        pci_traverse_device_nodes(slot->dn, pnv_php_add_one_pdn, hose);
+}
+
+static int pnv_php_add_devtree(struct pnv_php_slot *php_slot)
+{
+        void *fdt, *fdt1, *dt;
+        int ret;
+
+        /* We don't know the FDT blob size. We try to get it through
+         * maximal memory chunk and then copy it to another chunk that
+         * fits the real size.
+         */
+        fdt1 = kzalloc(0x10000, GFP_KERNEL);
+        if (unlikely(!fdt1)) {
+                ret = -ENOMEM;
+                dev_warn(&php_slot->pdev->dev, "Cannot alloc FDT blob\n");
+                goto out;
+        }
+
+        ret = pnv_pci_get_device_tree(php_slot->dn->phandle, fdt1, 0x10000);
+        if (unlikely(ret)) {
+                dev_warn(&php_slot->pdev->dev, "Error %d getting FDT blob\n",
+                         ret);
+                goto free_fdt1;
+        }
+
+        fdt = kzalloc(fdt_totalsize(fdt1), GFP_KERNEL);
+        if (unlikely(!fdt)) {
+                ret = -ENOMEM;
+                dev_warn(&php_slot->pdev->dev, "Cannot %d bytes memory\n",
+                         fdt_totalsize(fdt1));
+                goto free_fdt1;
+        }
+
+        /* Unflatten device tree blob */
+        memcpy(fdt, fdt1, fdt_totalsize(fdt1));
+        dt = of_fdt_unflatten_tree(fdt, php_slot->dn, NULL);
+        if (unlikely(!dt)) {
+                ret = -EINVAL;
+                dev_warn(&php_slot->pdev->dev, "Cannot unflatten FDT\n");
+                goto free_fdt;
+        }
+
+        /* Initialize and apply the changeset */
+        of_changeset_init(&php_slot->ocs);
+        pnv_php_reverse_nodes(php_slot->dn);
+        ret = pnv_php_populate_changeset(&php_slot->ocs, php_slot->dn);
+        if (unlikely(ret)) {
+                pnv_php_reverse_nodes(php_slot->dn);
+                dev_warn(&php_slot->pdev->dev, "Error %d populating changeset\n",
+                         ret);
+                goto free_dt;
+        }
+
+        php_slot->dn->child = NULL;
+        ret = of_changeset_apply(&php_slot->ocs);
+        if (unlikely(ret)) {
+                dev_warn(&php_slot->pdev->dev, "Error %d applying changeset\n",
+                         ret);
+                goto destroy_changeset;
+        }
+
+        /* Add device node firmware data */
+        pnv_php_add_pdns(php_slot);
+        php_slot->fdt = fdt;
+        php_slot->dt  = dt;
+        kfree(fdt1);
+        goto out;
+
+destroy_changeset:
+        of_changeset_destroy(&php_slot->ocs);
+free_dt:
+        kfree(dt);
+        php_slot->dn->child = NULL;
+free_fdt:
+        kfree(fdt);
+free_fdt1:
+        kfree(fdt1);
+out:
+        return ret;
+}
+
+int pnv_php_set_slot_power_state(struct hotplug_slot *slot,
+                                 uint8_t state)
+{
+        struct pnv_php_slot *php_slot = slot->private;
+        struct opal_msg msg;
+        int ret;
+
+        ret = pnv_pci_set_power_state(php_slot->id, state, &msg);
+        if (likely(ret > 0)) {
+                if (be64_to_cpu(msg.params[1]) != php_slot->dn->phandle ||
+                    be64_to_cpu(msg.params[2]) != state                 ||
+                    be64_to_cpu(msg.params[3]) != OPAL_SUCCESS) {
+                        dev_warn(&php_slot->pdev->dev, "Wrong msg (%lld, %lld, %lld)\n",
+                                 be64_to_cpu(msg.params[1]),
+                                 be64_to_cpu(msg.params[2]),
+                                 be64_to_cpu(msg.params[3]));
+                        return -ENOMSG;
+                }
+        } else if (unlikely(ret < 0)) {
+                dev_warn(&php_slot->pdev->dev, "Error %d powering %s\n",
+                         ret, (state == OPAL_PCI_SLOT_POWER_ON) ? "on" : "off");
+                return ret;
+        }
+
+        if (state == OPAL_PCI_SLOT_POWER_OFF || state == OPAL_PCI_SLOT_OFFLINE)
+                pnv_php_rmv_devtree(php_slot);
+        else
+                ret = pnv_php_add_devtree(php_slot);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pnv_php_set_slot_power_state);
+
+static int pnv_php_get_power_state(struct hotplug_slot *slot, u8 *state)
+{
+        struct pnv_php_slot *php_slot = slot->private;
+        uint8_t power_state = OPAL_PCI_SLOT_POWER_ON;
+        int ret;
+
+        /*
+         * Retrieve power status from firmware. If we fail
+         * getting that, the power status fails back to
+         * be on.
+         */
+        ret = pnv_pci_get_power_state(php_slot->id, &power_state);
+        if (unlikely(ret)) {
+                dev_warn(&php_slot->pdev->dev, "Error %d getting power status\n",
+                         ret);
+        } else {
+                *state = power_state;
+                slot->info->power_status = power_state;
+        }
+
+        return 0;
+}
+
+static int pnv_php_get_adapter_state(struct hotplug_slot *slot, u8 *state)
+{
+        struct pnv_php_slot *php_slot = slot->private;
+        uint8_t presence = OPAL_PCI_SLOT_EMPTY;
+        int ret;
+
+        /*
+         * Retrieve presence status from firmware. If we can't
+         * get that, it will fail back to be empty.
+         */
+        ret = pnv_pci_get_presence_state(php_slot->id, &presence);
+        if (likely(ret >= 0)) {
+                *state = presence;
+                slot->info->adapter_status = presence;
+                ret = 0;
+        } else {
+                dev_warn(&php_slot->pdev->dev, "Error %d getting presence\n",
+                         ret);
+        }
+
+        return ret;
+}
+
+static int pnv_php_set_attention_state(struct hotplug_slot *slot, u8 state)
+{
+        /* FIXME: Make it real once firmware supports it */
+        slot->info->attention_status = state;
+
+        return 0;
+}
+
+static int pnv_php_enable(struct pnv_php_slot *php_slot, bool rescan)
+{
+        struct hotplug_slot *slot = &php_slot->slot;
+        uint8_t presence = OPAL_PCI_SLOT_EMPTY;
+        uint8_t power_status = OPAL_PCI_SLOT_POWER_ON;
+        int ret;
+
+        /* Check if the slot has been configured */
+        if (php_slot->state != PNV_PHP_STATE_REGISTERED)
+                return 0;
+
+        /* Retrieve slot presence status */
+        ret = pnv_php_get_adapter_state(slot, &presence);
+        if (unlikely(ret))
+                return ret;
+
+        /* Proceed if there have nothing behind the slot */
+        if (presence == OPAL_PCI_SLOT_EMPTY)
+                goto scan;
+
+        /*
+         * If the power supply to the slot is off, we can't detect
+         * adapter presence state. That means we have to turn the
+         * slot on before going to probe slot's presence state.
+         *
+         * On the first time, we don't change the power status to
+         * boost system boot with assumption that the firmware
+         * supplies consistent slot power status: empty slot always
+         * has its power off and non-empty slot has its power on.
+         */
+        if (!php_slot->power_state_check) {
+                php_slot->power_state_check = true;
+
+                ret = pnv_php_get_power_state(slot, &power_status);
+                if (unlikely(ret))
+                        return ret;
+
+                if (power_status != OPAL_PCI_SLOT_POWER_ON)
+                        return 0;
+        }
+
+        /* Check the power status. Scan the slot if it is already on */
+        ret = pnv_php_get_power_state(slot, &power_status);
+        if (unlikely(ret))
+                return ret;
+
+        if (power_status == OPAL_PCI_SLOT_POWER_ON)
+                goto scan;
+
+        /* Power is off, turn it on and then scan the slot */
+        ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_ON);
+        if (unlikely(ret))
+                return ret;
+
+scan:
+        if (presence == OPAL_PCI_SLOT_PRESENT) {
+                if (rescan) {
+                        pci_lock_rescan_remove();
+                        pci_hp_add_devices(php_slot->bus);
+                        pci_unlock_rescan_remove();
+                }
+
+                /* Rescan for child hotpluggable slots */
+                php_slot->state = PNV_PHP_STATE_POPULATED;
+                if (rescan)
+                        pnv_php_register(php_slot->dn);
+        } else {
+                php_slot->state = PNV_PHP_STATE_POPULATED;
+        }
+
+        return 0;
+}
+
+static int pnv_php_enable_slot(struct hotplug_slot *slot)
+{
+        struct pnv_php_slot *php_slot = container_of(slot,
+                                                     struct pnv_php_slot, slot);
+
+        return pnv_php_enable(php_slot, true);
+}
+
+static int pnv_php_disable_slot(struct hotplug_slot *slot)
+{
+        struct pnv_php_slot *php_slot = slot->private;
+        int ret;
+
+        if (php_slot->state != PNV_PHP_STATE_POPULATED)
+                return 0;
+
+        /* Remove all devices behind the slot */
+        pci_lock_rescan_remove();
+        pci_hp_remove_devices(php_slot->bus);
+        pci_unlock_rescan_remove();
+
+        /* Detach the child hotpluggable slots */
+        pnv_php_unregister(php_slot->dn);
+
+        /* Notify firmware and remove device nodes */
+        ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_OFF);
+
+        php_slot->state = PNV_PHP_STATE_REGISTERED;
+        return ret;
+}
+
+static struct hotplug_slot_ops php_slot_ops = {
+        .get_power_status       = pnv_php_get_power_state,
+        .get_adapter_status     = pnv_php_get_adapter_state,
+        .set_attention_status   = pnv_php_set_attention_state,
+        .enable_slot            = pnv_php_enable_slot,
+        .disable_slot           = pnv_php_disable_slot,
+};
+
+static void pnv_php_release(struct hotplug_slot *slot)
+{
+        struct pnv_php_slot *php_slot = slot->private;
+        unsigned long flags;
+
+        /* Remove from global or child list */
+        spin_lock_irqsave(&pnv_php_lock, flags);
+        list_del(&php_slot->link);
+        spin_unlock_irqrestore(&pnv_php_lock, flags);
+
+        /* Detach from parent */
+        pnv_php_put_slot(php_slot);
+        pnv_php_put_slot(php_slot->parent);
+}
+
+static struct pnv_php_slot *pnv_php_alloc_slot(struct device_node *dn)
+{
+        struct pnv_php_slot *php_slot;
+        struct pci_bus *bus;
+        const char *label;
+        uint64_t id;
+
+        label = of_get_property(dn, "ibm,slot-label", NULL);
+        if (unlikely(!label))
+                return NULL;
+
+        if (pnv_pci_get_slot_id(dn, &id))
+                return NULL;
+
+        bus = pci_find_bus_by_node(dn);
+        if (unlikely(!bus))
+                return NULL;
+
+        php_slot = kzalloc(sizeof(*php_slot), GFP_KERNEL);
+        if (unlikely(!php_slot))
+                return NULL;
+
+        php_slot->name = kstrdup(label, GFP_KERNEL);
+        if (unlikely(!php_slot->name)) {
+                kfree(php_slot);
+                return NULL;
+        }
+
+        if (likely(dn->child && PCI_DN(dn->child)))
+                php_slot->slot_no = PCI_SLOT(PCI_DN(dn->child)->devfn);
+        else
+                php_slot->slot_no = -1;   /* Placeholder slot */
+
+        kref_init(&php_slot->kref);
+        php_slot->state                 = PNV_PHP_STATE_INITIALIZED;
+        php_slot->dn                    = dn;
+        php_slot->pdev                  = bus->self;
+        php_slot->bus                   = bus;
+        php_slot->id                    = id;
+        php_slot->power_state_check     = false;
+        php_slot->slot.ops              = &php_slot_ops;
+        php_slot->slot.info             = &php_slot->slot_info;
+        php_slot->slot.release          = pnv_php_release;
+        php_slot->slot.private          = php_slot;
+
+        INIT_LIST_HEAD(&php_slot->children);
+        INIT_LIST_HEAD(&php_slot->link);
+
+        return php_slot;
+}
+
+static int pnv_php_register_slot(struct pnv_php_slot *php_slot)
+{
+        struct pnv_php_slot *parent;
+        struct device_node *dn = php_slot->dn;
+        unsigned long flags;
+        int ret;
+
+        /* Check if the slot is registered or not */
+        parent = pnv_php_find_slot(php_slot->dn);
+        if (unlikely(parent)) {
+                pnv_php_put_slot(parent);
+                return -EEXIST;
+        }
+
+        /* Register PCI slot */
+        ret = pci_hp_register(&php_slot->slot, php_slot->bus,
+                              php_slot->slot_no, php_slot->name);
+        if (unlikely(ret)) {
+                dev_warn(&php_slot->pdev->dev, "Error %d registering slot\n",
+                         ret);
+                return ret;
+        }
+
+        /* Attach to the parent's child list or global list */
+        while ((dn = of_get_parent(dn))) {
+                if (!PCI_DN(dn)) {
+                        of_node_put(dn);
+                        break;
+                }
+
+                parent = pnv_php_find_slot(dn);
+                if (parent) {
+                        of_node_put(dn);
+                        break;
+                }
+
+                of_node_put(dn);
+        }
+
+        spin_lock_irqsave(&pnv_php_lock, flags);
+        php_slot->parent = parent;
+        if (parent)
+                list_add_tail(&php_slot->link, &parent->children);
+        else
+                list_add_tail(&php_slot->link, &pnv_php_slot_list);
+        spin_unlock_irqrestore(&pnv_php_lock, flags);
+
+        php_slot->state = PNV_PHP_STATE_REGISTERED;
+        return 0;
+}
+
+static int pnv_php_register_one(struct device_node *dn)
+{
+        struct pnv_php_slot *php_slot;
+        const __be32 *prop32;
+        int ret;
+
+        /* Check if it's hotpluggable slot */
+        prop32 = of_get_property(dn, "ibm,slot-pluggable", NULL);
+        if (!prop32 || !of_read_number(prop32, 1))
+                return -ENXIO;
+
+        prop32 = of_get_property(dn, "ibm,reset-by-firmware", NULL);
+        if (!prop32 || !of_read_number(prop32, 1))
+                return -ENXIO;
+
+        php_slot = pnv_php_alloc_slot(dn);
+        if (unlikely(!php_slot))
+                return -ENODEV;
+
+        ret = pnv_php_register_slot(php_slot);
+        if (unlikely(ret))
+                goto free_slot;
+
+        ret = pnv_php_enable(php_slot, false);
+        if (unlikely(ret))
+                goto unregister_slot;
+
+        return 0;
+
+unregister_slot:
+        pnv_php_unregister_one(php_slot->dn);
+free_slot:
+        pnv_php_put_slot(php_slot);
+        return ret;
+}
+
+static void pnv_php_register(struct device_node *dn)
+{
+        struct device_node *child;
+
+        /*
+         * The parent slots should be registered before their
+         * child slots.
+         */
+        for_each_child_of_node(dn, child) {
+                pnv_php_register_one(child);
+                pnv_php_register(child);
+        }
+}
+
+static void pnv_php_unregister_one(struct device_node *dn)
+{
+        struct pnv_php_slot *php_slot;
+
+        php_slot = pnv_php_find_slot(dn);
+        if (!php_slot)
+                return;
+
+        php_slot->state = PNV_PHP_STATE_OFFLINE;
+        pnv_php_put_slot(php_slot);
+        pci_hp_deregister(&php_slot->slot);
+}
+
+static void pnv_php_unregister(struct device_node *dn)
+{
+        struct device_node *child;
+
+        /* The child slots should go before their parent slots */
+        for_each_child_of_node(dn, child) {
+                pnv_php_unregister(child);
+                pnv_php_unregister_one(child);
+        }
+}
+
+static int __init pnv_php_init(void)
+{
+        struct device_node *dn;
+
+        pr_info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
+        for_each_compatible_node(dn, NULL, "ibm,ioda2-phb")
+                pnv_php_register(dn);
+
+        return 0;
+}
+
+static void __exit pnv_php_exit(void)
+{
+        struct device_node *dn;
+
+        for_each_compatible_node(dn, NULL, "ibm,ioda2-phb")
+                pnv_php_unregister(dn);
+}
+
+module_init(pnv_php_init);
+module_exit(pnv_php_exit);
+
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/pci/hotplug/rpaphp_slot.c b/drivers/pci/hotplug/rpaphp_slot.c
index 6937c725b00b..388c4d8fcdd1 100644
--- a/drivers/pci/hotplug/rpaphp_slot.c
+++ b/drivers/pci/hotplug/rpaphp_slot.c
@@ -117,8 +117,10 @@ EXPORT_SYMBOL_GPL(rpaphp_deregister_slot);
 int rpaphp_register_slot(struct slot *slot)
 {
         struct hotplug_slot *php_slot = slot->hotplug_slot;
+        struct device_node *child;
+        u32 my_index;
         int retval;
-        int slotno;
+        int slotno = -1;
 
         dbg("%s registering slot:path[%s] index[%x], name[%s] pdomain[%x] type[%d]\n",
                 __func__, slot->dn->full_name, slot->index, slot->name,
@@ -130,10 +132,15 @@ int rpaphp_register_slot(struct slot *slot)
                 return -EAGAIN;
         }
 
-        if (slot->dn->child)
-                slotno = PCI_SLOT(PCI_DN(slot->dn->child)->devfn);
-        else
-                slotno = -1;
+        for_each_child_of_node(slot->dn, child) {
+                retval = of_property_read_u32(child, "ibm,my-drc-index", &my_index);
+                if (my_index == slot->index) {
+                        slotno = PCI_SLOT(PCI_DN(child)->devfn);
+                        of_node_put(child);
+                        break;
+                }
+        }
+
         retval = pci_hp_register(php_slot, slot->bus, slotno, slot->name);
         if (retval) {
                 err("pci_hp_register failed with error %d\n", retval);