Commit 8d9d4bdc authored by Tony Lindgren's avatar Tony Lindgren Committed by Herbert Xu

hwrng: omap3-rom - Use runtime PM instead of custom functions

Nowadays we have runtime PM, and we can use it with autosuspend_timeout
to idle things automatically. This allows us to get rid of the custom
PM implementation.

We enable clocks and init RNG in runtime_resume, and reset RNG and
disable clocks in runtime_suspend. And then omap3_rom_rng_read()
becomes very simple and we don't need the old functions for
omap3_rom_rng_idle() and omap3_rom_rng_get_random(). We can now also
get rid of pr_fmt as we're using dev_err instead.

Cc: Aaro Koskinen <aaro.koskinen@iki.fi>
Cc: Adam Ford <aford173@gmail.com>
Cc: Pali Rohár <pali.rohar@gmail.com>
Cc: Sebastian Reichel <sre@kernel.org>
Cc: Tero Kristo <t-kristo@ti.com>
Signed-off-by: default avatarTony Lindgren <tony@atomide.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent b8d665ae
...@@ -11,8 +11,6 @@ ...@@ -11,8 +11,6 @@
* warranty of any kind, whether express or implied. * warranty of any kind, whether express or implied.
*/ */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/random.h> #include <linux/random.h>
...@@ -23,73 +21,83 @@ ...@@ -23,73 +21,83 @@
#include <linux/of.h> #include <linux/of.h>
#include <linux/of_device.h> #include <linux/of_device.h>
#include <linux/platform_device.h> #include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#define RNG_RESET 0x01 #define RNG_RESET 0x01
#define RNG_GEN_PRNG_HW_INIT 0x02 #define RNG_GEN_PRNG_HW_INIT 0x02
#define RNG_GEN_HW 0x08 #define RNG_GEN_HW 0x08
/* param1: ptr, param2: count, param3: flag */
static u32 (*omap3_rom_rng_call)(u32, u32, u32);
struct omap_rom_rng { struct omap_rom_rng {
struct clk *clk; struct clk *clk;
struct device *dev; struct device *dev;
struct hwrng ops; struct hwrng ops;
u32 (*rom_rng_call)(u32 ptr, u32 count, u32 flag);
}; };
static struct delayed_work idle_work; static int omap3_rom_rng_read(struct hwrng *rng, void *data, size_t max, bool w)
static int rng_idle;
static struct clk *rng_clk;
static void omap3_rom_rng_idle(struct work_struct *work)
{ {
struct omap_rom_rng *ddata;
u32 ptr;
int r; int r;
r = omap3_rom_rng_call(0, 0, RNG_RESET); ddata = (struct omap_rom_rng *)rng->priv;
if (r != 0) {
pr_err("reset failed: %d\n", r); r = pm_runtime_get_sync(ddata->dev);
return; if (r < 0) {
pm_runtime_put_noidle(ddata->dev);
return r;
} }
clk_disable_unprepare(rng_clk);
rng_idle = 1; ptr = virt_to_phys(data);
r = ddata->rom_rng_call(ptr, 4, RNG_GEN_HW);
if (r != 0)
r = -EINVAL;
else
r = 4;
pm_runtime_mark_last_busy(ddata->dev);
pm_runtime_put_autosuspend(ddata->dev);
return r;
} }
static int omap3_rom_rng_get_random(void *buf, unsigned int count) static int omap_rom_rng_runtime_suspend(struct device *dev)
{ {
u32 r; struct omap_rom_rng *ddata;
u32 ptr; int r;
cancel_delayed_work_sync(&idle_work); ddata = dev_get_drvdata(dev);
if (rng_idle) {
r = clk_prepare_enable(rng_clk);
if (r)
return r;
r = omap3_rom_rng_call(0, 0, RNG_GEN_PRNG_HW_INIT);
if (r != 0) {
clk_disable_unprepare(rng_clk);
pr_err("HW init failed: %d\n", r);
return -EIO;
}
rng_idle = 0;
}
ptr = virt_to_phys(buf); r = ddata->rom_rng_call(0, 0, RNG_RESET);
r = omap3_rom_rng_call(ptr, count, RNG_GEN_HW);
schedule_delayed_work(&idle_work, msecs_to_jiffies(500));
if (r != 0) if (r != 0)
return -EINVAL; dev_err(dev, "reset failed: %d\n", r);
clk_disable_unprepare(ddata->clk);
return 0; return 0;
} }
static int omap3_rom_rng_read(struct hwrng *rng, void *data, size_t max, bool w) static int omap_rom_rng_runtime_resume(struct device *dev)
{ {
struct omap_rom_rng *ddata;
int r; int r;
r = omap3_rom_rng_get_random(data, 4); ddata = dev_get_drvdata(dev);
r = clk_prepare_enable(ddata->clk);
if (r < 0) if (r < 0)
return r; return r;
return 4;
r = ddata->rom_rng_call(0, 0, RNG_GEN_PRNG_HW_INIT);
if (r != 0) {
clk_disable(ddata->clk);
dev_err(dev, "HW init failed: %d\n", r);
return -EIO;
}
return 0;
} }
static int omap3_rom_rng_probe(struct platform_device *pdev) static int omap3_rom_rng_probe(struct platform_device *pdev)
...@@ -113,27 +121,33 @@ static int omap3_rom_rng_probe(struct platform_device *pdev) ...@@ -113,27 +121,33 @@ static int omap3_rom_rng_probe(struct platform_device *pdev)
} }
dev_set_drvdata(ddata->dev, ddata); dev_set_drvdata(ddata->dev, ddata);
omap3_rom_rng_call = pdev->dev.platform_data; ddata->rom_rng_call = pdev->dev.platform_data;
if (!omap3_rom_rng_call) { if (!ddata->rom_rng_call) {
dev_err(ddata->dev, "rom_rng_call is NULL\n"); dev_err(ddata->dev, "rom_rng_call is NULL\n");
return -EINVAL; return -EINVAL;
} }
INIT_DELAYED_WORK(&idle_work, omap3_rom_rng_idle);
ddata->clk = devm_clk_get(ddata->dev, "ick"); ddata->clk = devm_clk_get(ddata->dev, "ick");
if (IS_ERR(ddata->clk)) { if (IS_ERR(ddata->clk)) {
dev_err(ddata->dev, "unable to get RNG clock\n"); dev_err(ddata->dev, "unable to get RNG clock\n");
return PTR_ERR(ddata->clk); return PTR_ERR(ddata->clk);
} }
rng_clk = ddata->clk;
/* Leave the RNG in reset state. */ pm_runtime_enable(ddata->dev);
ret = clk_prepare_enable(ddata->clk);
if (ret) ret = hwrng_register(&ddata->ops);
return ret; if (!ret)
omap3_rom_rng_idle(0); goto err_disable;
pm_runtime_set_autosuspend_delay(ddata->dev, 500);
pm_runtime_use_autosuspend(ddata->dev);
return 0;
return hwrng_register(&ddata->ops); err_disable:
pm_runtime_disable(ddata->dev);
return ret;
} }
static int omap3_rom_rng_remove(struct platform_device *pdev) static int omap3_rom_rng_remove(struct platform_device *pdev)
...@@ -141,10 +155,10 @@ static int omap3_rom_rng_remove(struct platform_device *pdev) ...@@ -141,10 +155,10 @@ static int omap3_rom_rng_remove(struct platform_device *pdev)
struct omap_rom_rng *ddata; struct omap_rom_rng *ddata;
ddata = dev_get_drvdata(&pdev->dev); ddata = dev_get_drvdata(&pdev->dev);
cancel_delayed_work_sync(&idle_work);
hwrng_unregister(&ddata->ops); hwrng_unregister(&ddata->ops);
if (!rng_idle) pm_runtime_dont_use_autosuspend(ddata->dev);
clk_disable_unprepare(rng_clk); pm_runtime_disable(ddata->dev);
return 0; return 0;
} }
...@@ -154,10 +168,16 @@ static const struct of_device_id omap_rom_rng_match[] = { ...@@ -154,10 +168,16 @@ static const struct of_device_id omap_rom_rng_match[] = {
}; };
MODULE_DEVICE_TABLE(of, omap_rom_rng_match); MODULE_DEVICE_TABLE(of, omap_rom_rng_match);
static const struct dev_pm_ops omap_rom_rng_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(omap_rom_rng_runtime_suspend,
omap_rom_rng_runtime_resume)
};
static struct platform_driver omap3_rom_rng_driver = { static struct platform_driver omap3_rom_rng_driver = {
.driver = { .driver = {
.name = "omap3-rom-rng", .name = "omap3-rom-rng",
.of_match_table = omap_rom_rng_match, .of_match_table = omap_rom_rng_match,
.pm = &omap_rom_rng_pm_ops,
}, },
.probe = omap3_rom_rng_probe, .probe = omap3_rom_rng_probe,
.remove = omap3_rom_rng_remove, .remove = omap3_rom_rng_remove,
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment