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

Pull powerpc updates from Michael Ellerman:
 "Notable changes:

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

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

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

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

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

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

   - Add support for PTRACE_SYSEMU and PTRACE_SYSEMU_SINGLESTEP.

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

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

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

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

  And many other smaller enhancements and cleanups.

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

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

19 files changed, 327 insertions, 287 deletions

diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index 1106c076fa4b..600430685e28 100644
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -191,8 +191,7 @@ static int z2_open(struct block_device *bdev, fmode_t mode)
                         vfree(vmalloc (size));
                 }
 
-                vaddr = (unsigned long) __ioremap (paddr, size, 
-                                                   _PAGE_WRITETHRU);
+                vaddr = (unsigned long)ioremap_wt(paddr, size);
 
 #else
                 vaddr = (unsigned long)z_remap_nocache_nonser(paddr, size);
diff --git a/drivers/macintosh/adb-iop.c b/drivers/macintosh/adb-iop.c
index ca623e6446e4..fca31640e3ef 100644
--- a/drivers/macintosh/adb-iop.c
+++ b/drivers/macintosh/adb-iop.c
@@ -20,13 +20,13 @@
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 
-#include <asm/macintosh.h> 
-#include <asm/macints.h> 
+#include <asm/macintosh.h>
+#include <asm/macints.h>
 #include <asm/mac_iop.h>
 #include <asm/mac_oss.h>
 #include <asm/adb_iop.h>
 
-#include <linux/adb.h> 
+#include <linux/adb.h>
 
 /*#define DEBUG_ADB_IOP*/
 
@@ -38,9 +38,9 @@ static unsigned char *reply_ptr;
 #endif
 
 static enum adb_iop_state {
-    idle,
-    sending,
-    awaiting_reply
+        idle,
+        sending,
+        awaiting_reply
 } adb_iop_state;
 
 static void adb_iop_start(void);
@@ -66,7 +66,8 @@ static void adb_iop_end_req(struct adb_request *req, int state)
 {
         req->complete = 1;
         current_req = req->next;
-        if (req->done) (*req->done)(req);
+        if (req->done)
+                (*req->done)(req);
         adb_iop_state = state;
 }
 
@@ -100,7 +101,7 @@ static void adb_iop_complete(struct iop_msg *msg)
 
 static void adb_iop_listen(struct iop_msg *msg)
 {
-        struct adb_iopmsg *amsg = (struct adb_iopmsg *) msg->message;
+        struct adb_iopmsg *amsg = (struct adb_iopmsg *)msg->message;
         struct adb_request *req;
         unsigned long flags;
 #ifdef DEBUG_ADB_IOP
@@ -113,9 +114,9 @@ static void adb_iop_listen(struct iop_msg *msg)
 
 #ifdef DEBUG_ADB_IOP
         printk("adb_iop_listen %p: rcvd packet, %d bytes: %02X %02X", req,
-                (uint) amsg->count + 2, (uint) amsg->flags, (uint) amsg->cmd);
+               (uint)amsg->count + 2, (uint)amsg->flags, (uint)amsg->cmd);
         for (i = 0; i < amsg->count; i++)
-                printk(" %02X", (uint) amsg->data[i]);
+                printk(" %02X", (uint)amsg->data[i]);
         printk("\n");
 #endif
 
@@ -168,14 +169,15 @@ static void adb_iop_start(void)
 
         /* get the packet to send */
         req = current_req;
-        if (!req) return;
+        if (!req)
+                return;
 
         local_irq_save(flags);
 
 #ifdef DEBUG_ADB_IOP
         printk("adb_iop_start %p: sending packet, %d bytes:", req, req->nbytes);
-        for (i = 0 ; i < req->nbytes ; i++)
-                printk(" %02X", (uint) req->data[i]);
+        for (i = 0; i < req->nbytes; i++)
+                printk(" %02X", (uint)req->data[i]);
         printk("\n");
 #endif
 
@@ -196,19 +198,20 @@ static void adb_iop_start(void)
         /* Now send it. The IOP manager will call adb_iop_complete */
         /* when the packet has been sent.                          */
 
-        iop_send_message(ADB_IOP, ADB_CHAN, req,
-                         sizeof(amsg), (__u8 *) &amsg, adb_iop_complete);
+        iop_send_message(ADB_IOP, ADB_CHAN, req, sizeof(amsg), (__u8 *)&amsg,
+                         adb_iop_complete);
 }
 
 int adb_iop_probe(void)
 {
-        if (!iop_ism_present) return -ENODEV;
+        if (!iop_ism_present)
+                return -ENODEV;
         return 0;
 }
 
 int adb_iop_init(void)
 {
-        printk("adb: IOP ISM driver v0.4 for Unified ADB.\n");
+        pr_info("adb: IOP ISM driver v0.4 for Unified ADB\n");
         iop_listen(ADB_IOP, ADB_CHAN, adb_iop_listen, "ADB");
         return 0;
 }
@@ -218,10 +221,12 @@ int adb_iop_send_request(struct adb_request *req, int sync)
         int err;
 
         err = adb_iop_write(req);
-        if (err) return err;
+        if (err)
+                return err;
 
         if (sync) {
-                while (!req->complete) adb_iop_poll();
+                while (!req->complete)
+                        adb_iop_poll();
         }
         return 0;
 }
@@ -251,7 +256,9 @@ static int adb_iop_write(struct adb_request *req)
         }
 
         local_irq_restore(flags);
-        if (adb_iop_state == idle) adb_iop_start();
+
+        if (adb_iop_state == idle)
+                adb_iop_start();
         return 0;
 }
 
@@ -263,7 +270,8 @@ int adb_iop_autopoll(int devs)
 
 void adb_iop_poll(void)
 {
-        if (adb_iop_state == idle) adb_iop_start();
+        if (adb_iop_state == idle)
+                adb_iop_start();
         iop_ism_irq_poll(ADB_IOP);
 }
 
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 76e98f0f7a3e..e49d1f287a17 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -203,15 +203,15 @@ static int adb_scan_bus(void)
         }
 
         /* Now fill in the handler_id field of the adb_handler entries. */
-        pr_debug("adb devices:\n");
         for (i = 1; i < 16; i++) {
                 if (adb_handler[i].original_address == 0)
                         continue;
                 adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
                             (i << 4) | 0xf);
                 adb_handler[i].handler_id = req.reply[2];
