11 files changed, 180 insertions, 113 deletions

diff --git a/arch/x86/kernel/apic/ipi.c b/arch/x86/kernel/apic/ipi.c
index dbf5445727a9..6ef00ba4c886 100644
--- a/arch/x86/kernel/apic/ipi.c
+++ b/arch/x86/kernel/apic/ipi.c
@@ -106,6 +106,9 @@ void default_send_IPI_mask_logical(const struct cpumask *cpumask, int vector)
         unsigned long mask = cpumask_bits(cpumask)[0];
         unsigned long flags;
 
+        if (WARN_ONCE(!mask, "empty IPI mask"))
+                return;
+
         local_irq_save(flags);
         WARN_ON(mask & ~cpumask_bits(cpu_online_mask)[0]);
         __default_send_IPI_dest_field(mask, vector, apic->dest_logical);
diff --git a/arch/x86/mm/tlb.c b/arch/x86/mm/tlb.c
index 821e97017e95..c814e144a3f0 100644
--- a/arch/x86/mm/tlb.c
+++ b/arch/x86/mm/tlb.c
@@ -183,18 +183,17 @@ static void flush_tlb_others_ipi(const struct cpumask *cpumask,
 
         f->flush_mm = mm;
         f->flush_va = va;
-        cpumask_andnot(to_cpumask(f->flush_cpumask),
-                       cpumask, cpumask_of(smp_processor_id()));
-
-        /*
-         * We have to send the IPI only to
-         * CPUs affected.
-         */
-        apic->send_IPI_mask(to_cpumask(f->flush_cpumask),
-                      INVALIDATE_TLB_VECTOR_START + sender);
+        if (cpumask_andnot(to_cpumask(f->flush_cpumask), cpumask, cpumask_of(smp_processor_id()))) {
+                /*
+                 * We have to send the IPI only to
+                 * CPUs affected.
+                 */
+                apic->send_IPI_mask(to_cpumask(f->flush_cpumask),
+                              INVALIDATE_TLB_VECTOR_START + sender);
 
-        while (!cpumask_empty(to_cpumask(f->flush_cpumask)))
-                cpu_relax();
+                while (!cpumask_empty(to_cpumask(f->flush_cpumask)))
+                        cpu_relax();
+        }
 
         f->flush_mm = NULL;
         f->flush_va = 0;
diff --git a/drivers/i2c/busses/i2c-omap.c b/drivers/i2c/busses/i2c-omap.c
index d258b02aef44..827da0858136 100644
--- a/drivers/i2c/busses/i2c-omap.c
+++ b/drivers/i2c/busses/i2c-omap.c
@@ -674,7 +674,14 @@ omap_i2c_isr(int this_irq, void *dev_id)
 
                 err = 0;
 complete:
-                omap_i2c_write_reg(dev, OMAP_I2C_STAT_REG, stat);
+                /*
+                 * Ack the stat in one go, but [R/X]DR and [R/X]RDY should be
+                 * acked after the data operation is complete.
+                 * Ref: TRM SWPU114Q Figure 18-31
+                 */
+                omap_i2c_write_reg(dev, OMAP_I2C_STAT_REG, stat &
+                                ~(OMAP_I2C_STAT_RRDY | OMAP_I2C_STAT_RDR |
+                                OMAP_I2C_STAT_XRDY | OMAP_I2C_STAT_XDR));
 
                 if (stat & OMAP_I2C_STAT_NACK) {
                         err |= OMAP_I2C_STAT_NACK;
@@ -687,6 +694,9 @@ complete:
                 }
                 if (stat & (OMAP_I2C_STAT_ARDY | OMAP_I2C_STAT_NACK |
                                         OMAP_I2C_STAT_AL)) {
+                        omap_i2c_ack_stat(dev, stat &
+                                (OMAP_I2C_STAT_RRDY | OMAP_I2C_STAT_RDR |
+                                OMAP_I2C_STAT_XRDY | OMAP_I2C_STAT_XDR));
                         omap_i2c_complete_cmd(dev, err);
                         return IRQ_HANDLED;
                 }
@@ -774,7 +784,7 @@ complete:
                                  * memory to the I2C interface.
                                  */
 
-                                if (cpu_is_omap34xx()) {
+                                if (dev->rev <= OMAP_I2C_REV_ON_3430) {
                                                 while (!(stat & OMAP_I2C_STAT_XUDF)) {
                                                         if (stat & (OMAP_I2C_STAT_NACK | OMAP_I2C_STAT_AL)) {
                                                                 omap_i2c_ack_stat(dev, stat & (OMAP_I2C_STAT_XRDY | OMAP_I2C_STAT_XDR));
diff --git a/drivers/i2c/busses/i2c-stu300.c b/drivers/i2c/busses/i2c-stu300.c
index 182e711318ba..d2728a28a8db 100644
--- a/drivers/i2c/busses/i2c-stu300.c
+++ b/drivers/i2c/busses/i2c-stu300.c
@@ -117,7 +117,8 @@ enum stu300_error {
         STU300_ERROR_NONE = 0,
         STU300_ERROR_ACKNOWLEDGE_FAILURE,
         STU300_ERROR_BUS_ERROR,
-        STU300_ERROR_ARBITRATION_LOST
+        STU300_ERROR_ARBITRATION_LOST,
+        STU300_ERROR_UNKNOWN
 };
 
 /* timeout waiting for the controller to respond */
@@ -127,7 +128,7 @@ enum stu300_error {
  * The number of address send athemps tried before giving up.
  * If the first one failes it seems like 5 to 8 attempts are required.
  */
-#define NUM_ADDR_RESEND_ATTEMPTS 10
+#define NUM_ADDR_RESEND_ATTEMPTS 12
 
 /* I2C clock speed, in Hz 0-400kHz*/
 static unsigned int scl_frequency = 100000;
@@ -149,6 +150,7 @@ module_param(scl_frequency, uint,  0644);
  * @msg_index: index of current message
  * @msg_len: length of current message
  */
+
 struct stu300_dev {
         struct platform_device  *pdev;
         struct i2c_adapter      adapter;
@@ -188,6 +190,27 @@ static inline u32 stu300_r8(void __iomem *address)
         return readl(address) & 0x000000FFU;
 }
 
+static void stu300_irq_enable(struct stu300_dev *dev)
+{
+        u32 val;
+        val = stu300_r8(dev->virtbase + I2C_CR);
+        val |= I2C_CR_INTERRUPT_ENABLE;
+        /* Twice paranoia (possible HW glitch) */
+        stu300_wr8(val, dev->virtbase + I2C_CR);
+        stu300_wr8(val, dev->virtbase + I2C_CR);
+}
+
+static void stu300_irq_disable(struct stu300_dev *dev)
+{
+        u32 val;
+        val = stu300_r8(dev->virtbase + I2C_CR);
+        val &= ~I2C_CR_INTERRUPT_ENABLE;
+        /* Twice paranoia (possible HW glitch) */
+        stu300_wr8(val, dev->virtbase + I2C_CR);
+        stu300_wr8(val, dev->virtbase + I2C_CR);
+}
+
+
 /*
  * Tells whether a certain event or events occurred in
  * response to a command. The events represent states in
@@ -196,9 +219,10 @@ static inline u32 stu300_r8(void __iomem *address)
  * documentation and can only be treated as abstract state
  * machine states.
  *
- * @ret 0 = event has not occurred, any other value means
- * the event occurred.
+ * @ret 0 = event has not occurred or unknown error, any
+ * other value means the correct event occurred or an error.
  */
+
 static int stu300_event_occurred(struct stu300_dev *dev,
                                    enum stu300_event mr_event) {
         u32 status1;
@@ -206,11 +230,28 @@ static int stu300_event_occurred(struct stu300_dev *dev,
 
         /* What event happened? */
         status1 = stu300_r8(dev->virtbase + I2C_SR1);
+
         if (!(status1 & I2C_SR1_EVF_IND))
                 /* No event at all */
                 return 0;
+
         status2 = stu300_r8(dev->virtbase + I2C_SR2);
 
+        /* Block any multiple interrupts */
+        stu300_irq_disable(dev);
+
+        /* Check for errors first */
+        if (status2 & I2C_SR2_AF_IND) {
+                dev->cmd_err = STU300_ERROR_ACKNOWLEDGE_FAILURE;
+                return 1;
+        } else if (status2 & I2C_SR2_BERR_IND) {
+                dev->cmd_err = STU300_ERROR_BUS_ERROR;
+                return 1;
+        } else if (status2 & I2C_SR2_ARLO_IND) {
+                dev->cmd_err = STU300_ERROR_ARBITRATION_LOST;
+                return 1;
+        }
+
         switch (mr_event) {
         case STU300_EVENT_1:
                 if (status1 & I2C_SR1_ADSL_IND)
@@ -221,10 +262,6 @@ static int stu300_event_occurred(struct stu300_dev *dev,
         case STU300_EVENT_7:
         case STU300_EVENT_8:
                 if (status1 & I2C_SR1_BTF_IND) {
-                        if (status2 & I2C_SR2_AF_IND)
-                                dev->cmd_err = STU300_ERROR_ACKNOWLEDGE_FAILURE;
-                        else if (status2 & I2C_SR2_BERR_IND)
-                                dev->cmd_err = STU300_ERROR_BUS_ERROR;
                         return 1;
                 }
                 break;
@@ -240,8 +277,6 @@ static int stu300_event_occurred(struct stu300_dev *dev,
         case STU300_EVENT_6:
                 if (status2 & I2C_SR2_ENDAD_IND) {
                         /* First check for any errors */
-                        if (status2 & I2C_SR2_AF_IND)
-                                dev->cmd_err = STU300_ERROR_ACKNOWLEDGE_FAILURE;
                         return 1;
                 }
                 break;
@@ -252,8 +287,15 @@ static int stu300_event_occurred(struct stu300_dev *dev,
         default:
                 break;
         }
-        if (status2 & I2C_SR2_ARLO_IND)
-                dev->cmd_err = STU300_ERROR_ARBITRATION_LOST;
+        /* If we get here, we're on thin ice.
+         * Here we are in a status where we have
+         * gotten a response that does not match
+         * what we requested.
+         */
+        dev->cmd_err = STU300_ERROR_UNKNOWN;
+        dev_err(&dev->pdev->dev,
+                "Unhandled interrupt! %d sr1: 0x%x sr2: 0x%x\n",
+                mr_event, status1, status2);
         return 0;
 }
 
@@ -262,21 +304,20 @@ static irqreturn_t stu300_irh(int irq, void *data)
         struct stu300_dev *dev = data;
         int res;
 
+        /* Just make sure that the block is clocked */
+        clk_enable(dev->clk);
+
         /* See if this was what we were waiting for */
         spin_lock(&dev->cmd_issue_lock);
-        if (dev->cmd_event != STU300_EVENT_NONE) {
-                res = stu300_event_occurred(dev, dev->cmd_event);
-                if (res || dev->cmd_err != STU300_ERROR_NONE) {
-                        u32 val;
-
-                        complete(&dev->cmd_complete);
-                        /* Block any multiple interrupts */
-                        val = stu300_r8(dev->virtbase + I2C_CR);
-                        val &= ~I2C_CR_INTERRUPT_ENABLE;
-                        stu300_wr8(val, dev->virtbase + I2C_CR);
-                }
-        }
+
+        res = stu300_event_occurred(dev, dev->cmd_event);
+        if (res || dev->cmd_err != STU300_ERROR_NONE)
+                complete(&dev->cmd_complete);
+
         spin_unlock(&dev->cmd_issue_lock);
+
+        clk_disable(dev->clk);
+
         return IRQ_HANDLED;
 }
 
@@ -308,7 +349,6 @@ static int stu300_start_and_await_event(struct stu300_dev *dev,
         stu300_wr8(cr_value, dev->virtbase + I2C_CR);
         ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
                                                         STU300_TIMEOUT);
-
         if (ret < 0) {
                 dev_err(&dev->pdev->dev,
                        "wait_for_completion_interruptible_timeout() "
@@ -342,7 +382,6 @@ static int stu300_await_event(struct stu300_dev *dev,
                                 enum stu300_event mr_event)
 {
         int ret;
-        u32 val;
 
         if (unlikely(irqs_disabled())) {
                 /* TODO: implement polling for this case if need be. */
@@ -354,36 +393,18 @@ static int stu300_await_event(struct stu300_dev *dev,
         /* Is it already here? */
         spin_lock_irq(&dev->cmd_issue_lock);
         dev->cmd_err = STU300_ERROR_NONE;
-        if (stu300_event_occurred(dev, mr_event)) {
-                spin_unlock_irq(&dev->cmd_issue_lock);
-                goto exit_await_check_err;
-        }
-        init_completion(&dev->cmd_complete);
-        dev->cmd_err = STU300_ERROR_NONE;
         dev->cmd_event = mr_event;
 
-        /* Turn on the I2C interrupt for current operation */
-        val = stu300_r8(dev->virtbase + I2C_CR);
-        val |= I2C_CR_INTERRUPT_ENABLE;
-        stu300_wr8(val, dev->virtbase + I2C_CR);
-
-        /* Twice paranoia (possible HW glitch) */
-        stu300_wr8(val, dev->virtbase + I2C_CR);
+        init_completion(&dev->cmd_complete);
 
-        /* Check again: is it already here? */
-        if (unlikely(stu300_event_occurred(dev, mr_event))) {
-                /* Disable IRQ again. */
-                val &= ~I2C_CR_INTERRUPT_ENABLE;
-                stu300_wr8(val, dev->virtbase + I2C_CR);
-                spin_unlock_irq(&dev->cmd_issue_lock);
-                goto exit_await_check_err;
-        }
+        /* Turn on the I2C interrupt for current operation */
+        stu300_irq_enable(dev);
 
         /* Unlock the command block and wait for the event to occur */
         spin_unlock_irq(&dev->cmd_issue_lock);
+
         ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
                                                         STU300_TIMEOUT);
-
         if (ret < 0) {
                 dev_err(&dev->pdev->dev,
                        "wait_for_completion_interruptible_timeout()"
@@ -401,7 +422,6 @@ static int stu300_await_event(struct stu300_dev *dev,
                 return -ETIMEDOUT;
         }
 
- exit_await_check_err:
         if (dev->cmd_err != STU300_ERROR_NONE) {
                 if (mr_event != STU300_EVENT_6) {
                         dev_err(&dev->pdev->dev, "controller "
@@ -457,18 +477,19 @@ struct stu300_clkset {
 };
 
 static const struct stu300_clkset stu300_clktable[] = {
-        { 0, 0xFFU },
-        { 2500000, I2C_OAR2_FR_25_10MHZ },
-        { 10000000, I2C_OAR2_FR_10_1667MHZ },
-        { 16670000, I2C_OAR2_FR_1667_2667MHZ },
-        { 26670000, I2C_OAR2_FR_2667_40MHZ },
-        { 40000000, I2C_OAR2_FR_40_5333MHZ },
-        { 53330000, I2C_OAR2_FR_5333_66MHZ },
-        { 66000000, I2C_OAR2_FR_66_80MHZ },
-        { 80000000, I2C_OAR2_FR_80_100MHZ },
+        { 0,         0xFFU },
+        { 2500000,   I2C_OAR2_FR_25_10MHZ },
+        { 10000000,  I2C_OAR2_FR_10_1667MHZ },
+        { 16670000,  I2C_OAR2_FR_1667_2667MHZ },
+        { 26670000,  I2C_OAR2_FR_2667_40MHZ },
+        { 40000000,  I2C_OAR2_FR_40_5333MHZ },
+        { 53330000,  I2C_OAR2_FR_5333_66MHZ },
+        { 66000000,  I2C_OAR2_FR_66_80MHZ },
+        { 80000000,  I2C_OAR2_FR_80_100MHZ },
         { 100000000, 0xFFU },
 };
 
+
 static int stu300_set_clk(struct stu300_dev *dev, unsigned long clkrate)
 {
 
@@ -494,10 +515,10 @@ static int stu300_set_clk(struct stu300_dev *dev, unsigned long clkrate)
 
         if (dev->speed > 100000)
                 /* Fast Mode I2C */
-                val = ((clkrate/dev->speed)-9)/3;
+                val = ((clkrate/dev->speed) - 9)/3 + 1;
         else
                 /* Standard Mode I2C */
-                val = ((clkrate/dev->speed)-7)/2;
+                val = ((clkrate/dev->speed) - 7)/2 + 1;
 
         /* According to spec the divider must be > 2 */
         if (val < 0x002) {
@@ -557,6 +578,7 @@ static int stu300_init_hw(struct stu300_dev *dev)
          */
         clkrate = clk_get_rate(dev->clk);
         ret = stu300_set_clk(dev, clkrate);
+
         if (ret)
                 return ret;
         /*
@@ -641,7 +663,6 @@ static int stu300_xfer_msg(struct i2c_adapter *adap,
         int attempts = 0;
         struct stu300_dev *dev = i2c_get_adapdata(adap);
 
-
         clk_enable(dev->clk);
 
         /* Remove this if (0) to trace each and every message. */
@@ -715,14 +736,15 @@ static int stu300_xfer_msg(struct i2c_adapter *adap,
 
         if (attempts < NUM_ADDR_RESEND_ATTEMPTS && attempts > 0) {
                 dev_dbg(&dev->pdev->dev, "managed to get address "
-                       "through after %d attempts\n", attempts);
+                        "through after %d attempts\n", attempts);
         } else if (attempts == NUM_ADDR_RESEND_ATTEMPTS) {
                 dev_dbg(&dev->pdev->dev, "I give up, tried %d times "
-                       "to resend address.\n",
-                       NUM_ADDR_RESEND_ATTEMPTS);
+                        "to resend address.\n",
+                        NUM_ADDR_RESEND_ATTEMPTS);
                 goto exit_disable;
         }
 
+
         if (msg->flags & I2C_M_RD) {
                 /* READ: we read the actual bytes one at a time */
                 for (i = 0; i < msg->len; i++) {
@@ -804,8 +826,10 @@ static int stu300_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
 {
         int ret = -1;
         int i;
+
         struct stu300_dev *dev = i2c_get_adapdata(adap);
         dev->msg_len = num;
+
         for (i = 0; i < num; i++) {
                 /*
                  * Another driver appears to send stop for each message,
@@ -817,6 +841,7 @@ static int stu300_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
                 dev->msg_index = i;
 
                 ret = stu300_xfer_msg(adap, &msgs[i], (i == (num - 1)));
+
                 if (ret != 0) {
                         num = ret;
                         break;
@@ -845,6 +870,7 @@ stu300_probe(struct platform_device *pdev)
         struct resource *res;
         int bus_nr;
         int ret = 0;
+        char clk_name[] = "I2C0";
 
         dev = kzalloc(sizeof(struct stu300_dev), GFP_KERNEL);
         if (!dev) {
@@ -854,7 +880,8 @@ stu300_probe(struct platform_device *pdev)
         }
 
         bus_nr = pdev->id;
-        dev->clk = clk_get(&pdev->dev, NULL);
+        clk_name[3] += (char)bus_nr;
+        dev->clk = clk_get(&pdev->dev, clk_name);
         if (IS_ERR(dev->clk)) {
                 ret = PTR_ERR(dev->clk);
                 dev_err(&pdev->dev, "could not retrieve i2c bus clock\n");
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 272b9b2bea86..59cba180fe83 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -3099,8 +3099,12 @@ static void inode_tree_add(struct inode *inode)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_inode *entry;
-        struct rb_node **p = &root->inode_tree.rb_node;
-        struct rb_node *parent = NULL;
+        struct rb_node **p;
+        struct rb_node *parent;
+
+again:
+        p = &root->inode_tree.rb_node;
+        parent = NULL;
 
         spin_lock(&root->inode_lock);
         while (*p) {
@@ -3108,13 +3112,16 @@ static void inode_tree_add(struct inode *inode)
                 entry = rb_entry(parent, struct btrfs_inode, rb_node);
 
                 if (inode->i_ino < entry->vfs_inode.i_ino)
-                        p = &(*p)->rb_left;
+                        p = &parent->rb_left;
                 else if (inode->i_ino > entry->vfs_inode.i_ino)
-                        p = &(*p)->rb_right;
+                        p = &parent->rb_right;
                 else {
                         WARN_ON(!(entry->vfs_inode.i_state &
                                   (I_WILL_FREE | I_FREEING | I_CLEAR)));
-                        break;
+                        rb_erase(parent, &root->inode_tree);
+                        RB_CLEAR_NODE(parent);
+                        spin_unlock(&root->inode_lock);
+                        goto again;
                 }
         }
         rb_link_node(&BTRFS_I(inode)->rb_node, parent, p);
@@ -3126,12 +3133,12 @@ static void inode_tree_del(struct inode *inode)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
 
+        spin_lock(&root->inode_lock);
         if (!RB_EMPTY_NODE(&BTRFS_I(inode)->rb_node)) {
-                spin_lock(&root->inode_lock);
                 rb_erase(&BTRFS_I(inode)->rb_node, &root->inode_tree);
-                spin_unlock(&root->inode_lock);
                 RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
         }
+        spin_unlock(&root->inode_lock);
 }
 
 static noinline void init_btrfs_i(struct inode *inode)
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 2878811c6134..756d78b8c1c5 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -94,13 +94,13 @@ extern void __bitmap_shift_right(unsigned long *dst,
                         const unsigned long *src, int shift, int bits);
 extern void __bitmap_shift_left(unsigned long *dst,
                         const unsigned long *src, int shift, int bits);
-extern void __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
+extern int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
                         const unsigned long *bitmap2, int bits);
 extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
                         const unsigned long *bitmap2, int bits);
 extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
                         const unsigned long *bitmap2, int bits);
-extern void __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
+extern int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
                         const unsigned long *bitmap2, int bits);
 extern int __bitmap_intersects(const unsigned long *bitmap1,
                         const unsigned long *bitmap2, int bits);
@@ -171,13 +171,12 @@ static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
         }
 }
 
-static inline void bitmap_and(unsigned long *dst, const unsigned long *src1,
+static inline int bitmap_and(unsigned long *dst, const unsigned long *src1,
                         const unsigned long *src2, int nbits)
 {
         if (small_const_nbits(nbits))
-                *dst = *src1 & *src2;
-        else
-                __bitmap_and(dst, src1, src2, nbits);
+                return (*dst = *src1 & *src2) != 0;
+        return __bitmap_and(dst, src1, src2, nbits);
 }
 
 static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
@@ -198,13 +197,12 @@ static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1,
                 __bitmap_xor(dst, src1, src2, nbits);
 }
 
-static inline void bitmap_andnot(unsigned long *dst, const unsigned long *src1,
+static inline int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
                         const unsigned long *src2, int nbits)
 {
         if (small_const_nbits(nbits))
-                *dst = *src1 & ~(*src2);
-        else
-                __bitmap_andnot(dst, src1, src2, nbits);
+                return (*dst = *src1 & ~(*src2)) != 0;
+        return __bitmap_andnot(dst, src1, src2, nbits);
 }
 
 static inline void bitmap_complement(unsigned long *dst, const unsigned long *src,
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index c5ac87ca7bc6..796df12091b7 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -43,10 +43,10 @@
  * int cpu_isset(cpu, mask)             true iff bit 'cpu' set in mask
  * int cpu_test_and_set(cpu, mask)      test and set bit 'cpu' in mask
  *
- * void cpus_and(dst, src1, src2)       dst = src1 & src2  [intersection]
+ * int cpus_and(dst, src1, src2)        dst = src1 & src2  [intersection]
  * void cpus_or(dst, src1, src2)        dst = src1 | src2  [union]
  * void cpus_xor(dst, src1, src2)       dst = src1 ^ src2
- * void cpus_andnot(dst, src1, src2)    dst = src1 & ~src2
+ * int cpus_andnot(dst, src1, src2)     dst = src1 & ~src2
  * void cpus_complement(dst, src)       dst = ~src
  *
  * int cpus_equal(mask1, mask2)         Does mask1 == mask2?
@@ -179,10 +179,10 @@ static inline int __cpu_test_and_set(int cpu, cpumask_t *addr)
 }
 
 #define cpus_and(dst, src1, src2) __cpus_and(&(dst), &(src1), &(src2), NR_CPUS)
-static inline void __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
+static inline int __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
                                         const cpumask_t *src2p, int nbits)
 {
-        bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
+        return bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
 
 #define cpus_or(dst, src1, src2) __cpus_or(&(dst), &(src1), &(src2), NR_CPUS)
@@ -201,10 +201,10 @@ static inline void __cpus_xor(cpumask_t *dstp, const cpumask_t *src1p,
 
 #define cpus_andnot(dst, src1, src2) \
                                 __cpus_andnot(&(dst), &(src1), &(src2), NR_CPUS)
-static inline void __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
+static inline int __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
                                         const cpumask_t *src2p, int nbits)
 {
-        bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
+        return bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
 
 #define cpus_complement(dst, src) __cpus_complement(&(dst), &(src), NR_CPUS)
@@ -738,11 +738,11 @@ static inline void cpumask_clear(struct cpumask *dstp)
  * @src1p: the first input
  * @src2p: the second input
  */
-static inline void cpumask_and(struct cpumask *dstp,
+static inline int cpumask_and(struct cpumask *dstp,
                                const struct cpumask *src1p,
                                const struct cpumask *src2p)
 {
-        bitmap_and(cpumask_bits(dstp), cpumask_bits(src1p),
+        return bitmap_and(cpumask_bits(dstp), cpumask_bits(src1p),
                                        cpumask_bits(src2p), nr_cpumask_bits);
 }
 
@@ -779,11 +779,11 @@ static inline void cpumask_xor(struct cpumask *dstp,
  * @src1p: the first input
  * @src2p: the second input
  */
-static inline void cpumask_andnot(struct cpumask *dstp,
+static inline int cpumask_andnot(struct cpumask *dstp,
                                   const struct cpumask *src1p,
                                   const struct cpumask *src2p)
 {
-        bitmap_andnot(cpumask_bits(dstp), cpumask_bits(src1p),
+        return bitmap_andnot(cpumask_bits(dstp), cpumask_bits(src1p),
                                           cpumask_bits(src2p), nr_cpumask_bits);
 }
 
diff --git a/lib/bitmap.c b/lib/bitmap.c
index 35a1f7ff4149..702565821c99 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -179,14 +179,16 @@ void __bitmap_shift_left(unsigned long *dst,
 }
 EXPORT_SYMBOL(__bitmap_shift_left);
 
-void __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
+int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
                                 const unsigned long *bitmap2, int bits)
 {
         int k;
         int nr = BITS_TO_LONGS(bits);
+        unsigned long result = 0;
 
         for (k = 0; k < nr; k++)
-                dst[k] = bitmap1[k] & bitmap2[k];
+                result |= (dst[k] = bitmap1[k] & bitmap2[k]);
+        return result != 0;
 }
 EXPORT_SYMBOL(__bitmap_and);
 
@@ -212,14 +214,16 @@ void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
 }
 EXPORT_SYMBOL(__bitmap_xor);
 
-void __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
+int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
                                 const unsigned long *bitmap2, int bits)
 {
         int k;
         int nr = BITS_TO_LONGS(bits);
+        unsigned long result = 0;
 
         for (k = 0; k < nr; k++)
-                dst[k] = bitmap1[k] & ~bitmap2[k];
+                result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);
+        return result != 0;
 }
 EXPORT_SYMBOL(__bitmap_andnot);
 
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index 3da85caf8af1..403588c6e3f6 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -3835,9 +3835,11 @@ static struct hda_verb ad1884a_laptop_verbs[] = {
         /* Port-F (int speaker) mixer - route only from analog mixer */
         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
-        /* Port-F pin */
-        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
+        /* Port-F (int speaker) pin */
+        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
+        /* required for compaq 6530s/6531s speaker output */
+        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
         /* Port-C pin - internal mic-in */
         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index fea976793ae5..6f683e451f2b 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -12521,8 +12521,6 @@ static struct snd_pci_quirk alc268_cfg_tbl[] = {
                            ALC268_TOSHIBA),
         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
-        SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
-                           ALC268_TOSHIBA),
         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
@@ -12530,6 +12528,15 @@ static struct snd_pci_quirk alc268_cfg_tbl[] = {
         {}
 };
 
+/* Toshiba laptops have no unique PCI SSID but only codec SSID */
+static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
+        SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
+        SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
+        SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
+                           ALC268_TOSHIBA),
+        {}
+};
+
 static struct alc_config_preset alc268_presets[] = {
         [ALC267_QUANTA_IL1] = {
                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
@@ -12696,6 +12703,10 @@ static int patch_alc268(struct hda_codec *codec)
                                                   alc268_models,
                                                   alc268_cfg_tbl);
 
+        if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
+                board_config = snd_hda_check_board_codec_sid_config(codec,
+                        ALC882_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
+
         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
                        "trying auto-probe from BIOS...\n", codec->chip_name);
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 456ef6ac12e4..6990cfcb6a38 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -76,6 +76,7 @@ enum {
         STAC_92HD73XX_AUTO,
         STAC_92HD73XX_NO_JD, /* no jack-detection */
         STAC_92HD73XX_REF,
+        STAC_92HD73XX_INTEL,
         STAC_DELL_M6_AMIC,
         STAC_DELL_M6_DMIC,
         STAC_DELL_M6_BOTH,
@@ -1777,6 +1778,7 @@ static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
         [STAC_92HD73XX_AUTO] = "auto",
         [STAC_92HD73XX_NO_JD] = "no-jd",
         [STAC_92HD73XX_REF] = "ref",
+        [STAC_92HD73XX_INTEL] = "intel",
         [STAC_DELL_M6_AMIC] = "dell-m6-amic",
         [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
         [STAC_DELL_M6_BOTH] = "dell-m6",
@@ -1789,6 +1791,10 @@ static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
                                 "DFI LanParty", STAC_92HD73XX_REF),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
                                 "DFI LanParty", STAC_92HD73XX_REF),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
+                                "Intel DG45ID", STAC_92HD73XX_INTEL),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
+                                "Intel DG45FC", STAC_92HD73XX_INTEL),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
                                 "Dell Studio 1535", STAC_DELL_M6_DMIC),
         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,