static int ahci_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
 static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc);
-static void ahci_irq_clear(struct ata_port *ap);
 static int ahci_port_start(struct ata_port *ap);
 static void ahci_port_stop(struct ata_port *ap);
 static void ahci_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
        .qc_prep                = ahci_qc_prep,
        .qc_issue               = ahci_qc_issue,
 
-       .irq_clear              = ahci_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
 
        .scr_read               = ahci_scr_read,
        .scr_write              = ahci_scr_write,
        .qc_prep                = ahci_qc_prep,
        .qc_issue               = ahci_qc_issue,
 
-       .irq_clear              = ahci_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
 
        .scr_read               = ahci_scr_read,
        .scr_write              = ahci_scr_write,
        .qc_prep                = ahci_qc_prep,
        .qc_issue               = ahci_qc_issue,
 
-       .irq_clear              = ahci_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
 
        .scr_read               = ahci_scr_read,
        .scr_write              = ahci_scr_write,
        }
 }
 
-static void ahci_irq_clear(struct ata_port *ap)
-{
-       /* TODO */
-}
-
 static irqreturn_t ahci_interrupt(int irq, void *dev_instance)
 {
        struct ata_host *host = dev_instance;
 
 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
 EXPORT_SYMBOL_GPL(ata_bmdma_start);
 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
+EXPORT_SYMBOL_GPL(ata_noop_irq_clear);
 EXPORT_SYMBOL_GPL(ata_bmdma_status);
 EXPORT_SYMBOL_GPL(ata_bmdma_stop);
 EXPORT_SYMBOL_GPL(ata_bmdma_freeze);
 
        iowrite8(ioread8(mmio + ATA_DMA_STATUS), mmio + ATA_DMA_STATUS);
 }
 
+/**
+ *     ata_noop_irq_clear - Noop placeholder for irq_clear
+ *     @ap: Port associated with this ATA transaction.
+ */
+void ata_noop_irq_clear(struct ata_port *ap)
+{
+}
+
 /**
  *     ata_bmdma_status - Read PCI IDE BMDMA status
  *     @ap: Port associated with this ATA transaction.
 
        .data_xfer      = ata_data_xfer,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
        }
 }
 
-static void pata_at32_irq_clear(struct ata_port *ap)
-{
-       /* No DMA controller yet */
-}
-
 static struct scsi_host_template at32_sht = {
        .module                 = THIS_MODULE,
        .name                   = DRV_NAME,
 
        .data_xfer              = ata_data_xfer,
 
-       .irq_clear              = pata_at32_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .port_start             = ata_sff_port_start,
 
        .bios_param             = ata_std_bios_param,
 };
 
-/* wish this was exported from libata-core */
-static void ata_dummy_noret(struct ata_port *port)
-{
-}
-
 static void pata_icside_postreset(struct ata_link *link, unsigned int *classes)
 {
        struct ata_port *ap = link->ap;
        .error_handler          = pata_icside_error_handler,
        .post_internal_cmd      = pata_icside_bmdma_stop,
 
-       .irq_clear              = ata_dummy_noret,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .bmdma_stop             = pata_icside_bmdma_stop,
 
 
        .data_xfer      = ata_data_xfer,
 
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
        .cable_detect           = ata_cable_40wire,
 
        .irq_handler            = ata_interrupt,
-       .irq_clear              = ata_bmdma_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .port_start             = ata_port_start,
 
        .data_xfer      = ata_data_xfer_noirq,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = ata_data_xfer_noirq,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = pdc_data_xfer_vlb,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = ata_data_xfer,        /* Check vlb/noirq */
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = ata_data_xfer,    /* FIXME: Check 32bit and noirq */
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = ata_data_xfer,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = ata_data_xfer,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = vlb32_data_xfer,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = vlb32_data_xfer,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
        .data_xfer      = vlb32_data_xfer,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
        .data_xfer      = vlb32_data_xfer,
 
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
        .qc_prep                = ata_qc_prep,
        .qc_issue               = ata_qc_issue_prot,
        .data_xfer              = ata_data_xfer,
-       .irq_clear              = ata_bmdma_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
        .port_start             = ata_port_start,
 };
 
        .qc_issue       = mpiix_qc_issue_prot,
        .data_xfer      = ata_data_xfer,
 
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
        .data_xfer      = ata_data_xfer,
 
        .irq_handler    = ata_interrupt,
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
 
        .data_xfer      = ata_data_xfer_noirq,
 
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
        .data_xfer      = ata_data_xfer_8bit,
 
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
 
        .data_xfer              = ata_data_xfer_noirq,
 
-       .irq_clear              = ata_bmdma_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .port_start             = ata_dummy_ret0,
 
 
        .data_xfer      = qdi_data_xfer,
 
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
        .data_xfer      = qdi_data_xfer,
 
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
        return IRQ_HANDLED;
 }
 
-static void rb500_pata_irq_clear(struct ata_port *ap)
-{
-}
-
 static int rb500_pata_port_start(struct ata_port *ap)
 {
        return 0;
        .error_handler          = ata_bmdma_error_handler,
 
        .irq_handler            = rb500_pata_irq_handler,
-       .irq_clear              = rb500_pata_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .port_start             = rb500_pata_port_start,
 
 
        .data_xfer      = winbond_data_xfer,
 
-       .irq_clear      = ata_bmdma_irq_clear,
+       .irq_clear      = ata_noop_irq_clear,
        .irq_on         = ata_irq_on,
 
        .port_start     = ata_sff_port_start,
 
 static int adma_check_atapi_dma(struct ata_queued_cmd *qc);
 static void adma_bmdma_stop(struct ata_queued_cmd *qc);
 static u8 adma_bmdma_status(struct ata_port *ap);
-static void adma_irq_clear(struct ata_port *ap);
 static void adma_freeze(struct ata_port *ap);
 static void adma_thaw(struct ata_port *ap);
 static void adma_error_handler(struct ata_port *ap);
        .freeze                 = adma_freeze,
        .thaw                   = adma_thaw,
        .error_handler          = adma_error_handler,
-       .irq_clear              = adma_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
        .port_start             = adma_port_start,
        .port_stop              = adma_port_stop,
        return 0;
 }
 
