Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6

Pull crypto update from Herbert Xu:
 - Optimised AES/SHA1 for ARM.
 - IPsec ESN support in talitos and caam.
 - x86_64/avx implementation of cast5/cast6.
 - Add/use multi-algorithm registration helpers where possible.
 - Added IBM Power7+ in-Nest support.
 - Misc fixes.

Fix up trivial conflicts in crypto/Kconfig due to the sparc64 crypto
config options being added next to the new ARM ones.

[ Side note: cut-and-paste duplicate help texts make those conflicts
  harder to read than necessary, thanks to git being smart about
  minimizing conflicts and maximizing the common parts... ]

* git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6: (71 commits)
  crypto: x86/glue_helper - fix storing of new IV in CBC encryption
  crypto: cast5/avx - fix storing of new IV in CBC encryption
  crypto: tcrypt - add missing tests for camellia and ghash
  crypto: testmgr - make test_aead also test 'dst != src' code paths
  crypto: testmgr - make test_skcipher also test 'dst != src' code paths
  crypto: testmgr - add test vectors for CTR mode IV increasement
  crypto: testmgr - add test vectors for partial ctr(cast5) and ctr(cast6)
  crypto: testmgr - allow non-multi page and multi page skcipher tests from same test template
  crypto: caam - increase TRNG clocks per sample
  crypto, tcrypt: remove local_bh_disable/enable() around local_irq_disable/enable()
  crypto: tegra-aes - fix error return code
  crypto: crypto4xx - fix error return code
  crypto: hifn_795x - fix error return code
  crypto: ux500 - fix error return code
  crypto: caam - fix error IDs for SEC v5.x RNG4
  hwrng: mxc-rnga - Access data via structure
  hwrng: mxc-rnga - Adapt clocks to new i.mx clock framework
  crypto: caam - add IPsec ESN support
  crypto: 842 - remove .cra_list initialization
  Revert "[CRYPTO] cast6: inline bloat--"
  ...

2 files changed, 56 insertions, 69 deletions

diff --git a/drivers/char/hw_random/mxc-rnga.c b/drivers/char/hw_random/mxc-rnga.c
index 85074de5042e..f05d85713fd3 100644
--- a/drivers/char/hw_random/mxc-rnga.c
+++ b/drivers/char/hw_random/mxc-rnga.c
@@ -59,16 +59,21 @@
 #define RNGA_STATUS_LAST_READ_STATUS    0x00000002
 #define RNGA_STATUS_SECURITY_VIOLATION  0x00000001
 
