Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6.git] / drivers / pci / msi.c
index 3627732..f9cf317 100644 (file)
@@ -16,9 +16,8 @@
 #include <linux/proc_fs.h>
 #include <linux/msi.h>
 #include <linux/smp.h>
-
-#include <asm/errno.h>
-#include <asm/io.h>
+#include <linux/errno.h>
+#include <linux/io.h>
 
 #include "pci.h"
 #include "msi.h"
@@ -75,22 +74,17 @@ void arch_teardown_msi_irqs(struct pci_dev *dev)
 }
 #endif
 
-static void __msi_set_enable(struct pci_dev *dev, int pos, int enable)
+static void msi_set_enable(struct pci_dev *dev, int pos, int enable)
 {
        u16 control;
 
-       if (pos) {
-               pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &control);
-               control &= ~PCI_MSI_FLAGS_ENABLE;
-               if (enable)
-                       control |= PCI_MSI_FLAGS_ENABLE;
-               pci_write_config_word(dev, pos + PCI_MSI_FLAGS, control);
-       }
-}
+       BUG_ON(!pos);
 
-static void msi_set_enable(struct pci_dev *dev, int enable)
-{
-       __msi_set_enable(dev, pci_find_capability(dev, PCI_CAP_ID_MSI), enable);
+       pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &control);
+       control &= ~PCI_MSI_FLAGS_ENABLE;
+       if (enable)
+               control |= PCI_MSI_FLAGS_ENABLE;
+       pci_write_config_word(dev, pos + PCI_MSI_FLAGS, control);
 }
 
 static void msix_set_enable(struct pci_dev *dev, int enable)
@@ -131,21 +125,24 @@ static inline __attribute_const__ u32 msi_enabled_mask(u16 control)
  * mask all MSI interrupts by clearing the MSI enable bit does not work
  * reliably as devices without an INTx disable bit will then generate a
  * level IRQ which will never be cleared.
- *
- * Returns 1 if it succeeded in masking the interrupt and 0 if the device
- * doesn't support MSI masking.
  */
-static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
+static u32 __msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
 {
        u32 mask_bits = desc->masked;
 
        if (!desc->msi_attrib.maskbit)
-               return;
+               return 0;
 
        mask_bits &= ~mask;
        mask_bits |= flag;
        pci_write_config_dword(desc->dev, desc->mask_pos, mask_bits);
-       desc->masked = mask_bits;
+
+       return mask_bits;
+}
+
+static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
+{
+       desc->masked = __msi_mask_irq(desc, mask, flag);
 }
 
 /*
@@ -155,15 +152,21 @@ static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
  * file.  This saves a few milliseconds when initialising devices with lots
  * of MSI-X interrupts.
  */
-static void msix_mask_irq(struct msi_desc *desc, u32 flag)
+static u32 __msix_mask_irq(struct msi_desc *desc, u32 flag)
 {
        u32 mask_bits = desc->masked;
        unsigned offset = desc->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
-                                       PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET;
+                                               PCI_MSIX_ENTRY_VECTOR_CTRL;
        mask_bits &= ~1;
        mask_bits |= flag;
        writel(mask_bits, desc->mask_base + offset);
-       desc->masked = mask_bits;
+
+       return mask_bits;
+}
+
+static void msix_mask_irq(struct msi_desc *desc, u32 flag)
+{
+       desc->masked = __msix_mask_irq(desc, flag);
 }
 
 static void msi_set_mask_bit(unsigned irq, u32 flag)
@@ -196,9 +199,9 @@ void read_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
                void __iomem *base = entry->mask_base +
                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
 
