Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

20 files changed, 140 insertions, 67 deletions

diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index 3263b68cdfa3..3188da3df8da 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -250,6 +250,10 @@ static int __acpi_bus_set_power(struct acpi_device *device, int state)
                 return -ENODEV;
         }
 
+        /* For D3cold we should execute _PS3, not _PS4. */
+        if (state == ACPI_STATE_D3_COLD)
+                object_name[3] = '3';
+
         /*
          * Transition Power
          * ----------------
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 330bb4d75852..0500f719f63e 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -660,7 +660,7 @@ int acpi_power_on_resources(struct acpi_device *device, int state)
 
 int acpi_power_transition(struct acpi_device *device, int state)
 {
-        int result;
+        int result = 0;
 
         if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
                 return -EINVAL;
@@ -679,8 +679,11 @@ int acpi_power_transition(struct acpi_device *device, int state)
          * (e.g. so the device doesn't lose power while transitioning).  Then,
          * we dereference all power resources used in the current list.
          */
-        result = acpi_power_on_list(&device->power.states[state].resources);
-        if (!result)
+        if (state < ACPI_STATE_D3_COLD)
+                result = acpi_power_on_list(
+                        &device->power.states[state].resources);
+
+        if (!result && device->power.state < ACPI_STATE_D3_COLD)
                 acpi_power_off_list(
                         &device->power.states[device->power.state].resources);
 
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 7417267e88fa..85cbfdccc97c 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -908,6 +908,10 @@ static int acpi_bus_get_power_flags(struct acpi_device *device)
         device->power.states[ACPI_STATE_D3].flags.valid = 1;
         device->power.states[ACPI_STATE_D3].power = 0;
 
+        /* Set D3cold's explicit_set flag if _PS3 exists. */
+        if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
+                device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;
+
         acpi_bus_init_power(device);
 
         return 0;
diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 8db9089127c5..9a13e889837e 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -6580,24 +6580,21 @@ static const struct file_operations dac960_user_command_proc_fops = {
 
 static void DAC960_CreateProcEntries(DAC960_Controller_T *Controller)
 {
-        struct proc_dir_entry *StatusProcEntry;
         struct proc_dir_entry *ControllerProcEntry;
-        struct proc_dir_entry *UserCommandProcEntry;
 
         if (DAC960_ProcDirectoryEntry == NULL) {
-                DAC960_ProcDirectoryEntry = proc_mkdir("rd", NULL);
-                StatusProcEntry = proc_create("status", 0,
-                                           DAC960_ProcDirectoryEntry,
-                                           &dac960_proc_fops);
+                DAC960_ProcDirectoryEntry = proc_mkdir("rd", NULL);
+                proc_create("status", 0, DAC960_ProcDirectoryEntry,
+                            &dac960_proc_fops);
         }
 
-      sprintf(Controller->ControllerName, "c%d", Controller->ControllerNumber);
-      ControllerProcEntry = proc_mkdir(Controller->ControllerName,
-                                       DAC960_ProcDirectoryEntry);
-      proc_create_data("initial_status", 0, ControllerProcEntry, &dac960_initial_status_proc_fops, Controller);
-      proc_create_data("current_status", 0, ControllerProcEntry, &dac960_current_status_proc_fops, Controller);
-      UserCommandProcEntry = proc_create_data("user_command", S_IWUSR | S_IRUSR, ControllerProcEntry, &dac960_user_command_proc_fops, Controller);
-      Controller->ControllerProcEntry = ControllerProcEntry;
+        sprintf(Controller->ControllerName, "c%d", Controller->ControllerNumber);
+        ControllerProcEntry = proc_mkdir(Controller->ControllerName,
+                                         DAC960_ProcDirectoryEntry);
+        proc_create_data("initial_status", 0, ControllerProcEntry, &dac960_initial_status_proc_fops, Controller);
+        proc_create_data("current_status", 0, ControllerProcEntry, &dac960_current_status_proc_fops, Controller);
+        proc_create_data("user_command", S_IWUSR | S_IRUSR, ControllerProcEntry, &dac960_user_command_proc_fops, Controller);
+        Controller->ControllerProcEntry = ControllerProcEntry;
 }
 
 
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 00f9fc992090..304000c3d433 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -2510,8 +2510,10 @@ static struct scatterlist *mtip_hw_get_scatterlist(struct driver_data *dd,
                 up(&dd->port->cmd_slot);
                 return NULL;
         }
-        if (unlikely(*tag < 0))
+        if (unlikely(*tag < 0)) {
+                up(&dd->port->cmd_slot);
                 return NULL;
+        }
 
         return dd->port->commands[*tag].sg;
 }
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index ddf86b6500b7..cdf2f5451c76 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -1895,6 +1895,13 @@ static int virtcons_restore(struct virtio_device *vdev)
 
                 /* Get port open/close status on the host */
                 send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