-                pr_debug(" [%d]: %d %x\n", i, adb_handler[i].original_address,
-                         adb_handler[i].handler_id);
+                printk(KERN_DEBUG "adb device [%d]: %d 0x%X\n", i,
+                       adb_handler[i].original_address,
+                       adb_handler[i].handler_id);
                 devmask |= 1 << i;
         }
         return devmask;
@@ -579,6 +579,8 @@ adb_try_handler_change(int address, int new_id)
         mutex_lock(&adb_handler_mutex);
         ret = try_handler_change(address, new_id);
         mutex_unlock(&adb_handler_mutex);
+        if (ret)
+                pr_debug("adb handler change: [%d] 0x%X\n", address, new_id);
         return ret;
 }
 EXPORT_SYMBOL(adb_try_handler_change);
diff --git a/drivers/macintosh/adbhid.c b/drivers/macintosh/adbhid.c
index a261892c03b3..75482eeab2c4 100644
--- a/drivers/macintosh/adbhid.c
+++ b/drivers/macintosh/adbhid.c
@@ -757,6 +757,7 @@ adbhid_input_register(int id, int default_id, int original_handler_id,
         struct input_dev *input_dev;
         int err;
         int i;
+        char *keyboard_type;
 
         if (adbhid[id]) {
                 pr_err("Trying to reregister ADB HID on ID %d\n", id);
@@ -798,24 +799,23 @@ adbhid_input_register(int id, int default_id, int original_handler_id,
 
                 memcpy(hid->keycode, adb_to_linux_keycodes, sizeof(adb_to_linux_keycodes));
 
-                pr_info("Detected ADB keyboard, type ");
                 switch (original_handler_id) {
                 default:
-                        pr_cont("<unknown>.\n");
+                        keyboard_type = "<unknown>";
                         input_dev->id.version = ADB_KEYBOARD_UNKNOWN;
                         break;
 
                 case 0x01: case 0x02: case 0x03: case 0x06: case 0x08:
                 case 0x0C: case 0x10: case 0x18: case 0x1B: case 0x1C:
                 case 0xC0: case 0xC3: case 0xC6:
-                        pr_cont("ANSI.\n");
+                        keyboard_type = "ANSI";
                         input_dev->id.version = ADB_KEYBOARD_ANSI;
                         break;
 
                 case 0x04: case 0x05: case 0x07: case 0x09: case 0x0D:
                 case 0x11: case 0x14: case 0x19: case 0x1D: case 0xC1:
                 case 0xC4: case 0xC7:
-                        pr_cont("ISO, swapping keys.\n");
+                        keyboard_type = "ISO, swapping keys";
                         input_dev->id.version = ADB_KEYBOARD_ISO;
                         i = hid->keycode[10];
                         hid->keycode[10] = hid->keycode[50];
@@ -824,10 +824,11 @@ adbhid_input_register(int id, int default_id, int original_handler_id,
 
                 case 0x12: case 0x15: case 0x16: case 0x17: case 0x1A:
                 case 0x1E: case 0xC2: case 0xC5: case 0xC8: case 0xC9:
-                        pr_cont("JIS.\n");
+                        keyboard_type = "JIS";
                         input_dev->id.version = ADB_KEYBOARD_JIS;
                         break;
                 }
+                pr_info("Detected ADB keyboard, type %s.\n", keyboard_type);
 
                 for (i = 0; i < 128; i++)
                         if (hid->keycode[i])
@@ -972,16 +973,13 @@ adbhid_probe(void)
                    ->get it to send separate codes for left and right shift,
                    control, option keys */
 #if 0           /* handler 5 doesn't send separate codes for R modifiers */
-                if (adb_try_handler_change(id, 5))
-                        printk("ADB keyboard at %d, handler set to 5\n", id);
-                else
+                if (!adb_try_handler_change(id, 5))
 #endif
-                if (adb_try_handler_change(id, 3))
-                        printk("ADB keyboard at %d, handler set to 3\n", id);
-                else
-                        printk("ADB keyboard at %d, handler 1\n", id);
+                adb_try_handler_change(id, 3);
 
                 adb_get_infos(id, &default_id, &cur_handler_id);
+                printk(KERN_DEBUG "ADB keyboard at %d has handler 0x%X\n",
+                       id, cur_handler_id);
                 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
                                                cur_handler_id, 0);
         }
@@ -999,48 +997,44 @@ adbhid_probe(void)
         for (i = 0; i < mouse_ids.nids; i++) {
                 int id = mouse_ids.id[i];
                 int mouse_kind;
+                char *desc = "standard";
 
                 adb_get_infos(id, &default_id, &org_handler_id);
 
                 if (adb_try_handler_change(id, 4)) {
-                        printk("ADB mouse at %d, handler set to 4", id);
                         mouse_kind = ADBMOUSE_EXTENDED;
                 }
                 else if (adb_try_handler_change(id, 0x2F)) {
-                        printk("ADB mouse at %d, handler set to 0x2F", id);
                         mouse_kind = ADBMOUSE_MICROSPEED;
                 }
                 else if (adb_try_handler_change(id, 0x42)) {
-                        printk("ADB mouse at %d, handler set to 0x42", id);
                         mouse_kind = ADBMOUSE_TRACKBALLPRO;
                 }
                 else if (adb_try_handler_change(id, 0x66)) {
-                        printk("ADB mouse at %d, handler set to 0x66", id);
                         mouse_kind = ADBMOUSE_MICROSPEED;
                 }
                 else if (adb_try_handler_change(id, 0x5F)) {
-                        printk("ADB mouse at %d, handler set to 0x5F", id);
                         mouse_kind = ADBMOUSE_MICROSPEED;
                 }
                 else if (adb_try_handler_change(id, 3)) {
-                        printk("ADB mouse at %d, handler set to 3", id);
                         mouse_kind = ADBMOUSE_MS_A3;
                 }
                 else if (adb_try_handler_change(id, 2)) {
-                        printk("ADB mouse at %d, handler set to 2", id);
                         mouse_kind = ADBMOUSE_STANDARD_200;
                 }
                 else {
-                        printk("ADB mouse at %d, handler 1", id);
                         mouse_kind = ADBMOUSE_STANDARD_100;
                 }
 
                 if ((mouse_kind == ADBMOUSE_TRACKBALLPRO)
                     || (mouse_kind == ADBMOUSE_MICROSPEED)) {
+                        desc = "Microspeed/MacPoint or compatible";
                         init_microspeed(id);
                 } else if (mouse_kind == ADBMOUSE_MS_A3) {
+                        desc = "Mouse Systems A3 Mouse or compatible";
                         init_ms_a3(id);
                 } else if (mouse_kind ==  ADBMOUSE_EXTENDED) {
+                        desc = "extended";
                         /*
                          * Register 1 is usually used for device
                          * identification.  Here, we try to identify
@@ -1054,32 +1048,36 @@ adbhid_probe(void)
                             (req.reply[1] == 0x9a) && ((req.reply[2] == 0x21)
                                 || (req.reply[2] == 0x20))) {
                                 mouse_kind = ADBMOUSE_TRACKBALL;
+                                desc = "trackman/mouseman";
                                 init_trackball(id);
                         }
                         else if ((req.reply_len >= 4) &&
                             (req.reply[1] == 0x74) && (req.reply[2] == 0x70) &&
                             (req.reply[3] == 0x61) && (req.reply[4] == 0x64)) {
                                 mouse_kind = ADBMOUSE_TRACKPAD;
+                                desc = "trackpad";
                                 init_trackpad(id);
                         }
                         else if ((req.reply_len >= 4) &&
                             (req.reply[1] == 0x4b) && (req.reply[2] == 0x4d) &&
                             (req.reply[3] == 0x4c) && (req.reply[4] == 0x31)) {
                                 mouse_kind = ADBMOUSE_TURBOMOUSE5;
+                                desc = "TurboMouse 5";
                                 init_turbomouse(id);
                         }
                         else if ((req.reply_len == 9) &&
                             (req.reply[1] == 0x4b) && (req.reply[2] == 0x4f) &&
                             (req.reply[3] == 0x49) && (req.reply[4] == 0x54)) {
                                 if (adb_try_handler_change(id, 0x42)) {
-                                        pr_cont("\nADB MacAlly 2-button mouse at %d, handler set to 0x42", id);
                                         mouse_kind = ADBMOUSE_MACALLY2;
+                                        desc = "MacAlly 2-button";
                                 }
                         }
                 }
-                pr_cont("\n");
 
                 adb_get_infos(id, &default_id, &cur_handler_id);
+                printk(KERN_DEBUG "ADB mouse (%s) at %d has handler 0x%X\n",
+                       desc, id, cur_handler_id);
                 reg |= adbhid_input_reregister(id, default_id, org_handler_id,
                                                cur_handler_id, mouse_kind);
         }
@@ -1092,12 +1090,10 @@ init_trackpad(int id)
         struct adb_request req;
         unsigned char r1_buffer[8];
 
-        pr_cont(" (trackpad)");
-
         adb_request(&req, NULL, ADBREQ_SYNC | ADBREQ_REPLY, 1,
                     ADB_READREG(id,1));
         if (req.reply_len < 8)
-            pr_cont("bad length for reg. 1\n");
+                pr_err("%s: bad length for reg. 1\n", __func__);
         else
         {
             memcpy(r1_buffer, &req.reply[1], 8);
@@ -1145,8 +1141,6 @@ init_trackball(int id)
 {
         struct adb_request req;
 
-        pr_cont(" (trackman/mouseman)");
-
         adb_request(&req, NULL, ADBREQ_SYNC, 3,
         ADB_WRITEREG(id,1), 00,0x81);
 
@@ -1177,8 +1171,6 @@ init_turbomouse(int id)
 {
         struct adb_request req;
 
-        pr_cont(" (TurboMouse 5)");
-
         adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
 
         adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(3));
@@ -1213,8 +1205,6 @@ init_microspeed(int id)
 {
         struct adb_request req;
 
-        pr_cont(" (Microspeed/MacPoint or compatible)");
-
         adb_request(&req, NULL, ADBREQ_SYNC, 1, ADB_FLUSH(id));
 
         /* This will initialize mice using the Microspeed, MacPoint and
@@ -1253,7 +1243,6 @@ init_ms_a3(int id)
 {
         struct adb_request req;
 
-        pr_cont(" (Mouse Systems A3 Mouse, or compatible)");
         adb_request(&req, NULL, ADBREQ_SYNC, 3,
         ADB_WRITEREG(id, 0x2),
             0x00,
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 07074820a167..17d3bc917562 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -360,9 +360,10 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
                                                struct macio_dev *in_bay,
                                                struct resource *parent_res)
 {
+        char name[MAX_NODE_NAME_SIZE + 1];
         struct macio_dev *dev;
         const u32 *reg;
-        
+
         if (np == NULL)
                 return NULL;
 
@@ -402,6 +403,7 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
 #endif
 
         /* MacIO itself has a different reg, we use it's PCI base */
+        snprintf(name, sizeof(name), "%pOFn", np);
         if (np == chip->of_node) {
                 dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s",
                              chip->lbus.index,
@@ -410,12 +412,12 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
 #else
                         0, /* NuBus may want to do something better here */
 #endif
-                        MAX_NODE_NAME_SIZE, np->name);
+                        MAX_NODE_NAME_SIZE, name);
         } else {
                 reg = of_get_property(np, "reg", NULL);
                 dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s",
                              chip->lbus.index,
-                             reg ? *reg : 0, MAX_NODE_NAME_SIZE, np->name);
+                             reg ? *reg : 0, MAX_NODE_NAME_SIZE, name);
         }
 
         /* Setup interrupts & resources */