-static void adma_irq_clear(struct ata_port *ap)
-{
-       /* nothing */
-}
-
 static void adma_reset_engine(struct ata_port *ap)
 {
        void __iomem *chan = ADMA_PORT_REGS(ap);
 
        }
 }
 
-static void sata_fsl_irq_clear(struct ata_port *ap)
-{
-       /* unused */
-}
-
 static void sata_fsl_error_intr(struct ata_port *ap)
 {
        struct ata_link *link = &ap->link;
 
        .qc_prep = sata_fsl_qc_prep,
        .qc_issue = sata_fsl_qc_issue,
-       .irq_clear = sata_fsl_irq_clear,
+       .irq_clear = ata_noop_irq_clear,
 
        .scr_read = sata_fsl_scr_read,
        .scr_write = sata_fsl_scr_write,
 
        return ATA_DMA_INTR;
 }
 
-static void inic_irq_clear(struct ata_port *ap)
-{
-       /* noop */
-}
-
 static void inic_host_intr(struct ata_port *ap)
 {
        void __iomem *port_base = inic_port_base(ap);
        .bmdma_stop             = inic_bmdma_stop,
        .bmdma_status           = inic_bmdma_status,
 
-       .irq_clear              = inic_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .qc_prep                = ata_qc_prep,
 
        void (*reset_bus)(struct ata_host *host, void __iomem *mmio);
 };
 
-static void mv_irq_clear(struct ata_port *ap);
 static int mv_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
 static int mv_scr_write(struct ata_port *ap, unsigned int sc_reg_in, u32 val);
 static int mv5_scr_read(struct ata_port *ap, unsigned int sc_reg_in, u32 *val);
        .qc_issue               = mv_qc_issue,
        .data_xfer              = ata_data_xfer,
 
-       .irq_clear              = mv_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .error_handler          = mv_error_handler,
        .qc_issue               = mv_qc_issue,
        .data_xfer              = ata_data_xfer,
 
-       .irq_clear              = mv_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .error_handler          = mv_error_handler,
        .qc_issue               = mv_qc_issue,
        .data_xfer              = ata_data_xfer,
 
-       .irq_clear              = mv_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
 
        .error_handler          = mv_error_handler,
        return ((port_flags & MV_FLAG_DUAL_HC) ? 2 : 1);
 }
 
-static void mv_irq_clear(struct ata_port *ap)
-{
-}
-
 static void mv_set_edma_ptrs(void __iomem *port_mmio,
                             struct mv_host_priv *hpriv,
                             struct mv_port_priv *pp)
 
 static int qs_check_atapi_dma(struct ata_queued_cmd *qc);
 static void qs_bmdma_stop(struct ata_queued_cmd *qc);
 static u8 qs_bmdma_status(struct ata_port *ap);
-static void qs_irq_clear(struct ata_port *ap);
 static void qs_freeze(struct ata_port *ap);
 static void qs_thaw(struct ata_port *ap);
 static void qs_error_handler(struct ata_port *ap);
        .freeze                 = qs_freeze,
        .thaw                   = qs_thaw,
        .error_handler          = qs_error_handler,
-       .irq_clear              = qs_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
        .irq_on                 = ata_irq_on,
        .scr_read               = qs_scr_read,
        .scr_write              = qs_scr_write,
        return 0;
 }
 
-static void qs_irq_clear(struct ata_port *ap)
-{
-       /* nothing */
-}
-
 static inline void qs_enter_reg_mode(struct ata_port *ap)
 {
        u8 __iomem *chan = qs_mmio_base(ap->host) + (ap->port_no * 0x4000);
 
 static int sil24_qc_defer(struct ata_queued_cmd *qc);
 static void sil24_qc_prep(struct ata_queued_cmd *qc);
 static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
-static void sil24_irq_clear(struct ata_port *ap);
 static void sil24_pmp_attach(struct ata_port *ap);
 static void sil24_pmp_detach(struct ata_port *ap);
 static void sil24_freeze(struct ata_port *ap);
        .qc_prep                = sil24_qc_prep,
        .qc_issue               = sil24_qc_issue,
 
-       .irq_clear              = sil24_irq_clear,
+       .irq_clear              = ata_noop_irq_clear,
 
        .scr_read               = sil24_scr_read,
        .scr_write              = sil24_scr_write,
        return 0;
 }
 
-static void sil24_irq_clear(struct ata_port *ap)
-{
-       /* unused */
-}
-
 static void sil24_pmp_attach(struct ata_port *ap)
 {
        sil24_config_pmp(ap, 1);
 
 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
 extern u8   ata_bmdma_status(struct ata_port *ap);
 extern void ata_bmdma_irq_clear(struct ata_port *ap);
+extern void ata_noop_irq_clear(struct ata_port *ap);
 extern void ata_bmdma_freeze(struct ata_port *ap);
 extern void ata_bmdma_thaw(struct ata_port *ap);
 extern void ata_bmdma_drive_eh(struct ata_port *ap, ata_prereset_fn_t prereset,