+
+                /*
+                 * If a port was open at the time of suspending, we
+                 * have to let the host know that it's still open.
+                 */
+                if (port->guest_connected)
+                        send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
         }
         return 0;
 }
diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
index ab9abb46d01a..dd414d9350ef 100644
--- a/drivers/crypto/Kconfig
+++ b/drivers/crypto/Kconfig
@@ -164,6 +164,7 @@ config CRYPTO_DEV_MV_CESA
         select CRYPTO_ALGAPI
         select CRYPTO_AES
         select CRYPTO_BLKCIPHER2
+        select CRYPTO_HASH
         help
           This driver allows you to utilize the Cryptographic Engines and
           Security Accelerator (CESA) which can be found on the Marvell Orion
diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c
index 445fdf811695..bf0d7e4e345b 100644
--- a/drivers/dma/at_hdmac.c
+++ b/drivers/dma/at_hdmac.c
@@ -245,7 +245,9 @@ atc_chain_complete(struct at_dma_chan *atchan, struct at_desc *desc)
         dev_vdbg(chan2dev(&atchan->chan_common),
                 "descriptor %u complete\n", txd->cookie);
 
-        dma_cookie_complete(txd);
+        /* mark the descriptor as complete for non cyclic cases only */
+        if (!atc_chan_is_cyclic(atchan))
+                dma_cookie_complete(txd);
 
         /* move children to free_list */
         list_splice_init(&desc->tx_list, &atchan->free_list);
diff --git a/drivers/dma/ep93xx_dma.c b/drivers/dma/ep93xx_dma.c
index e6f133b78dc2..f6e9b572b998 100644
--- a/drivers/dma/ep93xx_dma.c
+++ b/drivers/dma/ep93xx_dma.c
@@ -703,7 +703,9 @@ static void ep93xx_dma_tasklet(unsigned long data)
         desc = ep93xx_dma_get_active(edmac);
         if (desc) {
                 if (desc->complete) {
-                        dma_cookie_complete(&desc->txd);
+                        /* mark descriptor complete for non cyclic case only */
+                        if (!test_bit(EP93XX_DMA_IS_CYCLIC, &edmac->flags))
+                                dma_cookie_complete(&desc->txd);
                         list_splice_init(&edmac->active, &list);
                 }
                 callback = desc->txd.callback;
diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
index 2ee6e23930ad..fa3fb21e60be 100644
--- a/drivers/dma/pl330.c
+++ b/drivers/dma/pl330.c
@@ -2322,7 +2322,8 @@ static void pl330_tasklet(unsigned long data)
         /* Pick up ripe tomatoes */
         list_for_each_entry_safe(desc, _dt, &pch->work_list, node)
                 if (desc->status == DONE) {
-                        dma_cookie_complete(&desc->txd);
+                        if (pch->cyclic)
+                                dma_cookie_complete(&desc->txd);
                         list_move_tail(&desc->node, &list);
                 }
 
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 2fd87b544a93..eb3d138ff55a 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -1632,6 +1632,21 @@ static int bind_control_target(struct pool *pool, struct dm_target *ti)
         pool->low_water_blocks = pt->low_water_blocks;
         pool->pf = pt->pf;
 
+        /*
+         * If discard_passdown was enabled verify that the data device
+         * supports discards.  Disable discard_passdown if not; otherwise
+         * -EOPNOTSUPP will be returned.
+         */
+        if (pt->pf.discard_passdown) {
+                struct request_queue *q = bdev_get_queue(pt->data_dev->bdev);
+                if (!q || !blk_queue_discard(q)) {
+                        char buf[BDEVNAME_SIZE];
+                        DMWARN("Discard unsupported by data device (%s): Disabling discard passdown.",
+                               bdevname(pt->data_dev->bdev, buf));
+                        pool->pf.discard_passdown = 0;
+                }
+        }
+
         return 0;
 }
 
