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

Pull powerpc updates from Michael Ellerman:

 - Numerous minor fixes, cleanups etc.

 - More EEH work from Gavin to remove its dependency on device_nodes.

 - Memory hotplug implemented entirely in the kernel from Nathan
   Fontenot.

 - Removal of redundant CONFIG_PPC_OF by Kevin Hao.

 - Rewrite of VPHN parsing logic & tests from Greg Kurz.

 - A fix from Nish Aravamudan to reduce memory usage by clamping
   nodes_possible_map.

 - Support for pstore on powernv from Hari Bathini.

 - Removal of old powerpc specific byte swap routines by David Gibson.

 - Fix from Vasant Hegde to prevent the flash driver telling you it was
   flashing your firmware when it wasn't.

 - Patch from Ben Herrenschmidt to add an OPAL heartbeat driver.

 - Fix for an oops causing get/put_cpu_var() imbalance in perf by Jan
   Stancek.

 - Some fixes for migration from Tyrel Datwyler.

 - A new syscall to switch the cpu endian by Michael Ellerman.

 - Large series from Wei Yang to implement SRIOV, reviewed and acked by
   Bjorn.

 - A fix for the OPAL sensor driver from Cédric Le Goater.

 - Fixes to get STRICT_MM_TYPECHECKS building again by Michael Ellerman.

 - Large series from Daniel Axtens to make our PCI hooks per PHB rather
   than per machine.

 - Small patch from Sam Bobroff to explicitly abort non-suspended
   transactions on syscalls, plus a test to exercise it.

 - Numerous reworks and fixes for the 24x7 PMU from Sukadev Bhattiprolu.

 - Small patch to enable the hard lockup detector from Anton Blanchard.

 - Fix from Dave Olson for missing L2 cache information on some CPUs.

 - Some fixes from Michael Ellerman to get Cell machines booting again.

 - Freescale updates from Scott: Highlights include BMan device tree
   nodes, an MSI erratum workaround, a couple minor performance
   improvements, config updates, and misc fixes/cleanup.

* tag 'powerpc-4.1-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mpe/linux: (196 commits)
  powerpc/powermac: Fix build error seen with powermac smp builds
  powerpc/pseries: Fix compile of memory hotplug without CONFIG_MEMORY_HOTREMOVE
  powerpc: Remove PPC32 code from pseries specific find_and_init_phbs()
  powerpc/cell: Fix iommu breakage caused by controller_ops change
  powerpc/eeh: Fix crash in eeh_add_device_early() on Cell
  powerpc/perf: Cap 64bit userspace backtraces to PERF_MAX_STACK_DEPTH
  powerpc/perf/hv-24x7: Fail 24x7 initcall if create_events_from_catalog() fails
  powerpc/pseries: Correct memory hotplug locking
  powerpc: Fix missing L2 cache size in /sys/devices/system/cpu
  powerpc: Add ppc64 hard lockup detector support
  oprofile: Disable oprofile NMI timer on ppc64
  powerpc/perf/hv-24x7: Add missing put_cpu_var()
  powerpc/perf/hv-24x7: Break up single_24x7_request
  powerpc/perf/hv-24x7: Define update_event_count()
  powerpc/perf/hv-24x7: Whitespace cleanup
  powerpc/perf/hv-24x7: Define add_event_to_24x7_request()
  powerpc/perf/hv-24x7: Rename hv_24x7_event_update
  powerpc/perf/hv-24x7: Move debug prints to separate function
  powerpc/perf/hv-24x7: Drop event_24x7_request()
  powerpc/perf/hv-24x7: Use pr_devel() to log message
  ...

Conflicts:
	tools/testing/selftests/powerpc/Makefile
	tools/testing/selftests/powerpc/tm/Makefile

37 files changed, 346 insertions, 276 deletions

diff --git a/drivers/ata/pata_macio.c b/drivers/ata/pata_macio.c
index a02f76fdcfcd..b0028588ff1c 100644
--- a/drivers/ata/pata_macio.c
+++ b/drivers/ata/pata_macio.c
@@ -540,9 +540,9 @@ static void pata_macio_qc_prep(struct ata_queued_cmd *qc)
                         BUG_ON (pi++ >= MAX_DCMDS);
 
                         len = (sg_len < MAX_DBDMA_SEG) ? sg_len : MAX_DBDMA_SEG;
-                        st_le16(&table->command, write ? OUTPUT_MORE: INPUT_MORE);
-                        st_le16(&table->req_count, len);
-                        st_le32(&table->phy_addr, addr);
+                        table->command = cpu_to_le16(write ? OUTPUT_MORE: INPUT_MORE);
+                        table->req_count = cpu_to_le16(len);
+                        table->phy_addr = cpu_to_le32(addr);
                         table->cmd_dep = 0;
                         table->xfer_status = 0;
                         table->res_count = 0;
@@ -557,12 +557,12 @@ static void pata_macio_qc_prep(struct ata_queued_cmd *qc)
 
         /* Convert the last command to an input/output */
         table--;
-        st_le16(&table->command, write ? OUTPUT_LAST: INPUT_LAST);
+        table->command = cpu_to_le16(write ? OUTPUT_LAST: INPUT_LAST);
         table++;
 
         /* Add the stop command to the end of the list */
         memset(table, 0, sizeof(struct dbdma_cmd));
-        st_le16(&table->command, DBDMA_STOP);
+        table->command = cpu_to_le16(DBDMA_STOP);
 
         dev_dbgdma(priv->dev, "%s: %d DMA list entries\n", __func__, pi);
 }
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index ff8307b30ff0..ff614be55d0f 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -47,11 +47,7 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi.h>
 #include <linux/libata.h>
-
-#ifdef CONFIG_PPC_OF
-#include <asm/prom.h>
-#include <asm/pci-bridge.h>
-#endif /* CONFIG_PPC_OF */
+#include <linux/of.h>
 
 #define DRV_NAME        "sata_svw"
 #define DRV_VERSION     "2.3"
@@ -320,7 +316,6 @@ static u8 k2_stat_check_status(struct ata_port *ap)
         return readl(ap->ioaddr.status_addr);
 }
 
-#ifdef CONFIG_PPC_OF
 static int k2_sata_show_info(struct seq_file *m, struct Scsi_Host *shost)
 {
         struct ata_port *ap;
@@ -350,14 +345,10 @@ static int k2_sata_show_info(struct seq_file *m, struct Scsi_Host *shost)
         }
         return 0;
 }
-#endif /* CONFIG_PPC_OF */
-
 
 static struct scsi_host_template k2_sata_sht = {
         ATA_BMDMA_SHT(DRV_NAME),
-#ifdef CONFIG_PPC_OF
         .show_info              = k2_sata_show_info,
-#endif
 };
 
 
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 523ee8fd4c15..c264f2d284a7 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -440,9 +440,9 @@ static inline void seek_track(struct floppy_state *fs, int n)
 static inline void init_dma(struct dbdma_cmd *cp, int cmd,
                             void *buf, int count)
 {
-        st_le16(&cp->req_count, count);
-        st_le16(&cp->command, cmd);
-        st_le32(&cp->phy_addr, virt_to_bus(buf));
+        cp->req_count = cpu_to_le16(count);
+        cp->command = cpu_to_le16(cmd);
+        cp->phy_addr = cpu_to_le32(virt_to_bus(buf));
         cp->xfer_status = 0;
 }
 
@@ -771,8 +771,8 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                 }
                 /* turn off DMA */
                 out_le32(&dr->control, (RUN | PAUSE) << 16);
-                stat = ld_le16(&cp->xfer_status);
-                resid = ld_le16(&cp->res_count);
+                stat = le16_to_cpu(cp->xfer_status);
+                resid = le16_to_cpu(cp->res_count);
                 if (intr & ERROR_INTR) {
                         n = fs->scount - 1 - resid / 512;
                         if (n > 0) {
@@ -1170,7 +1170,7 @@ static int swim3_add_device(struct macio_dev *mdev, int index)
 
         fs->dma_cmd = (struct dbdma_cmd *) DBDMA_ALIGN(fs->dbdma_cmd_space);
         memset(fs->dma_cmd, 0, 2 * sizeof(struct dbdma_cmd));
-        st_le16(&fs->dma_cmd[1].command, DBDMA_STOP);
+        fs->dma_cmd[1].command = cpu_to_le16(DBDMA_STOP);
 
         if (mdev->media_bay == NULL || check_media_bay(mdev->media_bay) == MB_FD)
                 swim3_mb_event(mdev, MB_FD);
diff --git a/drivers/ide/pmac.c b/drivers/ide/pmac.c
index 2db803cd095c..d24a3f8b49bc 100644
--- a/drivers/ide/pmac.c
+++ b/drivers/ide/pmac.c
@@ -1497,9 +1497,9 @@ static int pmac_ide_build_dmatable(ide_drive_t *drive, struct ide_cmd *cmd)
                                        drive->name);
                                 return 0;
                         }
-                        st_le16(&table->command, wr? OUTPUT_MORE: INPUT_MORE);
-                        st_le16(&table->req_count, tc);
-                        st_le32(&table->phy_addr, cur_addr);
+                        table->command = cpu_to_le16(wr? OUTPUT_MORE: INPUT_MORE);
+                        table->req_count = cpu_to_le16(tc);
+                        table->phy_addr = cpu_to_le32(cur_addr);
                         table->cmd_dep = 0;
                         table->xfer_status = 0;
                         table->res_count = 0;