-               msg->address_lo = readl(base + PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-               msg->address_hi = readl(base + PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-               msg->data = readl(base + PCI_MSIX_ENTRY_DATA_OFFSET);
+               msg->address_lo = readl(base + PCI_MSIX_ENTRY_LOWER_ADDR);
+               msg->address_hi = readl(base + PCI_MSIX_ENTRY_UPPER_ADDR);
+               msg->data = readl(base + PCI_MSIX_ENTRY_DATA);
        } else {
                struct pci_dev *dev = entry->dev;
                int pos = entry->msi_attrib.pos;
@@ -233,11 +236,9 @@ void write_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
                base = entry->mask_base +
                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
 
-               writel(msg->address_lo,
-                       base + PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-               writel(msg->address_hi,
-                       base + PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-               writel(msg->data, base + PCI_MSIX_ENTRY_DATA_OFFSET);
+               writel(msg->address_lo, base + PCI_MSIX_ENTRY_LOWER_ADDR);
+               writel(msg->address_hi, base + PCI_MSIX_ENTRY_UPPER_ADDR);
+               writel(msg->data, base + PCI_MSIX_ENTRY_DATA);
        } else {
                struct pci_dev *dev = entry->dev;
                int pos = entry->msi_attrib.pos;
@@ -270,7 +271,30 @@ void write_msi_msg(unsigned int irq, struct msi_msg *msg)
        write_msi_msg_desc(desc, msg);
 }
 
-static int msi_free_irqs(struct pci_dev* dev);
+static void free_msi_irqs(struct pci_dev *dev)
+{
+       struct msi_desc *entry, *tmp;
+
+       list_for_each_entry(entry, &dev->msi_list, list) {
+               int i, nvec;
+               if (!entry->irq)
+                       continue;
+               nvec = 1 << entry->msi_attrib.multiple;
+               for (i = 0; i < nvec; i++)
+                       BUG_ON(irq_has_action(entry->irq + i));
+       }
+
+       arch_teardown_msi_irqs(dev);
+
+       list_for_each_entry_safe(entry, tmp, &dev->msi_list, list) {
+               if (entry->msi_attrib.is_msix) {
+                       if (list_is_last(&entry->list, &dev->msi_list))
+                               iounmap(entry->mask_base);
+               }
+               list_del(&entry->list);
+               kfree(entry);
+       }
+}
 
 static struct msi_desc *alloc_msi_entry(struct pci_dev *dev)
 {
@@ -303,7 +327,7 @@ static void __pci_restore_msi_state(struct pci_dev *dev)
        pos = entry->msi_attrib.pos;
 
        pci_intx_for_msi(dev, 0);
-       msi_set_enable(dev, 0);
+       msi_set_enable(dev, pos, 0);
        write_msi_msg(dev->irq, &entry->msg);
 
        pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &control);
@@ -321,22 +345,22 @@ static void __pci_restore_msix_state(struct pci_dev *dev)
 
        if (!dev->msix_enabled)
                return;
+       BUG_ON(list_empty(&dev->msi_list));
+       entry = list_first_entry(&dev->msi_list, struct msi_desc, list);
+       pos = entry->msi_attrib.pos;
+       pci_read_config_word(dev, pos + PCI_MSIX_FLAGS, &control);
 
        /* route the table */
        pci_intx_for_msi(dev, 0);
-       msix_set_enable(dev, 0);
+       control |= PCI_MSIX_FLAGS_ENABLE | PCI_MSIX_FLAGS_MASKALL;
+       pci_write_config_word(dev, pos + PCI_MSIX_FLAGS, control);
 
        list_for_each_entry(entry, &dev->msi_list, list) {
                write_msi_msg(entry->irq, &entry->msg);
                msix_mask_irq(entry, entry->masked);
        }
 
-       BUG_ON(list_empty(&dev->msi_list));
-       entry = list_entry(dev->msi_list.next, struct msi_desc, list);
-       pos = entry->msi_attrib.pos;
-       pci_read_config_word(dev, pos + PCI_MSIX_FLAGS, &control);
        control &= ~PCI_MSIX_FLAGS_MASKALL;
-       control |= PCI_MSIX_FLAGS_ENABLE;
        pci_write_config_word(dev, pos + PCI_MSIX_FLAGS, control);
 }
 
@@ -365,23 +389,23 @@ static int msi_capability_init(struct pci_dev *dev, int nvec)
        u16 control;
        unsigned mask;
 
-       msi_set_enable(dev, 0); /* Ensure msi is disabled as I set it up */
+       pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
+       msi_set_enable(dev, pos, 0);    /* Disable MSI during set up */
 
-       pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
        pci_read_config_word(dev, msi_control_reg(pos), &control);
        /* MSI Entry Initialization */
        entry = alloc_msi_entry(dev);
        if (!entry)
                return -ENOMEM;
 
-       entry->msi_attrib.is_msix = 0;
-       entry->msi_attrib.is_64 = is_64bit_address(control);
-       entry->msi_attrib.entry_nr = 0;
-       entry->msi_attrib.maskbit = is_mask_bit_support(control);
-       entry->msi_attrib.default_irq = dev->irq;       /* Save IOAPIC IRQ */
-       entry->msi_attrib.pos = pos;
+       entry->msi_attrib.is_msix       = 0;
+       entry->msi_attrib.is_64         = is_64bit_address(control);
+       entry->msi_attrib.entry_nr      = 0;
+       entry->msi_attrib.maskbit       = is_mask_bit_support(control);
+       entry->msi_attrib.default_irq   = dev->irq;     /* Save IOAPIC IRQ */
+       entry->msi_attrib.pos           = pos;
 
-       entry->mask_pos = msi_mask_bits_reg(pos, entry->msi_attrib.is_64);
+       entry->mask_pos = msi_mask_reg(pos, entry->msi_attrib.is_64);
        /* All MSIs are unmasked by default, Mask them all */
        if (entry->msi_attrib.maskbit)
                pci_read_config_dword(dev, entry->mask_pos, &entry->masked);
@@ -393,19 +417,84 @@ static int msi_capability_init(struct pci_dev *dev, int nvec)
        /* Configure MSI capability structure */
        ret = arch_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSI);
        if (ret) {
-               msi_free_irqs(dev);
+               msi_mask_irq(entry, mask, ~mask);
+               free_msi_irqs(dev);
                return ret;
        }
 
        /* Set MSI enabled bits  */
        pci_intx_for_msi(dev, 0);
-       msi_set_enable(dev, 1);
+       msi_set_enable(dev, pos, 1);
        dev->msi_enabled = 1;
 
        dev->irq = entry->irq;
        return 0;
 }
 
