0006-aacraid-reset-irq-affinity.patch

   1 From 8b1462e0ebb677ee07da6c18f7047539ea6e449e Mon Sep 17 00:00:00 2001
   2 From: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
   3 Date: Fri, 28 Aug 2015 06:38:38 -0400
   4 Subject: aacraid: Reset irq affinity hints
   5
   6 Reset irq affinity hints before releasing IRQ.
   7 Removed duplicate code of IRQ acquire/release.
   8
   9 Reviewed-by: Tomas Henzl <thenzl@redhat.com>
  10 Reviewed-by: Murthy Bhat <Murthy.Bhat@pmcs.com>
  11 Reviewed-by: Karthikeya Sunkesula <Karthikeya.Sunkesula@pmcs.com>
  12 Signed-off-by: Mahesh Rajashekhara <Mahesh.Rajashekhara@pmcs.com>
  13 Signed-off-by: James Bottomley <JBottomley@Odin.com>
  14 ---
  15  drivers/scsi/aacraid/aacraid.h |   2 +
  16  drivers/scsi/aacraid/commsup.c | 113 ++++++++++++++++++++++++++++++-----------
  17  drivers/scsi/aacraid/src.c     |  48 ++---------------
  18  3 files changed, 88 insertions(+), 75 deletions(-)
  19
  20 diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
  21 index e54f597..7b95227 100644
  22 --- a/drivers/scsi/aacraid/aacraid.h
  23 +++ b/drivers/scsi/aacraid/aacraid.h
  24 @@ -2110,6 +2110,8 @@ static inline unsigned int cap_to_cyls(sector_t capacity, unsigned divisor)
  25  #define AAC_OWNER_ERROR_HANDLER        0x103
  26  #define AAC_OWNER_FIRMWARE     0x106
  27
  28 +int aac_acquire_irq(struct aac_dev *dev);
  29 +void aac_free_irq(struct aac_dev *dev);
  30  const char *aac_driverinfo(struct Scsi_Host *);
  31  struct fib *aac_fib_alloc(struct aac_dev *dev);
  32  int aac_fib_setup(struct aac_dev *dev);
  33 diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
  34 index 4da5749..a1f90fe 100644
  35 --- a/drivers/scsi/aacraid/commsup.c
  36 +++ b/drivers/scsi/aacraid/commsup.c
  37 @@ -1270,13 +1270,12 @@ retry_next:
  38  static int _aac_reset_adapter(struct aac_dev *aac, int forced)
  39  {
  40         int index, quirks;
  41 -       int retval, i;
  42 +       int retval;
  43         struct Scsi_Host *host;
  44         struct scsi_device *dev;
  45         struct scsi_cmnd *command;
  46         struct scsi_cmnd *command_list;
  47         int jafo = 0;
  48 -       int cpu;
  49
  50         /*
  51          * Assumptions:
  52 @@ -1339,35 +1338,7 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced)
  53         aac->comm_phys = 0;
  54         kfree(aac->queues);
  55         aac->queues = NULL;
  56 -       cpu = cpumask_first(cpu_online_mask);
  57 -       if (aac->pdev->device == PMC_DEVICE_S6 ||
  58 -           aac->pdev->device == PMC_DEVICE_S7 ||
  59 -           aac->pdev->device == PMC_DEVICE_S8 ||
  60 -           aac->pdev->device == PMC_DEVICE_S9) {
  61 -               if (aac->max_msix > 1) {
  62 -                       for (i = 0; i < aac->max_msix; i++) {
  63 -                               if (irq_set_affinity_hint(
  64 -                                   aac->msixentry[i].vector,
  65 -                                   NULL)) {
  66 -                                       printk(KERN_ERR "%s%d: Failed to reset IRQ affinity for cpu %d\n",
  67 -                                               aac->name,
  68 -                                               aac->id,
  69 -                                               cpu);
  70 -                               }
  71 -                               cpu = cpumask_next(cpu,
  72 -                                               cpu_online_mask);
  73 -                               free_irq(aac->msixentry[i].vector,
  74 -                                        &(aac->aac_msix[i]));
  75 -                       }
  76 -                       pci_disable_msix(aac->pdev);
  77 -               } else {
  78 -                       free_irq(aac->pdev->irq, &(aac->aac_msix[0]));
  79 -               }
  80 -       } else {
  81 -               free_irq(aac->pdev->irq, aac);
  82 -       }
  83 -       if (aac->msi)
  84 -               pci_disable_msi(aac->pdev);
  85 +       aac_free_irq(aac);
  86         kfree(aac->fsa_dev);
  87         aac->fsa_dev = NULL;
  88         quirks = aac_get_driver_ident(index)->quirks;
  89 @@ -1978,3 +1949,83 @@ int aac_command_thread(void *data)
  90         dev->aif_thread = 0;
  91         return 0;
  92  }
  93 +
  94 +int aac_acquire_irq(struct aac_dev *dev)
  95 +{
  96 +       int i;
  97 +       int j;
  98 +       int ret = 0;
  99 +       int cpu;
 100 +
 101 +       cpu = cpumask_first(cpu_online_mask);
 102 +       if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) {
 103 +               for (i = 0; i < dev->max_msix; i++) {
 104 +                       dev->aac_msix[i].vector_no = i;
 105 +                       dev->aac_msix[i].dev = dev;
 106 +                       if (request_irq(dev->msixentry[i].vector,
 107 +                                       dev->a_ops.adapter_intr,
 108 +                                       0, "aacraid", &(dev->aac_msix[i]))) {
 109 +                               printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n",
 110 +                                               dev->name, dev->id, i);
 111 +                               for (j = 0 ; j < i ; j++)
 112 +                                       free_irq(dev->msixentry[j].vector,
 113 +                                                &(dev->aac_msix[j]));
 114 +                               pci_disable_msix(dev->pdev);
 115 +                               ret = -1;
 116 +                       }
 117 +                       if (irq_set_affinity_hint(dev->msixentry[i].vector,
 118 +                                                       get_cpu_mask(cpu))) {
 119 +                               printk(KERN_ERR "%s%d: Failed to set IRQ affinity for cpu %d\n",
 120 +                                           dev->name, dev->id, cpu);
 121 +                       }
 122 +                       cpu = cpumask_next(cpu, cpu_online_mask);
 123 +               }
 124 +       } else {
 125 +               dev->aac_msix[0].vector_no = 0;
 126 +               dev->aac_msix[0].dev = dev;
 127 +
 128 +               if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
 129 +                       IRQF_SHARED, "aacraid",
 130 +                       &(dev->aac_msix[0])) < 0) {
 131 +                       if (dev->msi)
 132 +                               pci_disable_msi(dev->pdev);
 133 +                       printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
 134 +                                       dev->name, dev->id);
 135 +                       ret = -1;
 136 +               }
 137 +       }
 138 +       return ret;
 139 +}
 140 +
 141 +void aac_free_irq(struct aac_dev *dev)
 142 +{
 143 +       int i;
 144 +       int cpu;
 145 +
 146 +       cpu = cpumask_first(cpu_online_mask);
 147 +       if (dev->pdev->device == PMC_DEVICE_S6 ||
 148 +           dev->pdev->device == PMC_DEVICE_S7 ||
 149 +           dev->pdev->device == PMC_DEVICE_S8 ||
 150 +           dev->pdev->device == PMC_DEVICE_S9) {
 151 +               if (dev->max_msix > 1) {
 152 +                       for (i = 0; i < dev->max_msix; i++) {
 153 +                               if (irq_set_affinity_hint(
 154 +                                       dev->msixentry[i].vector, NULL)) {
 155 +                                       printk(KERN_ERR "%s%d: Failed to reset IRQ affinity for cpu %d\n",
 156 +                                           dev->name, dev->id, cpu);
 157 +                               }
 158 +                               cpu = cpumask_next(cpu, cpu_online_mask);
 159 +                               free_irq(dev->msixentry[i].vector,
 160 +                                               &(dev->aac_msix[i]));
 161 +                       }
 162 +               } else {
 163 +                       free_irq(dev->pdev->irq, &(dev->aac_msix[0]));
 164 +               }
 165 +       } else {
 166 +               free_irq(dev->pdev->irq, dev);
 167 +       }
 168 +       if (dev->msi)
 169 +               pci_disable_msi(dev->pdev);
 170 +       else if (dev->max_msix > 1)
 171 +               pci_disable_msix(dev->pdev);
 172 +}
 173 diff --git a/drivers/scsi/aacraid/src.c b/drivers/scsi/aacraid/src.c
 174 index 1409a0b..2aa34ea 100644
 175 --- a/drivers/scsi/aacraid/src.c
 176 +++ b/drivers/scsi/aacraid/src.c
 177 @@ -798,9 +798,7 @@ int aac_srcv_init(struct aac_dev *dev)
 178         unsigned long status;
 179         int restart = 0;
 180         int instance = dev->id;
 181 -       int i, j;
 182         const char *name = dev->name;
 183 -       int cpu;
 184
 185         dev->a_ops.adapter_ioremap = aac_srcv_ioremap;
 186         dev->a_ops.adapter_comm = aac_src_select_comm;
 187 @@ -918,48 +916,10 @@ int aac_srcv_init(struct aac_dev *dev)
 188                 goto error_iounmap;
 189         if (dev->msi_enabled)
 190                 aac_src_access_devreg(dev, AAC_ENABLE_MSIX);
 191 -       if (!dev->sync_mode && dev->msi_enabled && dev->max_msix > 1) {
 192 -               cpu = cpumask_first(cpu_online_mask);
 193 -               for (i = 0; i < dev->max_msix; i++) {
 194 -                       dev->aac_msix[i].vector_no = i;
 195 -                       dev->aac_msix[i].dev = dev;
 196 -
 197 -                       if (request_irq(dev->msixentry[i].vector,
 198 -                                       dev->a_ops.adapter_intr,
 199 -                                       0,
 200 -                                       "aacraid",
 201 -                                       &(dev->aac_msix[i]))) {
 202 -                               printk(KERN_ERR "%s%d: Failed to register IRQ for vector %d.\n",
 203 -                                               name, instance, i);
 204 -                               for (j = 0 ; j < i ; j++)
 205 -                                       free_irq(dev->msixentry[j].vector,
 206 -                                                &(dev->aac_msix[j]));
 207 -                               pci_disable_msix(dev->pdev);
 208 -                               goto error_iounmap;
 209 -                       }
 210 -                       if (irq_set_affinity_hint(
 211 -                          dev->msixentry[i].vector,
 212 -                          get_cpu_mask(cpu))) {
 213 -                               printk(KERN_ERR "%s%d: Failed to set IRQ affinity for cpu %d\n",
 214 -                                               name, instance, cpu);
 215 -                       }
 216 -                       cpu = cpumask_next(cpu, cpu_online_mask);
 217 -               }
 218 -       } else {
 219 -               dev->aac_msix[0].vector_no = 0;
 220 -               dev->aac_msix[0].dev = dev;
 221 -
 222 -               if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
 223 -                               IRQF_SHARED,
 224 -                               "aacraid",
 225 -                               &(dev->aac_msix[0])) < 0) {
 226 -                       if (dev->msi)
 227 -                               pci_disable_msi(dev->pdev);
 228 -                       printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
 229 -                                       name, instance);
 230 -                       goto error_iounmap;
 231 -               }
 232 -       }
 233 +
 234 +       if (aac_acquire_irq(dev))
 235 +               goto error_iounmap;
 236 +
 237         dev->dbg_base = dev->base_start;
 238         dev->dbg_base_mapped = dev->base;
 239         dev->dbg_size = dev->base_size;
 240 --
 241 cgit v0.11.2
 242