PCI: aerdrv: rework do_recovery

[safe/jmp/linux-2.6] / drivers / pci / access.c

diff --git a/drivers/pci/access.c b/drivers/pci/access.c
index 86ec4ad..affb83b 100644 (file)
--- a/drivers/pci/access.c
+++ b/drivers/pci/access.c
@@ -2,6 +2,7 @@
 #include <linux/pci.h>
 #include <linux/module.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/wait.h>
 
@@ -12,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
@@ -32,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;                                                     \
 }
 
@@ -46,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;                                                     \
 }
 
@@ -66,6 +67,25 @@ EXPORT_SYMBOL(pci_bus_write_config_byte);
 EXPORT_SYMBOL(pci_bus_write_config_word);
 EXPORT_SYMBOL(pci_bus_write_config_dword);
 
+/**
+ * pci_bus_set_ops - Set raw operations of pci bus
+ * @bus:       pci bus struct
+ * @ops:       new raw operations
+ *
+ * Return previous raw operations
+ */
+struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops)
+{
+       struct pci_ops *old_ops;
+       unsigned long flags;
+
+       raw_spin_lock_irqsave(&pci_lock, flags);
+       old_ops = bus->ops;
+       bus->ops = ops;
+       raw_spin_unlock_irqrestore(&pci_lock, flags);
+       return old_ops;
+}
+EXPORT_SYMBOL(pci_bus_set_ops);
 
 /**
  * pci_read_vpd - Read one entry from Vital Product Data
@@ -87,8 +107,8 @@ EXPORT_SYMBOL(pci_read_vpd);
  * pci_write_vpd - Write entry to Vital Product Data
  * @dev:       pci device struct
  * @pos:       offset in vpd space
- * @count:     number of bytes to read
- * @val:       value to write
+ * @count:     number of bytes to write
+ * @buf:       buffer containing write data
  *
  */
 ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void *buf)
@@ -116,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);
 }
@@ -130,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;                                                     \
 }
@@ -145,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;                                                     \
 }
 
@@ -340,6 +360,30 @@ int pci_vpd_pci22_init(struct pci_dev *dev)
 }
 
 /**
+ * pci_vpd_truncate - Set available Vital Product Data size
+ * @dev:       pci device struct
+ * @size:      available memory in bytes
+ *
+ * Adjust size of available VPD area.
+ */
+int pci_vpd_truncate(struct pci_dev *dev, size_t size)
+{
+       if (!dev->vpd)
+               return -EINVAL;
+
+       /* limited by the access method */
+       if (size > dev->vpd->len)
+               return -EINVAL;
+
+       dev->vpd->len = size;
+       if (dev->vpd->attr)
+               dev->vpd->attr->size = size;
+
+       return 0;
+}
+EXPORT_SYMBOL(pci_vpd_truncate);
+
+/**
  * pci_block_user_cfg_access - Block userspace PCI config reads/writes
  * @dev:       pci device struct
  *
@@ -352,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 */
@@ -373,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. */
@@ -381,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);