18 files changed, 198 insertions, 180 deletions

diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index abbdb37a7f5f..f36db22ce1ae 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -577,6 +577,8 @@ acpi_processor_register_performance(struct acpi_processor_performance
                 return_VALUE(-EBUSY);
         }
 
+        WARN_ON(!performance);
+
         pr->performance = performance;
 
         if (acpi_processor_get_performance_info(pr)) {
@@ -609,7 +611,8 @@ acpi_processor_unregister_performance(struct acpi_processor_performance
                 return_VOID;
         }
 
-        kfree(pr->performance->states);
+        if (pr->performance)
+                kfree(pr->performance->states);
         pr->performance = NULL;
 
         acpi_cpufreq_remove_file(pr);
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index a59876a0bfa1..3170eaa25087 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -1009,9 +1009,9 @@ int cdrom_open(struct cdrom_device_info *cdi, struct inode *ip, struct file *fp)
                 if (fp->f_mode & FMODE_WRITE) {
                         ret = -EROFS;
                         if (cdrom_open_write(cdi))
-                                goto err;
+                                goto err_release;
                         if (!CDROM_CAN(CDC_RAM))
-                                goto err;
+                                goto err_release;
                         ret = 0;
                         cdi->media_written = 0;
                 }
@@ -1026,6 +1026,8 @@ int cdrom_open(struct cdrom_device_info *cdi, struct inode *ip, struct file *fp)
             not be mounting, but opening with O_NONBLOCK */
         check_disk_change(ip->i_bdev);
         return 0;
+err_release:
+        cdi->ops->release(cdi);
 err:
         cdi->use_count--;
         return ret;
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index f5b01c6d498e..fb919bfb2824 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -41,9 +41,9 @@ obj-$(CONFIG_N_HDLC)		+= n_hdlc.o
 obj-$(CONFIG_AMIGA_BUILTIN_SERIAL) += amiserial.o
 obj-$(CONFIG_SX)                += sx.o generic_serial.o
 obj-$(CONFIG_RIO)               += rio/ generic_serial.o
-obj-$(CONFIG_HVC_DRIVER)        += hvc_console.o
 obj-$(CONFIG_HVC_CONSOLE)       += hvc_vio.o hvsi.o
 obj-$(CONFIG_HVC_RTAS)          += hvc_rtas.o
+obj-$(CONFIG_HVC_DRIVER)        += hvc_console.o
 obj-$(CONFIG_RAW_DRIVER)        += raw.o
 obj-$(CONFIG_SGI_SNSC)          += snsc.o snsc_event.o
 obj-$(CONFIG_MMTIMER)           += mmtimer.o
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/message/fusion/mptspi.c b/drivers/message/fusion/mptspi.c
index f2a4d382ea19..3201de053943 100644
--- a/drivers/message/fusion/mptspi.c
+++ b/drivers/message/fusion/mptspi.c
@@ -831,6 +831,7 @@ mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
         return rc;
 }
 
+#ifdef CONFIG_PM
 /*
  * spi module resume handler
  */
@@ -846,6 +847,7 @@ mptspi_resume(struct pci_dev *pdev)
 
         return rc;
 }
+#endif
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
diff --git a/drivers/message/i2o/exec-osm.c b/drivers/message/i2o/exec-osm.c
index 5ea133c59afb..7bd4d85d0b42 100644
--- a/drivers/message/i2o/exec-osm.c
+++ b/drivers/message/i2o/exec-osm.c
@@ -55,6 +55,7 @@ struct i2o_exec_wait {
         u32 m;                  /* message id */
         struct i2o_message *msg;        /* pointer to the reply message */
         struct list_head list;  /* node in global wait list */
+        spinlock_t lock;        /* lock before modifying */
 };
 
 /* Work struct needed to handle LCT NOTIFY replies */
@@ -87,6 +88,7 @@ static struct i2o_exec_wait *i2o_exec_wait_alloc(void)
                 return NULL;
 
         INIT_LIST_HEAD(&wait->list);
+        spin_lock_init(&wait->lock);
 
         return wait;
 };
@@ -125,6 +127,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,
         DECLARE_WAIT_QUEUE_HEAD(wq);
         struct i2o_exec_wait *wait;
         static u32 tcntxt = 0x80000000;
