include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...

[safe/jmp/linux-2.6] / drivers / infiniband / hw / mthca / mthca_eq.c

diff --git a/drivers/infiniband/hw/mthca/mthca_eq.c b/drivers/infiniband/hw/mthca/mthca_eq.c
index 4e36aa7..9388164 100644 (file)
--- a/drivers/infiniband/hw/mthca/mthca_eq.c
+++ b/drivers/infiniband/hw/mthca/mthca_eq.c
@@ -34,6 +34,7 @@
 #include <linux/errno.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 
 #include "mthca_dev.h"
 #include "mthca_cmd.h"
@@ -641,9 +642,11 @@ static void mthca_free_irqs(struct mthca_dev *dev)
        if (dev->eq_table.have_irq)
                free_irq(dev->pdev->irq, dev);
        for (i = 0; i < MTHCA_NUM_EQ; ++i)
-               if (dev->eq_table.eq[i].have_irq)
+               if (dev->eq_table.eq[i].have_irq) {
                        free_irq(dev->eq_table.eq[i].msi_x_vector,
                                 dev->eq_table.eq + i);
+                       dev->eq_table.eq[i].have_irq = 0;
+               }
 }
 
 static int mthca_map_reg(struct mthca_dev *dev,
@@ -652,27 +655,13 @@ static int mthca_map_reg(struct mthca_dev *dev,
 {
        unsigned long base = pci_resource_start(dev->pdev, 0);
 
-       if (!request_mem_region(base + offset, size, DRV_NAME))
-               return -EBUSY;
-
        *map = ioremap(base + offset, size);
-       if (!*map) {
-               release_mem_region(base + offset, size);
+       if (!*map)
                return -ENOMEM;
-       }
 
        return 0;
 }
 
-static void mthca_unmap_reg(struct mthca_dev *dev, unsigned long offset,
-                           unsigned long size, void __iomem *map)
-{
-       unsigned long base = pci_resource_start(dev->pdev, 0);
-
-       release_mem_region(base + offset, size);
-       iounmap(map);
-}
-
 static int mthca_map_eq_regs(struct mthca_dev *dev)
 {
        if (mthca_is_memfree(dev)) {
@@ -699,9 +688,7 @@ static int mthca_map_eq_regs(struct mthca_dev *dev)
                                        dev->fw.arbel.eq_arm_base) + 4, 4,
                                  &dev->eq_regs.arbel.eq_arm)) {
                        mthca_err(dev, "Couldn't map EQ arm register, aborting.\n");
-                       mthca_unmap_reg(dev, (pci_resource_len(dev->pdev, 0) - 1) &
-                                       dev->fw.arbel.clr_int_base, MTHCA_CLR_INT_SIZE,
-                                       dev->clr_base);
+                       iounmap(dev->clr_base);
                        return -ENOMEM;
                }
 
@@ -710,12 +697,8 @@ static int mthca_map_eq_regs(struct mthca_dev *dev)
                                  MTHCA_EQ_SET_CI_SIZE,
                                  &dev->eq_regs.arbel.eq_set_ci_base)) {
                        mthca_err(dev, "Couldn't map EQ CI register, aborting.\n");
-                       mthca_unmap_reg(dev, ((pci_resource_len(dev->pdev, 0) - 1) &
-                                             dev->fw.arbel.eq_arm_base) + 4, 4,
-                                       dev->eq_regs.arbel.eq_arm);
-                       mthca_unmap_reg(dev, (pci_resource_len(dev->pdev, 0) - 1) &
-                                       dev->fw.arbel.clr_int_base, MTHCA_CLR_INT_SIZE,
-                                       dev->clr_base);
+                       iounmap(dev->eq_regs.arbel.eq_arm);
+                       iounmap(dev->clr_base);
                        return -ENOMEM;
                }
        } else {
@@ -731,8 +714,7 @@ static int mthca_map_eq_regs(struct mthca_dev *dev)
                                  &dev->eq_regs.tavor.ecr_base)) {
                        mthca_err(dev, "Couldn't map ecr register, "
                                  "aborting.\n");
-                       mthca_unmap_reg(dev, MTHCA_CLR_INT_BASE, MTHCA_CLR_INT_SIZE,
-                                       dev->clr_base);
+                       iounmap(dev->clr_base);
                        return -ENOMEM;
                }
        }
