linux-imx

/*

 * Copyright(c) 2007 Yuri Tikhonov <yur@emcraft.com>

 * Copyright(c) 2009 Intel Corporation

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by the Free

 * Software Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc., 59

 * Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 *

 * The full GNU General Public License is included in this distribution in the

 * file called COPYING.

 */

#include <linux/kernel.h>

#include <linux/interrupt.h>

#include <linux/module.h>

#include <linux/dma-mapping.h>

#include <linux/raid/pq.h>

#include <linux/async_tx.h>

#include <linux/gfp.h>

​

/**

 * pq_scribble_page - space to hold throwaway P or Q buffer for

 * synchronous gen_syndrome

 */

static struct page *pq_scribble_page;

​

/* the struct page *blocks[] parameter passed to async_gen_syndrome()

 * and async_syndrome_val() contains the 'P' destination address at

 * blocks[disks-2] and the 'Q' destination address at blocks[disks-1]

 *

 * note: these are macros as they are used as lvalues

 */

#define P(b, d) (b[d-2])

#define Q(b, d) (b[d-1])

​

#define MAX_DISKS 255

​

/**

 * do_async_gen_syndrome - asynchronously calculate P and/or Q

 */

static __async_inline struct dma_async_tx_descriptor *

do_async_gen_syndrome(struct dma_chan *chan,

              const unsigned char *scfs, int disks,

              struct dmaengine_unmap_data *unmap,

              enum dma_ctrl_flags dma_flags,

              struct async_submit_ctl *submit)

{

    struct dma_async_tx_descriptor *tx = NULL;

    struct dma_device *dma = chan->device;

    enum async_tx_flags flags_orig = submit->flags;

    dma_async_tx_callback cb_fn_orig = submit->cb_fn;

    dma_async_tx_callback cb_param_orig = submit->cb_param;

    int src_cnt = disks - 2;

    unsigned short pq_src_cnt;

    dma_addr_t dma_dest[2];

    int src_off = 0;

​

    while (src_cnt > 0) {

        submit->flags = flags_orig;

        pq_src_cnt = min(src_cnt, dma_maxpq(dma, dma_flags));

        /* if we are submitting additional pqs, leave the chain open,

         * clear the callback parameters, and leave the destination

         * buffers mapped

         */

        if (src_cnt > pq_src_cnt) {

            submit->flags &= ~ASYNC_TX_ACK;

            submit->flags |= ASYNC_TX_FENCE;

            submit->cb_fn = NULL;

            submit->cb_param = NULL;

        } else {

            submit->cb_fn = cb_fn_orig;

            submit->cb_param = cb_param_orig;

            if (cb_fn_orig)

                dma_flags |= DMA_PREP_INTERRUPT;

        }

        if (submit->flags & ASYNC_TX_FENCE)

            dma_flags |= DMA_PREP_FENCE;

​

        /* Drivers force forward progress in case they can not provide

         * a descriptor

         */

        for (;;) {

            dma_dest[0] = unmap->addr[disks - 2];