+        long flags;
         int rc = 0;
 
         wait = i2o_exec_wait_alloc();
@@ -146,33 +149,28 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,
         wait->tcntxt = tcntxt++;
         msg->u.s.tcntxt = cpu_to_le32(wait->tcntxt);
 
+        wait->wq = &wq;
+        /*
+         * we add elements to the head, because if a entry in the list will
+         * never be removed, we have to iterate over it every time
+         */
+        list_add(&wait->list, &i2o_exec_wait_list);
+
         /*
          * Post the message to the controller. At some point later it will
          * return. If we time out before it returns then complete will be zero.
          */
         i2o_msg_post(c, msg);
 
-        if (!wait->complete) {
-                wait->wq = &wq;
-                /*
-                 * we add elements add the head, because if a entry in the list
-                 * will never be removed, we have to iterate over it every time
-                 */
-                list_add(&wait->list, &i2o_exec_wait_list);
-
-                wait_event_interruptible_timeout(wq, wait->complete,
-                                                 timeout * HZ);
+        wait_event_interruptible_timeout(wq, wait->complete, timeout * HZ);
 
-                wait->wq = NULL;
-        }
+        spin_lock_irqsave(&wait->lock, flags);
 
-        barrier();
+        wait->wq = NULL;
 
-        if (wait->complete) {
+        if (wait->complete)
                 rc = le32_to_cpu(wait->msg->body[0]) >> 24;
-                i2o_flush_reply(c, wait->m);
-                i2o_exec_wait_free(wait);
-        } else {
+        else {
                 /*
                  * We cannot remove it now. This is important. When it does
                  * terminate (which it must do if the controller has not
@@ -186,6 +184,13 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,
                 rc = -ETIMEDOUT;
         }
 
+        spin_unlock_irqrestore(&wait->lock, flags);
+
+        if (rc != -ETIMEDOUT) {
+                i2o_flush_reply(c, wait->m);
+                i2o_exec_wait_free(wait);
+        }
+
         return rc;
 };
 
@@ -213,7 +218,6 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
 {
         struct i2o_exec_wait *wait, *tmp;
         unsigned long flags;
-        static spinlock_t lock = SPIN_LOCK_UNLOCKED;
         int rc = 1;
 
         /*
@@ -223,23 +227,24 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
          * already expired. Not much we can do about that except log it for
          * debug purposes, increase timeout, and recompile.
          */
-        spin_lock_irqsave(&lock, flags);
         list_for_each_entry_safe(wait, tmp, &i2o_exec_wait_list, list) {
                 if (wait->tcntxt == context) {
-                        list_del(&wait->list);
+                        spin_lock_irqsave(&wait->lock, flags);
 
-                        spin_unlock_irqrestore(&lock, flags);
+                        list_del(&wait->list);
 
                         wait->m = m;
                         wait->msg = msg;
                         wait->complete = 1;
 
-                        barrier();
-
-                        if (wait->wq) {
-                                wake_up_interruptible(wait->wq);
+                        if (wait->wq)
                                 rc = 0;
-                        } else {
+                        else
+                                rc = -1;
+
+                        spin_unlock_irqrestore(&wait->lock, flags);
+
+                        if (rc) {
                                 struct device *dev;
 
                                 dev = &c->pdev->dev;
@@ -248,15 +253,13 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
                                          c->name);
                                 i2o_dma_free(dev, &wait->dma);
                                 i2o_exec_wait_free(wait);
-                                rc = -1;
-                        }
+                        } else
+                                wake_up_interruptible(wait->wq);
 
                         return rc;
                 }
         }
 
-        spin_unlock_irqrestore(&lock, flags);
-
         osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
                  context);
 
@@ -322,14 +325,9 @@ static DEVICE_ATTR(product_id, S_IRUGO, i2o_exec_show_product_id, NULL);
 static int i2o_exec_probe(struct device *dev)
 {
         struct i2o_device *i2o_dev = to_i2o_device(dev);
-        struct i2o_controller *c = i2o_dev->iop;
 
         i2o_event_register(i2o_dev, &i2o_exec_driver, 0, 0xffffffff);
 
-        c->exec = i2o_dev;
-
-        i2o_exec_lct_notify(c, c->lct->change_ind + 1);
-
         device_create_file(dev, &dev_attr_vendor_id);
         device_create_file(dev, &dev_attr_product_id);
 
@@ -523,6 +521,8 @@ static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
         struct device *dev;
         struct i2o_message *msg;
 
+        down(&c->lct_lock);
+
         dev = &c->pdev->dev;
 
         if (i2o_dma_realloc
@@ -545,6 +545,8 @@ static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind)
 
         i2o_msg_post(c, msg);
 
+        up(&c->lct_lock);
+
         return 0;
 };
 