@@ -1988,19 +2003,6 @@ static int pool_ctr(struct dm_target *ti, unsigned argc, char **argv)
                 goto out_flags_changed;
         }
 
-        /*
-         * If discard_passdown was enabled verify that the data device
-         * supports discards.  Disable discard_passdown if not; otherwise
-         * -EOPNOTSUPP will be returned.
-         */
-        if (pf.discard_passdown) {
-                struct request_queue *q = bdev_get_queue(data_dev->bdev);
-                if (!q || !blk_queue_discard(q)) {
-                        DMWARN("Discard unsupported by data device: Disabling discard passdown.");
-                        pf.discard_passdown = 0;
-                }
-        }
-
         pt->pool = pool;
         pt->ti = ti;
         pt->metadata_dev = metadata_dev;
@@ -2385,7 +2387,7 @@ static int pool_status(struct dm_target *ti, status_type_t type,
                        (unsigned long long)pt->low_water_blocks);
 
                 count = !pool->pf.zero_new_blocks + !pool->pf.discard_enabled +
-                        !pool->pf.discard_passdown;
+                        !pt->pf.discard_passdown;
                 DMEMIT("%u ", count);
 
                 if (!pool->pf.zero_new_blocks)
@@ -2394,7 +2396,7 @@ static int pool_status(struct dm_target *ti, status_type_t type,
                 if (!pool->pf.discard_enabled)
                         DMEMIT("ignore_discard ");
 
-                if (!pool->pf.discard_passdown)
+                if (!pt->pf.discard_passdown)
                         DMEMIT("no_discard_passdown ");
 
                 break;
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 477eb2e180c0..01233d855eb2 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -391,6 +391,8 @@ void mddev_suspend(struct mddev *mddev)
         synchronize_rcu();
         wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
         mddev->pers->quiesce(mddev, 1);
+
+        del_timer_sync(&mddev->safemode_timer);
 }
 EXPORT_SYMBOL_GPL(mddev_suspend);
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index c8dbb84d5357..3f91c2e1dfe7 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -3164,12 +3164,40 @@ raid10_size(struct mddev *mddev, sector_t sectors, int raid_disks)
         return size << conf->chunk_shift;
 }
 
+static void calc_sectors(struct r10conf *conf, sector_t size)
+{
+        /* Calculate the number of sectors-per-device that will
+         * actually be used, and set conf->dev_sectors and
+         * conf->stride
+         */
+
+        size = size >> conf->chunk_shift;
+        sector_div(size, conf->far_copies);
+        size = size * conf->raid_disks;
+        sector_div(size, conf->near_copies);
+        /* 'size' is now the number of chunks in the array */
+        /* calculate "used chunks per device" */
+        size = size * conf->copies;
+
+        /* We need to round up when dividing by raid_disks to
+         * get the stride size.
+         */
+        size = DIV_ROUND_UP_SECTOR_T(size, conf->raid_disks);
+
+        conf->dev_sectors = size << conf->chunk_shift;
+
+        if (conf->far_offset)
+                conf->stride = 1 << conf->chunk_shift;
+        else {
+                sector_div(size, conf->far_copies);
+                conf->stride = size << conf->chunk_shift;
+        }
+}
 
 static struct r10conf *setup_conf(struct mddev *mddev)
 {
         struct r10conf *conf = NULL;
         int nc, fc, fo;
-        sector_t stride, size;
         int err = -EINVAL;
 
         if (mddev->new_chunk_sectors < (PAGE_SIZE >> 9) ||
@@ -3219,28 +3247,7 @@ static struct r10conf *setup_conf(struct mddev *mddev)
         if (!conf->r10bio_pool)
                 goto out;
 
-        size = mddev->dev_sectors >> conf->chunk_shift;
-        sector_div(size, fc);
-        size = size * conf->raid_disks;
-        sector_div(size, nc);
-        /* 'size' is now the number of chunks in the array */
-        /* calculate "used chunks per device" in 'stride' */
-        stride = size * conf->copies;
-
-        /* We need to round up when dividing by raid_disks to
-         * get the stride size.
-         */
-        stride += conf->raid_disks - 1;
-        sector_div(stride, conf->raid_disks);
-
-        conf->dev_sectors = stride << conf->chunk_shift;
-
-        if (fo)
-                stride = 1;
-        else
-                sector_div(stride, fc);
-        conf->stride = stride << conf->chunk_shift;
-
+        calc_sectors(conf, mddev->dev_sectors);
 
         spin_lock_init(&conf->device_lock);
         INIT_LIST_HEAD(&conf->retry_list);
@@ -3468,7 +3475,8 @@ static int raid10_resize(struct mddev *mddev, sector_t sectors)
                 mddev->recovery_cp = oldsize;
                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
         }
-        mddev->dev_sectors = sectors;
+        calc_sectors(conf, sectors);
+        mddev->dev_sectors = conf->dev_sectors;
         mddev->resync_max_sectors = size;
         return 0;
 }
