* Needed for primary domain lookup to succeed
         * This is a primary irqchip, and can never have a parent
         */
-       irq_set_default_host(root_domain);
+       irq_set_default_domain(root_domain);
 
 #ifdef CONFIG_SMP
        irq_create_mapping(root_domain, IPI_IRQ);
 
         * Needed for primary domain lookup to succeed
         * This is a primary irqchip, and can never have a parent
         */
-       irq_set_default_host(root_domain);
+       irq_set_default_domain(root_domain);
 
        return 0;
 }
 
                                               &pxa_irq_ops, NULL);
        if (!pxa_irq_domain)
                panic("Unable to add PXA IRQ domain\n");
-       irq_set_default_host(pxa_irq_domain);
+       irq_set_default_domain(pxa_irq_domain);
 
        for (n = 0; n < irq_nr; n += 32) {
                void __iomem *base = irq_base(n >> 5);
 
 
        ciu_domain = irq_domain_add_tree(
                ciu_node, &octeon_irq_domain_ciu_ops, dd);
-       irq_set_default_host(ciu_domain);
+       irq_set_default_domain(ciu_domain);
 
        /* CIU_0 */
        for (i = 0; i < 16; i++) {
 
        ciu_domain = irq_domain_add_tree(
                ciu_node, &octeon_irq_domain_ciu2_ops, NULL);
-       irq_set_default_host(ciu_domain);
+       irq_set_default_domain(ciu_domain);
 
        /* CUI2 */
        for (i = 0; i < 64; i++) {
                /* Only do per CPU things if it is the CIU of the boot node. */
                octeon_irq_ciu3_alloc_resources(ciu3_info);
                if (node == 0)
-                       irq_set_default_host(domain);
+                       irq_set_default_domain(domain);
 
                octeon_irq_use_ip4 = false;
                /* Enable the CIU lines */
 
        if (WARN_ON(domain == NULL))
                return;
 
-       irq_set_default_host(domain);
+       irq_set_default_domain(domain);
 
        irq_set_percpu_devid(IP27_HUB_PEND0_IRQ);
        irq_set_chained_handler_and_data(IP27_HUB_PEND0_IRQ, ip27_do_irq_mask0,
 
        if (!domain)
                return;
 
-       irq_set_default_host(domain);
+       irq_set_default_domain(domain);
 
        irq_set_percpu_devid(IP30_HEART_L0_IRQ);
        irq_set_chained_handler_and_data(IP30_HEART_L0_IRQ, ip30_normal_irq,
 
        domain = irq_domain_add_linear(node, NIOS2_CPU_NR_IRQS, &irq_ops, NULL);
        BUG_ON(!domain);
 
-       irq_set_default_host(domain);
+       irq_set_default_domain(domain);
        of_node_put(node);
        /* Load the initial ienable value */
        ienable = RDCTL(CTL_IENABLE);
 
        if (!primary_uic)
                panic("Unable to initialize primary UIC %pOF\n", np);
 
-       irq_set_default_host(primary_uic->irqhost);
+       irq_set_default_domain(primary_uic->irqhost);
        of_node_put(np);
 
        /* The scan again for cascaded UICs */
 
        if (!mpc52xx_irqhost)
                panic(__FILE__ ": Cannot allocate the IRQ host\n");
 
-       irq_set_default_host(mpc52xx_irqhost);
+       irq_set_default_domain(mpc52xx_irqhost);
 
        pr_info("MPC52xx PIC is up and running!\n");
 }
 
 
        i8259_init(pic, int_ack);
        ppc_md.get_irq = i8259_irq;
-       irq_set_default_host(i8259_get_host());
+       irq_set_default_domain(i8259_get_host());
 }
 
 static int __init request_isa_regions(void)
 
        i8259_init(pic, chrp_int_ack);
        if (ppc_md.get_irq == NULL) {
                ppc_md.get_irq = i8259_irq;
-               irq_set_default_host(i8259_get_host());
+               irq_set_default_domain(i8259_get_host());
        }
        if (chrp_mpic != NULL) {
                cascade_irq = irq_of_parse_and_map(pic, 0);
 
        flipper_irq_host = flipper_pic_init(np);
        BUG_ON(!flipper_irq_host);
 
-       irq_set_default_host(flipper_irq_host);
+       irq_set_default_domain(flipper_irq_host);
 
        of_node_put(np);
 }
 
        irq_set_chained_handler(gpio_virq, sb600_8259_cascade);
        mpic_unmask_irq(irq_get_irq_data(gpio_virq));
 
-       irq_set_default_host(mpic->irqhost);
+       irq_set_default_domain(mpic->irqhost);
 }
 
 #else
 
        pmac_pic_host = irq_domain_add_linear(master, max_irqs,
                                              &pmac_pic_host_ops, NULL);
        BUG_ON(pmac_pic_host == NULL);
-       irq_set_default_host(pmac_pic_host);
+       irq_set_default_domain(pmac_pic_host);
 
        /* Get addresses of first controller if we have a node for it */
        BUG_ON(of_address_to_resource(master, 0, &r));
 
        struct irq_domain *host;
 
        host = irq_domain_add_nomap(NULL, PS3_PLUG_MAX + 1, &ps3_host_ops, NULL);
-       irq_set_default_host(host);
+       irq_set_default_domain(host);
 
        for_each_possible_cpu(cpu) {
                struct ps3_private *pd = &per_cpu(ps3_private, cpu);
 
        ehv_pic->coreint_flag = of_property_read_bool(np, "has-external-proxy");
 
        global_ehv_pic = ehv_pic;
-       irq_set_default_host(global_ehv_pic->irqhost);
+       irq_set_default_domain(global_ehv_pic->irqhost);
 }
 
        ipic_write(ipic->regs, IPIC_SEMSR, temp);
 
        primary_ipic = ipic;
-       irq_set_default_host(primary_ipic->irqhost);
+       irq_set_default_domain(primary_ipic->irqhost);
 
        ipic_write(ipic->regs, IPIC_SIMSR_H, 0);
        ipic_write(ipic->regs, IPIC_SIMSR_L, 0);
 
 
        if (!(mpic->flags & MPIC_SECONDARY)) {
                mpic_primary = mpic;
-               irq_set_default_host(mpic->irqhost);
+               irq_set_default_domain(mpic->irqhost);
        }
 
        return mpic;
 
                return -ENOMEM;
        }
 
-       irq_set_default_host(xics_host);
+       irq_set_default_domain(xics_host);
        return 0;
 }
 
 
        xive_irq_domain = irq_domain_add_tree(np, &xive_irq_domain_ops, NULL);
        if (WARN_ON(xive_irq_domain == NULL))
                return;
