return -ENODEV;
 
        for (match = __earlycon_table; match < __earlycon_table_end; match++) {
-               u64 addr;
-
                if (!match->compatible[0])
                        continue;
 
                if (fdt_node_check_compatible(fdt, offset, match->compatible))
                        continue;
 
-               addr = fdt_translate_address(fdt, offset);
-               if (addr == OF_BAD_ADDR)
-                       return -ENXIO;
-
-               of_setup_earlycon(addr, match, offset, options);
+               of_setup_earlycon(match, offset, options);
                return 0;
        }
        return -ENODEV;
 
  * that can be mapped to a cpu physical address). This is not really specified
  * that way, but this is traditionally the way IBM at least do things
  */
-u64 __init fdt_translate_address(const void *blob, int node_offset)
+static u64 __init fdt_translate_address(const void *blob, int node_offset)
 {
        int parent, len;
        const struct of_bus *bus, *pbus;
  bail:
        return result;
 }
+
+/**
+ * of_flat_dt_translate_address - translate DT addr into CPU phys addr
+ * @node: node in the flat blob
+ */
+u64 __init of_flat_dt_translate_address(unsigned long node)
+{
+       return fdt_translate_address(initial_boot_params, node);
+}
 
 #include <linux/io.h>
 #include <linux/serial_core.h>
 #include <linux/sizes.h>
+#include <linux/of.h>
 #include <linux/of_fdt.h>
 
 #ifdef CONFIG_FIX_EARLYCON_MEM
 
 #ifdef CONFIG_OF_EARLY_FLATTREE
 
-int __init of_setup_earlycon(unsigned long addr,
-                            const struct earlycon_id *match,
+int __init of_setup_earlycon(const struct earlycon_id *match,
                             unsigned long node,
                             const char *options)
 {
        struct uart_port *port = &early_console_dev.port;
        const __be32 *val;
        bool big_endian;
+       u64 addr;
 
        spin_lock_init(&port->lock);
        port->iotype = UPIO_MEM;
+       addr = of_flat_dt_translate_address(node);
+       if (addr == OF_BAD_ADDR) {
+               pr_warn("[%s] bad address\n", match->name);
+               return -ENXIO;
+       }
        port->mapbase = addr;
        port->uartclk = BASE_BAUD * 16;
-       port->membase = earlycon_map(addr, SZ_4K);
+       port->membase = earlycon_map(port->mapbase, SZ_4K);
 
        val = of_get_flat_dt_prop(node, "reg-offset", NULL);
        if (val)
 
 extern void unflatten_and_copy_device_tree(void);
 extern void early_init_devtree(void *);
 extern void early_get_first_memblock_info(void *, phys_addr_t *);
-extern u64 fdt_translate_address(const void *blob, int node_offset);
+extern u64 of_flat_dt_translate_address(unsigned long node);
 extern void of_fdt_limit_memory(int limit);
 #else /* CONFIG_OF_FLATTREE */
 static inline void early_init_fdt_scan_reserved_mem(void) {}
 
 #define EARLYCON_DECLARE(_name, fn)    OF_EARLYCON_DECLARE(_name, "", fn)
 
 extern int setup_earlycon(char *buf);
-extern int of_setup_earlycon(unsigned long addr, const struct earlycon_id *match,
+extern int of_setup_earlycon(const struct earlycon_id *match,
                             unsigned long node,
                             const char *options);