+static void __iomem *msix_map_region(struct pci_dev *dev, unsigned pos,
+                                                       unsigned nr_entries)
+{
+       unsigned long phys_addr;
+       u32 table_offset;
+       u8 bir;
+
+       pci_read_config_dword(dev, msix_table_offset_reg(pos), &table_offset);
+       bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
+       table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
+       phys_addr = pci_resource_start(dev, bir) + table_offset;
+
+       return ioremap_nocache(phys_addr, nr_entries * PCI_MSIX_ENTRY_SIZE);
+}
+
+static int msix_setup_entries(struct pci_dev *dev, unsigned pos,
+                               void __iomem *base, struct msix_entry *entries,
+                               int nvec)
+{
+       struct msi_desc *entry;
+       int i;
+
+       for (i = 0; i < nvec; i++) {
+               entry = alloc_msi_entry(dev);
+               if (!entry) {
+                       if (!i)
+                               iounmap(base);
+                       else
+                               free_msi_irqs(dev);
+                       /* No enough memory. Don't try again */
+                       return -ENOMEM;
+               }
+
+               entry->msi_attrib.is_msix       = 1;
+               entry->msi_attrib.is_64         = 1;
+               entry->msi_attrib.entry_nr      = entries[i].entry;
+               entry->msi_attrib.default_irq   = dev->irq;
+               entry->msi_attrib.pos           = pos;
+               entry->mask_base                = base;
+
+               list_add_tail(&entry->list, &dev->msi_list);
+       }
+
+       return 0;
+}
+
+static void msix_program_entries(struct pci_dev *dev,
+                                       struct msix_entry *entries)
+{
+       struct msi_desc *entry;
+       int i = 0;
+
+       list_for_each_entry(entry, &dev->msi_list, list) {
+               int offset = entries[i].entry * PCI_MSIX_ENTRY_SIZE +
+                                               PCI_MSIX_ENTRY_VECTOR_CTRL;
+
+               entries[i].vector = entry->irq;
+               set_irq_msi(entry->irq, entry);
+               entry->masked = readl(entry->mask_base + offset);
+               msix_mask_irq(entry, 1);
+               i++;
+       }
+}
+
 /**
  * msix_capability_init - configure device's MSI-X capability
  * @dev: pointer to the pci_dev data structure of MSI-X device function
@@ -419,85 +508,69 @@ static int msi_capability_init(struct pci_dev *dev, int nvec)
 static int msix_capability_init(struct pci_dev *dev,
                                struct msix_entry *entries, int nvec)
 {
-       struct msi_desc *entry;
-       int pos, i, j, nr_entries, ret;
-       unsigned long phys_addr;
-       u32 table_offset;
-       u16 control;
-       u8 bir;
+       int pos, ret;
+       u16 control;
        void __iomem *base;
 
-       msix_set_enable(dev, 0);/* Ensure msix is disabled as I set it up */
+       pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
+       pci_read_config_word(dev, pos + PCI_MSIX_FLAGS, &control);
 
