drivers/xen/xen-pciback/pciback_ops.c

   1 /*
   2  * PCI Backend Operations - respond to PCI requests from Frontend
   3  *
   4  *   Author: Ryan Wilson <hap9@epoch.ncsc.mil>
   5  */
   6 #include <linux/module.h>
   7 #include <linux/wait.h>
   8 #include <linux/bitops.h>
   9 #ifndef CONFIG_XEN
  10 #include <xen/events.h>
  11 #else
  12 #include <xen/evtchn.h>
  13 #endif
  14 #include <linux/sched.h>
  15 #include "pciback.h"
  16
  17 int verbose_request;
  18 module_param(verbose_request, int, 0644);
  19
  20 #ifndef CONFIG_XEN
  21 static irqreturn_t xen_pcibk_guest_interrupt(int irq, void *dev_id);
  22
  23 /* Ensure a device is has the fake IRQ handler "turned on/off" and is
  24  * ready to be exported. This MUST be run after xen_pcibk_reset_device
  25  * which does the actual PCI device enable/disable.
  26  */
  27 static void xen_pcibk_control_isr(struct pci_dev *dev, int reset)
  28 {
  29         struct xen_pcibk_dev_data *dev_data;
  30         int rc;
  31         int enable = 0;
  32
  33         dev_data = pci_get_drvdata(dev);
  34         if (!dev_data)
  35                 return;
  36
  37         /* We don't deal with bridges */
  38         if (dev->hdr_type != PCI_HEADER_TYPE_NORMAL)
  39                 return;
  40
  41         if (reset) {
  42                 dev_data->enable_intx = 0;
  43                 dev_data->ack_intr = 0;
  44         }
  45         enable =  dev_data->enable_intx;
  46
  47         /* Asked to disable, but ISR isn't runnig */
  48         if (!enable && !dev_data->isr_on)
  49                 return;
  50
  51         /* Squirrel away the IRQs in the dev_data. We need this
  52          * b/c when device transitions to MSI, the dev->irq is
  53          * overwritten with the MSI vector.
  54          */
  55         if (enable)
  56                 dev_data->irq = dev->irq;
  57
  58         /*
  59          * SR-IOV devices in all use MSI-X and have no legacy
  60          * interrupts, so inhibit creating a fake IRQ handler for them.
  61          */
  62         if (dev_data->irq == 0)
  63                 goto out;
  64
  65         dev_dbg(&dev->dev, "%s: #%d %s %s%s %s-> %s\n",
  66                 dev_data->irq_name,
  67                 dev_data->irq,
  68                 pci_is_enabled(dev) ? "on" : "off",
  69                 dev->msi_enabled ? "MSI" : "",
  70                 dev->msix_enabled ? "MSI/X" : "",
  71                 dev_data->isr_on ? "enable" : "disable",
  72                 enable ? "enable" : "disable");
  73
  74         if (enable) {
  75                 rc = request_irq(dev_data->irq,
  76                                 xen_pcibk_guest_interrupt, IRQF_SHARED,
  77                                 dev_data->irq_name, dev);
  78                 if (rc) {
  79                         dev_err(&dev->dev, "%s: failed to install fake IRQ " \
  80                                 "handler for IRQ %d! (rc:%d)\n",
  81                                 dev_data->irq_name, dev_data->irq, rc);
  82                         goto out;
  83                 }
  84         } else {
  85                 free_irq(dev_data->irq, dev);
  86                 dev_data->irq = 0;
  87         }
  88         dev_data->isr_on = enable;
  89         dev_data->ack_intr = enable;
  90 out:
  91         dev_dbg(&dev->dev, "%s: #%d %s %s%s %s\n",
  92                 dev_data->irq_name,
  93                 dev_data->irq,
  94                 pci_is_enabled(dev) ? "on" : "off",
  95                 dev->msi_enabled ? "MSI" : "",
  96                 dev->msix_enabled ? "MSI/X" : "",
  97                 enable ? (dev_data->isr_on ? "enabled" : "failed to enable") :
  98                         (dev_data->isr_on ? "failed to disable" : "disabled"));
  99 }
 100 #endif
 101
 102 /* Ensure a device is "turned off" and ready to be exported.
 103  * (Also see xen_pcibk_config_reset to ensure virtual configuration space is
 104  * ready to be re-exported)
 105  */
 106 void xen_pcibk_reset_device(struct pci_dev *dev)
 107 {
 108         u16 cmd;
 109
 110 #ifndef CONFIG_XEN
 111         xen_pcibk_control_isr(dev, 1 /* reset device */);
 112 #endif
 113
 114         /* Disable devices (but not bridges) */
 115         if (dev->hdr_type == PCI_HEADER_TYPE_NORMAL) {
 116 #ifdef CONFIG_PCI_MSI
 117                 /* The guest could have been abruptly killed without
 118                  * disabling MSI/MSI-X interrupts.*/
 119                 if (dev->msix_enabled)
 120                         pci_disable_msix(dev);
 121                 if (dev->msi_enabled)
 122                         pci_disable_msi(dev);
 123 #endif
 124                 pci_disable_device(dev);
 125
 126                 pci_write_config_word(dev, PCI_COMMAND, 0);
 127
 128 #ifdef CONFIG_XEN
 129                 atomic_set(&dev->enable_cnt, 0);
 130 #endif
 131                 dev->is_busmaster = 0;
 132         } else {
 133                 pci_read_config_word(dev, PCI_COMMAND, &cmd);
 134                 if (cmd & (PCI_COMMAND_INVALIDATE)) {
 135                         cmd &= ~(PCI_COMMAND_INVALIDATE);
 136                         pci_write_config_word(dev, PCI_COMMAND, cmd);
 137
 138                         dev->is_busmaster = 0;
 139                 }
 140         }
 141 }
 142
 143 #ifdef CONFIG_PCI_MSI
 144 static
 145 int xen_pcibk_enable_msi(struct xen_pcibk_device *pdev,
 146                          struct pci_dev *dev, struct xen_pci_op *op)
 147 {
 148 #ifndef CONFIG_XEN
 149         struct xen_pcibk_dev_data *dev_data;
 150 #endif
 151         int otherend = pdev->xdev->otherend_id;
 152         int status;
 153
 154         if (unlikely(verbose_request))
 155                 printk(KERN_DEBUG DRV_NAME ": %s: enable MSI\n", pci_name(dev));
 156
 157         status = pci_enable_msi(dev);
 158
 159         if (status) {
 160                 printk(KERN_ERR "error enable msi for guest %x status %x\n",
 161                         otherend, status);
 162                 op->value = 0;
 163                 return XEN_PCI_ERR_op_failed;
 164         }
 165
 166         /* The value the guest needs is actually the IDT vector, not the
 167          * the local domain's IRQ number. */
 168
 169 #ifndef CONFIG_XEN
 170         op->value = dev->irq ? xen_pirq_from_irq(dev->irq) : 0;
 171 #else
 172         op->value = dev->irq;
 173 #endif
 174         if (unlikely(verbose_request))
 175                 printk(KERN_DEBUG DRV_NAME ": %s: MSI: %d\n", pci_name(dev),
 176                         op->value);
 177
 178 #ifndef CONFIG_XEN
 179         dev_data = pci_get_drvdata(dev);
 180         if (dev_data)
 181                 dev_data->ack_intr = 0;
 182 #endif
 183
 184         return 0;
 185 }
 186
 187 static
 188 int xen_pcibk_disable_msi(struct xen_pcibk_device *pdev,
 189                           struct pci_dev *dev, struct xen_pci_op *op)
 190 {
 191 #ifndef CONFIG_XEN
 192         struct xen_pcibk_dev_data *dev_data;
 193 #endif
 194
 195         if (unlikely(verbose_request))
 196                 printk(KERN_DEBUG DRV_NAME ": %s: disable MSI\n",
 197                        pci_name(dev));
 198         pci_disable_msi(dev);
 199
 200 #ifndef CONFIG_XEN
 201         op->value = dev->irq ? xen_pirq_from_irq(dev->irq) : 0;
 202 #else
 203         op->value = dev->irq;
 204 #endif
 205         if (unlikely(verbose_request))
 206                 printk(KERN_DEBUG DRV_NAME ": %s: MSI: %d\n", pci_name(dev),
 207                         op->value);
 208 #ifndef CONFIG_XEN
 209         dev_data = pci_get_drvdata(dev);
 210         if (dev_data)
 211                 dev_data->ack_intr = 1;
 212 #endif
 213         return 0;
 214 }
 215
 216 static
 217 int xen_pcibk_enable_msix(struct xen_pcibk_device *pdev,
 218                           struct pci_dev *dev, struct xen_pci_op *op)
 219 {
 220 #ifndef CONFIG_XEN
 221         struct xen_pcibk_dev_data *dev_data;
 222 #endif
 223         int i, result;
 224         struct msix_entry *entries;
 225
 226         if (unlikely(verbose_request))
 227                 printk(KERN_DEBUG DRV_NAME ": %s: enable MSI-X\n",
 228                        pci_name(dev));
 229         if (op->value > SH_INFO_MAX_VEC)
 230                 return -EINVAL;
 231
 232         entries = kmalloc(op->value * sizeof(*entries), GFP_KERNEL);
 233         if (entries == NULL)
 234                 return -ENOMEM;
 235
 236         for (i = 0; i < op->value; i++) {
 237                 entries[i].entry = op->msix_entries[i].entry;
 238                 entries[i].vector = op->msix_entries[i].vector;
 239         }
 240
 241         result = pci_enable_msix(dev, entries, op->value);
 242
 243         if (result == 0) {
 244                 for (i = 0; i < op->value; i++) {
 245                         op->msix_entries[i].entry = entries[i].entry;
 246 #ifndef CONFIG_XEN
 247                         if (entries[i].vector)
 248                                 op->msix_entries[i].vector =
 249                                         xen_pirq_from_irq(entries[i].vector);
 250 #else
 251                         op->msix_entries[i].vector = entries[i].vector;
 252 #endif
 253                                 if (unlikely(verbose_request))
 254                                         printk(KERN_DEBUG DRV_NAME ": %s: " \
 255                                                 "MSI-X[%d]: %d\n",
 256                                                 pci_name(dev), i,
 257                                                 op->msix_entries[i].vector);
 258                 }
 259         } else {
 260                 printk(KERN_WARNING DRV_NAME ": %s: failed to enable MSI-X: err %d!\n",
 261                         pci_name(dev), result);
 262         }
 263         kfree(entries);
 264
 265         op->value = result;
 266 #ifndef CONFIG_XEN
 267         dev_data = pci_get_drvdata(dev);
 268         if (dev_data)
 269                 dev_data->ack_intr = 0;
 270 #endif
 271
 272         return result;
 273 }
 274
 275 static
 276 int xen_pcibk_disable_msix(struct xen_pcibk_device *pdev,
 277                            struct pci_dev *dev, struct xen_pci_op *op)
 278 {
 279 #ifndef CONFIG_XEN
 280         struct xen_pcibk_dev_data *dev_data;
 281 #endif
 282
 283         if (unlikely(verbose_request))
 284                 printk(KERN_DEBUG DRV_NAME ": %s: disable MSI-X\n",
 285                         pci_name(dev));
 286         pci_disable_msix(dev);
 287
 288 #ifndef CONFIG_XEN
 289         /*
 290          * SR-IOV devices (which don't have any legacy IRQ) have
 291          * an undefined IRQ value of zero.
 292          */
 293         op->value = dev->irq ? xen_pirq_from_irq(dev->irq) : 0;
 294         if (unlikely(verbose_request))
 295                 printk(KERN_DEBUG DRV_NAME ": %s: MSI-X: %d\n", pci_name(dev),
 296                         op->value);
 297         dev_data = pci_get_drvdata(dev);
 298         if (dev_data)
 299                 dev_data->ack_intr = 1;
 300 #else
 301         op->value = dev->irq;
 302 #endif
 303         return 0;
 304 }
 305 #endif
 306 /*
 307 * Now the same evtchn is used for both pcifront conf_read_write request
 308 * as well as pcie aer front end ack. We use a new work_queue to schedule
 309 * xen_pcibk conf_read_write service for avoiding confict with aer_core
 310 * do_recovery job which also use the system default work_queue
 311 */
 312 void xen_pcibk_test_and_schedule_op(struct xen_pcibk_device *pdev)
 313 {
 314         /* Check that frontend is requesting an operation and that we are not
 315          * already processing a request */
 316         if (test_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags)
 317             && !test_and_set_bit(_PDEVF_op_active, &pdev->flags)) {
 318                 queue_work(xen_pcibk_wq, &pdev->op_work);
 319         }
 320         /*_XEN_PCIB_active should have been cleared by pcifront. And also make
 321         sure xen_pcibk is waiting for ack by checking _PCIB_op_pending*/
 322         if (!test_bit(_XEN_PCIB_active, (unsigned long *)&pdev->sh_info->flags)
 323             && test_bit(_PCIB_op_pending, &pdev->flags)) {
 324                 wake_up(&xen_pcibk_aer_wait_queue);
 325         }
 326 }
 327
 328 /* Performing the configuration space reads/writes must not be done in atomic
 329  * context because some of the pci_* functions can sleep (mostly due to ACPI
 330  * use of semaphores). This function is intended to be called from a work
 331  * queue in process context taking a struct xen_pcibk_device as a parameter */
 332
 333 void xen_pcibk_do_op(struct work_struct *data)
 334 {
 335         struct xen_pcibk_device *pdev =
 336                 container_of(data, struct xen_pcibk_device, op_work);
 337         struct pci_dev *dev;
 338         struct xen_pcibk_dev_data *dev_data = NULL;
 339         struct xen_pci_op *op = &pdev->sh_info->op;
 340         int test_intx = 0;
 341
 342         dev = xen_pcibk_get_pci_dev(pdev, op->domain, op->bus, op->devfn);
 343
 344         if (dev == NULL)
 345                 op->err = XEN_PCI_ERR_dev_not_found;
 346         else {
 347 #ifndef CONFIG_XEN
 348                 dev_data = pci_get_drvdata(dev);
 349                 if (dev_data)
 350                         test_intx = dev_data->enable_intx;
 351 #else
 352                 (void)dev_data;
 353                 (void)test_intx;
 354 #endif
 355                 switch (op->cmd) {
 356                 case XEN_PCI_OP_conf_read:
 357                         op->err = xen_pcibk_config_read(dev,
 358                                   op->offset, op->size, &op->value);
 359                         break;
 360                 case XEN_PCI_OP_conf_write:
 361                         op->err = xen_pcibk_config_write(dev,
 362                                   op->offset, op->size, op->value);
 363                         break;
 364 #ifdef CONFIG_PCI_MSI
 365                 case XEN_PCI_OP_enable_msi:
 366                         op->err = xen_pcibk_enable_msi(pdev, dev, op);
 367                         break;
 368                 case XEN_PCI_OP_disable_msi:
 369                         op->err = xen_pcibk_disable_msi(pdev, dev, op);
 370                         break;
 371                 case XEN_PCI_OP_enable_msix:
 372                         op->err = xen_pcibk_enable_msix(pdev, dev, op);
 373                         break;
 374                 case XEN_PCI_OP_disable_msix:
 375                         op->err = xen_pcibk_disable_msix(pdev, dev, op);
 376                         break;
 377 #endif
 378                 default:
 379                         op->err = XEN_PCI_ERR_not_implemented;
 380                         break;
 381                 }
 382         }
 383 #ifndef CONFIG_XEN
 384         if (!op->err && dev && dev_data) {
 385                 /* Transition detected */
 386                 if ((dev_data->enable_intx != test_intx))
 387                         xen_pcibk_control_isr(dev, 0 /* no reset */);
 388         }
 389 #endif
 390         /* Tell the driver domain that we're done. */
 391         wmb();
 392         clear_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags);
 393         notify_remote_via_irq(pdev->evtchn_irq);
 394
 395         /* Mark that we're done. */
 396         smp_mb__before_clear_bit(); /* /after/ clearing PCIF_active */
 397         clear_bit(_PDEVF_op_active, &pdev->flags);
 398         smp_mb__after_clear_bit(); /* /before/ final check for work */
 399
 400         /* Check to see if the driver domain tried to start another request in
 401          * between clearing _XEN_PCIF_active and clearing _PDEVF_op_active.
 402         */
 403         xen_pcibk_test_and_schedule_op(pdev);
 404 }
 405
 406 irqreturn_t xen_pcibk_handle_event(int irq, void *dev_id)
 407 {
 408         struct xen_pcibk_device *pdev = dev_id;
 409
 410         xen_pcibk_test_and_schedule_op(pdev);
 411
 412         return IRQ_HANDLED;
 413 }
 414
 415 #ifndef CONFIG_XEN
 416 static irqreturn_t xen_pcibk_guest_interrupt(int irq, void *dev_id)
 417 {
 418         struct pci_dev *dev = (struct pci_dev *)dev_id;
 419         struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev);
 420
 421         if (dev_data->isr_on && dev_data->ack_intr) {
 422                 dev_data->handled++;
 423                 if ((dev_data->handled % 1000) == 0) {
 424                         if (xen_test_irq_shared(irq)) {
 425                                 printk(KERN_INFO "%s IRQ line is not shared "
 426                                         "with other domains. Turning ISR off\n",
 427                                          dev_data->irq_name);
 428                                 dev_data->ack_intr = 0;
 429                         }
 430                 }
 431                 return IRQ_HANDLED;
 432         }
 433         return IRQ_NONE;
 434 }
 435 #endif