@@ -1513,10 +1513,10 @@ static int pmac_ide_build_dmatable(ide_drive_t *drive, struct ide_cmd *cmd)
 
         /* convert the last command to an input/output last command */
         if (count) {
-                st_le16(&table[-1].command, wr? OUTPUT_LAST: INPUT_LAST);
+                table[-1].command = cpu_to_le16(wr? OUTPUT_LAST: INPUT_LAST);
                 /* add the stop command to the end of the list */
                 memset(table, 0, sizeof(struct dbdma_cmd));
-                st_le16(&table->command, DBDMA_STOP);
+                table->command = cpu_to_le16(DBDMA_STOP);
                 mb();
                 writel(hwif->dmatable_dma, &dma->cmdptr);
                 return 1;
diff --git a/drivers/macintosh/rack-meter.c b/drivers/macintosh/rack-meter.c
index 4192901cab40..048901a1111a 100644
--- a/drivers/macintosh/rack-meter.c
+++ b/drivers/macintosh/rack-meter.c
@@ -182,31 +182,31 @@ static void rackmeter_setup_dbdma(struct rackmeter *rm)
 
         /* Prepare 4 dbdma commands for the 2 buffers */
         memset(cmd, 0, 4 * sizeof(struct dbdma_cmd));
-        st_le16(&cmd->req_count, 4);
-        st_le16(&cmd->command, STORE_WORD | INTR_ALWAYS | KEY_SYSTEM);
-        st_le32(&cmd->phy_addr, rm->dma_buf_p +
+        cmd->req_count = cpu_to_le16(4);
+        cmd->command = cpu_to_le16(STORE_WORD | INTR_ALWAYS | KEY_SYSTEM);
+        cmd->phy_addr = cpu_to_le32(rm->dma_buf_p +
                 offsetof(struct rackmeter_dma, mark));
-        st_le32(&cmd->cmd_dep, 0x02000000);
+        cmd->cmd_dep = cpu_to_le32(0x02000000);
         cmd++;
 
-        st_le16(&cmd->req_count, SAMPLE_COUNT * 4);
-        st_le16(&cmd->command, OUTPUT_MORE);
-        st_le32(&cmd->phy_addr, rm->dma_buf_p +
+        cmd->req_count = cpu_to_le16(SAMPLE_COUNT * 4);
+        cmd->command = cpu_to_le16(OUTPUT_MORE);
+        cmd->phy_addr = cpu_to_le32(rm->dma_buf_p +
                 offsetof(struct rackmeter_dma, buf1));
         cmd++;
 
-        st_le16(&cmd->req_count, 4);
-        st_le16(&cmd->command, STORE_WORD | INTR_ALWAYS | KEY_SYSTEM);
-        st_le32(&cmd->phy_addr, rm->dma_buf_p +
+        cmd->req_count = cpu_to_le16(4);
+        cmd->command = cpu_to_le16(STORE_WORD | INTR_ALWAYS | KEY_SYSTEM);
+        cmd->phy_addr = cpu_to_le32(rm->dma_buf_p +
                 offsetof(struct rackmeter_dma, mark));
-        st_le32(&cmd->cmd_dep, 0x01000000);
+        cmd->cmd_dep = cpu_to_le32(0x01000000);
         cmd++;
 
-        st_le16(&cmd->req_count, SAMPLE_COUNT * 4);
-        st_le16(&cmd->command, OUTPUT_MORE | BR_ALWAYS);
-        st_le32(&cmd->phy_addr, rm->dma_buf_p +
+        cmd->req_count = cpu_to_le16(SAMPLE_COUNT * 4);
+        cmd->command = cpu_to_le16(OUTPUT_MORE | BR_ALWAYS);
+        cmd->phy_addr = cpu_to_le32(rm->dma_buf_p +
                 offsetof(struct rackmeter_dma, buf2));
-        st_le32(&cmd->cmd_dep, rm->dma_buf_p);
+        cmd->cmd_dep = cpu_to_le32(rm->dma_buf_p);
 
         rackmeter_do_pause(rm, 0);
 }
diff --git a/drivers/macintosh/smu.c b/drivers/macintosh/smu.c
index 10ae69bcbbd2..d531f804455d 100644
--- a/drivers/macintosh/smu.c
+++ b/drivers/macintosh/smu.c
@@ -557,8 +557,7 @@ int __init smu_init (void)
         return 0;
 
 fail_msg_node:
-        if (smu->msg_node)
-                of_node_put(smu->msg_node);
+        of_node_put(smu->msg_node);
 fail_db_node:
         of_node_put(smu->db_node);
 fail_bootmem:
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index dee88e59f0d3..f9512bfa6c3c 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -329,10 +329,11 @@ int __init find_via_pmu(void)
                                 gaddr = of_translate_address(gpiop, reg);
                         if (gaddr != OF_BAD_ADDR)
                                 gpio_reg = ioremap(gaddr, 0x10);
+                        of_node_put(gpiop);
                 }
                 if (gpio_reg == NULL) {
                         printk(KERN_ERR "via-pmu: Can't find GPIO reg !\n");
-                        goto fail_gpio;
+                        goto fail;
                 }
         } else
                 pmu_kind = PMU_UNKNOWN;
@@ -340,7 +341,7 @@ int __init find_via_pmu(void)
         via = ioremap(taddr, 0x2000);
         if (via == NULL) {
                 printk(KERN_ERR "via-pmu: Can't map address !\n");
-                goto fail;
+                goto fail_via_remap;
         }
         
         out_8(&via[IER], IER_CLR | 0x7f);       /* disable all intrs */
@@ -348,10 +349,8 @@ int __init find_via_pmu(void)
 
         pmu_state = idle;
 
-        if (!init_pmu()) {
-                via = NULL;
-                return 0;
-        }
+        if (!init_pmu())
+                goto fail_init;
 
         printk(KERN_INFO "PMU driver v%d initialized for %s, firmware: %02x\n",
                PMU_DRIVER_VERSION, pbook_type[pmu_kind], pmu_version);
@@ -359,11 +358,15 @@ int __init find_via_pmu(void)
         sys_ctrler = SYS_CTRLER_PMU;
         
         return 1;
- fail:
-        of_node_put(vias);
+
+ fail_init:
+        iounmap(via);
+        via = NULL;
+ fail_via_remap:
         iounmap(gpio_reg);
         gpio_reg = NULL;
- fail_gpio:
+ fail:
+        of_node_put(vias);
         vias = NULL;
         return 0;
 }
@@ -2109,7 +2112,7 @@ pmu_read(struct file *file, char __user *buf,
 
         spin_lock_irqsave(&pp->lock, flags);
         add_wait_queue(&pp->wait, &wait);
-        current->state = TASK_INTERRUPTIBLE;
+        set_current_state(TASK_INTERRUPTIBLE);
 
         for (;;) {
                 ret = -EAGAIN;
@@ -2138,7 +2141,7 @@ pmu_read(struct file *file, char __user *buf,
                 schedule();
                 spin_lock_irqsave(&pp->lock, flags);
         }
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
         remove_wait_queue(&pp->wait, &wait);
         spin_unlock_irqrestore(&pp->lock, flags);
         
diff --git a/drivers/media/pci/bt8xx/bt878.c b/drivers/media/pci/bt8xx/bt878.c
index 0939d399b774..8aa726651630 100644
--- a/drivers/media/pci/bt8xx/bt878.c
+++ b/drivers/media/pci/bt8xx/bt878.c
@@ -416,9 +416,6 @@ static int bt878_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
         int result = 0;
         unsigned char lat;
         struct bt878 *bt;
-#if defined(__powerpc__)
-        unsigned int cmd;
-#endif
         unsigned int cardid;
 
         printk(KERN_INFO "bt878: Bt878 AUDIO function found (%d).\n",
@@ -461,15 +458,6 @@ static int bt878_probe(struct pci_dev *dev, const struct pci_device_id *pci_id)
         printk("irq: %d, latency: %d, memory: 0x%lx\n",
                bt->irq, lat, bt->bt878_adr);
 
-
-#if defined(__powerpc__)
-        /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
-        /* response on cards with no firmware is not enabled by OF */
-        pci_read_config_dword(dev, PCI_COMMAND, &cmd);
-        cmd = (cmd | PCI_COMMAND_MEMORY);
-        pci_write_config_dword(dev, PCI_COMMAND, cmd);
-#endif
-
 #ifdef __sparc__
         bt->bt878_mem = (unsigned char *) bt->bt878_adr;
 #else
diff --git a/drivers/media/pci/bt8xx/bt878.h b/drivers/media/pci/bt8xx/bt878.h
index d19b59299d78..49af240b5894 100644
--- a/drivers/media/pci/bt8xx/bt878.h
+++ b/drivers/media/pci/bt8xx/bt878.h
@@ -142,18 +142,7 @@ void bt878_start(struct bt878 *bt, u32 controlreg, u32 op_sync_orin,
                 u32 irq_err_ignore);
 void bt878_stop(struct bt878 *bt);
 
-#if defined(__powerpc__)        /* big-endian */
-static inline void io_st_le32(volatile unsigned __iomem *addr, unsigned val)
-{
-        st_le32(addr, val);
-        eieio();
-}
-
-#define bmtwrite(dat,adr)  io_st_le32((adr),(dat))
-#define bmtread(adr)       ld_le32((adr))
-#else
 #define bmtwrite(dat,adr)  writel((dat), (adr))
 #define bmtread(adr)       readl(adr)
-#endif
 
 #endif
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index 5316d9b9e7b4..317d709f7550 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -281,7 +281,7 @@ static inline void buffer_swap32(u32 *buf, int len)
         int i;
 
         for (i = 0; i < ((len + 3) / 4); i++) {
-                st_le32(buf, *buf);
+                *buf = swab32(*buf);
                 buf++;
         }
 }
diff --git a/drivers/net/ethernet/apple/bmac.c b/drivers/net/ethernet/apple/bmac.c
index 2f98846e2d89..a65d7a60f116 100644
--- a/drivers/net/ethernet/apple/bmac.c
+++ b/drivers/net/ethernet/apple/bmac.c
@@ -483,8 +483,8 @@ static int bmac_suspend(struct macio_dev *mdev, pm_message_t state)
                 bmwrite(dev, TXCFG, (config & ~TxMACEnable));
                 bmwrite(dev, INTDISABLE, DisableAll); /* disable all intrs */
                 /* disable rx and tx dma */
-                st_le32(&rd->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE));       /* clear run bit */
-                st_le32(&td->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE));       /* clear run bit */
+                rd->control = cpu_to_le32(DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE));   /* clear run bit */
+                td->control = cpu_to_le32(DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE));   /* clear run bit */
                 /* free some skb's */
                 for (i=0; i<N_RX_RING; i++) {
                         if (bp->rx_bufs[i] != NULL) {
@@ -699,8 +699,8 @@ static irqreturn_t bmac_rxdma_intr(int irq, void *dev_id)
 
         while (1) {
                 cp = &bp->rx_cmds[i];
-                stat = ld_le16(&cp->xfer_status);
-                residual = ld_le16(&cp->res_count);
+                stat = le16_to_cpu(cp->xfer_status);
+                residual = le16_to_cpu(cp->res_count);
                 if ((stat & ACTIVE) == 0)
                         break;
                 nb = RX_BUFLEN - residual - 2;
@@ -728,8 +728,8 @@ static irqreturn_t bmac_rxdma_intr(int irq, void *dev_id)
                                 skb_reserve(bp->rx_bufs[i], 2);
                 }
                 bmac_construct_rxbuff(skb, &bp->rx_cmds[i]);
-                st_le16(&cp->res_count, 0);
-                st_le16(&cp->xfer_status, 0);
+                cp->res_count = cpu_to_le16(0);
+                cp->xfer_status = cpu_to_le16(0);
                 last = i;
                 if (++i >= N_RX_RING) i = 0;
         }
@@ -769,7 +769,7 @@ static irqreturn_t bmac_txdma_intr(int irq, void *dev_id)
 
         while (1) {
                 cp = &bp->tx_cmds[bp->tx_empty];
-                stat = ld_le16(&cp->xfer_status);
+                stat = le16_to_cpu(cp->xfer_status);
                 if (txintcount < 10) {
                         XXDEBUG(("bmac_txdma_xfer_stat=%#0x\n", stat));
                 }
@@ -1411,8 +1411,8 @@ static int bmac_close(struct net_device *dev)
         bmwrite(dev, INTDISABLE, DisableAll); /* disable all intrs */
 
         /* disable rx and tx dma */
-        st_le32(&rd->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE));       /* clear run bit */
-        st_le32(&td->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE));       /* clear run bit */
+        rd->control = cpu_to_le32(DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE));   /* clear run bit */
+        td->control = cpu_to_le32(DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE));   /* clear run bit */
 
         /* free some skb's */
         XXDEBUG(("bmac: free rx bufs\n"));