-       pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
-       /* Request & Map MSI-X table region */
-       pci_read_config_word(dev, msi_control_reg(pos), &control);
-       nr_entries = multi_msix_capable(control);
+       /* Ensure MSI-X is disabled while it is set up */
+       control &= ~PCI_MSIX_FLAGS_ENABLE;
+       pci_write_config_word(dev, pos + PCI_MSIX_FLAGS, control);
 
-       pci_read_config_dword(dev, msix_table_offset_reg(pos), &table_offset);
-       bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
-       table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
-       phys_addr = pci_resource_start (dev, bir) + table_offset;
-       base = ioremap_nocache(phys_addr, nr_entries * PCI_MSIX_ENTRY_SIZE);
-       if (base == NULL)
+       /* Request & Map MSI-X table region */
+       base = msix_map_region(dev, pos, multi_msix_capable(control));
+       if (!base)
                return -ENOMEM;
 
-       /* MSI-X Table Initialization */
-       for (i = 0; i < nvec; i++) {
-               entry = alloc_msi_entry(dev);
-               if (!entry)
-                       break;
-
-               j = entries[i].entry;
-               entry->msi_attrib.is_msix = 1;
-               entry->msi_attrib.is_64 = 1;
-               entry->msi_attrib.entry_nr = j;
-               entry->msi_attrib.default_irq = dev->irq;
-               entry->msi_attrib.pos = pos;
-               entry->mask_base = base;
-               msix_mask_irq(entry, 1);
-
-               list_add_tail(&entry->list, &dev->msi_list);
-       }
+       ret = msix_setup_entries(dev, pos, base, entries, nvec);
+       if (ret)
+               return ret;
 
        ret = arch_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSIX);
+       if (ret)
+               goto error;
+
+       /*
+        * Some devices require MSI-X to be enabled before we can touch the
+        * MSI-X registers.  We need to mask all the vectors to prevent
+        * interrupts coming in before they're fully set up.
+        */
+       control |= PCI_MSIX_FLAGS_MASKALL | PCI_MSIX_FLAGS_ENABLE;
+       pci_write_config_word(dev, pos + PCI_MSIX_FLAGS, control);
+
+       msix_program_entries(dev, entries);
+
+       /* Set MSI-X enabled bits and unmask the function */
+       pci_intx_for_msi(dev, 0);
+       dev->msix_enabled = 1;
+
+       control &= ~PCI_MSIX_FLAGS_MASKALL;
+       pci_write_config_word(dev, pos + PCI_MSIX_FLAGS, control);
+
+       return 0;
+
+error:
        if (ret < 0) {
-               /* If we had some success report the number of irqs
-                * we succeeded in setting up. */
+               /*
+                * If we had some success, report the number of irqs
+                * we succeeded in setting up.
+                */
+               struct msi_desc *entry;
                int avail = 0;
+
                list_for_each_entry(entry, &dev->msi_list, list) {
-                       if (entry->irq != 0) {
+                       if (entry->irq != 0)
                                avail++;
-                       }
                }
-
                if (avail != 0)
                        ret = avail;
        }
 