diff --git a/drivers/macintosh/macio_sysfs.c b/drivers/macintosh/macio_sysfs.c
index ca4fcffe454b..d2451e58acb9 100644
--- a/drivers/macintosh/macio_sysfs.c
+++ b/drivers/macintosh/macio_sysfs.c
@@ -58,7 +58,13 @@ static ssize_t devspec_show(struct device *dev,
 static DEVICE_ATTR_RO(modalias);
 static DEVICE_ATTR_RO(devspec);
 
-macio_config_of_attr (name, "%s\n");
+static ssize_t name_show(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%pOFn\n", dev->of_node);
+}
+static DEVICE_ATTR_RO(name);
+
 macio_config_of_attr (type, "%s\n");
 
 static struct attribute *macio_dev_attrs[] = {
diff --git a/drivers/macintosh/via-cuda.c b/drivers/macintosh/via-cuda.c
index 98dd702eb867..bbec6ac0a966 100644
--- a/drivers/macintosh/via-cuda.c
+++ b/drivers/macintosh/via-cuda.c
@@ -766,3 +766,38 @@ cuda_input(unsigned char *buf, int nb)
                        buf, nb, false);
     }
 }
+
+/* Offset between Unix time (1970-based) and Mac time (1904-based) */
+#define RTC_OFFSET      2082844800
+
+time64_t cuda_get_time(void)
+{
+        struct adb_request req;
+        u32 now;
+
+        if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME) < 0)
+                return 0;
+        while (!req.complete)
+                cuda_poll();
+        if (req.reply_len != 7)
+                pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
+        now = (req.reply[3] << 24) + (req.reply[4] << 16) +
+              (req.reply[5] << 8) + req.reply[6];
+        return (time64_t)now - RTC_OFFSET;
+}
+
+int cuda_set_rtc_time(struct rtc_time *tm)
+{
+        u32 now;
+        struct adb_request req;
+
+        now = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
+        if (cuda_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME,
+                         now >> 24, now >> 16, now >> 8, now) < 0)
+                return -ENXIO;
+        while (!req.complete)
+                cuda_poll();
+        if ((req.reply_len != 3) && (req.reply_len != 7))
+                pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
+        return 0;
+}
diff --git a/drivers/macintosh/via-macii.c b/drivers/macintosh/via-macii.c
index cf6f7d52d6be..ac824d7b2dcf 100644
--- a/drivers/macintosh/via-macii.c
+++ b/drivers/macintosh/via-macii.c
@@ -12,7 +12,7 @@
  *
  * 1999-08-02 (jmt) - Initial rewrite for Unified ADB.
  * 2000-03-29 Tony Mantler <tonym@mac.linux-m68k.org>
