Merge branch 'md-raid6-accel' into ioat3.2

Conflicts:
	include/linux/dmaengine.h

diff --cc arch/arm/mach-iop13xx/setup.c
Simple merge

diff --cc arch/arm/plat-iop/adma.c
Simple merge

diff --cc drivers/dma/dmaengine.c
Simple merge

diff --cc drivers/dma/dmatest.c
Simple merge

diff --cc drivers/md/raid5.c
index bb37fb1,364ea37..0a5cf21
--- 1/drivers/md/raid5.c
--- 2/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@@ -3187,9 -3383,21 +3383,21 @@@ static bool handle_stripe6(struct strip
                        }
                }
  
-       if (s.expanded && test_bit(STRIPE_EXPANDING, &sh->state)) {
+       /* Finish reconstruct operations initiated by the expansion process */
+       if (sh->reconstruct_state == reconstruct_state_result) {
+               sh->reconstruct_state = reconstruct_state_idle;
+               clear_bit(STRIPE_EXPANDING, &sh->state);
+               for (i = conf->raid_disks; i--; ) {
+                       set_bit(R5_Wantwrite, &sh->dev[i].flags);
+                       set_bit(R5_LOCKED, &sh->dev[i].flags);
+                       s.locked++;
+               }
+       }
+ 
+       if (s.expanded && test_bit(STRIPE_EXPANDING, &sh->state) &&
+           !sh->reconstruct_state) {
                struct stripe_head *sh2
 -                      = get_active_stripe(conf, sh->sector, 1, 1);
 +                      = get_active_stripe(conf, sh->sector, 1, 1, 1);
                if (sh2 && test_bit(STRIPE_EXPAND_SOURCE, &sh2->state)) {
                        /* sh cannot be written until sh2 has been read.
                         * so arrange for sh to be delayed a little

diff --cc include/linux/dmaengine.h
index ffefba8,ce010cd..1012f1a
--- 1/include/linux/dmaengine.h
--- 2/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@@ -70,26 -70,28 +70,34 @@@ enum dma_transaction_type 
  
  /**
   * enum dma_ctrl_flags - DMA flags to augment operation preparation,
-  *    control completion, and communicate status.
+  *  control completion, and communicate status.
   * @DMA_PREP_INTERRUPT - trigger an interrupt (callback) upon completion of
-  *    this transaction
+  *  this transaction
   * @DMA_CTRL_ACK - the descriptor cannot be reused until the client
-  *    acknowledges receipt, i.e. has has a chance to establish any
-  *    dependency chains
+  *  acknowledges receipt, i.e. has has a chance to establish any dependency
+  *  chains
   * @DMA_COMPL_SKIP_SRC_UNMAP - set to disable dma-unmapping the source buffer(s)
   * @DMA_COMPL_SKIP_DEST_UNMAP - set to disable dma-unmapping the destination(s)
 + * @DMA_COMPL_SRC_UNMAP_SINGLE - set to do the source dma-unmapping as single
 + *    (if not set, do the source dma-unmapping as page)
 + * @DMA_COMPL_DEST_UNMAP_SINGLE - set to do the destination dma-unmapping as single
 + *    (if not set, do the destination dma-unmapping as page)
+  * @DMA_PREP_PQ_DISABLE_P - prevent generation of P while generating Q
+  * @DMA_PREP_PQ_DISABLE_Q - prevent generation of Q while generating P
+  * @DMA_PREP_CONTINUE - indicate to a driver that it is reusing buffers as
+  *  sources that were the result of a previous operation, in the case of a PQ
+  *  operation it continues the calculation with new sources
   */
  enum dma_ctrl_flags {
        DMA_PREP_INTERRUPT = (1 << 0),
        DMA_CTRL_ACK = (1 << 1),
        DMA_COMPL_SKIP_SRC_UNMAP = (1 << 2),
        DMA_COMPL_SKIP_DEST_UNMAP = (1 << 3),
 -      DMA_PREP_PQ_DISABLE_P = (1 << 4),
 -      DMA_PREP_PQ_DISABLE_Q = (1 << 5),
 -      DMA_PREP_CONTINUE = (1 << 6),
 +      DMA_COMPL_SRC_UNMAP_SINGLE = (1 << 4),
 +      DMA_COMPL_DEST_UNMAP_SINGLE = (1 << 5),
++      DMA_PREP_PQ_DISABLE_P = (1 << 6),
++      DMA_PREP_PQ_DISABLE_Q = (1 << 7),
++      DMA_PREP_CONTINUE = (1 << 8),
  };
  
  /**