-       if (ret) {
-               msi_free_irqs(dev);
-               return ret;
-       }
-
-       i = 0;
-       list_for_each_entry(entry, &dev->msi_list, list) {
-               entries[i].vector = entry->irq;
-               set_irq_msi(entry->irq, entry);
-               i++;
-       }
-       /* Set MSI-X enabled bits */
-       pci_intx_for_msi(dev, 0);
-       msix_set_enable(dev, 1);
-       dev->msix_enabled = 1;
-
-       list_for_each_entry(entry, &dev->msi_list, list) {
-               int vector = entry->msi_attrib.entry_nr;
-               entry->masked = readl(base + vector * PCI_MSIX_ENTRY_SIZE +
-                                       PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET);
-       }
+       free_msi_irqs(dev);
 
-       return 0;
+       return ret;
 }
 
 /**
@@ -510,7 +583,7 @@ static int msix_capability_init(struct pci_dev *dev,
  * to determine if MSI/-X are supported for the device. If MSI/-X is
  * supported return 0, else return an error code.
  **/
-static int pci_msi_check_device(struct pci_dev* dev, int nvec, int type)
+static int pci_msi_check_device(struct pci_dev *dev, int nvec, int type)
 {
        struct pci_bus *bus;
        int ret;
@@ -527,8 +600,9 @@ static int pci_msi_check_device(struct pci_dev* dev, int nvec, int type)
        if (nvec < 1)
                return -ERANGE;
 
-       /* Any bridge which does NOT route MSI transactions from it's
-        * secondary bus to it's primary bus must set NO_MSI flag on
+       /*
+        * Any bridge which does NOT route MSI transactions from its
+        * secondary bus to its primary bus must set NO_MSI flag on
         * the secondary pci_bus.
         * We expect only arch-specific PCI host bus controller driver
         * or quirks for specific PCI bridges to be setting NO_MSI.
@@ -596,72 +670,39 @@ void pci_msi_shutdown(struct pci_dev *dev)
        struct msi_desc *desc;
        u32 mask;
        u16 ctrl;
+       unsigned pos;
 
        if (!pci_msi_enable || !dev || !dev->msi_enabled)
                return;
 
-       msi_set_enable(dev, 0);
+       BUG_ON(list_empty(&dev->msi_list));
+       desc = list_first_entry(&dev->msi_list, struct msi_desc, list);
+       pos = desc->msi_attrib.pos;
+
+       msi_set_enable(dev, pos, 0);
        pci_intx_for_msi(dev, 1);
        dev->msi_enabled = 0;
 
-       BUG_ON(list_empty(&dev->msi_list));
-       desc = list_first_entry(&dev->msi_list, struct msi_desc, list);
-       pci_read_config_word(dev, desc->msi_attrib.pos + PCI_MSI_FLAGS, &ctrl);
+       /* Return the device with MSI unmasked as initial states */
+       pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &ctrl);
        mask = msi_capable_mask(ctrl);
-       msi_mask_irq(desc, mask, ~mask);
+       /* Keep cached state to be restored */
+       __msi_mask_irq(desc, mask, ~mask);
 
        /* Restore dev->irq to its default pin-assertion irq */
        dev->irq = desc->msi_attrib.default_irq;
 }
 
-void pci_disable_msi(struct pci_dev* dev)
+void pci_disable_msi(struct pci_dev *dev)
 {
-       struct msi_desc *entry;
-
        if (!pci_msi_enable || !dev || !dev->msi_enabled)
                return;
 
        pci_msi_shutdown(dev);
-
-       entry = list_entry(dev->msi_list.next, struct msi_desc, list);
-       if (entry->msi_attrib.is_msix)
-               return;
-
-       msi_free_irqs(dev);
+       free_msi_irqs(dev);
 }
 EXPORT_SYMBOL(pci_disable_msi);
 
