linux-imx

/*

 * Handle async block request by crypto hardware engine.

 *

 * Copyright (C) 2016 Linaro, Inc.

 *

 * Author: Baolin Wang <baolin.wang@linaro.org>

 *

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

 *

 */

​

#include <linux/err.h>

#include <linux/delay.h>

#include <crypto/engine.h>

#include <uapi/linux/sched/types.h>

#include "internal.h"

​

#define CRYPTO_ENGINE_MAX_QLEN 10

​

/**

 * crypto_finalize_request - finalize one request if the request is done

 * @engine: the hardware engine

 * @req: the request need to be finalized

 * @err: error number

 */

static void crypto_finalize_request(struct crypto_engine *engine,

                 struct crypto_async_request *req, int err)

{

    unsigned long flags;

    bool finalize_cur_req = false;

    int ret;

    struct crypto_engine_ctx *enginectx;

​

    spin_lock_irqsave(&engine->queue_lock, flags);

    if (engine->cur_req == req)

        finalize_cur_req = true;

    spin_unlock_irqrestore(&engine->queue_lock, flags);

​

    if (finalize_cur_req) {

        enginectx = crypto_tfm_ctx(req->tfm);

        if (engine->cur_req_prepared &&

            enginectx->op.unprepare_request) {

            ret = enginectx->op.unprepare_request(engine, req);

            if (ret)

                dev_err(engine->dev, "failed to unprepare request\n");

        }

        spin_lock_irqsave(&engine->queue_lock, flags);

        engine->cur_req = NULL;

        engine->cur_req_prepared = false;

        spin_unlock_irqrestore(&engine->queue_lock, flags);

    }

​

    req->complete(req, err);

​

    kthread_queue_work(engine->kworker, &engine->pump_requests);

}

​

/**

 * crypto_pump_requests - dequeue one request from engine queue to process

 * @engine: the hardware engine

 * @in_kthread: true if we are in the context of the request pump thread

 *

 * This function checks if there is any request in the engine queue that

 * needs processing and if so call out to the driver to initialize hardware

 * and handle each request.

 */

static void crypto_pump_requests(struct crypto_engine *engine,

                 bool in_kthread)

{

    struct crypto_async_request *async_req, *backlog;

    unsigned long flags;

    bool was_busy = false;

    int ret;

    struct crypto_engine_ctx *enginectx;

​

    spin_lock_irqsave(&engine->queue_lock, flags);

​

    /* Make sure we are not already running a request */

    if (engine->cur_req)

        goto out;

​

    /* If another context is idling then defer */

    if (engine->idling) {

        kthread_queue_work(engine->kworker, &engine->pump_requests);

        goto out;

    }

​

    /* Check if the engine queue is idle */

    if (!crypto_queue_len(&engine->queue) || !engine->running) {