@@ -1493,7 +1493,7 @@ static void bmac_tx_timeout(unsigned long data)
 
         cp = &bp->tx_cmds[bp->tx_empty];
 /*      XXDEBUG((KERN_DEBUG "bmac: tx dmastat=%x %x runt=%d pr=%x fs=%x fc=%x\n", */
-/*         ld_le32(&td->status), ld_le16(&cp->xfer_status), bp->tx_bad_runt, */
+/*         le32_to_cpu(td->status), le16_to_cpu(cp->xfer_status), bp->tx_bad_runt, */
 /*         mb->pr, mb->xmtfs, mb->fifofc)); */
 
         /* turn off both tx and rx and reset the chip */
@@ -1506,7 +1506,7 @@ static void bmac_tx_timeout(unsigned long data)
         bmac_enable_and_reset_chip(dev);
 
         /* restart rx dma */
-        cp = bus_to_virt(ld_le32(&rd->cmdptr));
+        cp = bus_to_virt(le32_to_cpu(rd->cmdptr));
         out_le32(&rd->control, DBDMA_CLEAR(RUN|PAUSE|FLUSH|WAKE|ACTIVE|DEAD));
         out_le16(&cp->xfer_status, 0);
         out_le32(&rd->cmdptr, virt_to_bus(cp));
@@ -1553,10 +1553,10 @@ static void dump_dbdma(volatile struct dbdma_cmd *cp,int count)
                 ip = (int*)(cp+i);
 
                 printk("dbdma req 0x%x addr 0x%x baddr 0x%x xfer/res 0x%x\n",
-                       ld_le32(ip+0),
-                       ld_le32(ip+1),
-                       ld_le32(ip+2),
-                       ld_le32(ip+3));
+                       le32_to_cpup(ip+0),
+                       le32_to_cpup(ip+1),
+                       le32_to_cpup(ip+2),
+                       le32_to_cpup(ip+3));
         }
 
 }
diff --git a/drivers/net/ethernet/apple/mace.c b/drivers/net/ethernet/apple/mace.c
index a18948286682..e58a7c73766e 100644
--- a/drivers/net/ethernet/apple/mace.c
+++ b/drivers/net/ethernet/apple/mace.c
@@ -310,7 +310,7 @@ static void dbdma_reset(volatile struct dbdma_regs __iomem *dma)
      * way on some machines.
      */
     for (i = 200; i > 0; --i)
-        if (ld_le32(&dma->control) & RUN)
+        if (le32_to_cpu(dma->control) & RUN)
             udelay(1);
 }
 
@@ -452,21 +452,21 @@ static int mace_open(struct net_device *dev)
             data = skb->data;
         }
         mp->rx_bufs[i] = skb;
-        st_le16(&cp->req_count, RX_BUFLEN);
-        st_le16(&cp->command, INPUT_LAST + INTR_ALWAYS);
-        st_le32(&cp->phy_addr, virt_to_bus(data));
+        cp->req_count = cpu_to_le16(RX_BUFLEN);
+        cp->command = cpu_to_le16(INPUT_LAST + INTR_ALWAYS);
+        cp->phy_addr = cpu_to_le32(virt_to_bus(data));
         cp->xfer_status = 0;
         ++cp;
     }
     mp->rx_bufs[i] = NULL;
-    st_le16(&cp->command, DBDMA_STOP);
+    cp->command = cpu_to_le16(DBDMA_STOP);
     mp->rx_fill = i;
     mp->rx_empty = 0;
 
     /* Put a branch back to the beginning of the receive command list */
     ++cp;
-    st_le16(&cp->command, DBDMA_NOP + BR_ALWAYS);
-    st_le32(&cp->cmd_dep, virt_to_bus(mp->rx_cmds));
+    cp->command = cpu_to_le16(DBDMA_NOP + BR_ALWAYS);
+    cp->cmd_dep = cpu_to_le32(virt_to_bus(mp->rx_cmds));
 
     /* start rx dma */
     out_le32(&rd->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* clear run bit */
@@ -475,8 +475,8 @@ static int mace_open(struct net_device *dev)
 
     /* put a branch at the end of the tx command list */
     cp = mp->tx_cmds + NCMDS_TX * N_TX_RING;
-    st_le16(&cp->command, DBDMA_NOP + BR_ALWAYS);
-    st_le32(&cp->cmd_dep, virt_to_bus(mp->tx_cmds));
+    cp->command = cpu_to_le16(DBDMA_NOP + BR_ALWAYS);
+    cp->cmd_dep = cpu_to_le32(virt_to_bus(mp->tx_cmds));
 
     /* reset tx dma */
     out_le32(&td->control, (RUN|PAUSE|FLUSH|WAKE) << 16);
@@ -507,8 +507,8 @@ static int mace_close(struct net_device *dev)
     out_8(&mb->imr, 0xff);              /* disable all intrs */
 
     /* disable rx and tx dma */
-    st_le32(&rd->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* clear run bit */
-    st_le32(&td->control, (RUN|PAUSE|FLUSH|WAKE) << 16); /* clear run bit */
+    rd->control = cpu_to_le32((RUN|PAUSE|FLUSH|WAKE) << 16); /* clear run bit */
+    td->control = cpu_to_le32((RUN|PAUSE|FLUSH|WAKE) << 16); /* clear run bit */
 
     mace_clean_rings(mp);
 
@@ -558,8 +558,8 @@ static int mace_xmit_start(struct sk_buff *skb, struct net_device *dev)
     }
     mp->tx_bufs[fill] = skb;
     cp = mp->tx_cmds + NCMDS_TX * fill;
-    st_le16(&cp->req_count, len);
-    st_le32(&cp->phy_addr, virt_to_bus(skb->data));
+    cp->req_count = cpu_to_le16(len);
+    cp->phy_addr = cpu_to_le32(virt_to_bus(skb->data));
 
     np = mp->tx_cmds + NCMDS_TX * next;
     out_le16(&np->command, DBDMA_STOP);
@@ -691,7 +691,7 @@ static irqreturn_t mace_interrupt(int irq, void *dev_id)
             out_8(&mb->xmtfc, AUTO_PAD_XMIT);
             continue;
         }
-        dstat = ld_le32(&td->status);
+        dstat = le32_to_cpu(td->status);
         /* stop DMA controller */
         out_le32(&td->control, RUN << 16);
         /*
@@ -724,7 +724,7 @@ static irqreturn_t mace_interrupt(int irq, void *dev_id)
                  */
         }
         cp = mp->tx_cmds + NCMDS_TX * i;
-        stat = ld_le16(&cp->xfer_status);
+        stat = le16_to_cpu(cp->xfer_status);
         if ((fs & (UFLO|LCOL|LCAR|RTRY)) || (dstat & DEAD) || xcount == 0) {
             /*
              * Check whether there were in fact 2 bytes written to
@@ -830,7 +830,7 @@ static void mace_tx_timeout(unsigned long data)
     mace_reset(dev);
 
     /* restart rx dma */
-    cp = bus_to_virt(ld_le32(&rd->cmdptr));
+    cp = bus_to_virt(le32_to_cpu(rd->cmdptr));
     dbdma_reset(rd);
     out_le16(&cp->xfer_status, 0);
     out_le32(&rd->cmdptr, virt_to_bus(cp));
@@ -889,20 +889,20 @@ static irqreturn_t mace_rxdma_intr(int irq, void *dev_id)
     spin_lock_irqsave(&mp->lock, flags);
     for (i = mp->rx_empty; i != mp->rx_fill; ) {
         cp = mp->rx_cmds + i;
-        stat = ld_le16(&cp->xfer_status);
+        stat = le16_to_cpu(cp->xfer_status);
         if ((stat & ACTIVE) == 0) {
             next = i + 1;
             if (next >= N_RX_RING)
                 next = 0;
             np = mp->rx_cmds + next;
             if (next != mp->rx_fill &&
-                (ld_le16(&np->xfer_status) & ACTIVE) != 0) {
+                (le16_to_cpu(np->xfer_status) & ACTIVE) != 0) {
                 printk(KERN_DEBUG "mace: lost a status word\n");
                 ++mace_lost_status;
             } else
                 break;
         }
-        nb = ld_le16(&cp->req_count) - ld_le16(&cp->res_count);
+        nb = le16_to_cpu(cp->req_count) - le16_to_cpu(cp->res_count);
         out_le16(&cp->command, DBDMA_STOP);
         /* got a packet, have a look at it */
         skb = mp->rx_bufs[i];
@@ -962,13 +962,13 @@ static irqreturn_t mace_rxdma_intr(int irq, void *dev_id)
                 mp->rx_bufs[i] = skb;
             }
         }
-        st_le16(&cp->req_count, RX_BUFLEN);
+        cp->req_count = cpu_to_le16(RX_BUFLEN);
         data = skb? skb->data: dummy_buf;
-        st_le32(&cp->phy_addr, virt_to_bus(data));
+        cp->phy_addr = cpu_to_le32(virt_to_bus(data));
         out_le16(&cp->xfer_status, 0);
         out_le16(&cp->command, INPUT_LAST + INTR_ALWAYS);
 #if 0
