linux-imx

/*

 * Copyright (c) 2015, Daniel Thompson

 *

 * This file 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 file 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/clk.h>

#include <linux/delay.h>

#include <linux/hw_random.h>

#include <linux/io.h>

#include <linux/iopoll.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/of_address.h>

#include <linux/of_platform.h>

#include <linux/pm_runtime.h>

#include <linux/reset.h>

#include <linux/slab.h>

​

#define RNG_CR 0x00

#define RNG_CR_RNGEN BIT(2)

#define RNG_CR_CED BIT(5)

​

#define RNG_SR 0x04

#define RNG_SR_SEIS BIT(6)

#define RNG_SR_CEIS BIT(5)

#define RNG_SR_DRDY BIT(0)

​

#define RNG_DR 0x08

​

struct stm32_rng_private {

    struct hwrng rng;

    void __iomem *base;

    struct clk *clk;

    struct reset_control *rst;

    bool ced;

};

​

static int stm32_rng_read(struct hwrng *rng, void *data, size_t max, bool wait)

{

    struct stm32_rng_private *priv =

        container_of(rng, struct stm32_rng_private, rng);

    u32 sr;

    int retval = 0;

​

    pm_runtime_get_sync((struct device *) priv->rng.priv);

​

    while (max > sizeof(u32)) {

        sr = readl_relaxed(priv->base + RNG_SR);

        /* Manage timeout which is based on timer and take */

        /* care of initial delay time when enabling rng */

        if (!sr && wait) {

            retval = readl_relaxed_poll_timeout_atomic(priv->base

                                   + RNG_SR,

                                   sr, sr,

                                   10, 50000);

            if (retval)

                dev_err((struct device *)priv->rng.priv,

                    "%s: timeout %x!\n", __func__, sr);

        }

​

        /* If error detected or data not ready... */

        if (sr != RNG_SR_DRDY) {

            if (WARN_ONCE(sr & (RNG_SR_SEIS | RNG_SR_CEIS),

                    "bad RNG status - %x\n", sr))

                writel_relaxed(0, priv->base + RNG_SR);

            break;

        }

​

        *(u32 *)data = readl_relaxed(priv->base + RNG_DR);

​

        retval += sizeof(u32);

        data += sizeof(u32);

        max -= sizeof(u32);

    }

​

    pm_runtime_mark_last_busy((struct device *) priv->rng.priv);

    pm_runtime_put_sync_autosuspend((struct device *) priv->rng.priv);

​

    return retval || !wait ? retval : -EIO;

}

​

static int stm32_rng_init(struct hwrng *rng)

{