-       irq_set_default_host(xive_irq_domain);
+       irq_set_default_domain(xive_irq_domain);
 }
 
 static void xive_cleanup_cpu_queues(unsigned int cpu, struct xive_cpu *xc)
 
        x86_vector_domain = irq_domain_create_tree(fn, &x86_vector_domain_ops,
                                                   NULL);
        BUG_ON(x86_vector_domain == NULL);
-       irq_set_default_host(x86_vector_domain);
+       irq_set_default_domain(x86_vector_domain);
 
        BUG_ON(!alloc_cpumask_var(&vector_searchmask, GFP_KERNEL));
 
 
        }
 
        if (mpic_is_ipi_available(mpic)) {
-               irq_set_default_host(mpic->domain);
+               irq_set_default_domain(mpic->domain);
                set_handle_irq(mpic_handle_irq);
 #ifdef CONFIG_SMP
                err = mpic_ipi_init(mpic, node);
 
                goto out_irqfree;
        }
 
-       irq_set_default_host(clps711x_intc->domain);
+       irq_set_default_domain(clps711x_intc->domain);
        set_handle_irq(clps711x_irqh);
 
 #ifdef CONFIG_FIQ
 
                kfree(cd);
                return -ENOMEM;
        }
-       irq_set_default_host(domain);
+       irq_set_default_domain(domain);
 
        /* Initially mask all interrupts */
        for (i = 0; i < IMR_NUM; i++) {
 
                gc->private = &priv[i];
        }
 
-       irq_set_default_host(evic_irq_domain);
+       irq_set_default_domain(evic_irq_domain);
 
        /*
         * External interrupts have software configurable edge polarity. These
 
                }
        } else {
                primary_intc = irqc;
-               irq_set_default_host(primary_intc->root_domain);
+               irq_set_default_domain(primary_intc->root_domain);
                set_handle_irq(xil_intc_handle_irq);
        }
 
 
 {
        unsigned int i;
 
-       irq_set_default_host(root_domain);
+       irq_set_default_domain(root_domain);
        secondary_init_irq();
 
        /* Initialize default IRQ routing to CPU 0 */
 
        struct irq_domain *root_domain =
                irq_domain_add_legacy(NULL, NR_IRQS - 1, 1, 0,
                                &xtensa_irq_domain_ops, &xtensa_irq_chip);
-       irq_set_default_host(root_domain);
+       irq_set_default_domain(root_domain);
        return 0;
 }
 
        struct irq_domain *root_domain =
                irq_domain_add_linear(np, NR_IRQS, &xtensa_irq_domain_ops,
                                &xtensa_irq_chip);
-       irq_set_default_host(root_domain);
+       irq_set_default_domain(root_domain);
        return 0;
 }
 IRQCHIP_DECLARE(xtensa_irq_chip, "cdns,xtensa-pic", xtensa_pic_init);
 
                                            void *host_data);
 struct irq_domain *irq_find_matching_fwspec(struct irq_fwspec *fwspec,
                                            enum irq_domain_bus_token bus_token);
-void irq_set_default_host(struct irq_domain *host);
+void irq_set_default_domain(struct irq_domain *domain);
 struct irq_domain *irq_get_default_host(void);
 int irq_domain_alloc_descs(int virq, unsigned int nr_irqs,
                           irq_hw_number_t hwirq, int node,
 
         * If the going away domain is the default one, reset it.
         */
        if (unlikely(irq_default_domain == domain))
-               irq_set_default_host(NULL);
+               irq_set_default_domain(NULL);
 
        mutex_unlock(&irq_domain_mutex);
 
 EXPORT_SYMBOL_GPL(irq_find_matching_fwspec);
 
 /**
- * irq_set_default_host() - Set a "default" irq domain
+ * irq_set_default_domain() - Set a "default" irq domain
  * @domain: default domain pointer
  *
  * For convenience, it's possible to set a "default" domain that will be used
  * platforms that want to manipulate a few hard coded interrupt numbers that
  * aren't properly represented in the device-tree.
  */
-void irq_set_default_host(struct irq_domain *domain)
+void irq_set_default_domain(struct irq_domain *domain)
 {
        pr_debug("Default domain set to @0x%p\n", domain);
 
        irq_default_domain = domain;
 }
-EXPORT_SYMBOL_GPL(irq_set_default_host);
+EXPORT_SYMBOL_GPL(irq_set_default_domain);
 
 /**
  * irq_get_default_host() - Retrieve the "default" irq domain