-        if ((ld_le32(&rd->status) & ACTIVE) != 0) {
+        if ((le32_to_cpu(rd->status) & ACTIVE) != 0) {
             out_le32(&rd->control, (PAUSE << 16) | PAUSE);
             while ((in_le32(&rd->status) & ACTIVE) != 0)
                 ;
diff --git a/drivers/net/ethernet/ibm/emac/core.c b/drivers/net/ethernet/ibm/emac/core.c
index 8a17b97baa20..de7919322190 100644
--- a/drivers/net/ethernet/ibm/emac/core.c
+++ b/drivers/net/ethernet/ibm/emac/core.c
@@ -79,13 +79,6 @@ MODULE_AUTHOR
     ("Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>");
 MODULE_LICENSE("GPL");
 
-/*
- * PPC64 doesn't (yet) have a cacheable_memcpy
- */
-#ifdef CONFIG_PPC64
-#define cacheable_memcpy(d,s,n) memcpy((d),(s),(n))
-#endif
-
 /* minimum number of free TX descriptors required to wake up TX process */
 #define EMAC_TX_WAKEUP_THRESH           (NUM_TX_BUFF / 4)
 
@@ -1673,7 +1666,7 @@ static inline int emac_rx_sg_append(struct emac_instance *dev, int slot)
                         dev_kfree_skb(dev->rx_sg_skb);
                         dev->rx_sg_skb = NULL;
                 } else {
-                        cacheable_memcpy(skb_tail_pointer(dev->rx_sg_skb),
+                        memcpy(skb_tail_pointer(dev->rx_sg_skb),
                                          dev->rx_skb[slot]->data, len);
                         skb_put(dev->rx_sg_skb, len);
                         emac_recycle_rx_skb(dev, slot, len);
@@ -1730,8 +1723,7 @@ static int emac_poll_rx(void *param, int budget)
                                 goto oom;
 
                         skb_reserve(copy_skb, EMAC_RX_SKB_HEADROOM + 2);
-                        cacheable_memcpy(copy_skb->data - 2, skb->data - 2,
-                                         len + 2);
+                        memcpy(copy_skb->data - 2, skb->data - 2, len + 2);
                         emac_recycle_rx_skb(dev, slot, len);
                         skb = copy_skb;
                 } else if (unlikely(emac_alloc_rx_skb(dev, slot, GFP_ATOMIC)))
diff --git a/drivers/net/ethernet/sfc/efx.c b/drivers/net/ethernet/sfc/efx.c
index 33d2f9aa1b53..4b00545a3ace 100644
--- a/drivers/net/ethernet/sfc/efx.c
+++ b/drivers/net/ethernet/sfc/efx.c
@@ -2523,9 +2523,7 @@ int efx_try_recovery(struct efx_nic *efx)
          * schedule a 'recover or reset', leading to this recovery handler.
          * Manually call the eeh failure check function.
          */
-        struct eeh_dev *eehdev =
-                of_node_to_eeh_dev(pci_device_to_OF_node(efx->pci_dev));
-
+        struct eeh_dev *eehdev = pci_dev_to_eeh_dev(efx->pci_dev);
         if (eeh_dev_check_failure(eehdev)) {
                 /* The EEH mechanisms will handle the error and reset the
                  * device if necessary.
diff --git a/drivers/net/ethernet/sfc/siena.c b/drivers/net/ethernet/sfc/siena.c
index 3583f0208a6e..f12c811938d2 100644
--- a/drivers/net/ethernet/sfc/siena.c
+++ b/drivers/net/ethernet/sfc/siena.c
@@ -205,8 +205,7 @@ static int siena_map_reset_flags(u32 *flags)
  */
 static void siena_monitor(struct efx_nic *efx)
 {
-        struct eeh_dev *eehdev =
-                of_node_to_eeh_dev(pci_device_to_OF_node(efx->pci_dev));
+        struct eeh_dev *eehdev = pci_dev_to_eeh_dev(efx->pci_dev);
 
         eeh_dev_check_failure(eehdev);
 }
diff --git a/drivers/pci/hotplug/rpadlpar_core.c b/drivers/pci/hotplug/rpadlpar_core.c
index 7660232ef460..e12bafdc42e0 100644
--- a/drivers/pci/hotplug/rpadlpar_core.c
+++ b/drivers/pci/hotplug/rpadlpar_core.c
@@ -146,7 +146,7 @@ static void dlpar_pci_add_bus(struct device_node *dn)
         struct pci_controller *phb = pdn->phb;
         struct pci_dev *dev = NULL;
 
-        eeh_add_device_tree_early(dn);
+        eeh_add_device_tree_early(pdn);
 
         /* Add EADS device to PHB bus, adding new entry to bus->devices */
         dev = of_create_pci_dev(dn, phb->bus, pdn->devfn);
diff --git a/drivers/pci/iov.c b/drivers/pci/iov.c
index 4b3a4eaad996..ee0ebff103a4 100644
--- a/drivers/pci/iov.c
+++ b/drivers/pci/iov.c
@@ -19,16 +19,59 @@
 
 #define VIRTFN_ID_LEN   16
 
-static inline u8 virtfn_bus(struct pci_dev *dev, int id)
+int pci_iov_virtfn_bus(struct pci_dev *dev, int vf_id)
 {
+        if (!dev->is_physfn)
+                return -EINVAL;
         return dev->bus->number + ((dev->devfn + dev->sriov->offset +
-                                    dev->sriov->stride * id) >> 8);
+                                    dev->sriov->stride * vf_id) >> 8);
 }
 
-static inline u8 virtfn_devfn(struct pci_dev *dev, int id)
+int pci_iov_virtfn_devfn(struct pci_dev *dev, int vf_id)
 {
+        if (!dev->is_physfn)
+                return -EINVAL;
         return (dev->devfn + dev->sriov->offset +
-                dev->sriov->stride * id) & 0xff;
+                dev->sriov->stride * vf_id) & 0xff;
+}
+
+/*
+ * Per SR-IOV spec sec 3.3.10 and 3.3.11, First VF Offset and VF Stride may
+ * change when NumVFs changes.
+ *
+ * Update iov->offset and iov->stride when NumVFs is written.
+ */
+static inline void pci_iov_set_numvfs(struct pci_dev *dev, int nr_virtfn)
+{
+        struct pci_sriov *iov = dev->sriov;
+
+        pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn);
+        pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_OFFSET, &iov->offset);
+        pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_STRIDE, &iov->stride);
+}
+
+/*
+ * The PF consumes one bus number.  NumVFs, First VF Offset, and VF Stride
+ * determine how many additional bus numbers will be consumed by VFs.
+ *
+ * Iterate over all valid NumVFs and calculate the maximum number of bus
+ * numbers that could ever be required.
+ */
+static inline u8 virtfn_max_buses(struct pci_dev *dev)
+{
+        struct pci_sriov *iov = dev->sriov;
+        int nr_virtfn;
+        u8 max = 0;
+        int busnr;
+
+        for (nr_virtfn = 1; nr_virtfn <= iov->total_VFs; nr_virtfn++) {
+                pci_iov_set_numvfs(dev, nr_virtfn);
+                busnr = pci_iov_virtfn_bus(dev, nr_virtfn - 1);
+                if (busnr > max)
+                        max = busnr;
+        }
+
+        return max;
 }
 
 static struct pci_bus *virtfn_add_bus(struct pci_bus *bus, int busnr)
@@ -57,6 +100,14 @@ static void virtfn_remove_bus(struct pci_bus *physbus, struct pci_bus *virtbus)
                 pci_remove_bus(virtbus);
 }
 
+resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno)
+{
+        if (!dev->is_physfn)
+                return 0;
+
+        return dev->sriov->barsz[resno - PCI_IOV_RESOURCES];
+}
+
 static int virtfn_add(struct pci_dev *dev, int id, int reset)
 {
         int i;
@@ -69,7 +120,7 @@ static int virtfn_add(struct pci_dev *dev, int id, int reset)
         struct pci_bus *bus;
 
         mutex_lock(&iov->dev->sriov->lock);
-        bus = virtfn_add_bus(dev->bus, virtfn_bus(dev, id));
+        bus = virtfn_add_bus(dev->bus, pci_iov_virtfn_bus(dev, id));
         if (!bus)
                 goto failed;
 
@@ -77,7 +128,7 @@ static int virtfn_add(struct pci_dev *dev, int id, int reset)
         if (!virtfn)
                 goto failed0;
 
-        virtfn->devfn = virtfn_devfn(dev, id);
+        virtfn->devfn = pci_iov_virtfn_devfn(dev, id);
         virtfn->vendor = dev->vendor;
         pci_read_config_word(dev, iov->pos + PCI_SRIOV_VF_DID, &virtfn->device);
         pci_setup_device(virtfn);
@@ -87,13 +138,12 @@ static int virtfn_add(struct pci_dev *dev, int id, int reset)
         virtfn->multifunction = 0;
 
         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
-                res = dev->resource + PCI_IOV_RESOURCES + i;
+                res = &dev->resource[i + PCI_IOV_RESOURCES];
                 if (!res->parent)
                         continue;
                 virtfn->resource[i].name = pci_name(virtfn);
                 virtfn->resource[i].flags = res->flags;
-                size = resource_size(res);
-                do_div(size, iov->total_VFs);
+                size = pci_iov_resource_size(dev, i + PCI_IOV_RESOURCES);
                 virtfn->resource[i].start = res->start + size * id;
                 virtfn->resource[i].end = virtfn->resource[i].start + size - 1;
                 rc = request_resource(res, &virtfn->resource[i]);
@@ -140,8 +190,8 @@ static void virtfn_remove(struct pci_dev *dev, int id, int reset)
         struct pci_sriov *iov = dev->sriov;
 
         virtfn = pci_get_domain_bus_and_slot(pci_domain_nr(dev->bus),
-                                             virtfn_bus(dev, id),
-                                             virtfn_devfn(dev, id));
+                                             pci_iov_virtfn_bus(dev, id),
+                                             pci_iov_virtfn_devfn(dev, id));
         if (!virtfn)
                 return;
 
@@ -170,6 +220,11 @@ static void virtfn_remove(struct pci_dev *dev, int id, int reset)
         pci_dev_put(dev);
 }
 
+int __weak pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs)
+{
+       return 0;
+}
+
 static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
 {
         int rc;
@@ -180,6 +235,8 @@ static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
         struct pci_dev *pdev;
         struct pci_sriov *iov = dev->sriov;
         int bars = 0;
+        int bus;
+        int retval;
 
         if (!nr_virtfn)
                 return 0;
@@ -204,7 +261,7 @@ static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
         nres = 0;
         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
                 bars |= (1 << (i + PCI_IOV_RESOURCES));
-                res = dev->resource + PCI_IOV_RESOURCES + i;
+                res = &dev->resource[i + PCI_IOV_RESOURCES];
                 if (res->parent)
                         nres++;
         }
@@ -216,8 +273,10 @@ static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
         iov->offset = offset;
         iov->stride = stride;
 
-        if (virtfn_bus(dev, nr_virtfn - 1) > dev->bus->busn_res.end) {
-                dev_err(&dev->dev, "SR-IOV: bus number out of range\n");
+        bus = pci_iov_virtfn_bus(dev, nr_virtfn - 1);
+        if (bus > dev->bus->busn_res.end) {
+                dev_err(&dev->dev, "can't enable %d VFs (bus %02x out of range of %pR)\n",
+                        nr_virtfn, bus, &dev->bus->busn_res);
                 return -ENOMEM;
         }
 
@@ -243,7 +302,7 @@ static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
                         return rc;
         }
 
