FEX-Emu/linux
1
0
Fork 0
mirror of https://github.com/FEX-Emu/linux.git synced 2024-12-22 01:10:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

PCI: handle long delays in VPD access

Browse Source 
Accessing the VPD area can take a long time.  The existing
VPD access code fails consistently on my hardware. There are comments
in the SysKonnect vendor driver that it can take up to 13ms per word.

Change the access routines to:
  * use a mutex rather than spinning with IRQ's disabled and lock held
  * have a much longer timeout
  * call cond_resched while spinning

Signed-off-by: Stephen Hemminger <shemminger@vyatta.com>
Reviewed-by: Matthew Wilcox <willy@linux.intel.com>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
This commit is contained in:
Stephen Hemminger 2008-12-18 09:17:16 -08:00 committed by Jesse Barnes
parent 904d6a3033
commit 1120f8b816
1 changed files with 33 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
drivers/pci/access.c
View File

@ -133,39 +133,46 @@ PCI_USER_WRITE_CONFIG(dword, u32)
struct pci_vpd_pci22 { struct pci_vpd_pci22 {
struct pci_vpd base; struct pci_vpd base;
spinlock_t lock; /* controls access to hardware and the flags */ struct mutex lock;
u8 cap; u16 flag;
bool busy; bool busy;
bool flag; /* value of F bit to wait for */ u8 cap;
}; };
/* Wait for last operation to complete */ /*
* Wait for last operation to complete.
* This code has to spin since there is no other notification from the PCI
* hardware. Since the VPD is often implemented by serial attachment to an
* EEPROM, it may take many milliseconds to complete.
*/
static int pci_vpd_pci22_wait(struct pci_dev *dev) static int pci_vpd_pci22_wait(struct pci_dev *dev)
{ {
struct pci_vpd_pci22 *vpd = struct pci_vpd_pci22 *vpd =
container_of(dev->vpd, struct pci_vpd_pci22, base); container_of(dev->vpd, struct pci_vpd_pci22, base);
u16 flag, status; unsigned long timeout = jiffies + HZ/20 + 2;
int wait; u16 status;
int ret; int ret;
if (!vpd->busy) if (!vpd->busy)
return 0; return 0;
flag = vpd->flag ? PCI_VPD_ADDR_F : 0;
wait = vpd->flag ? 10 : 1000; /* read: 100 us; write: 10 ms */
for (;;) { for (;;) {
ret = pci_user_read_config_word(dev, ret = pci_user_read_config_word(dev, vpd->cap + PCI_VPD_ADDR,
vpd->cap + PCI_VPD_ADDR,
&status); &status);
if (ret < 0) if (ret)
return ret; return ret;
if ((status & PCI_VPD_ADDR_F) == flag) {
if ((status & PCI_VPD_ADDR_F) == vpd->flag) {
vpd->busy = false; vpd->busy = false;
return 0; return 0;
} }
if (wait-- == 0)
if (time_after(jiffies, timeout))
return -ETIMEDOUT; return -ETIMEDOUT;
udelay(10); if (fatal_signal_pending(current))
return -EINTR;
if (!cond_resched())
udelay(10);
} }
} }
@ -175,7 +182,7 @@ static int pci_vpd_pci22_read(struct pci_dev *dev, int pos, int size,
struct pci_vpd_pci22 *vpd = struct pci_vpd_pci22 *vpd =
container_of(dev->vpd, struct pci_vpd_pci22, base); container_of(dev->vpd, struct pci_vpd_pci22, base);
u32 val; u32 val;
int ret; int ret = 0;
int begin, end, i; int begin, end, i;
if (pos < 0 || pos > vpd->base.len || size > vpd->base.len - pos) if (pos < 0 || pos > vpd->base.len || size > vpd->base.len - pos)
@ -183,7 +190,9 @@ static int pci_vpd_pci22_read(struct pci_dev *dev, int pos, int size,
if (size == 0) if (size == 0)
return 0; return 0;
spin_lock_irq(&vpd->lock); if (mutex_lock_killable(&vpd->lock))
return -EINTR;
ret = pci_vpd_pci22_wait(dev); ret = pci_vpd_pci22_wait(dev);
if (ret < 0) if (ret < 0)
goto out; goto out;
@ -191,15 +200,16 @@ static int pci_vpd_pci22_read(struct pci_dev *dev, int pos, int size,
pos & ~3); pos & ~3);
if (ret < 0) if (ret < 0)
goto out; goto out;
vpd->busy = true; vpd->busy = true;
vpd->flag = 1; vpd->flag = PCI_VPD_ADDR_F;
ret = pci_vpd_pci22_wait(dev); ret = pci_vpd_pci22_wait(dev);
if (ret < 0) if (ret < 0)
goto out; goto out;
ret = pci_user_read_config_dword(dev, vpd->cap + PCI_VPD_DATA, ret = pci_user_read_config_dword(dev, vpd->cap + PCI_VPD_DATA,
&val); &val);
out: out:
spin_unlock_irq(&vpd->lock); mutex_unlock(&vpd->lock);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -220,7 +230,7 @@ static int pci_vpd_pci22_write(struct pci_dev *dev, int pos, int size,
struct pci_vpd_pci22 *vpd = struct pci_vpd_pci22 *vpd =
container_of(dev->vpd, struct pci_vpd_pci22, base); container_of(dev->vpd, struct pci_vpd_pci22, base);
u32 val; u32 val;
int ret; int ret = 0;
if (pos < 0 || pos > vpd->base.len || pos & 3 || if (pos < 0 || pos > vpd->base.len || pos & 3 ||
size > vpd->base.len - pos || size < 4) size > vpd->base.len - pos || size < 4)
@ -231,7 +241,8 @@ static int pci_vpd_pci22_write(struct pci_dev *dev, int pos, int size,
val |= ((u8) *buf++) << 16; val |= ((u8) *buf++) << 16;
val |= ((u32)(u8) *buf++) << 24; val |= ((u32)(u8) *buf++) << 24;
spin_lock_irq(&vpd->lock); if (mutex_lock_killable(&vpd->lock))
return -EINTR;
ret = pci_vpd_pci22_wait(dev); ret = pci_vpd_pci22_wait(dev);
if (ret < 0) if (ret < 0)
goto out; goto out;
@ -247,7 +258,7 @@ static int pci_vpd_pci22_write(struct pci_dev *dev, int pos, int size,
vpd->flag = 0; vpd->flag = 0;
ret = pci_vpd_pci22_wait(dev); ret = pci_vpd_pci22_wait(dev);
out: out:
spin_unlock_irq(&vpd->lock); mutex_unlock(&vpd->lock);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -279,7 +290,7 @@ int pci_vpd_pci22_init(struct pci_dev *dev)
vpd->base.len = PCI_VPD_PCI22_SIZE; vpd->base.len = PCI_VPD_PCI22_SIZE;
vpd->base.ops = &pci_vpd_pci22_ops; vpd->base.ops = &pci_vpd_pci22_ops;
spin_lock_init(&vpd->lock); mutex_init(&vpd->lock);
vpd->cap = cap; vpd->cap = cap;
vpd->busy = false; vpd->busy = false;
dev->vpd = &vpd->base; dev->vpd = &vpd->base;