msr = mfdcr(primary_uic->dcrbase + UIC_MSR);
        src = 32 - ffs(msr);
 
-       return irq_linear_revmap(primary_uic->irqhost, src);
+       return irq_find_mapping(primary_uic->irqhost, src);
 }
 
        mutex_lock(&mpc52xx_gpt_list_mutex);
        list_for_each(pos, &mpc52xx_gpt_list) {
                gpt = container_of(pos, struct mpc52xx_gpt_priv, list);
-               if (gpt->irqhost && irq == irq_linear_revmap(gpt->irqhost, 0)) {
+               if (gpt->irqhost && irq == irq_find_mapping(gpt->irqhost, 0)) {
                        mutex_unlock(&mpc52xx_gpt_list_mutex);
                        return gpt;
                }
 
                return 0;
        }
 
-       return irq_linear_revmap(mpc52xx_irqhost, irq);
+       return irq_find_mapping(mpc52xx_irqhost, irq);
 }
 
                if (cause >> (i + 16))
                        break;
        }
-       return irq_linear_revmap(socrates_fpga_pic_irq_host,
+       return irq_find_mapping(socrates_fpga_pic_irq_host,
                        (irq_hw_number_t)i);
 }
 
 
        cpm_vec = in_be16(&data->reg->cpic_civr);
        cpm_vec >>= 11;
 
-       return irq_linear_revmap(data->host, cpm_vec);
+       return irq_find_mapping(data->host, cpm_vec);
 }
 
 static void cpm_cascade(struct irq_desc *desc)
 
        if (irq == PIC_VEC_SPURRIOUS)
                return 0;
 
-        return irq_linear_revmap(mpc8xx_pic_host, irq);
+        return irq_find_mapping(mpc8xx_pic_host, irq);
 
 }
 
 
                return 0;       /* no more IRQs pending */
 
        irq = __ffs(irq_status);
-       return irq_linear_revmap(flipper_irq_host, irq);
+       return irq_find_mapping(flipper_irq_host, irq);
 }
 
 /*
 
 unsigned int hlwd_pic_get_irq(void)
 {
        unsigned int hwirq = __hlwd_pic_get_irq(hlwd_irq_host);
-       return hwirq ? irq_linear_revmap(hlwd_irq_host, hwirq) : 0;
+       return hwirq ? irq_find_mapping(hlwd_irq_host, hwirq) : 0;
 }
 
 /*
 
        raw_spin_unlock_irqrestore(&pmac_pic_lock, flags);
        if (unlikely(irq < 0))
                return 0;
-       return irq_linear_revmap(pmac_pic_host, irq);
+       return irq_find_mapping(pmac_pic_host, irq);
 }
 
 static int pmac_pic_host_match(struct irq_domain *h, struct device_node *node,
 
 
        if (irq == 0)
                return(-1);
-       return irq_linear_revmap(cpm2_pic_host, irq);
+       return irq_find_mapping(cpm2_pic_host, irq);
 }
 
 static int cpm2_pic_host_map(struct irq_domain *h, unsigned int virq,
 
         * this will also setup revmap[] in the slow path for the first
         * time, next calls will always use fast path by indexing revmap
         */
-       return irq_linear_revmap(global_ehv_pic->irqhost, irq);
+       return irq_find_mapping(global_ehv_pic->irqhost, irq);
 }
 
 static int ehv_pic_host_match(struct irq_domain *h, struct device_node *node,
 
                        if (active & (0x1 << hwirq))
                                break;
                }
-               virq = irq_linear_revmap(gef_pic_irq_host,
+               virq = irq_find_mapping(gef_pic_irq_host,
                        (irq_hw_number_t)hwirq);
        }
 
 
        if (irq == 0)    /* 0 --> no irq is pending */
                return 0;
 
-       return irq_linear_revmap(primary_ipic->irqhost, irq);
+       return irq_find_mapping(primary_ipic->irqhost, irq);
 }
 
 #ifdef CONFIG_SUSPEND
 
                return 0;
        }
 
-       return irq_linear_revmap(mpic->irqhost, src);
+       return irq_find_mapping(mpic->irqhost, src);
 }
 
 unsigned int mpic_get_one_irq(struct mpic *mpic)
                return 0;
        }
 
-       return irq_linear_revmap(mpic->irqhost, src);
+       return irq_find_mapping(mpic->irqhost, src);
 #else
        return 0;
 #endif