-        pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, nr_virtfn);
+        pci_iov_set_numvfs(dev, nr_virtfn);
         iov->ctrl |= PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE;
         pci_cfg_access_lock(dev);
         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
@@ -254,6 +313,12 @@ static int sriov_enable(struct pci_dev *dev, int nr_virtfn)
         if (nr_virtfn < initial)
                 initial = nr_virtfn;
 
+        if ((retval = pcibios_sriov_enable(dev, initial))) {
+                dev_err(&dev->dev, "failure %d from pcibios_sriov_enable()\n",
+                        retval);
+                return retval;
+        }
+
         for (i = 0; i < initial; i++) {
                 rc = virtfn_add(dev, i, 0);
                 if (rc)
@@ -272,7 +337,7 @@ failed:
         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
         pci_cfg_access_lock(dev);
         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
-        pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, 0);
+        pci_iov_set_numvfs(dev, 0);
         ssleep(1);
         pci_cfg_access_unlock(dev);
 
@@ -282,6 +347,11 @@ failed:
         return rc;
 }
 
+int __weak pcibios_sriov_disable(struct pci_dev *pdev)
+{
+       return 0;
+}
+
 static void sriov_disable(struct pci_dev *dev)
 {
         int i;
@@ -293,6 +363,8 @@ static void sriov_disable(struct pci_dev *dev)
         for (i = 0; i < iov->num_VFs; i++)
                 virtfn_remove(dev, i, 0);
 
+        pcibios_sriov_disable(dev);
+
         iov->ctrl &= ~(PCI_SRIOV_CTRL_VFE | PCI_SRIOV_CTRL_MSE);
         pci_cfg_access_lock(dev);
         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
@@ -303,12 +375,12 @@ static void sriov_disable(struct pci_dev *dev)
                 sysfs_remove_link(&dev->dev.kobj, "dep_link");
 
         iov->num_VFs = 0;
-        pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, 0);
+        pci_iov_set_numvfs(dev, 0);
 }
 
 static int sriov_init(struct pci_dev *dev, int pos)
 {
-        int i;
+        int i, bar64;
         int rc;
         int nres;
         u32 pgsz;
@@ -357,27 +429,29 @@ found:
         pgsz &= ~(pgsz - 1);
         pci_write_config_dword(dev, pos + PCI_SRIOV_SYS_PGSIZE, pgsz);
 
+        iov = kzalloc(sizeof(*iov), GFP_KERNEL);
+        if (!iov)
+                return -ENOMEM;
+
         nres = 0;
         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
-                res = dev->resource + PCI_IOV_RESOURCES + i;
-                i += __pci_read_base(dev, pci_bar_unknown, res,
-                                     pos + PCI_SRIOV_BAR + i * 4);
+                res = &dev->resource[i + PCI_IOV_RESOURCES];
+                bar64 = __pci_read_base(dev, pci_bar_unknown, res,
+                                        pos + PCI_SRIOV_BAR + i * 4);
                 if (!res->flags)
                         continue;
                 if (resource_size(res) & (PAGE_SIZE - 1)) {
                         rc = -EIO;
                         goto failed;
                 }
+                iov->barsz[i] = resource_size(res);
                 res->end = res->start + resource_size(res) * total - 1;
+                dev_info(&dev->dev, "VF(n) BAR%d space: %pR (contains BAR%d for %d VFs)\n",
+                         i, res, i, total);
+                i += bar64;
                 nres++;
         }
 
-        iov = kzalloc(sizeof(*iov), GFP_KERNEL);
-        if (!iov) {
-                rc = -ENOMEM;
-                goto failed;
-        }
-
         iov->pos = pos;
         iov->nres = nres;
         iov->ctrl = ctrl;
@@ -400,15 +474,17 @@ found:
 
         dev->sriov = iov;
         dev->is_physfn = 1;
+        iov->max_VF_buses = virtfn_max_buses(dev);
 
         return 0;
 
 failed:
         for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) {
-                res = dev->resource + PCI_IOV_RESOURCES + i;
+                res = &dev->resource[i + PCI_IOV_RESOURCES];
                 res->flags = 0;
         }
 
+        kfree(iov);
         return rc;
 }
 
@@ -439,7 +515,7 @@ static void sriov_restore_state(struct pci_dev *dev)
                 pci_update_resource(dev, i);
 
         pci_write_config_dword(dev, iov->pos + PCI_SRIOV_SYS_PGSIZE, iov->pgsz);
-        pci_write_config_word(dev, iov->pos + PCI_SRIOV_NUM_VF, iov->num_VFs);
+        pci_iov_set_numvfs(dev, iov->num_VFs);
         pci_write_config_word(dev, iov->pos + PCI_SRIOV_CTRL, iov->ctrl);
         if (iov->ctrl & PCI_SRIOV_CTRL_VFE)
                 msleep(100);
@@ -493,6 +569,12 @@ int pci_iov_resource_bar(struct pci_dev *dev, int resno)
                 4 * (resno - PCI_IOV_RESOURCES);
 }
 
+resource_size_t __weak pcibios_iov_resource_alignment(struct pci_dev *dev,
+                                                      int resno)
+{
+        return pci_iov_resource_size(dev, resno);
+}
+
 /**
  * pci_sriov_resource_alignment - get resource alignment for VF BAR
  * @dev: the PCI device
@@ -505,14 +587,7 @@ int pci_iov_resource_bar(struct pci_dev *dev, int resno)
  */
 resource_size_t pci_sriov_resource_alignment(struct pci_dev *dev, int resno)
 {
-        struct resource tmp;
-        int reg = pci_iov_resource_bar(dev, resno);
-
-        if (!reg)
-                return 0;
-
-         __pci_read_base(dev, pci_bar_unknown, &tmp, reg);
-        return resource_alignment(&tmp);
+        return pcibios_iov_resource_alignment(dev, resno);
 }
 
 /**
@@ -535,15 +610,13 @@ void pci_restore_iov_state(struct pci_dev *dev)
 int pci_iov_bus_range(struct pci_bus *bus)
 {
         int max = 0;
-        u8 busnr;
         struct pci_dev *dev;
 
         list_for_each_entry(dev, &bus->devices, bus_list) {
                 if (!dev->is_physfn)
                         continue;
-                busnr = virtfn_bus(dev, dev->sriov->total_VFs - 1);
-                if (busnr > max)
-                        max = busnr;
+                if (dev->sriov->max_VF_buses > max)
+                        max = dev->sriov->max_VF_buses;
         }
 
         return max ? max - bus->number : 0;
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index d72f849174a4..9bd762c237ab 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -243,10 +243,12 @@ struct pci_sriov {
         u16 stride;             /* following VF stride */
         u32 pgsz;               /* page size for BAR alignment */
         u8 link;                /* Function Dependency Link */
+        u8 max_VF_buses;        /* max buses consumed by VFs */
         u16 driver_max_VFs;     /* max num VFs driver supports */
         struct pci_dev *dev;    /* lowest numbered PF */
         struct pci_dev *self;   /* this PF */
         struct mutex lock;      /* lock for VF bus */
+        resource_size_t barsz[PCI_SRIOV_NUM_BARS];      /* VF BAR size */
 };
 
 #ifdef CONFIG_PCI_ATS
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 8169597e47cb..4fd0cacf7ca0 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -99,8 +99,8 @@ static void remove_from_list(struct list_head *head,
         }
 }
 
-static resource_size_t get_res_add_size(struct list_head *head,
-                                        struct resource *res)
+static struct pci_dev_resource *res_to_dev_res(struct list_head *head,
+                                               struct resource *res)
 {
         struct pci_dev_resource *dev_res;
 
@@ -109,17 +109,37 @@ static resource_size_t get_res_add_size(struct list_head *head,
                         int idx = res - &dev_res->dev->resource[0];
 
                         dev_printk(KERN_DEBUG, &dev_res->dev->dev,
-                                 "res[%d]=%pR get_res_add_size add_size %llx\n",
+                                 "res[%d]=%pR res_to_dev_res add_size %llx min_align %llx\n",
                                  idx, dev_res->res,
-                                 (unsigned long long)dev_res->add_size);
+                                 (unsigned long long)dev_res->add_size,
+                                 (unsigned long long)dev_res->min_align);
 
-                        return dev_res->add_size;
+                        return dev_res;
                 }
         }
 
-        return 0;
+        return NULL;
 }
 