diff --git a/drivers/message/i2o/iop.c b/drivers/message/i2o/iop.c
index 492167446936..febbdd4e0605 100644
--- a/drivers/message/i2o/iop.c
+++ b/drivers/message/i2o/iop.c
@@ -804,8 +804,6 @@ void i2o_iop_remove(struct i2o_controller *c)
 
         /* Ask the IOP to switch to RESET state */
         i2o_iop_reset(c);
-
-        put_device(&c->device);
 }
 
 /**
@@ -1059,7 +1057,7 @@ struct i2o_controller *i2o_iop_alloc(void)
 
         snprintf(poolname, sizeof(poolname), "i2o_%s_msg_inpool", c->name);
         if (i2o_pool_alloc
-            (&c->in_msg, poolname, I2O_INBOUND_MSG_FRAME_SIZE * 4,
+            (&c->in_msg, poolname, I2O_INBOUND_MSG_FRAME_SIZE * 4 + sizeof(u32),
              I2O_MSG_INPOOL_MIN)) {
                 kfree(c);
                 return ERR_PTR(-ENOMEM);
diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index ecccca35c6f4..d1c705b412c2 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -870,13 +870,16 @@ e1000_intr_test(struct e1000_adapter *adapter, uint64_t *data)
         *data = 0;
 
         /* Hook up test interrupt handler just for this test */
