PCI: Convert pci_lock to raw_spinlock

pci_lock must be a real spinlock in preempt-rt. Convert it to
raw_spinlock. No change for !RT kernels.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>

1 files changed, 17 insertions, 17 deletions

diff --git a/drivers/pci/access.c b/drivers/pci/access.c
index 2f646fe1260f..affb83b42ebb 100644
--- a/drivers/pci/access.c
+++ b/drivers/pci/access.c
@@ -13,7 +13,7 @@
  * configuration space.
  */
 
-static DEFINE_SPINLOCK(pci_lock);
+static DEFINE_RAW_SPINLOCK(pci_lock);
 
 /*
  *  Wrappers for all PCI configuration access functions.  They just check
@@ -33,10 +33,10 @@ int pci_bus_read_config_##size \
         unsigned long flags;                                            \
         u32 data = 0;                                                   \
         if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
-        spin_lock_irqsave(&pci_lock, flags);                            \
+        raw_spin_lock_irqsave(&pci_lock, flags);                        \
         res = bus->ops->read(bus, devfn, pos, len, &data);              \
         *value = (type)data;                                            \
-        spin_unlock_irqrestore(&pci_lock, flags);                       \
+        raw_spin_unlock_irqrestore(&pci_lock, flags);           \
         return res;                                                     \
 }
 
@@ -47,9 +47,9 @@ int pci_bus_write_config_##size \
         int res;                                                        \
         unsigned long flags;                                            \
         if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
-        spin_lock_irqsave(&pci_lock, flags);                            \
+        raw_spin_lock_irqsave(&pci_lock, flags);                        \
         res = bus->ops->write(bus, devfn, pos, len, value);             \
-        spin_unlock_irqrestore(&pci_lock, flags);                       \
+        raw_spin_unlock_irqrestore(&pci_lock, flags);           \
         return res;                                                     \
 }
 
@@ -79,10 +79,10 @@ struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops)
         struct pci_ops *old_ops;
         unsigned long flags;
 
-        spin_lock_irqsave(&pci_lock, flags);
+        raw_spin_lock_irqsave(&pci_lock, flags);
         old_ops = bus->ops;
         bus->ops = ops;
-        spin_unlock_irqrestore(&pci_lock, flags);
+        raw_spin_unlock_irqrestore(&pci_lock, flags);
         return old_ops;
 }
 EXPORT_SYMBOL(pci_bus_set_ops);
@@ -136,9 +136,9 @@ static noinline void pci_wait_ucfg(struct pci_dev *dev)
         __add_wait_queue(&pci_ucfg_wait, &wait);
         do {
                 set_current_state(TASK_UNINTERRUPTIBLE);
-                spin_unlock_irq(&pci_lock);
+                raw_spin_unlock_irq(&pci_lock);
                 schedule();
-                spin_lock_irq(&pci_lock);
+                raw_spin_lock_irq(&pci_lock);
         } while (dev->block_ucfg_access);
         __remove_wait_queue(&pci_ucfg_wait, &wait);
 }
@@ -150,11 +150,11 @@ int pci_user_read_config_##size						\
         int ret = 0;                                                    \
         u32 data = -1;                                                  \
         if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
-        spin_lock_irq(&pci_lock);                                       \
+        raw_spin_lock_irq(&pci_lock);                           \
         if (unlikely(dev->block_ucfg_access)) pci_wait_ucfg(dev);       \
         ret = dev->bus->ops->read(dev->bus, dev->devfn,                 \
                                         pos, sizeof(type), &data);      \
-        spin_unlock_irq(&pci_lock);                                     \
+        raw_spin_unlock_irq(&pci_lock);                         \
         *val = (type)data;                                              \
         return ret;                                                     \
 }
@@ -165,11 +165,11 @@ int pci_user_write_config_##size					\
 {                                                                       \
         int ret = -EIO;                                                 \
         if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
-        spin_lock_irq(&pci_lock);                                       \
+        raw_spin_lock_irq(&pci_lock);                           \
         if (unlikely(dev->block_ucfg_access)) pci_wait_ucfg(dev);       \
         ret = dev->bus->ops->write(dev->bus, dev->devfn,                \
                                         pos, sizeof(type), val);        \
-        spin_unlock_irq(&pci_lock);                                     \
+        raw_spin_unlock_irq(&pci_lock);                         \
         return ret;                                                     \
 }
 
@@ -396,10 +396,10 @@ void pci_block_user_cfg_access(struct pci_dev *dev)
         unsigned long flags;
         int was_blocked;
 
-        spin_lock_irqsave(&pci_lock, flags);
+        raw_spin_lock_irqsave(&pci_lock, flags);
         was_blocked = dev->block_ucfg_access;
         dev->block_ucfg_access = 1;
-        spin_unlock_irqrestore(&pci_lock, flags);
+        raw_spin_unlock_irqrestore(&pci_lock, flags);
 
         /* If we BUG() inside the pci_lock, we're guaranteed to hose
          * the machine */
@@ -417,7 +417,7 @@ void pci_unblock_user_cfg_access(struct pci_dev *dev)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&pci_lock, flags);
+        raw_spin_lock_irqsave(&pci_lock, flags);
 
         /* This indicates a problem in the caller, but we don't need
          * to kill them, unlike a double-block above. */
@@ -425,6 +425,6 @@ void pci_unblock_user_cfg_access(struct pci_dev *dev)
 
         dev->block_ucfg_access = 0;
         wake_up_all(&pci_ucfg_wait);
-        spin_unlock_irqrestore(&pci_lock, flags);
+        raw_spin_unlock_irqrestore(&pci_lock, flags);
 }
 EXPORT_SYMBOL_GPL(pci_unblock_user_cfg_access);