19 files changed, 116 insertions, 73 deletions
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 8f905089b72b..a6cbf7b808e6 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -934,8 +934,6 @@ static void blkfront_closing(struct xenbus_device *dev)
        spin_lock_irqsave(&blkif_io_lock, flags);
-        del_gendisk(info->gd);
        /* No more blkif_request(). */
        blk_stop_queue(info->rq);
@@ -949,6 +947,8 @@ static void blkfront_closing(struct xenbus_device *dev)
        blk_cleanup_queue(info->rq);
        info->rq = NULL;
+        del_gendisk(info->gd);
 out:
        xenbus_frontend_closed(dev);
 }
@@ -977,8 +977,10 @@ static void backend_changed(struct xenbus_device *dev,
                break;
        case XenbusStateClosing:
-                if (info->gd == NULL)
+                if (info->gd == NULL) {
-                        xenbus_dev_fatal(dev, -ENODEV, "gd is NULL");
+                        xenbus_frontend_closed(dev);
+                        break;
+                }
                bd = bdget_disk(info->gd, 0);
                if (bd == NULL)
                        xenbus_dev_fatal(dev, -ENODEV, "bdget failed");
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index 13929356135c..9b1624e0ddeb 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -587,7 +587,7 @@ static int viocd_probe(struct vio_dev *vdev, const struct vio_device_id *id)
        struct device_node *node = vdev->dev.archdata.of_node;
        deviceno = vdev->unit_address;
-        if (deviceno > VIOCD_MAX_CD)
+        if (deviceno >= VIOCD_MAX_CD)
                return -ENODEV;
        if (!node)
                return -ENODEV;
diff --git a/drivers/char/random.c b/drivers/char/random.c
index b2ced39d76b2..8c7444857a4b 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -1673,7 +1673,7 @@ unsigned int get_random_int(void)
        int ret;
        keyptr = get_keyptr();
-        hash[0] += current->pid + jiffies + get_cycles() + (int)(long)&ret;
+        hash[0] += current->pid + jiffies + get_cycles();
        ret = half_md4_transform(hash, keyptr->secret);
        put_cpu_var(get_random_int_hash);
diff --git a/drivers/char/tpm/tpm_bios.c b/drivers/char/tpm/tpm_bios.c
index ed306eb1057f..0c2f55a38b95 100644
--- a/drivers/char/tpm/tpm_bios.c
+++ b/drivers/char/tpm/tpm_bios.c
@@ -212,7 +212,8 @@ static int get_event_name(char *dest, struct tcpa_event *event,
                        unsigned char * event_entry)
 {
        const char *name = "";
-        char data[40] = "";
+        /* 41 so there is room for 40 data and 1 nul */
+        char data[41] = "";
        int i, n_len = 0, d_len = 0;
        struct tcpa_pc_event *pc_event;
diff --git a/drivers/crypto/ixp4xx_crypto.c b/drivers/crypto/ixp4xx_crypto.c
index f9f05d7a707d..6c6656d3b1e2 100644
--- a/drivers/crypto/ixp4xx_crypto.c
+++ b/drivers/crypto/ixp4xx_crypto.c
@@ -415,6 +415,7 @@ static void crypto_done_action(unsigned long arg)
 static int init_ixp_crypto(void)
 {
        int ret = -ENODEV;
+        u32 msg[2] = { 0, 0 };
        if (! ( ~(*IXP4XX_EXP_CFG2) & (IXP4XX_FEATURE_HASH |
                                IXP4XX_FEATURE_AES | IXP4XX_FEATURE_DES))) {
@@ -426,9 +427,35 @@ static int init_ixp_crypto(void)
                return ret;
        if (!npe_running(npe_c)) {
-                npe_load_firmware(npe_c, npe_name(npe_c), dev);
+                ret = npe_load_firmware(npe_c, npe_name(npe_c), dev);
+                if (ret) {
+                        return ret;
+                }
+                if (npe_recv_message(npe_c, msg, "STATUS_MSG"))
+                        goto npe_error;
+        } else {
+                if (npe_send_message(npe_c, msg, "STATUS_MSG"))
+                        goto npe_error;
+                if (npe_recv_message(npe_c, msg, "STATUS_MSG"))
+                        goto npe_error;
        }
+        switch ((msg[1]>>16) & 0xff) {
+        case 3:
+                printk(KERN_WARNING "Firmware of %s lacks AES support\n",
+                                npe_name(npe_c));
+                support_aes = 0;
+                break;
+        case 4:
+        case 5:
+                support_aes = 1;
+                break;
+        default:
+                printk(KERN_ERR "Firmware of %s lacks crypto support\n",
+                        npe_name(npe_c));
+                return -ENODEV;
+        }
        /* buffer_pool will also be used to sometimes store the hmac,
         * so assure it is large enough
         */
@@ -459,6 +486,10 @@ static int init_ixp_crypto(void)
        qmgr_enable_irq(RECV_QID);
        return 0;
+npe_error:
+        printk(KERN_ERR "%s not responding\n", npe_name(npe_c));
+        ret = -EIO;
 err:
        if (ctx_pool)
                dma_pool_destroy(ctx_pool);
diff --git a/drivers/crypto/padlock-aes.c b/drivers/crypto/padlock-aes.c
index 3f0fdd18255d..856b3cc25583 100644
--- a/drivers/crypto/padlock-aes.c
+++ b/drivers/crypto/padlock-aes.c
@@ -489,4 +489,4 @@ MODULE_DESCRIPTION("VIA PadLock AES algorithm support");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Michal Ludvig");
-MODULE_ALIAS("aes-all");
+MODULE_ALIAS("aes");
diff --git a/drivers/mfd/pcf50633-core.c b/drivers/mfd/pcf50633-core.c
index 7793932a513b..11a6248cc1c1 100644
--- a/drivers/mfd/pcf50633-core.c
+++ b/drivers/mfd/pcf50633-core.c
@@ -443,7 +443,7 @@ static irqreturn_t pcf50633_irq(int irq, void *data)
        dev_dbg(pcf->dev, "pcf50633_irq\n");
        get_device(pcf->dev);
-        disable_irq(pcf->irq);
+        disable_irq_nosync(pcf->irq);
        schedule_work(&pcf->irq_work);
        return IRQ_HANDLED;
diff --git a/drivers/mfd/wm8350-core.c b/drivers/mfd/wm8350-core.c
index c2be3088e2e1..fe24079387c5 100644
--- a/drivers/mfd/wm8350-core.c
+++ b/drivers/mfd/wm8350-core.c
@@ -79,10 +79,6 @@ static int wm8350_phys_read(struct wm8350 *wm8350, u8 reg, int num_regs,
                /* Cache is CPU endian */
                dest[i - reg] = be16_to_cpu(dest[i - reg]);
-                /* Satisfy non-volatile bits from cache */
-                dest[i - reg] &= wm8350_reg_io_map[i].vol;
-                dest[i - reg] |= wm8350->reg_cache[i];
                /* Mask out non-readable bits */
                dest[i - reg] &= wm8350_reg_io_map[i].readable;
        }
@@ -182,9 +178,6 @@ static int wm8350_write(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *src)
                        (wm8350->reg_cache[i] & ~wm8350_reg_io_map[i].writable)
                        | src[i - reg];
-                /* Don't store volatile bits */
-                wm8350->reg_cache[i] &= ~wm8350_reg_io_map[i].vol;
                src[i - reg] = cpu_to_be16(src[i - reg]);
        }
@@ -1261,7 +1254,6 @@ static int wm8350_create_cache(struct wm8350 *wm8350, int type, int mode)
                    (i < WM8350_CLOCK_CONTROL_1 || i > WM8350_AIF_TEST)) {
                        value = be16_to_cpu(wm8350->reg_cache[i]);
                        value &= wm8350_reg_io_map[i].readable;
-                        value &= ~wm8350_reg_io_map[i].vol;
                        wm8350->reg_cache[i] = value;
                } else
                        wm8350->reg_cache[i] = reg_map[i];
diff --git a/drivers/mtd/devices/mtd_dataflash.c b/drivers/mtd/devices/mtd_dataflash.c
index 62dee54af0a5..43976aa4dbb1 100644
--- a/drivers/mtd/devices/mtd_dataflash.c
+++ b/drivers/mtd/devices/mtd_dataflash.c
@@ -178,7 +178,7 @@ static int dataflash_erase(struct mtd_info *mtd, struct erase_info *instr)
                /* Calculate flash page address; use block erase (for speed) if
                 * we're at a block boundary and need to erase the whole block.
                 */
-                pageaddr = div_u64(instr->len, priv->page_size);
+                pageaddr = div_u64(instr->addr, priv->page_size);
                do_block = (pageaddr & 0x7) == 0 && instr->len >= blocksize;
                pageaddr = pageaddr << priv->page_offset;
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index c49ddd08b2aa..b4bb06fdf307 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -35,8 +35,22 @@
 #define DRV_VER                 "2.0.348"
 #define DRV_NAME                "be2net"
 #define BE_NAME                 "ServerEngines BladeEngine2 10Gbps NIC"
+#define OC_NAME                 "Emulex OneConnect 10Gbps NIC"
 #define DRV_DESC                BE_NAME "Driver"
+#define BE_VENDOR_ID            0x19a2
+#define BE_DEVICE_ID1           0x211
+#define OC_DEVICE_ID1           0x700
+#define OC_DEVICE_ID2           0x701
+static inline char *nic_name(struct pci_dev *pdev)
+{
+        if (pdev->device == OC_DEVICE_ID1 || pdev->device == OC_DEVICE_ID2)
+                return OC_NAME;
+        else
+                return BE_NAME;
+}
 /* Number of bytes of an RX frame that are copied to skb->data */
 #define BE_HDR_LEN              64
 #define BE_MAX_JUMBO_FRAME_SIZE 9018
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 30d0c81c989e..5c378b5e8e41 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -28,10 +28,10 @@ static unsigned int rx_frag_size = 2048;
 module_param(rx_frag_size, uint, S_IRUGO);
 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
-#define BE_VENDOR_ID            0x19a2
-#define BE2_DEVICE_ID_1         0x0211
 static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
-        { PCI_DEVICE(BE_VENDOR_ID, BE2_DEVICE_ID_1) },
+        { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
+        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
+        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
        { 0 }
 };
 MODULE_DEVICE_TABLE(pci, be_dev_ids);
@@ -1859,7 +1859,7 @@ static int __devinit be_probe(struct pci_dev *pdev,
        if (status != 0)
                goto stats_clean;
-        dev_info(&pdev->dev, BE_NAME " port %d\n", adapter->port_num);
+        dev_info(&pdev->dev, "%s port %d\n", nic_name(pdev), adapter->port_num);
        return 0;
 stats_clean:
@@ -1873,7 +1873,7 @@ rel_reg:
 disable_dev:
        pci_disable_device(pdev);
 do_none:
-        dev_warn(&pdev->dev, BE_NAME " initialization failed\n");
+        dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
        return status;
 }
diff --git a/drivers/net/bonding/bond_3ad.c b/drivers/net/bonding/bond_3ad.c
index 8c2e5ab51f08..faf094abef7f 100644
--- a/drivers/net/bonding/bond_3ad.c
+++ b/drivers/net/bonding/bond_3ad.c
@@ -1465,6 +1465,12 @@ static struct aggregator *ad_agg_selection_test(struct aggregator *best,
        return best;
 }
+static int agg_device_up(const struct aggregator *agg)
+{
+        return (netif_running(agg->slave->dev) &&
+                netif_carrier_ok(agg->slave->dev));
+}
 /**
 * ad_agg_selection_logic - select an aggregation group for a team
 * @aggregator: the aggregator we're looking at
@@ -1496,14 +1502,13 @@ static void ad_agg_selection_logic(struct aggregator *agg)
        struct port *port;
        origin = agg;
        active = __get_active_agg(agg);
-        best = active;
+        best = (active && agg_device_up(active)) ? active : NULL;
        do {
                agg->is_active = 0;
-                if (agg->num_of_ports)
+                if (agg->num_of_ports && agg_device_up(agg))
                        best = ad_agg_selection_test(best, agg);
        } while ((agg = __get_next_agg(agg)));
diff --git a/drivers/net/meth.c b/drivers/net/meth.c
index aa08987f6e81..dbd3436912b8 100644
--- a/drivers/net/meth.c
+++ b/drivers/net/meth.c
@@ -127,11 +127,11 @@ static unsigned long mdio_read(struct meth_private *priv, unsigned long phyreg)
 static int mdio_probe(struct meth_private *priv)
 {
        int i;
-        unsigned long p2, p3;
+        unsigned long p2, p3, flags;
        /* check if phy is detected already */
        if(priv->phy_addr>=0&&priv->phy_addr<32)
                return 0;
-        spin_lock(&priv->meth_lock);
+        spin_lock_irqsave(&priv->meth_lock, flags);
        for (i=0;i<32;++i){
                priv->phy_addr=i;
                p2=mdio_read(priv,2);
@@ -157,7 +157,7 @@ static int mdio_probe(struct meth_private *priv)
                        break;
                }
        }
-        spin_unlock(&priv->meth_lock);
+        spin_unlock_irqrestore(&priv->meth_lock, flags);
        if(priv->phy_addr<32) {
                return 0;
        }
@@ -373,14 +373,14 @@ static int meth_release(struct net_device *dev)
 static void meth_rx(struct net_device* dev, unsigned long int_status)
 {
        struct sk_buff *skb;
-        unsigned long status;
+        unsigned long status, flags;
        struct meth_private *priv = netdev_priv(dev);
        unsigned long fifo_rptr = (int_status & METH_INT_RX_RPTR_MASK) >> 8;
-        spin_lock(&priv->meth_lock);
+        spin_lock_irqsave(&priv->meth_lock, flags);
        priv->dma_ctrl &= ~METH_DMA_RX_INT_EN;
        mace->eth.dma_ctrl = priv->dma_ctrl;
-        spin_unlock(&priv->meth_lock);
+        spin_unlock_irqrestore(&priv->meth_lock, flags);
        if (int_status & METH_INT_RX_UNDERFLOW) {
                fifo_rptr = (fifo_rptr - 1) & 0x0f;
@@ -452,12 +452,12 @@ static void meth_rx(struct net_device* dev, unsigned long int_status)
                mace->eth.rx_fifo = priv->rx_ring_dmas[priv->rx_write];
                ADVANCE_RX_PTR(priv->rx_write);
        }
-        spin_lock(&priv->meth_lock);
+        spin_lock_irqsave(&priv->meth_lock, flags);
        /* In case there was underflow, and Rx DMA was disabled */
        priv->dma_ctrl |= METH_DMA_RX_INT_EN | METH_DMA_RX_EN;
        mace->eth.dma_ctrl = priv->dma_ctrl;
        mace->eth.int_stat = METH_INT_RX_THRESHOLD;
-        spin_unlock(&priv->meth_lock);
+        spin_unlock_irqrestore(&priv->meth_lock, flags);
 }
 static int meth_tx_full(struct net_device *dev)
@@ -470,11 +470,11 @@ static int meth_tx_full(struct net_device *dev)
 static void meth_tx_cleanup(struct net_device* dev, unsigned long int_status)
 {
        struct meth_private *priv = netdev_priv(dev);
-        unsigned long status;
+        unsigned long status, flags;
        struct sk_buff *skb;
        unsigned long rptr = (int_status&TX_INFO_RPTR) >> 16;
-        spin_lock(&priv->meth_lock);
+        spin_lock_irqsave(&priv->meth_lock, flags);
        /* Stop DMA notification */
        priv->dma_ctrl &= ~(METH_DMA_TX_INT_EN);
@@ -527,12 +527,13 @@ static void meth_tx_cleanup(struct net_device* dev, unsigned long int_status)
        }
        mace->eth.int_stat = METH_INT_TX_EMPTY | METH_INT_TX_PKT;
-        spin_unlock(&priv->meth_lock);
+        spin_unlock_irqrestore(&priv->meth_lock, flags);
 }
 static void meth_error(struct net_device* dev, unsigned status)
 {
        struct meth_private *priv = netdev_priv(dev);
+        unsigned long flags;
        printk(KERN_WARNING "meth: error status: 0x%08x\n",status);
        /* check for errors too... */
@@ -547,7 +548,7 @@ static void meth_error(struct net_device* dev, unsigned status)
                printk(KERN_WARNING "meth: Rx overflow\n");
        if (status & (METH_INT_RX_UNDERFLOW)) {
                printk(KERN_WARNING "meth: Rx underflow\n");
-                spin_lock(&priv->meth_lock);
+                spin_lock_irqsave(&priv->meth_lock, flags);
                mace->eth.int_stat = METH_INT_RX_UNDERFLOW;
                /* more underflow interrupts will be delivered,
                 * effectively throwing us into an infinite loop.
@@ -555,7 +556,7 @@ static void meth_error(struct net_device* dev, unsigned status)
                priv->dma_ctrl &= ~METH_DMA_RX_EN;
                mace->eth.dma_ctrl = priv->dma_ctrl;
                DPRINTK("Disabled meth Rx DMA temporarily\n");
-                spin_unlock(&priv->meth_lock);
+                spin_unlock_irqrestore(&priv->meth_lock, flags);
        }
        mace->eth.int_stat = METH_INT_ERROR;
 }
diff --git a/drivers/net/mlx4/en_cq.c b/drivers/net/mlx4/en_cq.c
index 91f50de84be9..a276125b709b 100644
--- a/drivers/net/mlx4/en_cq.c
+++ b/drivers/net/mlx4/en_cq.c
@@ -125,8 +125,10 @@ void mlx4_en_deactivate_cq(struct mlx4_en_priv *priv, struct mlx4_en_cq *cq)
        if (cq->is_tx)
                del_timer(&cq->timer);
-        else
+        else {
                napi_disable(&cq->napi);
+                netif_napi_del(&cq->napi);
+        }
        mlx4_cq_free(mdev->dev, &cq->mcq);
 }
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index a400d7115f78..6bb5af35eda6 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -569,7 +569,7 @@ static int rxq_process(struct rx_queue *rxq, int budget)
                if (rxq->rx_curr_desc == rxq->rx_ring_size)
                        rxq->rx_curr_desc = 0;
-                dma_unmap_single(NULL, rx_desc->buf_ptr,
+                dma_unmap_single(mp->dev->dev.parent, rx_desc->buf_ptr,
                                 rx_desc->buf_size, DMA_FROM_DEVICE);
                rxq->rx_desc_count--;
                rx++;
@@ -678,8 +678,9 @@ static int rxq_refill(struct rx_queue *rxq, int budget)
                rx_desc = rxq->rx_desc_area + rx;
-                rx_desc->buf_ptr = dma_map_single(NULL, skb->data,
+                rx_desc->buf_ptr = dma_map_single(mp->dev->dev.parent,
-                                        mp->skb_size, DMA_FROM_DEVICE);
+                                                  skb->data, mp->skb_size,
+                                                  DMA_FROM_DEVICE);
                rx_desc->buf_size = mp->skb_size;
                rxq->rx_skb[rx] = skb;
                wmb();
@@ -718,6 +719,7 @@ static inline unsigned int has_tiny_unaligned_frags(struct sk_buff *skb)
 static void txq_submit_frag_skb(struct tx_queue *txq, struct sk_buff *skb)
 {
+        struct mv643xx_eth_private *mp = txq_to_mp(txq);
        int nr_frags = skb_shinfo(skb)->nr_frags;
        int frag;
@@ -746,10 +748,10 @@ static void txq_submit_frag_skb(struct tx_queue *txq, struct sk_buff *skb)
                desc->l4i_chk = 0;
                desc->byte_cnt = this_frag->size;
-                desc->buf_ptr = dma_map_page(NULL, this_frag->page,
+                desc->buf_ptr = dma_map_page(mp->dev->dev.parent,
-                                                this_frag->page_offset,
+                                             this_frag->page,
-                                                this_frag->size,
+                                             this_frag->page_offset,
-                                                DMA_TO_DEVICE);
+                                             this_frag->size, DMA_TO_DEVICE);
        }
 }
@@ -826,7 +828,8 @@ no_csum:
        desc->l4i_chk = l4i_chk;
        desc->byte_cnt = length;
-        desc->buf_ptr = dma_map_single(NULL, skb->data, length, DMA_TO_DEVICE);
+        desc->buf_ptr = dma_map_single(mp->dev->dev.parent, skb->data,
+                                       length, DMA_TO_DEVICE);
        __skb_queue_tail(&txq->tx_skb, skb);
@@ -956,10 +959,10 @@ static int txq_reclaim(struct tx_queue *txq, int budget, int force)
                }
                if (cmd_sts & TX_FIRST_DESC) {
-                        dma_unmap_single(NULL, desc->buf_ptr,
+                        dma_unmap_single(mp->dev->dev.parent, desc->buf_ptr,
                                         desc->byte_cnt, DMA_TO_DEVICE);
                } else {
-                        dma_unmap_page(NULL, desc->buf_ptr,
+                        dma_unmap_page(mp->dev->dev.parent, desc->buf_ptr,
                                       desc->byte_cnt, DMA_TO_DEVICE);
                }
@@ -1894,9 +1897,9 @@ static int rxq_init(struct mv643xx_eth_private *mp, int index)
                                                mp->rx_desc_sram_size);
                rxq->rx_desc_dma = mp->rx_desc_sram_addr;
        } else {
-                rxq->rx_desc_area = dma_alloc_coherent(NULL, size,
+                rxq->rx_desc_area = dma_alloc_coherent(mp->dev->dev.parent,
-                                                        &rxq->rx_desc_dma,
+                                                       size, &rxq->rx_desc_dma,
-                                                        GFP_KERNEL);
+                                                       GFP_KERNEL);
        }
        if (rxq->rx_desc_area == NULL) {
@@ -1947,7 +1950,7 @@ out_free:
        if (index == 0 && size <= mp->rx_desc_sram_size)
                iounmap(rxq->rx_desc_area);
        else
-                dma_free_coherent(NULL, size,
+                dma_free_coherent(mp->dev->dev.parent, size,
                                  rxq->rx_desc_area,
                                  rxq->rx_desc_dma);
@@ -1979,7 +1982,7 @@ static void rxq_deinit(struct rx_queue *rxq)
            rxq->rx_desc_area_size <= mp->rx_desc_sram_size)
                iounmap(rxq->rx_desc_area);
        else
-                dma_free_coherent(NULL, rxq->rx_desc_area_size,
+                dma_free_coherent(mp->dev->dev.parent, rxq->rx_desc_area_size,
                                  rxq->rx_desc_area, rxq->rx_desc_dma);
        kfree(rxq->rx_skb);
@@ -2007,9 +2010,9 @@ static int txq_init(struct mv643xx_eth_private *mp, int index)
                                                mp->tx_desc_sram_size);
                txq->tx_desc_dma = mp->tx_desc_sram_addr;
        } else {
-                txq->tx_desc_area = dma_alloc_coherent(NULL, size,
+                txq->tx_desc_area = dma_alloc_coherent(mp->dev->dev.parent,
-                                                        &txq->tx_desc_dma,
+                                                       size, &txq->tx_desc_dma,
-                                                        GFP_KERNEL);
+                                                       GFP_KERNEL);
        }
        if (txq->tx_desc_area == NULL) {
@@ -2053,7 +2056,7 @@ static void txq_deinit(struct tx_queue *txq)
            txq->tx_desc_area_size <= mp->tx_desc_sram_size)
                iounmap(txq->tx_desc_area);
        else
-                dma_free_coherent(NULL, txq->tx_desc_area_size,
+                dma_free_coherent(mp->dev->dev.parent, txq->tx_desc_area_size,
                                  txq->tx_desc_area, txq->tx_desc_dma);
 }
diff --git a/drivers/net/vxge/vxge-traffic.c b/drivers/net/vxge/vxge-traffic.c
index 7be0ae10d69b..c2eeac4125f3 100644
--- a/drivers/net/vxge/vxge-traffic.c
+++ b/drivers/net/vxge/vxge-traffic.c
@@ -115,7 +115,7 @@ enum vxge_hw_status vxge_hw_vpath_intr_enable(struct __vxge_hw_vpath_handle *vp)
                VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_POISON|
                VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO2_POISON|
                VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_DMA_ERR|
-                VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_DMA_ERR), 0, 32),
+                VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO2_DMA_ERR), 0, 32),
                &vp_reg->kdfcctl_errors_mask);
        __vxge_hw_pio_mem_write32_upper(0, &vp_reg->vpath_ppif_int_mask);
diff --git a/drivers/net/wimax/i2400m/rx.c b/drivers/net/wimax/i2400m/rx.c
index 02419bfd64b5..f9fc38902322 100644
--- a/drivers/net/wimax/i2400m/rx.c
+++ b/drivers/net/wimax/i2400m/rx.c
@@ -819,10 +819,9 @@ void i2400m_roq_queue_update_ws(struct i2400m *i2400m, struct i2400m_roq *roq,
                        roq_data = (struct i2400m_roq_data *) &skb->cb;
                        i2400m_net_erx(i2400m, skb, roq_data->cs);
                }
-                else {
+                else
                        __i2400m_roq_queue(i2400m, roq, skb, sn, nsn);
-                        __i2400m_roq_update_ws(i2400m, roq, sn + 1);
+                __i2400m_roq_update_ws(i2400m, roq, sn + 1);
-                }
                i2400m_roq_log_add(i2400m, roq, I2400M_RO_TYPE_PACKET_WS,
                                   old_ws, len, sn, nsn, roq->ws);
        }
diff --git a/drivers/regulator/da903x.c b/drivers/regulator/da903x.c
index 72b15495183c..c6628f5a0af7 100644
--- a/drivers/regulator/da903x.c
+++ b/drivers/regulator/da903x.c
@@ -497,7 +497,7 @@ static struct platform_driver da903x_regulator_driver = {
                .owner  = THIS_MODULE,
        },
        .probe          = da903x_regulator_probe,
-        .remove         = da903x_regulator_remove,
+        .remove         = __devexit_p(da903x_regulator_remove),
 };
 static int __init da903x_regulator_init(void)
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 0ab8474b00cb..d9fcdaedf389 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1487,14 +1487,7 @@ static int ftdi_sio_port_remove(struct usb_serial_port *port)
        remove_sysfs_attrs(port);
-        /* all open ports are closed at this point
+        kref_put(&priv->kref, ftdi_sio_priv_release);
-         *    (by usbserial.c:__serial_close, which calls ftdi_close)
-         */
-        if (priv) {
-                usb_set_serial_port_data(port, NULL);
-                kref_put(&priv->kref, ftdi_sio_priv_release);
-        }
        return 0;
 }