5 files changed, 61 insertions, 23 deletions

diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index ede365d05387..b9371d5bf790 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -1384,8 +1384,10 @@ do_it_again:
                  * longer than TTY_THRESHOLD_UNTHROTTLE in canonical mode,
                  * we won't get any more characters.
                  */
-                if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE)
+                if (n_tty_chars_in_buffer(tty) <= TTY_THRESHOLD_UNTHROTTLE) {
+                        n_tty_set_room(tty);
                         check_unthrottle(tty);
+                }
 
                 if (b - buf >= minimum)
                         break;
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 959109609d85..97fe95666f3b 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -187,12 +187,11 @@ static u16 gm_phy_read(struct sky2_hw *hw, unsigned port, u16 reg)
         return v;
 }
 
-static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
+static void sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
 {
         u16 power_control;
         u32 reg1;
         int vaux;
-        int ret = 0;
 
         pr_debug("sky2_set_power_state %d\n", state);
         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
@@ -275,12 +274,10 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
                 break;
         default:
                 printk(KERN_ERR PFX "Unknown power state %d\n", state);
-                ret = -1;
         }
 
         sky2_pci_write16(hw, hw->pm_cap + PCI_PM_CTRL, power_control);
         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
-        return ret;
 }
 
 static void sky2_phy_reset(struct sky2_hw *hw, unsigned port)