diff --git a/drivers/net/ethernet/intel/e1000/e1000_main.c b/drivers/net/ethernet/intel/e1000/e1000_main.c
index 37b7d1c90723..95731c841044 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_main.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_main.c
@@ -493,7 +493,11 @@ out:
 static void e1000_down_and_stop(struct e1000_adapter *adapter)
 {
         set_bit(__E1000_DOWN, &adapter->flags);
-        cancel_work_sync(&adapter->reset_task);
+
+        /* Only kill reset task if adapter is not resetting */
+        if (!test_bit(__E1000_RESETTING, &adapter->flags))
+                cancel_work_sync(&adapter->reset_task);
+
         cancel_delayed_work_sync(&adapter->watchdog_task);
         cancel_delayed_work_sync(&adapter->phy_info_task);
         cancel_delayed_work_sync(&adapter->fifo_stall_task);
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index fa58c7869954..9ce6995e8d08 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -501,7 +501,9 @@ static void virtnet_napi_enable(struct virtnet_info *vi)
          * We synchronize against interrupts via NAPI_STATE_SCHED */
         if (napi_schedule_prep(&vi->napi)) {
                 virtqueue_disable_cb(vi->rvq);
+                local_bh_disable();
                 __napi_schedule(&vi->napi);
+                local_bh_enable();
         }
 }
 
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 1929c0c63b75..61e2fefeedab 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -223,7 +223,7 @@ static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
                 [PCI_D0] = ACPI_STATE_D0,
                 [PCI_D1] = ACPI_STATE_D1,
                 [PCI_D2] = ACPI_STATE_D2,
-                [PCI_D3hot] = ACPI_STATE_D3_HOT,
+                [PCI_D3hot] = ACPI_STATE_D3,
                 [PCI_D3cold] = ACPI_STATE_D3
         };
         int error = -EINVAL;
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
index 684ef4bbfce4..f027c063fb20 100644
--- a/drivers/rtc/rtc-pl031.c
+++ b/drivers/rtc/rtc-pl031.c
@@ -312,6 +312,7 @@ static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
         int ret;
         struct pl031_local *ldata;
         struct rtc_class_ops *ops = id->data;
+        unsigned long time;
 
         ret = amba_request_regions(adev, NULL);
         if (ret)
@@ -343,6 +344,23 @@ static int pl031_probe(struct amba_device *adev, const struct amba_id *id)
                 writel(readl(ldata->base + RTC_CR) | RTC_CR_CWEN,
                        ldata->base + RTC_CR);
 