- *                              - Big overhaul, should actually work now.
+ *            - Big overhaul, should actually work now.
  * 2006-12-31 Finn Thain - Another overhaul.
  *
  * Suggested reading:
@@ -23,7 +23,7 @@
  * Apple's "ADB Analyzer" bus sniffer is invaluable:
  *   ftp://ftp.apple.com/developer/Tool_Chest/Devices_-_Hardware/Apple_Desktop_Bus/
  */
- 
+
 #include <stdarg.h>
 #include <linux/types.h>
 #include <linux/errno.h>
@@ -77,7 +77,7 @@ static volatile unsigned char *via;
 #define ST_ODD          0x20            /* ADB state: odd data byte */
 #define ST_IDLE         0x30            /* ADB state: idle, nothing to send */
 
-static int  macii_init_via(void);
+static int macii_init_via(void);
 static void macii_start(void);
 static irqreturn_t macii_interrupt(int irq, void *arg);
 static void macii_queue_poll(void);
@@ -120,31 +120,15 @@ static int srq_asserted;     /* have to poll for the device that asserted it */
 static int command_byte;         /* the most recent command byte transmitted */
 static int autopoll_devs;      /* bits set are device addresses to be polled */
 
-/* Sanity check for request queue. Doesn't check for cycles. */
-static int request_is_queued(struct adb_request *req) {
-        struct adb_request *cur;
-        unsigned long flags;
-        local_irq_save(flags);
-        cur = current_req;
-        while (cur) {
-                if (cur == req) {
-                        local_irq_restore(flags);
-                        return 1;
-                }
-                cur = cur->next;
-        }
-        local_irq_restore(flags);
-        return 0;
-}
-
 /* Check for MacII style ADB */
 static int macii_probe(void)
 {
-        if (macintosh_config->adb_type != MAC_ADB_II) return -ENODEV;
+        if (macintosh_config->adb_type != MAC_ADB_II)
+                return -ENODEV;
 
         via = via1;
 
-        printk("adb: Mac II ADB Driver v1.0 for Unified ADB\n");
+        pr_info("adb: Mac II ADB Driver v1.0 for Unified ADB\n");
         return 0;
 }
 
@@ -153,15 +137,17 @@ int macii_init(void)
 {
         unsigned long flags;
         int err;
-        
+
         local_irq_save(flags);
-        
+
         err = macii_init_via();
-        if (err) goto out;
+        if (err)
+                goto out;
 
         err = request_irq(IRQ_MAC_ADB, macii_interrupt, 0, "ADB",
                           macii_interrupt);
-        if (err) goto out;
+        if (err)
+                goto out;
 
         macii_state = idle;
 out:
@@ -169,7 +155,7 @@ out:
         return err;
 }
 
-/* initialize the hardware */   
+/* initialize the hardware */
 static int macii_init_via(void)
 {
         unsigned char x;
@@ -179,7 +165,7 @@ static int macii_init_via(void)
 
         /* Set up state: idle */
         via[B] |= ST_IDLE;
-        last_status = via[B] & (ST_MASK|CTLR_IRQ);
+        last_status = via[B] & (ST_MASK | CTLR_IRQ);
 
         /* Shift register on input */
         via[ACR] = (via[ACR] & ~SR_CTRL) | SR_EXT;
@@ -205,7 +191,8 @@ static void macii_queue_poll(void)
         int next_device;
         static struct adb_request req;
 
-        if (!autopoll_devs) return;
+        if (!autopoll_devs)
+                return;
 
         device_mask = (1 << (((command_byte & 0xF0) >> 4) + 1)) - 1;
         if (autopoll_devs & ~device_mask)
@@ -213,10 +200,7 @@ static void macii_queue_poll(void)
         else
                 next_device = ffs(autopoll_devs) - 1;
 
-        BUG_ON(request_is_queued(&req));
-
-        adb_request(&req, NULL, ADBREQ_NOSEND, 1,
-                    ADB_READREG(next_device, 0));
+        adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_READREG(next_device, 0));
 
         req.sent = 0;
         req.complete = 0;
@@ -235,45 +219,47 @@ static void macii_queue_poll(void)
 static int macii_send_request(struct adb_request *req, int sync)
 {
         int err;
-        unsigned long flags;
 
-        BUG_ON(request_is_queued(req));
-
-        local_irq_save(flags);
         err = macii_write(req);
-        local_irq_restore(flags);
+        if (err)
+                return err;
 
-        if (!err && sync) {
-                while (!req->complete) {
+        if (sync)
+                while (!req->complete)
                         macii_poll();
-                }
-                BUG_ON(request_is_queued(req));
-        }
 
-        return err;
+        return 0;
 }
 
 /* Send an ADB request (append to request queue) */
 static int macii_write(struct adb_request *req)
 {
+        unsigned long flags;
+
         if (req->nbytes < 2 || req->data[0] != ADB_PACKET || req->nbytes > 15) {
                 req->complete = 1;
                 return -EINVAL;
         }
-        
+
         req->next = NULL;
         req->sent = 0;
         req->complete = 0;
         req->reply_len = 0;
 
+        local_irq_save(flags);
+
         if (current_req != NULL) {
                 last_req->next = req;
                 last_req = req;
         } else {
                 current_req = req;
                 last_req = req;
-                if (macii_state == idle) macii_start();
+                if (macii_state == idle)
+                        macii_start();
         }
+
+        local_irq_restore(flags);
+
         return 0;
 }
 