-static struct platform_device *rng_dev;
+struct mxc_rng {
+        struct device *dev;
+        struct hwrng rng;
+        void __iomem *mem;
+        struct clk *clk;
+};
 
 static int mxc_rnga_data_present(struct hwrng *rng, int wait)
 {
-        void __iomem *rng_base = (void __iomem *)rng->priv;
         int i;
+        struct mxc_rng *mxc_rng = container_of(rng, struct mxc_rng, rng);
 
         for (i = 0; i < 20; i++) {
                 /* how many random numbers are in FIFO? [0-16] */
-                int level = (__raw_readl(rng_base + RNGA_STATUS) &
+                int level = (__raw_readl(mxc_rng->mem + RNGA_STATUS) &
                                 RNGA_STATUS_LEVEL_MASK) >> 8;
                 if (level || !wait)
                         return !!level;
@@ -81,20 +86,20 @@ static int mxc_rnga_data_read(struct hwrng *rng, u32 * data)
 {
         int err;
         u32 ctrl;
-        void __iomem *rng_base = (void __iomem *)rng->priv;
+        struct mxc_rng *mxc_rng = container_of(rng, struct mxc_rng, rng);
 
         /* retrieve a random number from FIFO */
-        *data = __raw_readl(rng_base + RNGA_OUTPUT_FIFO);
+        *data = __raw_readl(mxc_rng->mem + RNGA_OUTPUT_FIFO);
 
         /* some error while reading this random number? */
-        err = __raw_readl(rng_base + RNGA_STATUS) & RNGA_STATUS_ERROR_INT;
+        err = __raw_readl(mxc_rng->mem + RNGA_STATUS) & RNGA_STATUS_ERROR_INT;
 
         /* if error: clear error interrupt, but doesn't return random number */
         if (err) {
-                dev_dbg(&rng_dev->dev, "Error while reading random number!\n");
-                ctrl = __raw_readl(rng_base + RNGA_CONTROL);
+                dev_dbg(mxc_rng->dev, "Error while reading random number!\n");
+                ctrl = __raw_readl(mxc_rng->mem + RNGA_CONTROL);
                 __raw_writel(ctrl | RNGA_CONTROL_CLEAR_INT,
-                                        rng_base + RNGA_CONTROL);
+                                        mxc_rng->mem + RNGA_CONTROL);
                 return 0;
         } else
                 return 4;
@@ -103,22 +108,22 @@ static int mxc_rnga_data_read(struct hwrng *rng, u32 * data)
 static int mxc_rnga_init(struct hwrng *rng)
 {
         u32 ctrl, osc;
-        void __iomem *rng_base = (void __iomem *)rng->priv;
+        struct mxc_rng *mxc_rng = container_of(rng, struct mxc_rng, rng);
 
         /* wake up */
-        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
-        __raw_writel(ctrl & ~RNGA_CONTROL_SLEEP, rng_base + RNGA_CONTROL);
+        ctrl = __raw_readl(mxc_rng->mem + RNGA_CONTROL);
+        __raw_writel(ctrl & ~RNGA_CONTROL_SLEEP, mxc_rng->mem + RNGA_CONTROL);
 
         /* verify if oscillator is working */
-        osc = __raw_readl(rng_base + RNGA_STATUS);
+        osc = __raw_readl(mxc_rng->mem + RNGA_STATUS);
         if (osc & RNGA_STATUS_OSC_DEAD) {
-                dev_err(&rng_dev->dev, "RNGA Oscillator is dead!\n");
+                dev_err(mxc_rng->dev, "RNGA Oscillator is dead!\n");
                 return -ENODEV;
         }
 
         /* go running */
-        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
-        __raw_writel(ctrl | RNGA_CONTROL_GO, rng_base + RNGA_CONTROL);
+        ctrl = __raw_readl(mxc_rng->mem + RNGA_CONTROL);
+        __raw_writel(ctrl | RNGA_CONTROL_GO, mxc_rng->mem + RNGA_CONTROL);
 
         return 0;
 }
@@ -126,40 +131,40 @@ static int mxc_rnga_init(struct hwrng *rng)
 static void mxc_rnga_cleanup(struct hwrng *rng)
 {
         u32 ctrl;
-        void __iomem *rng_base = (void __iomem *)rng->priv;
+        struct mxc_rng *mxc_rng = container_of(rng, struct mxc_rng, rng);
 
-        ctrl = __raw_readl(rng_base + RNGA_CONTROL);
+        ctrl = __raw_readl(mxc_rng->mem + RNGA_CONTROL);
 
         /* stop rnga */
-        __raw_writel(ctrl & ~RNGA_CONTROL_GO, rng_base + RNGA_CONTROL);
+        __raw_writel(ctrl & ~RNGA_CONTROL_GO, mxc_rng->mem + RNGA_CONTROL);
 }
 
-static struct hwrng mxc_rnga = {
-        .name = "mxc-rnga",
-        .init = mxc_rnga_init,
-        .cleanup = mxc_rnga_cleanup,
-        .data_present = mxc_rnga_data_present,
-        .data_read = mxc_rnga_data_read
-};
-
 static int __init mxc_rnga_probe(struct platform_device *pdev)
 {
         int err = -ENODEV;
-        struct clk *clk;
         struct resource *res, *mem;
-        void __iomem *rng_base = NULL;
-
-        if (rng_dev)
-                return -EBUSY;
-
-        clk = clk_get(&pdev->dev, "rng");
-        if (IS_ERR(clk)) {
+        struct mxc_rng *mxc_rng;
+
+        mxc_rng = devm_kzalloc(&pdev->dev, sizeof(struct mxc_rng),
+                                        GFP_KERNEL);
+        if (!mxc_rng)
+                return -ENOMEM;
+
+        mxc_rng->dev = &pdev->dev;
+        mxc_rng->rng.name = "mxc-rnga";
+        mxc_rng->rng.init = mxc_rnga_init;
+        mxc_rng->rng.cleanup = mxc_rnga_cleanup,
+        mxc_rng->rng.data_present = mxc_rnga_data_present,
+        mxc_rng->rng.data_read = mxc_rnga_data_read,
+
+        mxc_rng->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(mxc_rng->clk)) {
                 dev_err(&pdev->dev, "Could not get rng_clk!\n");
-                err = PTR_ERR(clk);
+                err = PTR_ERR(mxc_rng->clk);
                 goto out;
         }
 
-        clk_enable(clk);
+        clk_prepare_enable(mxc_rng->clk);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
@@ -173,36 +178,27 @@ static int __init mxc_rnga_probe(struct platform_device *pdev)
                 goto err_region;
         }
 
-        rng_base = ioremap(res->start, resource_size(res));
-        if (!rng_base) {
+        mxc_rng->mem = ioremap(res->start, resource_size(res));
+        if (!mxc_rng->mem) {
                 err = -ENOMEM;
                 goto err_ioremap;
         }
 
-        mxc_rnga.priv = (unsigned long)rng_base;
-
-        err = hwrng_register(&mxc_rnga);
+        err = hwrng_register(&mxc_rng->rng);
         if (err) {
                 dev_err(&pdev->dev, "MXC RNGA registering failed (%d)\n", err);
-                goto err_register;
+                goto err_ioremap;
         }
 
-        rng_dev = pdev;
-
         dev_info(&pdev->dev, "MXC RNGA Registered.\n");
 
         return 0;
 
-err_register:
-        iounmap(rng_base);
-        rng_base = NULL;
-
 err_ioremap:
         release_mem_region(res->start, resource_size(res));
 
 err_region:
-        clk_disable(clk);
-        clk_put(clk);
+        clk_disable_unprepare(mxc_rng->clk);
 
 out:
         return err;
@@ -211,17 +207,15 @@ out:
 static int __exit mxc_rnga_remove(struct platform_device *pdev)
 {
         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        void __iomem *rng_base = (void __iomem *)mxc_rnga.priv;
-        struct clk *clk = clk_get(&pdev->dev, "rng");
+        struct mxc_rng *mxc_rng = platform_get_drvdata(pdev);
 
-        hwrng_unregister(&mxc_rnga);
+        hwrng_unregister(&mxc_rng->rng);
 
-        iounmap(rng_base);
+        iounmap(mxc_rng->mem);
 
         release_mem_region(res->start, resource_size(res));
 
-        clk_disable(clk);
-        clk_put(clk);
+        clk_disable_unprepare(mxc_rng->clk);
 
         return 0;
 }
diff --git a/drivers/char/hw_random/octeon-rng.c b/drivers/char/hw_random/octeon-rng.c
index 0943edc782a1..5c34c092af71 100644
--- a/drivers/char/hw_random/octeon-rng.c
+++ b/drivers/char/hw_random/octeon-rng.c
@@ -75,42 +75,35 @@ static int __devinit octeon_rng_probe(struct platform_device *pdev)
 
         res_ports = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res_ports)
-                goto err_ports;
+                return -ENOENT;
 
         res_result = platform_get_resource(pdev, IORESOURCE_MEM, 1);
         if (!res_result)
-                goto err_ports;
+                return -ENOENT;
 
 
         rng->control_status = devm_ioremap_nocache(&pdev->dev,
                                                    res_ports->start,
                                                    sizeof(u64));
         if (!rng->control_status)
-                goto err_ports;
+                return -ENOENT;
 
         rng->result = devm_ioremap_nocache(&pdev->dev,
                                            res_result->start,
                                            sizeof(u64));
         if (!rng->result)
-                goto err_r;
+                return -ENOENT;
 
         rng->ops = ops;
 
         dev_set_drvdata(&pdev->dev, &rng->ops);
         ret = hwrng_register(&rng->ops);
         if (ret)
-                goto err;
+                return -ENOENT;
 
         dev_info(&pdev->dev, "Octeon Random Number Generator\n");
 
         return 0;
-err:
-        devm_iounmap(&pdev->dev, rng->control_status);
-err_r:
-        devm_iounmap(&pdev->dev, rng->result);
-err_ports:
-        devm_kfree(&pdev->dev, rng);
-        return -ENOENT;
 }
 
 static int __exit octeon_rng_remove(struct platform_device *pdev)