linux-imx

/*

 * Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.

 *

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

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * 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.

 */

​

#include <linux/device.h>

#include <linux/interrupt.h>

#include <linux/types.h>

#include <crypto/aes.h>

#include <crypto/des.h>

#include <crypto/internal/skcipher.h>

​

#include "cipher.h"

​

static LIST_HEAD(ablkcipher_algs);

​

static void qce_ablkcipher_done(void *data)

{

    struct crypto_async_request *async_req = data;

    struct ablkcipher_request *req = ablkcipher_request_cast(async_req);

    struct qce_cipher_reqctx *rctx = ablkcipher_request_ctx(req);

    struct qce_alg_template *tmpl = to_cipher_tmpl(async_req->tfm);

    struct qce_device *qce = tmpl->qce;

    enum dma_data_direction dir_src, dir_dst;

    u32 status;

    int error;

    bool diff_dst;

​

    diff_dst = (req->src != req->dst) ? true : false;

    dir_src = diff_dst ? DMA_TO_DEVICE : DMA_BIDIRECTIONAL;

    dir_dst = diff_dst ? DMA_FROM_DEVICE : DMA_BIDIRECTIONAL;

​

    error = qce_dma_terminate_all(&qce->dma);

    if (error)

        dev_dbg(qce->dev, "ablkcipher dma termination error (%d)\n",

            error);

​

    if (diff_dst)

        dma_unmap_sg(qce->dev, rctx->src_sg, rctx->src_nents, dir_src);

    dma_unmap_sg(qce->dev, rctx->dst_sg, rctx->dst_nents, dir_dst);

​

    sg_free_table(&rctx->dst_tbl);

​

    error = qce_check_status(qce, &status);

    if (error < 0)

        dev_dbg(qce->dev, "ablkcipher operation error (%x)\n", status);

​

    qce->async_req_done(tmpl->qce, error);

}

​

static int

qce_ablkcipher_async_req_handle(struct crypto_async_request *async_req)

{

    struct ablkcipher_request *req = ablkcipher_request_cast(async_req);

    struct qce_cipher_reqctx *rctx = ablkcipher_request_ctx(req);

    struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req);

    struct qce_alg_template *tmpl = to_cipher_tmpl(async_req->tfm);

    struct qce_device *qce = tmpl->qce;

    enum dma_data_direction dir_src, dir_dst;

    struct scatterlist *sg;

    bool diff_dst;

    gfp_t gfp;

    int ret;

​

    rctx->iv = req->info;

    rctx->ivsize = crypto_ablkcipher_ivsize(ablkcipher);

    rctx->cryptlen = req->nbytes;

​

    diff_dst = (req->src != req->dst) ? true : false;

    dir_src = diff_dst ? DMA_TO_DEVICE : DMA_BIDIRECTIONAL;

    dir_dst = diff_dst ? DMA_FROM_DEVICE : DMA_BIDIRECTIONAL;

​

    rctx->src_nents = sg_nents_for_len(req->src, req->nbytes);

    if (diff_dst)

        rctx->dst_nents = sg_nents_for_len(req->dst, req->nbytes);

    else

        rctx->dst_nents = rctx->src_nents;

    if (rctx->src_nents < 0) {

        dev_err(qce->dev, "Invalid numbers of src SG.\n");

        return rctx->src_nents;

    }

    if (rctx->dst_nents < 0) {

        dev_err(qce->dev, "Invalid numbers of dst SG.\n");

        return -rctx->dst_nents;