@@ -287,7 +273,8 @@ static int macii_autopoll(int devs)
         /* bit 1 == device 1, and so on. */
         autopoll_devs = devs & 0xFFFE;
 
-        if (!autopoll_devs) return 0;
+        if (!autopoll_devs)
+                return 0;
 
         local_irq_save(flags);
 
@@ -304,7 +291,8 @@ static int macii_autopoll(int devs)
         return err;
 }
 
-static inline int need_autopoll(void) {
+static inline int need_autopoll(void)
+{
         /* Was the last command Talk Reg 0
          * and is the target on the autopoll list?
          */
@@ -317,21 +305,17 @@ static inline int need_autopoll(void) {
 /* Prod the chip without interrupts */
 static void macii_poll(void)
 {
-        disable_irq(IRQ_MAC_ADB);
         macii_interrupt(0, NULL);
-        enable_irq(IRQ_MAC_ADB);
 }
 
 /* Reset the bus */
 static int macii_reset_bus(void)
 {
         static struct adb_request req;
-        
-        if (request_is_queued(&req))
-                return 0;
 
         /* Command = 0, Address = ignored */
-        adb_request(&req, NULL, 0, 1, ADB_BUSRESET);
+        adb_request(&req, NULL, ADBREQ_NOSEND, 1, ADB_BUSRESET);
+        macii_send_request(&req, 1);
 
         /* Don't want any more requests during the Global Reset low time. */
         udelay(3000);
@@ -346,10 +330,6 @@ static void macii_start(void)
 
         req = current_req;
 
-        BUG_ON(req == NULL);
-
-        BUG_ON(macii_state != idle);
-
         /* Now send it. Be careful though, that first byte of the request
          * is actually ADB_PACKET; the real data begins at index 1!
          * And req->nbytes is the number of bytes of real data plus one.
@@ -375,7 +355,7 @@ static void macii_start(void)
  * to be activity on the ADB bus. The chip will poll to achieve this.
  *
  * The basic ADB state machine was left unchanged from the original MacII code
- * by Alan Cox, which was based on the CUDA driver for PowerMac. 
+ * by Alan Cox, which was based on the CUDA driver for PowerMac.
  * The syntax of the ADB status lines is totally different on MacII,
  * though. MacII uses the states Command -> Even -> Odd -> Even ->...-> Idle
  * for sending and Idle -> Even -> Odd -> Even ->...-> Idle for receiving.
@@ -387,164 +367,166 @@ static void macii_start(void)
 static irqreturn_t macii_interrupt(int irq, void *arg)
 {
         int x;
-        static int entered;
         struct adb_request *req;
+        unsigned long flags;
+
+        local_irq_save(flags);
 
         if (!arg) {
                 /* Clear the SR IRQ flag when polling. */
                 if (via[IFR] & SR_INT)
                         via[IFR] = SR_INT;
-                else
+                else {
+                        local_irq_restore(flags);
                         return IRQ_NONE;
+                }
         }
 
-        BUG_ON(entered++);
-
         last_status = status;
-        status = via[B] & (ST_MASK|CTLR_IRQ);
+        status = via[B] & (ST_MASK | CTLR_IRQ);
 
         switch (macii_state) {
-                case idle:
-                        if (reading_reply) {
-                                reply_ptr = current_req->reply;
-                        } else {
-                                BUG_ON(current_req != NULL);
-                                reply_ptr = reply_buf;
-                        }
+        case idle:
+                if (reading_reply) {
+                        reply_ptr = current_req->reply;
+                } else {
+                        WARN_ON(current_req);
+                        reply_ptr = reply_buf;
+                }
 
-                        x = via[SR];
+                x = via[SR];
 
-                        if ((status & CTLR_IRQ) && (x == 0xFF)) {
-                                /* Bus timeout without SRQ sequence:
-                                 *     data is "FF" while CTLR_IRQ is "H"
-                                 */
-                                reply_len = 0;
-                                srq_asserted = 0;
-                                macii_state = read_done;
-                        } else {
-                                macii_state = reading;
-                                *reply_ptr = x;
-                                reply_len = 1;
-                        }
+                if ((status & CTLR_IRQ) && (x == 0xFF)) {
+                        /* Bus timeout without SRQ sequence:
+                         *     data is "FF" while CTLR_IRQ is "H"
+                         */
+                        reply_len = 0;
+                        srq_asserted = 0;
+                        macii_state = read_done;
+                } else {
+                        macii_state = reading;
+                        *reply_ptr = x;
+                        reply_len = 1;
+                }
 
-                        /* set ADB state = even for first data byte */
-                        via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
-                        break;
+                /* set ADB state = even for first data byte */
+                via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
+                break;
 
-                case sending:
-                        req = current_req;
-                        if (data_index >= req->nbytes) {
-                                req->sent = 1;
-                                macii_state = idle;
-
-                                if (req->reply_expected) {
-                                        reading_reply = 1;
-                                } else {
-                                        req->complete = 1;
-                                        current_req = req->next;
-                                        if (req->done) (*req->done)(req);
-
-                                        if (current_req)
-                                                macii_start();
-                                        else
-                                                if (need_autopoll())
-                                                        macii_autopoll(autopoll_devs);
-                                }
+        case sending:
+                req = current_req;
+                if (data_index >= req->nbytes) {
+                        req->sent = 1;
+                        macii_state = idle;
 
-                                if (macii_state == idle) {
-                                        /* reset to shift in */
-                                        via[ACR] &= ~SR_OUT;
-                                        x = via[SR];
-                                        /* set ADB state idle - might get SRQ */
-                                        via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
-                                }
+                        if (req->reply_expected) {
+                                reading_reply = 1;
                         } else {
-                                via[SR] = req->data[data_index++];
-
-                                if ( (via[B] & ST_MASK) == ST_CMD ) {
-                                        /* just sent the command byte, set to EVEN */
-                                        via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
-                                } else {
-                                        /* invert state bits, toggle ODD/EVEN */
-                                        via[B] ^= ST_MASK;
-                                }
-                        }
-                        break;
-
-                case reading:
-                        x = via[SR];
-                        BUG_ON((status & ST_MASK) == ST_CMD ||
-                               (status & ST_MASK) == ST_IDLE);
-
-                        /* Bus timeout with SRQ sequence:
-                         *     data is "XX FF"      while CTLR_IRQ is "L L"
-                         * End of packet without SRQ sequence:
-                         *     data is "XX...YY 00" while CTLR_IRQ is "L...H L"
-                         * End of packet SRQ sequence:
-                         *     data is "XX...YY 00" while CTLR_IRQ is "L...L L"
-                         * (where XX is the first response byte and
-                         * YY is the last byte of valid response data.)
-                         */
+                                req->complete = 1;
+                                current_req = req->next;
+                                if (req->done)
+                                        (*req->done)(req);
 
-                        srq_asserted = 0;
-                        if (!(status & CTLR_IRQ)) {
-                                if (x == 0xFF) {
-                                        if (!(last_status & CTLR_IRQ)) {
-                                                macii_state = read_done;
-                                                reply_len = 0;
-                                                srq_asserted = 1;
-                                        }
-                                } else if (x == 0x00) {
-                                        macii_state = read_done;
-                                        if (!(last_status & CTLR_IRQ))
-                                                srq_asserted = 1;
-                                }
+                                if (current_req)
+                                        macii_start();
+                                else if (need_autopoll())
+                                        macii_autopoll(autopoll_devs);
                         }
 
-                        if (macii_state == reading) {
-                                BUG_ON(reply_len > 15);
-                                reply_ptr++;
-                                *reply_ptr = x;
-                                reply_len++;
+                        if (macii_state == idle) {
+                                /* reset to shift in */
+                                via[ACR] &= ~SR_OUT;
+                                x = via[SR];
+                                /* set ADB state idle - might get SRQ */
+                                via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
                         }
+                } else {
+                        via[SR] = req->data[data_index++];
 
-                        /* invert state bits, toggle ODD/EVEN */
-                        via[B] ^= ST_MASK;
-                        break;
+                        if ((via[B] & ST_MASK) == ST_CMD) {
+                                /* just sent the command byte, set to EVEN */
+                                via[B] = (via[B] & ~ST_MASK) | ST_EVEN;
+                        } else {
+                                /* invert state bits, toggle ODD/EVEN */
+                                via[B] ^= ST_MASK;
+                        }
+                }
+                break;
 
-                case read_done:
-                        x = via[SR];
+        case reading:
+                x = via[SR];
+                WARN_ON((status & ST_MASK) == ST_CMD ||
+                        (status & ST_MASK) == ST_IDLE);
+
+                /* Bus timeout with SRQ sequence:
+                 *     data is "XX FF"      while CTLR_IRQ is "L L"
+                 * End of packet without SRQ sequence:
+                 *     data is "XX...YY 00" while CTLR_IRQ is "L...H L"
+                 * End of packet SRQ sequence:
+                 *     data is "XX...YY 00" while CTLR_IRQ is "L...L L"
+                 * (where XX is the first response byte and
+                 * YY is the last byte of valid response data.)
+                 */
 
-                        if (reading_reply) {
-                                reading_reply = 0;
-                                req = current_req;
-                                req->reply_len = reply_len;
-                                req->complete = 1;
-                                current_req = req->next;
-                                if (req->done) (*req->done)(req);
-                        } else if (reply_len && autopoll_devs)
-                                adb_input(reply_buf, reply_len, 0);
+                srq_asserted = 0;
+                if (!(status & CTLR_IRQ)) {
+                        if (x == 0xFF) {
+                                if (!(last_status & CTLR_IRQ)) {
+                                        macii_state = read_done;
+                                        reply_len = 0;
+                                        srq_asserted = 1;
+                                }
+                        } else if (x == 0x00) {
+                                macii_state = read_done;
+                                if (!(last_status & CTLR_IRQ))
+                                        srq_asserted = 1;
+                        }
+                }
 
-                        macii_state = idle;
+                if (macii_state == reading &&
+                    reply_len < ARRAY_SIZE(reply_buf)) {
+                        reply_ptr++;
+                        *reply_ptr = x;
+                        reply_len++;
+                }
 
-                        /* SRQ seen before, initiate poll now */
-                        if (srq_asserted)
-                                macii_queue_poll();
+                /* invert state bits, toggle ODD/EVEN */
+                via[B] ^= ST_MASK;
+                break;
 
-                        if (current_req)
-                                macii_start();
-                        else
-                                if (need_autopoll())
-                                        macii_autopoll(autopoll_devs);
+        case read_done:
+                x = via[SR];
 
-                        if (macii_state == idle)
-                                via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
-                        break;
+                if (reading_reply) {
+                        reading_reply = 0;
+                        req = current_req;
+                        req->reply_len = reply_len;
+                        req->complete = 1;
+                        current_req = req->next;
+                        if (req->done)
+                                (*req->done)(req);
+                } else if (reply_len && autopoll_devs)
+                        adb_input(reply_buf, reply_len, 0);
+
+                macii_state = idle;
+
+                /* SRQ seen before, initiate poll now */
+                if (srq_asserted)
+                        macii_queue_poll();
+
+                if (current_req)
+                        macii_start();
+                else if (need_autopoll())
+                        macii_autopoll(autopoll_devs);
+
+                if (macii_state == idle)
+                        via[B] = (via[B] & ~ST_MASK) | ST_IDLE;
+                break;
 
-                default:
+        default:
                 break;
         }
 
-        entered--;
+        local_irq_restore(flags);
         return IRQ_HANDLED;
 }
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index d72c450aebe5..60f57e2abf21 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -1737,6 +1737,39 @@ pmu_enable_irled(int on)
         pmu_wait_complete(&req);
 }
 
+/* Offset between Unix time (1970-based) and Mac time (1904-based) */
+#define RTC_OFFSET      2082844800
+
+time64_t pmu_get_time(void)
+{
+        struct adb_request req;
+        u32 now;
+
+        if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)
+                return 0;
+        pmu_wait_complete(&req);
+        if (req.reply_len != 4)
+                pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
+        now = (req.reply[0] << 24) + (req.reply[1] << 16) +
+              (req.reply[2] << 8) + req.reply[3];
+        return (time64_t)now - RTC_OFFSET;
+}
+
+int pmu_set_rtc_time(struct rtc_time *tm)
+{
+        u32 now;
+        struct adb_request req;
+
+        now = lower_32_bits(rtc_tm_to_time64(tm) + RTC_OFFSET);
+        if (pmu_request(&req, NULL, 5, PMU_SET_RTC,
+                        now >> 24, now >> 16, now >> 8, now) < 0)
+                return -ENXIO;
+        pmu_wait_complete(&req);
+        if (req.reply_len != 0)
+                pr_err("%s: got %d byte reply\n", __func__, req.reply_len);
+        return 0;
+}
+
 void
 pmu_restart(void)
 {
diff --git a/drivers/macintosh/windfarm_smu_controls.c b/drivers/macintosh/windfarm_smu_controls.c
index d174c7437337..86d65462a61c 100644
--- a/drivers/macintosh/windfarm_smu_controls.c
+++ b/drivers/macintosh/windfarm_smu_controls.c
@@ -277,7 +277,7 @@ static int __init smu_controls_init(void)
                 fct = smu_fan_create(fan, 0);
                 if (fct == NULL) {
                         printk(KERN_WARNING "windfarm: Failed to create SMU "
-                               "RPM fan %s\n", fan->name);
+                               "RPM fan %pOFn\n", fan);
                         continue;
                 }
                 list_add(&fct->link, &smu_fans);
@@ -296,7 +296,7 @@ static int __init smu_controls_init(void)
                 fct = smu_fan_create(fan, 1);
                 if (fct == NULL) {
                         printk(KERN_WARNING "windfarm: Failed to create SMU "
-                               "PWM fan %s\n", fan->name);
+                               "PWM fan %pOFn\n", fan);
                         continue;
                 }
                 list_add(&fct->link, &smu_fans);
diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c
index da7f4fc1a51d..a0f61eb853c5 100644
--- a/drivers/macintosh/windfarm_smu_sat.c
+++ b/drivers/macintosh/windfarm_smu_sat.c
@@ -22,14 +22,6 @@
 
 #define VERSION "1.0"
 
-#define DEBUG
-
-#ifdef DEBUG
-#define DBG(args...)    printk(args)
-#else
-#define DBG(args...)    do { } while(0)
-#endif
-
 /* If the cache is older than 800ms we'll refetch it */
 #define MAX_AGE         msecs_to_jiffies(800)
 
@@ -106,13 +98,10 @@ struct smu_sdbp_header *smu_sat_get_sdb_partition(unsigned int sat_id, int id,
                 buf[i+2] = data[3];
                 buf[i+3] = data[2];
         }
-#ifdef DEBUG
-        DBG(KERN_DEBUG "sat %d partition %x:", sat_id, id);
-        for (i = 0; i < len; ++i)
-                DBG(" %x", buf[i]);
-        DBG("\n");
-#endif
 
+        printk(KERN_DEBUG "sat %d partition %x:", sat_id, id);
+        print_hex_dump(KERN_DEBUG, "  ", DUMP_PREFIX_OFFSET,
+                       16, 1, buf, len, false);
         if (size)
                 *size = len;
         return (struct smu_sdbp_header *) buf;
@@ -132,13 +121,13 @@ static int wf_sat_read_cache(struct wf_sat *sat)
         if (err < 0)
                 return err;
         sat->last_read = jiffies;
+
 #ifdef LOTSA_DEBUG
         {
                 int i;
-                DBG(KERN_DEBUG "wf_sat_get: data is");
-                for (i = 0; i < 16; ++i)
-                        DBG(" %.2x", sat->cache[i]);
-                DBG("\n");
+                printk(KERN_DEBUG "wf_sat_get: data is");
+                print_hex_dump(KERN_DEBUG, "  ", DUMP_PREFIX_OFFSET,
+                               16, 1, sat->cache, 16, false);
         }
 #endif
         return 0;
diff --git a/drivers/misc/ocxl/config.c b/drivers/misc/ocxl/config.c
index 2e30de9c694a..57a6bb1fd3c9 100644
--- a/drivers/misc/ocxl/config.c
+++ b/drivers/misc/ocxl/config.c
@@ -280,7 +280,9 @@ int ocxl_config_check_afu_index(struct pci_dev *dev,
         u32 val;
         int rc, templ_major, templ_minor, len;
 
-        pci_write_config_word(dev, fn->dvsec_afu_info_pos, afu_idx);
+        pci_write_config_byte(dev,
+                        fn->dvsec_afu_info_pos + OCXL_DVSEC_AFU_INFO_AFU_IDX,
+                        afu_idx);
         rc = read_afu_info(dev, fn, OCXL_DVSEC_TEMPL_VERSION, &val);
         if (rc)
                 return rc;
diff --git a/drivers/pci/hotplug/pnv_php.c b/drivers/pci/hotplug/pnv_php.c
index ee54f5bacad1..6758fd7c382e 100644
--- a/drivers/pci/hotplug/pnv_php.c
+++ b/drivers/pci/hotplug/pnv_php.c
@@ -746,7 +746,7 @@ static irqreturn_t pnv_php_interrupt(int irq, void *data)
                 pe = edev ? edev->pe : NULL;
                 if (pe) {
                         eeh_serialize_lock(&flags);
-                        eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
+                        eeh_pe_mark_isolated(pe);
                         eeh_serialize_unlock(flags);
                         eeh_pe_set_option(pe, EEH_OPT_FREEZE_PE);
                 }
diff --git a/drivers/pcmcia/electra_cf.c b/drivers/pcmcia/electra_cf.c
index 9671ded549f0..b31abe35ed2c 100644
--- a/drivers/pcmcia/electra_cf.c
+++ b/drivers/pcmcia/electra_cf.c
@@ -230,7 +230,7 @@ static int electra_cf_probe(struct platform_device *ofdev)
 
         if (!cf->mem_base || !cf->io_virt || !cf->gpio_base ||
             (__ioremap_at(io.start, cf->io_virt, cf->io_size,
-                  pgprot_val(pgprot_noncached(__pgprot(0)))) == NULL)) {
+                          pgprot_noncached(PAGE_KERNEL)) == NULL)) {
                 dev_err(device, "can't ioremap ranges\n");
                 status = -ENOMEM;
                 goto fail1;
diff --git a/drivers/soc/fsl/qbman/qman_ccsr.c b/drivers/soc/fsl/qbman/qman_ccsr.c
index 6fd5fef5f39b..109b38de3176 100644
--- a/drivers/soc/fsl/qbman/qman_ccsr.c
+++ b/drivers/soc/fsl/qbman/qman_ccsr.c
@@ -419,7 +419,7 @@ static size_t fqd_sz, pfdr_sz;
 static int zero_priv_mem(phys_addr_t addr, size_t sz)
 {
         /* map as cacheable, non-guarded */
-        void __iomem *tmpp = ioremap_prot(addr, sz, 0);
+        void __iomem *tmpp = ioremap_cache(addr, sz);
 
         if (!tmpp)
                 return -ENOMEM;
diff --git a/drivers/video/fbdev/chipsfb.c b/drivers/video/fbdev/chipsfb.c
index f103665cad43..40182ed85648 100644
--- a/drivers/video/fbdev/chipsfb.c
+++ b/drivers/video/fbdev/chipsfb.c
@@ -27,7 +27,6 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/console.h>
-#include <asm/io.h>
 
 #ifdef CONFIG_PMAC_BACKLIGHT
 #include <asm/backlight.h>
@@ -401,7 +400,7 @@ static int chipsfb_pci_init(struct pci_dev *dp, const struct pci_device_id *ent)
 #endif /* CONFIG_PMAC_BACKLIGHT */
 
 #ifdef CONFIG_PPC
-        p->screen_base = __ioremap(addr, 0x200000, _PAGE_NO_CACHE);
+        p->screen_base = ioremap_wc(addr, 0x200000);
 #else
         p->screen_base = ioremap(addr, 0x200000);
 #endif
diff --git a/drivers/video/fbdev/controlfb.c b/drivers/video/fbdev/controlfb.c
index 8d14b29aafea..9cb0ef7ac29e 100644
--- a/drivers/video/fbdev/controlfb.c
+++ b/drivers/video/fbdev/controlfb.c
@@ -48,9 +48,7 @@
 #include <linux/nvram.h>
 #include <linux/adb.h>
 #include <linux/cuda.h>
-#include <asm/io.h>
 #include <asm/prom.h>
-#include <asm/pgtable.h>
 #include <asm/btext.h>
 
 #include "macmodes.h"
@@ -715,8 +713,7 @@ static int __init control_of_init(struct device_node *dp)
                 goto error_out;
         }
         /* map at most 8MB for the frame buffer */
-        p->frame_buffer = __ioremap(p->frame_buffer_phys, 0x800000,
-                                    _PAGE_WRITETHRU);
+        p->frame_buffer = ioremap_wt(p->frame_buffer_phys, 0x800000);
 
         if (!p->control_regs_phys ||
             !request_mem_region(p->control_regs_phys, p->control_regs_size,
diff --git a/drivers/video/fbdev/platinumfb.c b/drivers/video/fbdev/platinumfb.c
index 377d3399a3ad..bf6b7fb83cf4 100644
--- a/drivers/video/fbdev/platinumfb.c
+++ b/drivers/video/fbdev/platinumfb.c
@@ -32,9 +32,7 @@
 #include <linux/nvram.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
-#include <asm/io.h>
 #include <asm/prom.h>
-#include <asm/pgtable.h>
 
 #include "macmodes.h"
 #include "platinumfb.h"
@@ -577,8 +575,7 @@ static int platinumfb_probe(struct platform_device* odev)
 
         /* frame buffer - map only 4MB */
         pinfo->frame_buffer_phys = pinfo->rsrc_fb.start;
-        pinfo->frame_buffer = __ioremap(pinfo->rsrc_fb.start, 0x400000,
-                                        _PAGE_WRITETHRU);
+        pinfo->frame_buffer = ioremap_wt(pinfo->rsrc_fb.start, 0x400000);
         pinfo->base_frame_buffer = pinfo->frame_buffer;
 
         /* registers */
diff --git a/drivers/video/fbdev/valkyriefb.c b/drivers/video/fbdev/valkyriefb.c
index 275fb98236d3..d51c3a8009cb 100644
--- a/drivers/video/fbdev/valkyriefb.c
+++ b/drivers/video/fbdev/valkyriefb.c
@@ -54,13 +54,11 @@
 #include <linux/nvram.h>
 #include <linux/adb.h>
 #include <linux/cuda.h>
-#include <asm/io.h>
 #ifdef CONFIG_MAC
 #include <asm/macintosh.h>
 #else
 #include <asm/prom.h>
 #endif
-#include <asm/pgtable.h>
 
 #include "macmodes.h"
 #include "valkyriefb.h"
@@ -318,7 +316,7 @@ static void __init valkyrie_choose_mode(struct fb_info_valkyrie *p)
 int __init valkyriefb_init(void)
 {
         struct fb_info_valkyrie *p;
-        unsigned long frame_buffer_phys, cmap_regs_phys, flags;
+        unsigned long frame_buffer_phys, cmap_regs_phys;
         int err;
         char *option = NULL;
 
@@ -337,7 +335,6 @@ int __init valkyriefb_init(void)
         /* Hardcoded addresses... welcome to 68k Macintosh country :-) */
         frame_buffer_phys = 0xf9000000;
         cmap_regs_phys = 0x50f24000;
-        flags = IOMAP_NOCACHE_SER; /* IOMAP_WRITETHROUGH?? */
 #else /* ppc (!CONFIG_MAC) */
         {
                 struct device_node *dp;
@@ -354,7 +351,6 @@ int __init valkyriefb_init(void)
 
                 frame_buffer_phys = r.start;
                 cmap_regs_phys = r.start + 0x304000;
-                flags = _PAGE_WRITETHRU;
         }
 #endif /* ppc (!CONFIG_MAC) */
 
@@ -369,7 +365,11 @@ int __init valkyriefb_init(void)
         }
         p->total_vram = 0x100000;
         p->frame_buffer_phys = frame_buffer_phys;
-        p->frame_buffer = __ioremap(frame_buffer_phys, p->total_vram, flags);
+#ifdef CONFIG_MAC
+        p->frame_buffer = ioremap_nocache(frame_buffer_phys, p->total_vram);
+#else
+        p->frame_buffer = ioremap_wt(frame_buffer_phys, p->total_vram);
+#endif
         p->cmap_regs_phys = cmap_regs_phys;
         p->cmap_regs = ioremap(p->cmap_regs_phys, 0x1000);
         p->valkyrie_regs_phys = cmap_regs_phys+0x6000;