-        if (!request_irq(irq, &e1000_test_intr, 0, netdev->name, netdev)) {
+        if (!request_irq(irq, &e1000_test_intr, SA_PROBEIRQ, netdev->name,
+                         netdev)) {
                 shared_int = FALSE;
         } else if (request_irq(irq, &e1000_test_intr, SA_SHIRQ,
                               netdev->name, netdev)){
                 *data = 1;
                 return -1;
         }
+        DPRINTK(PROBE,INFO, "testing %s interrupt\n",
+                (shared_int ? "shared" : "unshared"));
 
         /* Disable all the interrupts */
         E1000_WRITE_REG(&adapter->hw, IMC, 0xFFFFFFFF);
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index ed15fcaedaf9..97e71a4fe8eb 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -3519,7 +3519,7 @@ e1000_clean_rx_irq(struct e1000_adapter *adapter,
         buffer_info = &rx_ring->buffer_info[i];
 
         while (rx_desc->status & E1000_RXD_STAT_DD) {
-                struct sk_buff *skb, *next_skb;
+                struct sk_buff *skb;
                 u8 status;
 #ifdef CONFIG_E1000_NAPI
                 if (*work_done >= work_to_do)
@@ -3537,8 +3537,6 @@ e1000_clean_rx_irq(struct e1000_adapter *adapter,
                 prefetch(next_rxd);
 
                 next_buffer = &rx_ring->buffer_info[i];
-                next_skb = next_buffer->skb;
-                prefetch(next_skb->data - NET_IP_ALIGN);
 
                 cleaned = TRUE;
                 cleaned_count++;
@@ -3668,7 +3666,7 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
         struct e1000_buffer *buffer_info, *next_buffer;
         struct e1000_ps_page *ps_page;
         struct e1000_ps_page_dma *ps_page_dma;
-        struct sk_buff *skb, *next_skb;
+        struct sk_buff *skb;
         unsigned int i, j;
         uint32_t length, staterr;
         int cleaned_count = 0;
@@ -3697,8 +3695,6 @@ e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
                 prefetch(next_rxd);
 
                 next_buffer = &rx_ring->buffer_info[i];
-                next_skb = next_buffer->skb;
-                prefetch(next_skb->data - NET_IP_ALIGN);
 
                 cleaned = TRUE;
                 cleaned_count++;
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 959109609d85..fba1e4d4d83d 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);
@@ -2248,8 +2255,10 @@ static irqreturn_t sky2_intr(int irq, void *dev_id, struct pt_regs *regs)
 static void sky2_netpoll(struct net_device *dev)
 {
         struct sky2_port *sky2 = netdev_priv(dev);
+        struct net_device *dev0 = sky2->hw->dev[0];
 
-        sky2_intr(sky2->hw->pdev->irq, sky2->hw, NULL);
+        if (netif_running(dev) && __netif_rx_schedule_prep(dev0))
+                __netif_rx_schedule(dev0);
 }
 #endif
 
@@ -3350,9 +3359,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 +3432,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) {
@@ -3435,10 +3448,14 @@ static int sky2_suspend(struct pci_dev *pdev, pm_message_t state)
 
                         sky2_down(dev);
                         netif_device_detach(dev);
+                        netif_poll_disable(dev);
                 }
         }
 
-        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,27 +3465,31 @@ 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);
+                        netif_poll_enable(dev);
+
                         err = sky2_up(dev);
                         if (err) {
                                 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/net/tg3.c b/drivers/net/tg3.c
index 49ad60b72657..862c226dbbe2 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -69,8 +69,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.58"
-#define DRV_MODULE_RELDATE      "May 22, 2006"
+#define DRV_MODULE_VERSION      "3.59"
+#define DRV_MODULE_RELDATE      "June 8, 2006"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -4485,9 +4485,8 @@ static void tg3_disable_nvram_access(struct tg3 *tp)
 /* tp->lock is held. */
 static void tg3_write_sig_pre_reset(struct tg3 *tp, int kind)
 {
-        if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X))
-                tg3_write_mem(tp, NIC_SRAM_FIRMWARE_MBOX,
-                              NIC_SRAM_FIRMWARE_MBOX_MAGIC1);
+        tg3_write_mem(tp, NIC_SRAM_FIRMWARE_MBOX,
+                      NIC_SRAM_FIRMWARE_MBOX_MAGIC1);
 
         if (tp->tg3_flags2 & TG3_FLG2_ASF_NEW_HANDSHAKE) {
                 switch (kind) {
@@ -4568,13 +4567,12 @@ static int tg3_chip_reset(struct tg3 *tp)
         void (*write_op)(struct tg3 *, u32, u32);
         int i;
 
-        if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X)) {
-                tg3_nvram_lock(tp);
-                /* No matching tg3_nvram_unlock() after this because
-                 * chip reset below will undo the nvram lock.
-                 */
-                tp->nvram_lock_cnt = 0;
-        }
+        tg3_nvram_lock(tp);
+
+        /* No matching tg3_nvram_unlock() after this because
+         * chip reset below will undo the nvram lock.
+         */
+        tp->nvram_lock_cnt = 0;
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
@@ -4727,20 +4725,25 @@ static int tg3_chip_reset(struct tg3 *tp)
                 tw32_f(MAC_MODE, 0);
         udelay(40);
 
-        if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X)) {
-                /* Wait for firmware initialization to complete. */
-                for (i = 0; i < 100000; i++) {
-                        tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val);
-                        if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
-                                break;
-                        udelay(10);
-                }
-                if (i >= 100000) {
-                        printk(KERN_ERR PFX "tg3_reset_hw timed out for %s, "
-                               "firmware will not restart magic=%08x\n",
-                               tp->dev->name, val);
-                        return -ENODEV;
-                }
+        /* Wait for firmware initialization to complete. */
+        for (i = 0; i < 100000; i++) {
+                tg3_read_mem(tp, NIC_SRAM_FIRMWARE_MBOX, &val);
+                if (val == ~NIC_SRAM_FIRMWARE_MBOX_MAGIC1)
+                        break;
+                udelay(10);
+        }
+
+        /* Chip might not be fitted with firmare.  Some Sun onboard
+         * parts are configured like that.  So don't signal the timeout
+         * of the above loop as an error, but do report the lack of
+         * running firmware once.
+         */
+        if (i >= 100000 &&
+            !(tp->tg3_flags2 & TG3_FLG2_NO_FWARE_REPORTED)) {
+                tp->tg3_flags2 |= TG3_FLG2_NO_FWARE_REPORTED;
+
+                printk(KERN_INFO PFX "%s: No firmware running.\n",
+                       tp->dev->name);
         }
 
         if ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
