fedora core 6 1.2949 + vserver 2.2.0

[linux-2.6.git] / drivers / pci / access.c

diff --git a/drivers/pci/access.c b/drivers/pci/access.c
index 24a76de..fc405f0 100644 (file)
--- a/drivers/pci/access.c
+++ b/drivers/pci/access.c
@@ -1,6 +1,10 @@
 #include <linux/pci.h>
 #include <linux/module.h>
+#include <linux/sched.h>
 #include <linux/ioport.h>
+#include <linux/wait.h>
+
+#include "pci.h"
 
 /*
  * This interrupt-safe spinlock protects all accesses to PCI
@@ -60,3 +64,110 @@ EXPORT_SYMBOL(pci_bus_read_config_dword);
 EXPORT_SYMBOL(pci_bus_write_config_byte);
 EXPORT_SYMBOL(pci_bus_write_config_word);
 EXPORT_SYMBOL(pci_bus_write_config_dword);
+
+/*
+ * The following routines are to prevent the user from accessing PCI config
+ * space when it's unsafe to do so.  Some devices require this during BIST and
+ * we're required to prevent it during D-state transitions.
+ *
+ * We have a bit per device to indicate it's blocked and a global wait queue
+ * for callers to sleep on until devices are unblocked.
+ */
+static DECLARE_WAIT_QUEUE_HEAD(pci_ucfg_wait);
+
+static noinline void pci_wait_ucfg(struct pci_dev *dev)
+{
+       DECLARE_WAITQUEUE(wait, current);
+
+       __add_wait_queue(&pci_ucfg_wait, &wait);
+       do {
+               set_current_state(TASK_UNINTERRUPTIBLE);
+               spin_unlock_irq(&pci_lock);
+               schedule();
+               spin_lock_irq(&pci_lock);
+       } while (dev->block_ucfg_access);
+       __remove_wait_queue(&pci_ucfg_wait, &wait);
+}
+
+#define PCI_USER_READ_CONFIG(size,type)                                        \
+int pci_user_read_config_##size                                                \
+       (struct pci_dev *dev, int pos, type *val)                       \
+{                                                                      \
+       int ret = 0;                                                    \
+       u32 data = -1;                                                  \
+       if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
+       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);                                     \
+       *val = (type)data;                                              \
+       return ret;                                                     \
+}
+
+#define PCI_USER_WRITE_CONFIG(size,type)                               \
+int pci_user_write_config_##size                                       \
+       (struct pci_dev *dev, int pos, type val)                        \
+{                                                                      \
+       int ret = -EIO;                                                 \
+       if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;       \
+       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);                                     \
+       return ret;                                                     \
+}
+
+PCI_USER_READ_CONFIG(byte, u8)
+PCI_USER_READ_CONFIG(word, u16)
+PCI_USER_READ_CONFIG(dword, u32)
+PCI_USER_WRITE_CONFIG(byte, u8)
+PCI_USER_WRITE_CONFIG(word, u16)
+PCI_USER_WRITE_CONFIG(dword, u32)
+
+/**
+ * pci_block_user_cfg_access - Block userspace PCI config reads/writes
+ * @dev:       pci device struct
+ *
+ * When user access is blocked, any reads or writes to config space will
+ * sleep until access is unblocked again.  We don't allow nesting of
+ * block/unblock calls.
+ */
+void pci_block_user_cfg_access(struct pci_dev *dev)
+{
+       unsigned long flags;
+       int was_blocked;
+
+       spin_lock_irqsave(&pci_lock, flags);
+       was_blocked = dev->block_ucfg_access;
+       dev->block_ucfg_access = 1;
+       spin_unlock_irqrestore(&pci_lock, flags);
+
+       /* If we BUG() inside the pci_lock, we're guaranteed to hose
+        * the machine */
+       BUG_ON(was_blocked);
+}
+EXPORT_SYMBOL_GPL(pci_block_user_cfg_access);
+
+/**
+ * pci_unblock_user_cfg_access - Unblock userspace PCI config reads/writes
+ * @dev:       pci device struct
+ *
+ * This function allows userspace PCI config accesses to resume.
+ */
+void pci_unblock_user_cfg_access(struct pci_dev *dev)
+{
+       unsigned long flags;
+
+       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. */
+       WARN_ON(!dev->block_ucfg_access);
+
+       dev->block_ucfg_access = 0;
+       wake_up_all(&pci_ucfg_wait);
+       spin_unlock_irqrestore(&pci_lock, flags);
+}
+EXPORT_SYMBOL_GPL(pci_unblock_user_cfg_access);