@@ -744,22 +726,12 @@ static int mthca_map_eq_regs(struct mthca_dev *dev)
 static void mthca_unmap_eq_regs(struct mthca_dev *dev)
 {
        if (mthca_is_memfree(dev)) {
-               mthca_unmap_reg(dev, (pci_resource_len(dev->pdev, 0) - 1) &
-                               dev->fw.arbel.eq_set_ci_base,
-                               MTHCA_EQ_SET_CI_SIZE,
-                               dev->eq_regs.arbel.eq_set_ci_base);
-               mthca_unmap_reg(dev, ((pci_resource_len(dev->pdev, 0) - 1) &
-                                     dev->fw.arbel.eq_arm_base) + 4, 4,
-                               dev->eq_regs.arbel.eq_arm);
-               mthca_unmap_reg(dev, (pci_resource_len(dev->pdev, 0) - 1) &
-                               dev->fw.arbel.clr_int_base, MTHCA_CLR_INT_SIZE,
-                               dev->clr_base);
+               iounmap(dev->eq_regs.arbel.eq_set_ci_base);
+               iounmap(dev->eq_regs.arbel.eq_arm);
+               iounmap(dev->clr_base);
        } else {
-               mthca_unmap_reg(dev, MTHCA_ECR_BASE,
-                               MTHCA_ECR_SIZE + MTHCA_ECR_CLR_SIZE,
-                               dev->eq_regs.tavor.ecr_base);
-               mthca_unmap_reg(dev, MTHCA_CLR_INT_BASE, MTHCA_CLR_INT_SIZE,
-                               dev->clr_base);
+               iounmap(dev->eq_regs.tavor.ecr_base);
+               iounmap(dev->clr_base);
        }
 }
 
@@ -780,7 +752,7 @@ int mthca_map_eq_icm(struct mthca_dev *dev, u64 icm_virt)
                return -ENOMEM;
        dev->eq_table.icm_dma  = pci_map_page(dev->pdev, dev->eq_table.icm_page, 0,
                                              PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
-       if (pci_dma_mapping_error(dev->eq_table.icm_dma)) {
+       if (pci_dma_mapping_error(dev->pdev, dev->eq_table.icm_dma)) {
                __free_page(dev->eq_table.icm_page);
                return -ENOMEM;
        }
@@ -858,27 +830,34 @@ int mthca_init_eq_table(struct mthca_dev *dev)
 
        if (dev->mthca_flags & MTHCA_FLAG_MSI_X) {
                static const char *eq_name[] = {
-                       [MTHCA_EQ_COMP]  = DRV_NAME " (comp)",
-                       [MTHCA_EQ_ASYNC] = DRV_NAME " (async)",
-                       [MTHCA_EQ_CMD]   = DRV_NAME " (cmd)"
+                       [MTHCA_EQ_COMP]  = DRV_NAME "-comp",
+                       [MTHCA_EQ_ASYNC] = DRV_NAME "-async",
+                       [MTHCA_EQ_CMD]   = DRV_NAME "-cmd"
                };
 
                for (i = 0; i < MTHCA_NUM_EQ; ++i) {
+                       snprintf(dev->eq_table.eq[i].irq_name,
+                                IB_DEVICE_NAME_MAX,
+                                "%s@pci:%s", eq_name[i],
+                                pci_name(dev->pdev));
                        err = request_irq(dev->eq_table.eq[i].msi_x_vector,
                                          mthca_is_memfree(dev) ?
                                          mthca_arbel_msi_x_interrupt :
                                          mthca_tavor_msi_x_interrupt,
-                                         0, eq_name[i], dev->eq_table.eq + i);
+                                         0, dev->eq_table.eq[i].irq_name,
+                                         dev->eq_table.eq + i);
                        if (err)
                                goto err_out_cmd;
                        dev->eq_table.eq[i].have_irq = 1;
                }
        } else {
+               snprintf(dev->eq_table.eq[0].irq_name, IB_DEVICE_NAME_MAX,
+                        DRV_NAME "@pci:%s", pci_name(dev->pdev));
                err = request_irq(dev->pdev->irq,
                                  mthca_is_memfree(dev) ?
                                  mthca_arbel_interrupt :
                                  mthca_tavor_interrupt,
-                                 IRQF_SHARED, DRV_NAME, dev);
+                                 IRQF_SHARED, dev->eq_table.eq[0].irq_name, dev);
                if (err)
                        goto err_out_cmd;
                dev->eq_table.have_irq = 1;