-static int msi_free_irqs(struct pci_dev* dev)
-{
-       struct msi_desc *entry, *tmp;
-
-       list_for_each_entry(entry, &dev->msi_list, list) {
-               int i, nvec;
-               if (!entry->irq)
-                       continue;
-               nvec = 1 << entry->msi_attrib.multiple;
-               for (i = 0; i < nvec; i++)
-                       BUG_ON(irq_has_action(entry->irq + i));
-       }
-
-       arch_teardown_msi_irqs(dev);
-
-       list_for_each_entry_safe(entry, tmp, &dev->msi_list, list) {
-               if (entry->msi_attrib.is_msix) {
-                       writel(1, entry->mask_base + entry->msi_attrib.entry_nr
-                                 * PCI_MSIX_ENTRY_SIZE
-                                 + PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET);
-
-                       if (list_is_last(&entry->list, &dev->msi_list))
-                               iounmap(entry->mask_base);
-               }
-               list_del(&entry->list);
-               kfree(entry);
-       }
-
-       return 0;
-}
-
 /**
  * pci_msix_table_size - return the number of device's MSI-X table entries
  * @dev: pointer to the pci_dev data structure of MSI-X device function
@@ -691,16 +732,16 @@ int pci_msix_table_size(struct pci_dev *dev)
  * indicates the successful configuration of MSI-X capability structure
  * with new allocated MSI-X irqs. A return of < 0 indicates a failure.
  * Or a return of > 0 indicates that driver request is exceeding the number
- * of irqs available. Driver should use the returned value to re-send
- * its request.
+ * of irqs or MSI-X vectors available. Driver should use the returned value to
+ * re-send its request.
  **/
-int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
+int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec)
 {
        int status, nr_entries;
        int i, j;
 
        if (!entries)
-               return -EINVAL;
+               return -EINVAL;
 
        status = pci_msi_check_device(dev, nvec, PCI_CAP_ID_MSIX);
        if (status)
@@ -708,7 +749,7 @@ int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
 
        nr_entries = pci_msix_table_size(dev);
        if (nvec > nr_entries)
-               return -EINVAL;
+               return nr_entries;
 
        /* Check for any invalid entries */
        for (i = 0; i < nvec; i++) {
@@ -722,7 +763,7 @@ int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
        WARN_ON(!!dev->msix_enabled);
 
        /* Check whether driver already requested for MSI irq */
-       if (dev->msi_enabled) {
+       if (dev->msi_enabled) {
                dev_info(&dev->dev, "can't enable MSI-X "
                       "(MSI IRQ already assigned)\n");
                return -EINVAL;
@@ -732,28 +773,31 @@ int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
 }
 EXPORT_SYMBOL(pci_enable_msix);
 
-static void msix_free_all_irqs(struct pci_dev *dev)
+void pci_msix_shutdown(struct pci_dev *dev)
 {
-       msi_free_irqs(dev);
-}
+       struct msi_desc *entry;
 
-void pci_msix_shutdown(struct pci_dev* dev)
-{
        if (!pci_msi_enable || !dev || !dev->msix_enabled)
                return;
 
+       /* Return the device with MSI-X masked as initial states */
+       list_for_each_entry(entry, &dev->msi_list, list) {
+               /* Keep cached states to be restored */
+               __msix_mask_irq(entry, 1);
+       }
+
        msix_set_enable(dev, 0);
        pci_intx_for_msi(dev, 1);
        dev->msix_enabled = 0;
 }
-void pci_disable_msix(struct pci_dev* dev)
+
+void pci_disable_msix(struct pci_dev *dev)
 {
        if (!pci_msi_enable || !dev || !dev->msix_enabled)
                return;
 
        pci_msix_shutdown(dev);
-
-       msix_free_all_irqs(dev);
+       free_msi_irqs(dev);
 }
 EXPORT_SYMBOL(pci_disable_msix);
 
@@ -766,16 +810,13 @@ EXPORT_SYMBOL(pci_disable_msix);
  * allocated for this device function, are reclaimed to unused state,
  * which may be used later on.
  **/
-void msi_remove_pci_irq_vectors(struct pci_dev* dev)
+void msi_remove_pci_irq_vectors(struct pci_dev *dev)
 {
        if (!pci_msi_enable || !dev)
-               return;
-
-       if (dev->msi_enabled)
-               msi_free_irqs(dev);
+               return;
 
-       if (dev->msix_enabled)
-               msix_free_all_irqs(dev);
+       if (dev->msi_enabled || dev->msix_enabled)
+               free_msi_irqs(dev);
 }
 
 void pci_no_msi(void)