@@ -9075,9 +9078,6 @@ static void __devinit tg3_nvram_init(struct tg3 *tp)
 {
         int j;
 
-        if (tp->tg3_flags2 & TG3_FLG2_SUN_570X)
-                return;
-
         tw32_f(GRC_EEPROM_ADDR,
              (EEPROM_ADDR_FSM_RESET |
               (EEPROM_DEFAULT_CLOCK_PERIOD <<
@@ -9210,11 +9210,6 @@ static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val)
 {
         int ret;
 
-        if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) {
-                printk(KERN_ERR PFX "Attempt to do nvram_read on Sun 570X\n");
-                return -EINVAL;
-        }
-
         if (!(tp->tg3_flags & TG3_FLAG_NVRAM))
                 return tg3_nvram_read_using_eeprom(tp, offset, val);
 
@@ -9447,11 +9442,6 @@ static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf)
 {
         int ret;
 
-        if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) {
-                printk(KERN_ERR PFX "Attempt to do nvram_write on Sun 570X\n");
-                return -EINVAL;
-        }
-
         if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
                 tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl &
                        ~GRC_LCLCTRL_GPIO_OUTPUT1);
@@ -9578,15 +9568,19 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
         pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
                                tp->misc_host_ctrl);
 
+        /* The memory arbiter has to be enabled in order for SRAM accesses
+         * to succeed.  Normally on powerup the tg3 chip firmware will make
+         * sure it is enabled, but other entities such as system netboot
+         * code might disable it.
+         */
+        val = tr32(MEMARB_MODE);
+        tw32(MEMARB_MODE, val | MEMARB_MODE_ENABLE);
+
         tp->phy_id = PHY_ID_INVALID;
         tp->led_ctrl = LED_CTRL_MODE_PHY_1;
 
-        /* Do not even try poking around in here on Sun parts.  */
-        if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) {
-                /* All SUN chips are built-in LOMs. */
-                tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT;
-                return;
-        }
+        /* Assume an onboard device by default.  */
+        tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT;
 
         tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
         if (val == NIC_SRAM_DATA_SIG_MAGIC) {
@@ -9686,6 +9680,8 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
 
                 if (nic_cfg & NIC_SRAM_DATA_CFG_EEPROM_WP)
                         tp->tg3_flags |= TG3_FLAG_EEPROM_WRITE_PROT;
+                else
+                        tp->tg3_flags &= ~TG3_FLAG_EEPROM_WRITE_PROT;
 
                 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
                         tp->tg3_flags |= TG3_FLAG_ENABLE_ASF;
@@ -9834,16 +9830,8 @@ static void __devinit tg3_read_partno(struct tg3 *tp)
         int i;
         u32 magic;
 
-        if (tp->tg3_flags2 & TG3_FLG2_SUN_570X) {
-                /* Sun decided not to put the necessary bits in the
-                 * NVRAM of their onboard tg3 parts :(
-                 */
-                strcpy(tp->board_part_number, "Sun 570X");
-                return;
-        }
-
         if (tg3_nvram_read_swab(tp, 0x0, &magic))
-                return;
+                goto out_not_found;
 
         if (magic == TG3_EEPROM_MAGIC) {
                 for (i = 0; i < 256; i += 4) {
@@ -9874,6 +9862,9 @@ static void __devinit tg3_read_partno(struct tg3 *tp)
                                         break;
                                 msleep(1);
                         }
+                        if (!(tmp16 & 0x8000))
+                                goto out_not_found;
+
                         pci_read_config_dword(tp->pdev, vpd_cap + PCI_VPD_DATA,
                                               &tmp);
                         tmp = cpu_to_le32(tmp);
@@ -9965,37 +9956,6 @@ static void __devinit tg3_read_fw_ver(struct tg3 *tp)
         }
 }
 