+static resource_size_t get_res_add_size(struct list_head *head,
+                                        struct resource *res)
+{
+        struct pci_dev_resource *dev_res;
+
+        dev_res = res_to_dev_res(head, res);
+        return dev_res ? dev_res->add_size : 0;
+}
+
+static resource_size_t get_res_add_align(struct list_head *head,
+                                         struct resource *res)
+{
+        struct pci_dev_resource *dev_res;
+
+        dev_res = res_to_dev_res(head, res);
+        return dev_res ? dev_res->min_align : 0;
+}
+
+
 /* Sort resources by alignment */
 static void pdev_sort_resources(struct pci_dev *dev, struct list_head *head)
 {
@@ -215,7 +235,7 @@ static void reassign_resources_sorted(struct list_head *realloc_head,
         struct resource *res;
         struct pci_dev_resource *add_res, *tmp;
         struct pci_dev_resource *dev_res;
-        resource_size_t add_size;
+        resource_size_t add_size, align;
         int idx;
 
         list_for_each_entry_safe(add_res, tmp, realloc_head, list) {
@@ -238,13 +258,13 @@ static void reassign_resources_sorted(struct list_head *realloc_head,
 
                 idx = res - &add_res->dev->resource[0];
                 add_size = add_res->add_size;
+                align = add_res->min_align;
                 if (!resource_size(res)) {
-                        res->start = add_res->start;
+                        res->start = align;
                         res->end = res->start + add_size - 1;
                         if (pci_assign_resource(add_res->dev, idx))
                                 reset_resource(res);
                 } else {
-                        resource_size_t align = add_res->min_align;
                         res->flags |= add_res->flags &
                                  (IORESOURCE_STARTALIGN|IORESOURCE_SIZEALIGN);
                         if (pci_reassign_resource(add_res->dev, idx,
@@ -368,8 +388,9 @@ static void __assign_resources_sorted(struct list_head *head,
         LIST_HEAD(save_head);
         LIST_HEAD(local_fail_head);
         struct pci_dev_resource *save_res;
-        struct pci_dev_resource *dev_res, *tmp_res;
+        struct pci_dev_resource *dev_res, *tmp_res, *dev_res2;
         unsigned long fail_type;
+        resource_size_t add_align, align;
 
         /* Check if optional add_size is there */
         if (!realloc_head || list_empty(realloc_head))
@@ -384,10 +405,44 @@ static void __assign_resources_sorted(struct list_head *head,
         }
 
         /* Update res in head list with add_size in realloc_head list */
-        list_for_each_entry(dev_res, head, list)
+        list_for_each_entry_safe(dev_res, tmp_res, head, list) {
                 dev_res->res->end += get_res_add_size(realloc_head,
                                                         dev_res->res);
 
+                /*
+                 * There are two kinds of additional resources in the list:
+                 * 1. bridge resource  -- IORESOURCE_STARTALIGN
+                 * 2. SR-IOV resource   -- IORESOURCE_SIZEALIGN
+                 * Here just fix the additional alignment for bridge
+                 */
+                if (!(dev_res->res->flags & IORESOURCE_STARTALIGN))
+                        continue;
+
+                add_align = get_res_add_align(realloc_head, dev_res->res);
+
+                /*
+                 * The "head" list is sorted by the alignment to make sure
+                 * resources with bigger alignment will be assigned first.
+                 * After we change the alignment of a dev_res in "head" list,
+                 * we need to reorder the list by alignment to make it
+                 * consistent.
+                 */
+                if (add_align > dev_res->res->start) {
+                        dev_res->res->start = add_align;
+                        dev_res->res->end = add_align +
+                                            resource_size(dev_res->res);
+
+                        list_for_each_entry(dev_res2, head, list) {
+                                align = pci_resource_alignment(dev_res2->dev,
+                                                               dev_res2->res);
+                                if (add_align > align)
+                                        list_move_tail(&dev_res->list,
+                                                       &dev_res2->list);
+                        }
+               }
+
+        }
+
         /* Try updated head list with add_size added */
         assign_requested_resources_sorted(head, &local_fail_head);
 
@@ -962,6 +1017,8 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         struct resource *b_res = find_free_bus_resource(bus,
                                         mask | IORESOURCE_PREFETCH, type);
         resource_size_t children_add_size = 0;
+        resource_size_t children_add_align = 0;
+        resource_size_t add_align = 0;
 
         if (!b_res)
                 return -ENOSPC;
@@ -986,6 +1043,7 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                         /* put SRIOV requested res to the optional list */
                         if (realloc_head && i >= PCI_IOV_RESOURCES &&
                                         i <= PCI_IOV_RESOURCE_END) {
+                                add_align = max(pci_resource_alignment(dev, r), add_align);
                                 r->end = r->start - 1;
                                 add_to_list(realloc_head, dev, r, r_size, 0/* don't care */);
                                 children_add_size += r_size;
@@ -1016,19 +1074,23 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                         if (order > max_order)
                                 max_order = order;
 
-                        if (realloc_head)
+                        if (realloc_head) {
                                 children_add_size += get_res_add_size(realloc_head, r);
+                                children_add_align = get_res_add_align(realloc_head, r);
+                                add_align = max(add_align, children_add_align);
+                        }
                 }
         }
 
         min_align = calculate_mem_align(aligns, max_order);
         min_align = max(min_align, window_alignment(bus, b_res->flags));
         size0 = calculate_memsize(size, min_size, 0, resource_size(b_res), min_align);
+        add_align = max(min_align, add_align);
         if (children_add_size > add_size)
                 add_size = children_add_size;
         size1 = (!realloc_head || (realloc_head && !add_size)) ? size0 :
                 calculate_memsize(size, min_size, add_size,
-                                resource_size(b_res), min_align);
+                                resource_size(b_res), add_align);
         if (!size0 && !size1) {
                 if (b_res->start || b_res->end)
                         dev_info(&bus->self->dev, "disabling bridge window %pR to %pR (unused)\n",
@@ -1040,10 +1102,11 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         b_res->end = size0 + min_align - 1;
         b_res->flags |= IORESOURCE_STARTALIGN;
         if (size1 > size0 && realloc_head) {
-                add_to_list(realloc_head, bus->self, b_res, size1-size0, min_align);
-                dev_printk(KERN_DEBUG, &bus->self->dev, "bridge window %pR to %pR add_size %llx\n",
+                add_to_list(realloc_head, bus->self, b_res, size1-size0, add_align);
+                dev_printk(KERN_DEBUG, &bus->self->dev, "bridge window %pR to %pR add_size %llx add_align %llx\n",
                            b_res, &bus->busn_res,
-                           (unsigned long long)size1-size0);
+                           (unsigned long long) (size1 - size0),
+                           (unsigned long long) add_align);
         }
         return 0;
 }
diff --git a/drivers/ps3/ps3-lpm.c b/drivers/ps3/ps3-lpm.c
index b139b7792e9f..cb7d3a67380d 100644
--- a/drivers/ps3/ps3-lpm.c
+++ b/drivers/ps3/ps3-lpm.c
@@ -105,7 +105,7 @@ struct ps3_lpm_shadow_regs {
  * @open: An atomic variable indicating the lpm driver has been opened.
  * @rights: The lpm rigths granted by the system policy module.  A logical
  *  OR of enum ps3_lpm_rights.
- * @node_id: The node id of a BE prosessor whose performance monitor this
+ * @node_id: The node id of a BE processor whose performance monitor this
  *  lpar has the right to use.
  * @pu_id: The lv1 id of the logical PU.
  * @lpm_id: The lv1 id of this lpm instance.
@@ -412,7 +412,7 @@ u32 ps3_read_pm(u32 cpu, enum pm_reg_name reg)
                 result = lv1_set_lpm_interval(lpm_priv->lpm_id, 0, 0, &val);
                 if (result) {
                         val = 0;
-                        dev_dbg(sbd_core(), "%s:%u: lv1 set_inteval failed: "
+                        dev_dbg(sbd_core(), "%s:%u: lv1 set_interval failed: "
                                 "reg %u, %s\n", __func__, __LINE__, reg,
                                 ps3_result(result));
                 }
diff --git a/drivers/scsi/mac53c94.c b/drivers/scsi/mac53c94.c
index e5cd8d8d4ce7..0adb2e015597 100644
--- a/drivers/scsi/mac53c94.c
+++ b/drivers/scsi/mac53c94.c
@@ -382,16 +382,16 @@ static void set_dma_cmds(struct fsc_state *state, struct scsi_cmnd *cmd)
                 if (dma_len > 0xffff)
                         panic("mac53c94: scatterlist element >= 64k");
                 total += dma_len;
-                st_le16(&dcmds->req_count, dma_len);
-                st_le16(&dcmds->command, dma_cmd);
-                st_le32(&dcmds->phy_addr, dma_addr);
+                dcmds->req_count = cpu_to_le16(dma_len);
+                dcmds->command = cpu_to_le16(dma_cmd);
+                dcmds->phy_addr = cpu_to_le32(dma_addr);
                 dcmds->xfer_status = 0;
                 ++dcmds;
         }
 
         dma_cmd += OUTPUT_LAST - OUTPUT_MORE;
-        st_le16(&dcmds[-1].command, dma_cmd);
-        st_le16(&dcmds->command, DBDMA_STOP);
+        dcmds[-1].command = cpu_to_le16(dma_cmd);
+        dcmds->command = cpu_to_le16(DBDMA_STOP);
         cmd->SCp.this_residual = total;
 }
 
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index 57a95e2c3442..555367f00228 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -1287,9 +1287,9 @@ static void set_dma_cmds(struct mesh_state *ms, struct scsi_cmnd *cmd)
                                 }
                                 if (dma_len > 0xffff)
                                         panic("mesh: scatterlist element >= 64k");
-                                st_le16(&dcmds->req_count, dma_len - off);
-                                st_le16(&dcmds->command, dma_cmd);
-                                st_le32(&dcmds->phy_addr, dma_addr + off);
+                                dcmds->req_count = cpu_to_le16(dma_len - off);
+                                dcmds->command = cpu_to_le16(dma_cmd);
+                                dcmds->phy_addr = cpu_to_le32(dma_addr + off);
                                 dcmds->xfer_status = 0;
                                 ++dcmds;
                                 dtot += dma_len - off;
@@ -1303,15 +1303,15 @@ static void set_dma_cmds(struct mesh_state *ms, struct scsi_cmnd *cmd)
                 static char mesh_extra_buf[64];
 
                 dtot = sizeof(mesh_extra_buf);
-                st_le16(&dcmds->req_count, dtot);
-                st_le32(&dcmds->phy_addr, virt_to_phys(mesh_extra_buf));
+                dcmds->req_count = cpu_to_le16(dtot);
+                dcmds->phy_addr = cpu_to_le32(virt_to_phys(mesh_extra_buf));
                 dcmds->xfer_status = 0;
                 ++dcmds;
         }
         dma_cmd += OUTPUT_LAST - OUTPUT_MORE;
-        st_le16(&dcmds[-1].command, dma_cmd);
+        dcmds[-1].command = cpu_to_le16(dma_cmd);
         memset(dcmds, 0, sizeof(*dcmds));
-        st_le16(&dcmds->command, DBDMA_STOP);
+        dcmds->command = cpu_to_le16(DBDMA_STOP);
         ms->dma_count = dtot;
 }
 
diff --git a/drivers/video/fbdev/Kconfig b/drivers/video/fbdev/Kconfig
index b3dd417b4719..109462303087 100644
--- a/drivers/video/fbdev/Kconfig
+++ b/drivers/video/fbdev/Kconfig
@@ -479,7 +479,7 @@ config FB_ATARI
 
 config FB_OF
         bool "Open Firmware frame buffer device support"
-        depends on (FB = y) && (PPC64 || PPC_OF) && (!PPC_PSERIES || PCI)
+        depends on (FB = y) && PPC && (!PPC_PSERIES || PCI)
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
@@ -1333,7 +1333,7 @@ config FB_RADEON
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
-        select FB_MACMODES if PPC_OF
+        select FB_MACMODES if PPC
         help
           Choose this option if you want to use an ATI Radeon graphics card as
           a framebuffer device.  There are both PCI and AGP versions.  You
diff --git a/drivers/video/fbdev/aty/aty128fb.c b/drivers/video/fbdev/aty/aty128fb.c
index aedf2fbf9bf6..0156954bf340 100644
--- a/drivers/video/fbdev/aty/aty128fb.c
+++ b/drivers/video/fbdev/aty/aty128fb.c
@@ -965,7 +965,7 @@ static void __iomem *aty128_find_mem_vbios(struct aty128fb_par *par)
 /* fill in known card constants if pll_block is not available */
 static void aty128_timings(struct aty128fb_par *par)
 {
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_PPC
         /* instead of a table lookup, assume OF has properly
          * setup the PLL registers and use their values
          * to set the XCLK values and reference divider values */
@@ -979,7 +979,7 @@ static void aty128_timings(struct aty128fb_par *par)
         if (!par->constants.ref_clk)
                 par->constants.ref_clk = 2950;
 
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_PPC
         x_mpll_ref_fb_div = aty_ld_pll(X_MPLL_REF_FB_DIV);
         xclk_cntl = aty_ld_pll(XCLK_CNTL) & 0x7;
         Nx = (x_mpll_ref_fb_div & 0x00ff00) >> 8;
diff --git a/drivers/video/fbdev/aty/radeon_base.c b/drivers/video/fbdev/aty/radeon_base.c
index 26d80a4486fb..01237c8fcdc6 100644
--- a/drivers/video/fbdev/aty/radeon_base.c
+++ b/drivers/video/fbdev/aty/radeon_base.c
@@ -74,7 +74,7 @@
 #include <asm/io.h>
 #include <linux/uaccess.h>
 
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_PPC
 
 #include <asm/pci-bridge.h>
 #include "../macmodes.h"
@@ -83,7 +83,7 @@
 #include <asm/btext.h>
 #endif
 
-#endif /* CONFIG_PPC_OF */
+#endif /* CONFIG_PPC */
 
 #ifdef CONFIG_MTRR
 #include <asm/mtrr.h>
@@ -418,7 +418,7 @@ static int  radeon_find_mem_vbios(struct radeonfb_info *rinfo)
 }
 #endif
 
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
 /*
  * Read XTAL (ref clock), SCLK and MCLK from Open Firmware device
  * tree. Hopefully, ATI OF driver is kind enough to fill these
@@ -448,7 +448,7 @@ static int radeon_read_xtal_OF(struct radeonfb_info *rinfo)
 
         return 0;
 }
-#endif /* CONFIG_PPC_OF || CONFIG_SPARC */
+#endif /* CONFIG_PPC || CONFIG_SPARC */
 
 /*
  * Read PLL infos from chip registers
@@ -653,7 +653,7 @@ static void radeon_get_pllinfo(struct radeonfb_info *rinfo)
         rinfo->pll.ref_div = INPLL(PPLL_REF_DIV) & PPLL_REF_DIV_MASK;
 
 
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
         /*
          * Retrieve PLL infos from Open Firmware first
          */
@@ -661,7 +661,7 @@ static void radeon_get_pllinfo(struct radeonfb_info *rinfo)
                 printk(KERN_INFO "radeonfb: Retrieved PLL infos from Open Firmware\n");
                 goto found;
         }
-#endif /* CONFIG_PPC_OF || CONFIG_SPARC */
+#endif /* CONFIG_PPC || CONFIG_SPARC */
 
         /*
          * Check out if we have an X86 which gave us some PLL informations
@@ -1910,7 +1910,7 @@ static int radeon_set_fbinfo(struct radeonfb_info *rinfo)
  * I put the card's memory at 0 in card space and AGP at some random high
  * local (0xe0000000 for now) that will be changed by XFree/DRI anyway
  */
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_PPC
 #undef SET_MC_FB_FROM_APERTURE
 static void fixup_memory_mappings(struct radeonfb_info *rinfo)
 {
@@ -1984,7 +1984,7 @@ static void fixup_memory_mappings(struct radeonfb_info *rinfo)
                 ((aper_base + aper_size - 1) & 0xffff0000) | (aper_base >> 16),
                 0xffff0000 | (agp_base >> 16));
 }
-#endif /* CONFIG_PPC_OF */
+#endif /* CONFIG_PPC */
 
 
 static void radeon_identify_vram(struct radeonfb_info *rinfo)
@@ -2236,7 +2236,7 @@ static int radeonfb_pci_register(struct pci_dev *pdev,
             rinfo->family == CHIP_FAMILY_RS200)
                 rinfo->errata |= CHIP_ERRATA_PLL_DELAY;
 
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
         /* On PPC, we obtain the OF device-node pointer to the firmware
          * data for this chip
          */
@@ -2245,14 +2245,14 @@ static int radeonfb_pci_register(struct pci_dev *pdev,
                 printk(KERN_WARNING "radeonfb (%s): Cannot match card to OF node !\n",
                        pci_name(rinfo->pdev));
 
-#endif /* CONFIG_PPC_OF || CONFIG_SPARC */
-#ifdef CONFIG_PPC_OF
+#endif /* CONFIG_PPC || CONFIG_SPARC */
+#ifdef CONFIG_PPC
         /* On PPC, the firmware sets up a memory mapping that tends
          * to cause lockups when enabling the engine. We reconfigure
          * the card internal memory mappings properly
          */
         fixup_memory_mappings(rinfo);
-#endif /* CONFIG_PPC_OF */
+#endif /* CONFIG_PPC */
 
         /* Get VRAM size and type */
         radeon_identify_vram(rinfo);
diff --git a/drivers/video/fbdev/aty/radeon_monitor.c b/drivers/video/fbdev/aty/radeon_monitor.c
index bc078d50d8f1..f1ce229de78d 100644
--- a/drivers/video/fbdev/aty/radeon_monitor.c
+++ b/drivers/video/fbdev/aty/radeon_monitor.c
@@ -55,7 +55,7 @@ static char *radeon_get_mon_name(int type)
 }
 
 
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
 /*
  * Try to find monitor informations & EDID data out of the Open Firmware
  * device-tree. This also contains some "hacks" to work around a few machine
@@ -160,7 +160,7 @@ static int radeon_probe_OF_head(struct radeonfb_info *rinfo, int head_no,
         }
         return MT_NONE;
 }
-#endif /* CONFIG_PPC_OF || CONFIG_SPARC */
+#endif /* CONFIG_PPC || CONFIG_SPARC */
 
 
 static int radeon_get_panel_info_BIOS(struct radeonfb_info *rinfo)
@@ -499,11 +499,11 @@ void radeon_probe_screens(struct radeonfb_info *rinfo,
                  * Old single head cards
                  */
                 if (!rinfo->has_CRTC2) {
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
                         if (rinfo->mon1_type == MT_NONE)
                                 rinfo->mon1_type = radeon_probe_OF_head(rinfo, 0,
                                                                         &rinfo->mon1_EDID);
-#endif /* CONFIG_PPC_OF || CONFIG_SPARC */
+#endif /* CONFIG_PPC || CONFIG_SPARC */
 #ifdef CONFIG_FB_RADEON_I2C
                         if (rinfo->mon1_type == MT_NONE)
                                 rinfo->mon1_type =
@@ -548,11 +548,11 @@ void radeon_probe_screens(struct radeonfb_info *rinfo,
                 /*
                  * Probe primary head (DVI or laptop internal panel)
                  */
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
                 if (rinfo->mon1_type == MT_NONE)
                         rinfo->mon1_type = radeon_probe_OF_head(rinfo, 0,
                                                                 &rinfo->mon1_EDID);
-#endif /* CONFIG_PPC_OF || CONFIG_SPARC */
+#endif /* CONFIG_PPC || CONFIG_SPARC */
 #ifdef CONFIG_FB_RADEON_I2C
                 if (rinfo->mon1_type == MT_NONE)
                         rinfo->mon1_type = radeon_probe_i2c_connector(rinfo, ddc_dvi,
@@ -576,11 +576,11 @@ void radeon_probe_screens(struct radeonfb_info *rinfo,
                 /*
                  * Probe secondary head (mostly VGA, can be DVI)
                  */
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
                 if (rinfo->mon2_type == MT_NONE)
                         rinfo->mon2_type = radeon_probe_OF_head(rinfo, 1,
                                                                 &rinfo->mon2_EDID);
-#endif /* CONFIG_PPC_OF || defined(CONFIG_SPARC) */
+#endif /* CONFIG_PPC || defined(CONFIG_SPARC) */
 #ifdef CONFIG_FB_RADEON_I2C
                 if (rinfo->mon2_type == MT_NONE)
                         rinfo->mon2_type = radeon_probe_i2c_connector(rinfo, ddc_vga,
@@ -653,7 +653,7 @@ void radeon_probe_screens(struct radeonfb_info *rinfo,
  */
 static void radeon_fixup_panel_info(struct radeonfb_info *rinfo)
 {
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_PPC
         /*
          * LCD Flat panels should use fixed dividers, we enfore that on
          * PPC only for now...
@@ -676,7 +676,7 @@ static void radeon_fixup_panel_info(struct radeonfb_info *rinfo)
                        (rinfo->panel_info.post_divider << 16),
                        ppll_div_sel);
         }
-#endif /* CONFIG_PPC_OF */
+#endif /* CONFIG_PPC */
 }
 
 
diff --git a/drivers/video/fbdev/aty/radeon_pm.c b/drivers/video/fbdev/aty/radeon_pm.c
index 46a12f1a93c3..1417542738fc 100644
--- a/drivers/video/fbdev/aty/radeon_pm.c
+++ b/drivers/video/fbdev/aty/radeon_pm.c
@@ -523,7 +523,7 @@ static void radeon_pm_enable_dynamic_mode(struct radeonfb_info *rinfo)
         OUTPLL(pllVCLK_ECP_CNTL, tmp);
 
         /* X doesn't do that ... hrm, we do on mobility && Macs */
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_PPC
         if (rinfo->is_mobility) {
                 tmp  = INPLL(pllMCLK_CNTL);
                 tmp &= ~(MCLK_CNTL__FORCE_MCLKA |
@@ -541,7 +541,7 @@ static void radeon_pm_enable_dynamic_mode(struct radeonfb_info *rinfo)
                 OUTPLL(pllMCLK_MISC, tmp);
                 radeon_msleep(15);
         }
-#endif /* CONFIG_PPC_OF */
+#endif /* CONFIG_PPC */
 }
 
 #ifdef CONFIG_PM
@@ -1288,7 +1288,7 @@ static void radeon_pm_full_reset_sdram(struct radeonfb_info *rinfo)
                 radeon_pm_enable_dll_m10(rinfo);
                 radeon_pm_yclk_mclk_sync_m10(rinfo);
 
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_PPC
                 if (rinfo->of_node != NULL) {
                         int size;
 
@@ -1298,7 +1298,7 @@ static void radeon_pm_full_reset_sdram(struct radeonfb_info *rinfo)
                         else
                                 mrtable = default_mrtable;
                 }
-#endif /* CONFIG_PPC_OF */
+#endif /* CONFIG_PPC */
 
                 /* Program the SDRAM */
                 sdram_mode_reg = mrtable[0];
@@ -1943,7 +1943,7 @@ static void radeon_reinitialize_M10(struct radeonfb_info *rinfo)
 }
 #endif
 
-#ifdef CONFIG_PPC_OF
+#ifdef CONFIG_PPC
 #ifdef CONFIG_PPC_PMAC
 static void radeon_pm_m9p_reconfigure_mc(struct radeonfb_info *rinfo)
 {
@@ -2512,7 +2512,7 @@ static void radeon_reinitialize_QW(struct radeonfb_info *rinfo)
 }
 #endif /* 0 */
 
-#endif /* CONFIG_PPC_OF */
+#endif /* CONFIG_PPC */
 
 static void radeonfb_whack_power_state(struct radeonfb_info *rinfo, pci_power_t state)
 {
@@ -2793,7 +2793,7 @@ int radeonfb_pci_resume(struct pci_dev *pdev)
         return rc;
 }
 
-#ifdef CONFIG_PPC_OF__disabled
+#ifdef CONFIG_PPC__disabled
 static void radeonfb_early_resume(void *data)
 {
         struct radeonfb_info *rinfo = data;
@@ -2803,7 +2803,7 @@ static void radeonfb_early_resume(void *data)
         radeonfb_pci_resume(rinfo->pdev);
         rinfo->no_schedule = 0;
 }
-#endif /* CONFIG_PPC_OF */
+#endif /* CONFIG_PPC */
 
 #endif /* CONFIG_PM */
 
diff --git a/drivers/video/fbdev/aty/radeonfb.h b/drivers/video/fbdev/aty/radeonfb.h
index cb846044f57c..039def41c920 100644
--- a/drivers/video/fbdev/aty/radeonfb.h
+++ b/drivers/video/fbdev/aty/radeonfb.h
@@ -20,7 +20,7 @@
 
 #include <asm/io.h>
 
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
 #include <asm/prom.h>
 #endif
 
@@ -301,7 +301,7 @@ struct radeonfb_info {
         unsigned long           fb_local_base;
 
         struct pci_dev          *pdev;
-#if defined(CONFIG_PPC_OF) || defined(CONFIG_SPARC)
+#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
         struct device_node      *of_node;
 #endif
 
diff --git a/drivers/video/fbdev/controlfb.c b/drivers/video/fbdev/controlfb.c
index 080fdd2a70f3..8d14b29aafea 100644
--- a/drivers/video/fbdev/controlfb.c
+++ b/drivers/video/fbdev/controlfb.c
@@ -315,7 +315,7 @@ static int controlfb_blank(int blank_mode, struct fb_info *info)
                 container_of(info, struct fb_info_control, info);
         unsigned ctrl;
 
-        ctrl = ld_le32(CNTRL_REG(p,ctrl));
+        ctrl = le32_to_cpup(CNTRL_REG(p,ctrl));
         if (blank_mode > 0)
                 switch (blank_mode) {
                 case FB_BLANK_VSYNC_SUSPEND:
diff --git a/drivers/video/fbdev/core/fbmon.c b/drivers/video/fbdev/core/fbmon.c
index 868facdec638..01ef1b953390 100644
--- a/drivers/video/fbdev/core/fbmon.c
+++ b/drivers/video/fbdev/core/fbmon.c
@@ -33,10 +33,6 @@
 #include <video/edid.h>
 #include <video/of_videomode.h>
 #include <video/videomode.h>
-#ifdef CONFIG_PPC_OF
-#include <asm/prom.h>
-#include <asm/pci-bridge.h>
-#endif
 #include "../edid.h"
 
 /*
diff --git a/drivers/video/fbdev/imsttfb.c b/drivers/video/fbdev/imsttfb.c
index aae10ce74f14..9b167f7ef6c6 100644
--- a/drivers/video/fbdev/imsttfb.c
+++ b/drivers/video/fbdev/imsttfb.c
@@ -1470,15 +1470,13 @@ static int imsttfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         unsigned long addr, size;
         struct imstt_par *par;
         struct fb_info *info;
-#ifdef CONFIG_PPC_OF
         struct device_node *dp;
         
         dp = pci_device_to_OF_node(pdev);
         if(dp)
                 printk(KERN_INFO "%s: OF name %s\n",__func__, dp->name);
-        else
+        else if (IS_ENABLED(CONFIG_OF))
                 printk(KERN_ERR "imsttfb: no OF node for pci device\n");
-#endif /* CONFIG_PPC_OF */
 
         info = framebuffer_alloc(sizeof(struct imstt_par), &pdev->dev);
 
@@ -1501,11 +1499,9 @@ static int imsttfb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         switch (pdev->device) {
                 case PCI_DEVICE_ID_IMS_TT128: /* IMS,tt128mbA */
                         par->ramdac = IBM;
-#ifdef CONFIG_PPC_OF
                         if (dp && ((strcmp(dp->name, "IMS,tt128mb8") == 0) ||
                                    (strcmp(dp->name, "IMS,tt128mb8A") == 0)))
                                 par->ramdac = TVP;
-#endif /* CONFIG_PPC_OF */
                         break;
                 case PCI_DEVICE_ID_IMS_TT3D:  /* IMS,tt3d */
                         par->ramdac = TVP;
diff --git a/drivers/video/fbdev/nvidia/Makefile b/drivers/video/fbdev/nvidia/Makefile
index ca47432113e0..917d3eb05feb 100644
--- a/drivers/video/fbdev/nvidia/Makefile
+++ b/drivers/video/fbdev/nvidia/Makefile
@@ -5,9 +5,8 @@
 obj-$(CONFIG_FB_NVIDIA)          += nvidiafb.o
 
 nvidiafb-y                       := nvidia.o nv_hw.o nv_setup.o \
-                                    nv_accel.o
+                                    nv_accel.o nv_of.o
 nvidiafb-$(CONFIG_FB_NVIDIA_I2C) += nv_i2c.o
 nvidiafb-$(CONFIG_FB_NVIDIA_BACKLIGHT)  += nv_backlight.o
-nvidiafb-$(CONFIG_PPC_OF)        += nv_of.o
 
 nvidiafb-objs                    := $(nvidiafb-y)
diff --git a/drivers/video/fbdev/nvidia/nv_of.c b/drivers/video/fbdev/nvidia/nv_of.c
index 3bc13df4b120..5f3e5179c25a 100644
--- a/drivers/video/fbdev/nvidia/nv_of.c
+++ b/drivers/video/fbdev/nvidia/nv_of.c
@@ -19,9 +19,6 @@
 
 #include <asm/io.h>
 
-#include <asm/prom.h>
-#include <asm/pci-bridge.h>
-
 #include "nv_type.h"
 #include "nv_local.h"
 #include "nv_proto.h"
diff --git a/drivers/video/fbdev/nvidia/nv_proto.h b/drivers/video/fbdev/nvidia/nv_proto.h
index ff5c410355ea..878a5ce02299 100644
--- a/drivers/video/fbdev/nvidia/nv_proto.h
+++ b/drivers/video/fbdev/nvidia/nv_proto.h
@@ -42,16 +42,8 @@ int nvidia_probe_i2c_connector(struct fb_info *info, int conn,
 #define nvidia_probe_i2c_connector(p, c, edid) (-1)
 #endif
 
-#ifdef CONFIG_PPC_OF
 int nvidia_probe_of_connector(struct fb_info *info, int conn,
                               u8 ** out_edid);
-#else
-static inline int nvidia_probe_of_connector(struct fb_info *info, int conn,
-                                      u8 ** out_edid)
-{
-        return -1;
-}
-#endif
 
 /* in nv_accel.c */
 extern void NVResetGraphics(struct fb_info *info);
diff --git a/drivers/video/fbdev/nvidia/nvidia.c b/drivers/video/fbdev/nvidia/nvidia.c
index def041204676..4273c6ee8cf6 100644
--- a/drivers/video/fbdev/nvidia/nvidia.c
+++ b/drivers/video/fbdev/nvidia/nvidia.c
@@ -24,10 +24,6 @@
 #ifdef CONFIG_MTRR
 #include <asm/mtrr.h>
 #endif
-#ifdef CONFIG_PPC_OF
-#include <asm/prom.h>
-#include <asm/pci-bridge.h>
-#endif
 #ifdef CONFIG_BOOTX_TEXT
 #include <asm/btext.h>
 #endif
diff --git a/drivers/video/fbdev/platinumfb.c b/drivers/video/fbdev/platinumfb.c
index 518d1fd38a81..377d3399a3ad 100644
--- a/drivers/video/fbdev/platinumfb.c
+++ b/drivers/video/fbdev/platinumfb.c
@@ -168,7 +168,7 @@ static int platinumfb_blank(int blank,  struct fb_info *fb)
         struct fb_info_platinum *info = (struct fb_info_platinum *) fb;
         int     ctrl;
 
-        ctrl = ld_le32(&info->platinum_regs->ctrl.r) | 0x33;
+        ctrl = le32_to_cpup(&info->platinum_regs->ctrl.r) | 0x33;
         if (blank)
                 --blank_mode;
         if (blank & VESA_VSYNC_SUSPEND)
diff --git a/drivers/video/fbdev/riva/fbdev.c b/drivers/video/fbdev/riva/fbdev.c
index be73727c7227..294a80908c8c 100644
--- a/drivers/video/fbdev/riva/fbdev.c
+++ b/drivers/video/fbdev/riva/fbdev.c
@@ -44,10 +44,6 @@
 #ifdef CONFIG_MTRR
 #include <asm/mtrr.h>
 #endif
-#ifdef CONFIG_PPC_OF
-#include <asm/prom.h>
-#include <asm/pci-bridge.h>
-#endif
 #ifdef CONFIG_PMAC_BACKLIGHT
 #include <asm/machdep.h>
 #include <asm/backlight.h>
@@ -1735,7 +1731,6 @@ static int riva_set_fbinfo(struct fb_info *info)
         return (rivafb_check_var(&info->var, info));
 }
 
-#ifdef CONFIG_PPC_OF
 static int riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd)
 {
         struct riva_par *par = info->par;
@@ -1766,9 +1761,8 @@ static int riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd)
         NVTRACE_LEAVE();
         return 0;
 }
-#endif /* CONFIG_PPC_OF */
 
-#if defined(CONFIG_FB_RIVA_I2C) && !defined(CONFIG_PPC_OF)
+#if defined(CONFIG_FB_RIVA_I2C)
 static int riva_get_EDID_i2c(struct fb_info *info)
 {
         struct riva_par *par = info->par;
@@ -1828,10 +1822,13 @@ static void riva_update_default_var(struct fb_var_screeninfo *var,
 static void riva_get_EDID(struct fb_info *info, struct pci_dev *pdev)
 {
         NVTRACE_ENTER();
-#ifdef CONFIG_PPC_OF
-        if (!riva_get_EDID_OF(info, pdev))
+        if (riva_get_EDID_OF(info, pdev)) {
+                NVTRACE_LEAVE();
+                return;
+        }
+        if (IS_ENABLED(CONFIG_OF))
                 printk(PFX "could not retrieve EDID from OF\n");
-#elif defined(CONFIG_FB_RIVA_I2C)
+#if defined(CONFIG_FB_RIVA_I2C)
         if (!riva_get_EDID_i2c(info))
                 printk(PFX "could not retrieve EDID from DDC/I2C\n");
 #endif