+        /*
+         * On ST PL031 variants, the RTC reset value does not provide correct
+         * weekday for 2000-01-01. Correct the erroneous sunday to saturday.
+         */
+        if (ldata->hw_designer == AMBA_VENDOR_ST) {
+                if (readl(ldata->base + RTC_YDR) == 0x2000) {
+                        time = readl(ldata->base + RTC_DR);
+                        if ((time &
+                             (RTC_MON_MASK | RTC_MDAY_MASK | RTC_WDAY_MASK))
+                            == 0x02120000) {
+                                time = time | (0x7 << RTC_WDAY_SHIFT);
+                                writel(0x2000, ldata->base + RTC_YLR);
+                                writel(time, ldata->base + RTC_LR);
+                        }
+                }
+        }
+
         ldata->rtc = rtc_device_register("pl031", &adev->dev, ops,
                                         THIS_MODULE);
         if (IS_ERR(ldata->rtc)) {
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index 7ed58e2df791..f286955331a2 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -169,6 +169,7 @@ static struct se_device *fd_create_virtdevice(
         inode = file->f_mapping->host;
         if (S_ISBLK(inode->i_mode)) {
                 struct request_queue *q;
+                unsigned long long dev_size;
                 /*
                  * Setup the local scope queue_limits from struct request_queue->limits
                  * to pass into transport_add_device_to_core_hba() as struct se_dev_limits.
@@ -183,13 +184,12 @@ static struct se_device *fd_create_virtdevice(
                  * one (1) logical sector from underlying struct block_device
                  */
                 fd_dev->fd_block_size = bdev_logical_block_size(inode->i_bdev);
-                fd_dev->fd_dev_size = (i_size_read(file->f_mapping->host) -
+                dev_size = (i_size_read(file->f_mapping->host) -
                                        fd_dev->fd_block_size);
 
                 pr_debug("FILEIO: Using size: %llu bytes from struct"
                         " block_device blocks: %llu logical_block_size: %d\n",
-                        fd_dev->fd_dev_size,
-                        div_u64(fd_dev->fd_dev_size, fd_dev->fd_block_size),
+                        dev_size, div_u64(dev_size, fd_dev->fd_block_size),
                         fd_dev->fd_block_size);
         } else {
                 if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
@@ -605,10 +605,20 @@ static u32 fd_get_device_type(struct se_device *dev)
 static sector_t fd_get_blocks(struct se_device *dev)
 {
         struct fd_dev *fd_dev = dev->dev_ptr;
-        unsigned long long blocks_long = div_u64(fd_dev->fd_dev_size,
-                        dev->se_sub_dev->se_dev_attrib.block_size);
+        struct file *f = fd_dev->fd_file;
+        struct inode *i = f->f_mapping->host;
+        unsigned long long dev_size;
+        /*
+         * When using a file that references an underlying struct block_device,
+         * ensure dev_size is always based on the current inode size in order
+         * to handle underlying block_device resize operations.
+         */
+        if (S_ISBLK(i->i_mode))
+                dev_size = (i_size_read(i) - fd_dev->fd_block_size);
+        else
+                dev_size = fd_dev->fd_dev_size;
 
-        return blocks_long;
+        return div_u64(dev_size, dev->se_sub_dev->se_dev_attrib.block_size);
 }
 
 static struct se_subsystem_api fileio_template = {
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 86f0c3b5d500..c3148b10b4b3 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -220,6 +220,9 @@ int target_scsi2_reservation_release(struct se_task *task)
         if (dev->dev_reserved_node_acl != sess->se_node_acl)
                 goto out_unlock;
 
+        if (dev->dev_res_bin_isid != sess->sess_bin_isid)
+                goto out_unlock;
+
         dev->dev_reserved_node_acl = NULL;
         dev->dev_flags &= ~DF_SPC2_RESERVATIONS;
         if (dev->dev_flags & DF_SPC2_RESERVATIONS_WITH_ISID) {
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index c2d05a8279fd..8807fe501d20 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -390,6 +390,7 @@ static void __devexit virtballoon_remove(struct virtio_device *vdev)
         /* There might be pages left in the balloon: free them. */
         while (vb->num_pages)
                 leak_balloon(vb, vb->num_pages);
+        update_balloon_size(vb);
 
         /* Now we reset the device so we can clean up the queues. */
         vdev->config->reset(vdev);