-#ifdef CONFIG_SPARC64
-static int __devinit tg3_is_sun_570X(struct tg3 *tp)
-{
-        struct pci_dev *pdev = tp->pdev;
-        struct pcidev_cookie *pcp = pdev->sysdata;
-
-        if (pcp != NULL) {
-                int node = pcp->prom_node;
-                u32 venid;
-                int err;
-
-                err = prom_getproperty(node, "subsystem-vendor-id",
-                                       (char *) &venid, sizeof(venid));
-                if (err == 0 || err == -1)
-                        return 0;
-                if (venid == PCI_VENDOR_ID_SUN)
-                        return 1;
-
-                /* TG3 chips onboard the SunBlade-2500 don't have the
-                 * subsystem-vendor-id set to PCI_VENDOR_ID_SUN but they
-                 * are distinguishable from non-Sun variants by being
-                 * named "network" by the firmware.  Non-Sun cards will
-                 * show up as being named "ethernet".
-                 */
-                if (!strcmp(pcp->prom_name, "network"))
-                        return 1;
-        }
-        return 0;
-}
-#endif
-
 static int __devinit tg3_get_invariants(struct tg3 *tp)
 {
         static struct pci_device_id write_reorder_chipsets[] = {
@@ -10012,11 +9972,6 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         u16 pci_cmd;
         int err;
 
-#ifdef CONFIG_SPARC64
-        if (tg3_is_sun_570X(tp))
-                tp->tg3_flags2 |= TG3_FLG2_SUN_570X;
-#endif
-
         /* Force memory write invalidate off.  If we leave it on,
          * then on 5700_BX chips we have to enable a workaround.
          * The workaround is to set the TG3PCI_DMA_RW_CTRL boundary
@@ -10312,8 +10267,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         if (tp->write32 == tg3_write_indirect_reg32 ||
             ((tp->tg3_flags & TG3_FLAG_PCIX_MODE) &&
              (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
-              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)) ||
-            (tp->tg3_flags2 & TG3_FLG2_SUN_570X))
+              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5701)))
                 tp->tg3_flags |= TG3_FLAG_SRAM_USE_CONFIG;
 
         /* Get eeprom hw config before calling tg3_set_power_state().
@@ -10594,8 +10548,7 @@ static int __devinit tg3_get_device_address(struct tg3 *tp)
 #endif
 
         mac_offset = 0x7c;
-        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 &&
-             !(tp->tg3_flags & TG3_FLG2_SUN_570X)) ||
+        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704) ||
             (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)) {
                 if (tr32(TG3PCI_DUAL_MAC_CTRL) & DUAL_MAC_CTRL_ID)
                         mac_offset = 0xcc;
@@ -10622,8 +10575,7 @@ static int __devinit tg3_get_device_address(struct tg3 *tp)
         }
         if (!addr_ok) {
                 /* Next, try NVRAM. */
-                if (!(tp->tg3_flags & TG3_FLG2_SUN_570X) &&
-                    !tg3_nvram_read(tp, mac_offset + 0, &hi) &&
+                if (!tg3_nvram_read(tp, mac_offset + 0, &hi) &&
                     !tg3_nvram_read(tp, mac_offset + 4, &lo)) {
                         dev->dev_addr[0] = ((hi >> 16) & 0xff);
                         dev->dev_addr[1] = ((hi >> 24) & 0xff);
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index 0e29b885d449..ff0faab94bd5 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2184,7 +2184,7 @@ struct tg3 {
 #define TG3_FLAG_INIT_COMPLETE          0x80000000
         u32                             tg3_flags2;
 #define TG3_FLG2_RESTART_TIMER          0x00000001
-#define TG3_FLG2_SUN_570X               0x00000002
+/*                                      0x00000002 available */
 #define TG3_FLG2_NO_ETH_WIRE_SPEED      0x00000004
 #define TG3_FLG2_IS_5788                0x00000008
 #define TG3_FLG2_MAX_RXPEND_64          0x00000010
@@ -2216,6 +2216,7 @@ struct tg3 {
 #define TG3_FLG2_HW_TSO                 (TG3_FLG2_HW_TSO_1 | TG3_FLG2_HW_TSO_2)
 #define TG3_FLG2_1SHOT_MSI              0x10000000
 #define TG3_FLG2_PHY_JITTER_BUG         0x20000000
+#define TG3_FLG2_NO_FWARE_REPORTED      0x40000000
 
         u32                             split_mode_max_reqs;
 #define SPLIT_MODE_5704_MAX_REQ         3
diff --git a/drivers/net/wireless/bcm43xx/bcm43xx_dma.c b/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
index bbecba02e697..d0318e525ba7 100644
--- a/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
+++ b/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
@@ -624,25 +624,28 @@ err_destroy_tx0:
 static u16 generate_cookie(struct bcm43xx_dmaring *ring,
                            int slot)
 {
-        u16 cookie = 0x0000;
+        u16 cookie = 0xF000;
 
         /* Use the upper 4 bits of the cookie as
          * DMA controller ID and store the slot number
-         * in the lower 12 bits
+         * in the lower 12 bits.
+         * Note that the cookie must never be 0, as this
+         * is a special value used in RX path.
          */
         switch (ring->mmio_base) {
         default:
                 assert(0);
         case BCM43xx_MMIO_DMA1_BASE:
+                cookie = 0xA000;
                 break;
         case BCM43xx_MMIO_DMA2_BASE:
-                cookie = 0x1000;
+                cookie = 0xB000;
                 break;
         case BCM43xx_MMIO_DMA3_BASE:
-                cookie = 0x2000;
+                cookie = 0xC000;
                 break;
         case BCM43xx_MMIO_DMA4_BASE:
-                cookie = 0x3000;
+                cookie = 0xD000;
                 break;
         }
         assert(((u16)slot & 0xF000) == 0x0000);
@@ -660,16 +663,16 @@ struct bcm43xx_dmaring * parse_cookie(struct bcm43xx_private *bcm,
         struct bcm43xx_dmaring *ring = NULL;
 
         switch (cookie & 0xF000) {
-        case 0x0000:
+        case 0xA000:
                 ring = dma->tx_ring0;
                 break;
-        case 0x1000:
+        case 0xB000:
                 ring = dma->tx_ring1;
                 break;
-        case 0x2000:
+        case 0xC000:
                 ring = dma->tx_ring2;
                 break;
-        case 0x3000:
+        case 0xD000:
                 ring = dma->tx_ring3;
                 break;
         default:
@@ -839,8 +842,18 @@ static void dma_rx(struct bcm43xx_dmaring *ring,
                 /* We received an xmit status. */
                 struct bcm43xx_hwxmitstatus *hw = (struct bcm43xx_hwxmitstatus *)skb->data;
                 struct bcm43xx_xmitstatus stat;
+                int i = 0;
 
                 stat.cookie = le16_to_cpu(hw->cookie);
+                while (stat.cookie == 0) {
+                        if (unlikely(++i >= 10000)) {
+                                assert(0);
+                                break;
+                        }
+                        udelay(2);
+                        barrier();
+                        stat.cookie = le16_to_cpu(hw->cookie);
+                }
                 stat.flags = hw->flags;
                 stat.cnt1 = hw->cnt1;
                 stat.cnt2 = hw->cnt2;
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/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index 9b8bca1ac1f0..f16f92a6ec0f 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -2035,6 +2035,7 @@ static void mv_phy_reset(struct ata_port *ap)
 static void mv_eng_timeout(struct ata_port *ap)
 {
         struct ata_queued_cmd *qc;
+        unsigned long flags;
 
         printk(KERN_ERR "ata%u: Entering mv_eng_timeout\n",ap->id);
         DPRINTK("All regs @ start of eng_timeout\n");
@@ -2046,8 +2047,10 @@ static void mv_eng_timeout(struct ata_port *ap)
                ap->host_set->mmio_base, ap, qc, qc->scsicmd,
                &qc->scsicmd->cmnd);
 
+        spin_lock_irqsave(&ap->host_set->lock, flags);
         mv_err_intr(ap, 0);
         mv_stop_and_reset(ap);
+        spin_unlock_irqrestore(&ap->host_set->lock, flags);
 
         WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
         if (qc->flags & ATA_QCFLAG_ACTIVE) {
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);
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 953eb8c171d6..47ba1a79adcd 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -1745,7 +1745,7 @@ static int fbcon_scroll(struct vc_data *vc, int t, int b, int dir,
                                         fbcon_redraw_move(vc, p, 0, t, count);
                                 ypan_up_redraw(vc, t, count);
                                 if (vc->vc_rows - b > 0)
-                                        fbcon_redraw_move(vc, p, b - count,
+                                        fbcon_redraw_move(vc, p, b,
                                                           vc->vc_rows - b, b);
                         } else
                                 fbcon_redraw_move(vc, p, t + count, b - t - count, t);