@@ -2164,6 +2161,13 @@ static void sky2_descriptor_error(struct sky2_hw *hw, unsigned port,
 /* If idle then force a fake soft NAPI poll once a second
  * to work around cases where sharing an edge triggered interrupt.
  */
+static inline void sky2_idle_start(struct sky2_hw *hw)
+{
+        if (idle_timeout > 0)
+                mod_timer(&hw->idle_timer,
+                          jiffies + msecs_to_jiffies(idle_timeout));
+}
+
 static void sky2_idle(unsigned long arg)
 {
         struct sky2_hw *hw = (struct sky2_hw *) arg;
@@ -2183,6 +2187,9 @@ static int sky2_poll(struct net_device *dev0, int *budget)
         int work_done = 0;
         u32 status = sky2_read32(hw, B0_Y2_SP_EISR);
 
+        if (!~status)
+                goto out;
+
         if (status & Y2_IS_HW_ERR)
                 sky2_hw_intr(hw);
 
@@ -2219,7 +2226,7 @@ static int sky2_poll(struct net_device *dev0, int *budget)
 
         if (sky2_more_work(hw))
                 return 1;
-
+out:
         netif_rx_complete(dev0);
 
         sky2_read32(hw, B0_Y2_SP_LISR);
@@ -3350,9 +3357,7 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
         sky2_write32(hw, B0_IMSK, Y2_IS_BASE);
 
         setup_timer(&hw->idle_timer, sky2_idle, (unsigned long) hw);
-        if (idle_timeout > 0)
-                mod_timer(&hw->idle_timer,
-                          jiffies + msecs_to_jiffies(idle_timeout));
+        sky2_idle_start(hw);
 
         pci_set_drvdata(pdev, hw);
 
@@ -3425,8 +3430,14 @@ static int sky2_suspend(struct pci_dev *pdev, pm_message_t state)
 {
         struct sky2_hw *hw = pci_get_drvdata(pdev);
         int i;
+        pci_power_t pstate = pci_choose_state(pdev, state);
+
+        if (!(pstate == PCI_D3hot || pstate == PCI_D3cold))
+                return -EINVAL;
+
+        del_timer_sync(&hw->idle_timer);
 
-        for (i = 0; i < 2; i++) {
+        for (i = 0; i < hw->ports; i++) {
                 struct net_device *dev = hw->dev[i];
 
                 if (dev) {
@@ -3438,7 +3449,10 @@ static int sky2_suspend(struct pci_dev *pdev, pm_message_t state)
                 }
         }
 
-        return sky2_set_power_state(hw, pci_choose_state(pdev, state));
+        sky2_write32(hw, B0_IMSK, 0);
+        pci_save_state(pdev);
+        sky2_set_power_state(hw, pstate);
+        return 0;
 }
 
 static int sky2_resume(struct pci_dev *pdev)
@@ -3448,15 +3462,15 @@ static int sky2_resume(struct pci_dev *pdev)
 
         pci_restore_state(pdev);
         pci_enable_wake(pdev, PCI_D0, 0);
-        err = sky2_set_power_state(hw, PCI_D0);
-        if (err)
-                goto out;
+        sky2_set_power_state(hw, PCI_D0);
 
         err = sky2_reset(hw);
         if (err)
                 goto out;
 
-        for (i = 0; i < 2; i++) {
+        sky2_write32(hw, B0_IMSK, Y2_IS_BASE);
+
+        for (i = 0; i < hw->ports; i++) {
                 struct net_device *dev = hw->dev[i];
                 if (dev && netif_running(dev)) {
                         netif_device_attach(dev);
@@ -3465,10 +3479,12 @@ static int sky2_resume(struct pci_dev *pdev)
                                 printk(KERN_ERR PFX "%s: could not up: %d\n",
                                        dev->name, err);
                                 dev_close(dev);
-                                break;
+                                goto out;
                         }
                 }
         }
+
+        sky2_idle_start(hw);
 out:
         return err;
 }
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 1456759936c5..10e1a905c144 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -285,9 +285,9 @@ static int pci_device_suspend(struct device * dev, pm_message_t state)
  * Default resume method for devices that have no driver provided resume,
  * or not even a driver at all.
  */
-static void pci_default_resume(struct pci_dev *pci_dev)
+static int pci_default_resume(struct pci_dev *pci_dev)
 {
-        int retval;
+        int retval = 0;
 
         /* restore the PCI config space */
         pci_restore_state(pci_dev);
@@ -297,18 +297,21 @@ static void pci_default_resume(struct pci_dev *pci_dev)
         /* if the device was busmaster before the suspend, make it busmaster again */
         if (pci_dev->is_busmaster)
                 pci_set_master(pci_dev);
+
+        return retval;
 }
 
 static int pci_device_resume(struct device * dev)
 {
+        int error;
         struct pci_dev * pci_dev = to_pci_dev(dev);
         struct pci_driver * drv = pci_dev->driver;
 
         if (drv && drv->resume)
-                drv->resume(pci_dev);
+                error = drv->resume(pci_dev);
         else
-                pci_default_resume(pci_dev);
-        return 0;
+                error = pci_default_resume(pci_dev);
+        return error;
 }
 
 static void pci_device_shutdown(struct device *dev)
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 2329f941a0dc..12286275b1c8 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -461,9 +461,23 @@ int
 pci_restore_state(struct pci_dev *dev)
 {
         int i;
+        int val;
 
-        for (i = 0; i < 16; i++)
-                pci_write_config_dword(dev,i * 4, dev->saved_config_space[i]);
+        /*
+         * The Base Address register should be programmed before the command
+         * register(s)
+         */
+        for (i = 15; i >= 0; i--) {
+                pci_read_config_dword(dev, i * 4, &val);
+                if (val != dev->saved_config_space[i]) {
+                        printk(KERN_DEBUG "PM: Writing back config space on "
+                                "device %s at offset %x (was %x, writing %x)\n",
+                                pci_name(dev), i,
+                                val, (int)dev->saved_config_space[i]);
+                        pci_write_config_dword(dev,i * 4,
+                                dev->saved_config_space[i]);
+                }
+        }
         pci_restore_msi_state(dev);
         pci_restore_msix_state(dev);
         return 0;
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index acde8868da21..fafe7c1265b3 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -185,6 +185,9 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         /* Select Power Management Mode */
         pxa27x_ohci_select_pmm(inf->port_mode);
 
+        if (inf->power_budget)
+                hcd->power_budget = inf->power_budget;
+
         ohci_hcd_init(hcd_to_ohci(hcd));
 
         retval = usb_add_hcd(hcd, pdev->resource[1].start, SA_INTERRUPT);