5 files changed, 93 insertions, 37 deletions

diff --git a/drivers/crypto/ux500/cryp/cryp.c b/drivers/crypto/ux500/cryp/cryp.c
index 3eafa903ebcd..43a0c8a26ab0 100644
--- a/drivers/crypto/ux500/cryp/cryp.c
+++ b/drivers/crypto/ux500/cryp/cryp.c
@@ -291,7 +291,7 @@ void cryp_save_device_context(struct cryp_device_data *device_data,
                               int cryp_mode)
 {
         enum cryp_algo_mode algomode;
-        struct cryp_register *src_reg = device_data->base;
+        struct cryp_register __iomem *src_reg = device_data->base;
         struct cryp_config *config =
                 (struct cryp_config *)device_data->current_ctx;
 
@@ -349,7 +349,7 @@ void cryp_save_device_context(struct cryp_device_data *device_data,
 void cryp_restore_device_context(struct cryp_device_data *device_data,
                                  struct cryp_device_context *ctx)
 {
-        struct cryp_register *reg = device_data->base;
+        struct cryp_register __iomem *reg = device_data->base;
         struct cryp_config *config =
                 (struct cryp_config *)device_data->current_ctx;
 
diff --git a/drivers/crypto/ux500/cryp/cryp.h b/drivers/crypto/ux500/cryp/cryp.h
index 14cfd05b777a..d1d6606fe56c 100644
--- a/drivers/crypto/ux500/cryp/cryp.h
+++ b/drivers/crypto/ux500/cryp/cryp.h
@@ -114,6 +114,9 @@ enum cryp_status_id {
 };
 
 /* Cryp DMA interface */
+#define CRYP_DMA_TX_FIFO        0x08
+#define CRYP_DMA_RX_FIFO        0x10
+
 enum cryp_dma_req_type {
         CRYP_DMA_DISABLE_BOTH,
         CRYP_DMA_ENABLE_IN_DATA,
@@ -217,7 +220,8 @@ struct cryp_dma {
 
 /**
  * struct cryp_device_data - structure for a cryp device.
- * @base: Pointer to the hardware base address.
+ * @base: Pointer to virtual base address of the cryp device.
+ * @phybase: Pointer to physical memory location of the cryp device.
  * @dev: Pointer to the devices dev structure.
  * @clk: Pointer to the device's clock control.
  * @pwr_regulator: Pointer to the device's power control.
@@ -232,6 +236,7 @@ struct cryp_dma {
  */
 struct cryp_device_data {
         struct cryp_register __iomem *base;
+        phys_addr_t phybase;
         struct device *dev;
         struct clk *clk;
         struct regulator *pwr_regulator;
diff --git a/drivers/crypto/ux500/cryp/cryp_core.c b/drivers/crypto/ux500/cryp/cryp_core.c
index 8c2777cf02f6..83d79b964d12 100644
--- a/drivers/crypto/ux500/cryp/cryp_core.c
+++ b/drivers/crypto/ux500/cryp/cryp_core.c
@@ -475,6 +475,19 @@ static int cryp_get_device_data(struct cryp_ctx *ctx,
 static void cryp_dma_setup_channel(struct cryp_device_data *device_data,
                                    struct device *dev)
 {
+        struct dma_slave_config mem2cryp = {
+                .direction = DMA_MEM_TO_DEV,
+                .dst_addr = device_data->phybase + CRYP_DMA_TX_FIFO,
+                .dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES,
+                .dst_maxburst = 4,
+        };
+        struct dma_slave_config cryp2mem = {
+                .direction = DMA_DEV_TO_MEM,
+                .src_addr = device_data->phybase + CRYP_DMA_RX_FIFO,
+                .src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES,
+                .src_maxburst = 4,
+        };
+
         dma_cap_zero(device_data->dma.mask);
         dma_cap_set(DMA_SLAVE, device_data->dma.mask);
 
@@ -490,6 +503,9 @@ static void cryp_dma_setup_channel(struct cryp_device_data *device_data,
                                     stedma40_filter,
                                     device_data->dma.cfg_cryp2mem);
 
+        dmaengine_slave_config(device_data->dma.chan_mem2cryp, &mem2cryp);
+        dmaengine_slave_config(device_data->dma.chan_cryp2mem, &cryp2mem);
+
         init_completion(&device_data->dma.cryp_dma_complete);
 }
 
@@ -537,10 +553,10 @@ static int cryp_set_dma_transfer(struct cryp_ctx *ctx,
                 dev_dbg(ctx->device->dev, "[%s]: Setting up DMA for buffer "
                         "(TO_DEVICE)", __func__);
 
-                desc = channel->device->device_prep_slave_sg(channel,
-                                             ctx->device->dma.sg_src,
-                                             ctx->device->dma.sg_src_len,
-                                             direction, DMA_CTRL_ACK, NULL);
+                desc = dmaengine_prep_slave_sg(channel,
+                                ctx->device->dma.sg_src,
+                                ctx->device->dma.sg_src_len,
+                                direction, DMA_CTRL_ACK);
                 break;
 
         case DMA_FROM_DEVICE:
@@ -561,12 +577,12 @@ static int cryp_set_dma_transfer(struct cryp_ctx *ctx,
                 dev_dbg(ctx->device->dev, "[%s]: Setting up DMA for buffer "
                         "(FROM_DEVICE)", __func__);
 
-                desc = channel->device->device_prep_slave_sg(channel,
-                                             ctx->device->dma.sg_dst,
-                                             ctx->device->dma.sg_dst_len,
-                                             direction,
-                                             DMA_CTRL_ACK |
-                                             DMA_PREP_INTERRUPT, NULL);
+                desc = dmaengine_prep_slave_sg(channel,
+                                ctx->device->dma.sg_dst,
+                                ctx->device->dma.sg_dst_len,
+                                direction,
+                                DMA_CTRL_ACK |
+                                DMA_PREP_INTERRUPT);
 
                 desc->callback = cryp_dma_out_callback;
                 desc->callback_param = ctx;
@@ -578,7 +594,7 @@ static int cryp_set_dma_transfer(struct cryp_ctx *ctx,
                 return -EFAULT;
         }
 
-        cookie = desc->tx_submit(desc);
+        cookie = dmaengine_submit(desc);
         dma_async_issue_pending(channel);
 
         return 0;
@@ -591,12 +607,12 @@ static void cryp_dma_done(struct cryp_ctx *ctx)
         dev_dbg(ctx->device->dev, "[%s]: ", __func__);
 
         chan = ctx->device->dma.chan_mem2cryp;
-        chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
+        dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
         dma_unmap_sg(chan->device->dev, ctx->device->dma.sg_src,
                      ctx->device->dma.sg_src_len, DMA_TO_DEVICE);
 
         chan = ctx->device->dma.chan_cryp2mem;
-        chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
+        dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
         dma_unmap_sg(chan->device->dev, ctx->device->dma.sg_dst,
                      ctx->device->dma.sg_dst_len, DMA_FROM_DEVICE);
 }
@@ -1431,6 +1447,7 @@ static int ux500_cryp_probe(struct platform_device *pdev)
                 goto out_kfree;
         }
 
+        device_data->phybase = res->start;
         device_data->base = ioremap(res->start, resource_size(res));
         if (!device_data->base) {
                 dev_err(dev, "[%s]: ioremap failed!", __func__);
@@ -1458,11 +1475,17 @@ static int ux500_cryp_probe(struct platform_device *pdev)
                 goto out_regulator;
         }
 
+        ret = clk_prepare(device_data->clk);
+        if (ret) {
+                dev_err(dev, "[%s]: clk_prepare() failed!", __func__);
+                goto out_clk;
+        }
+
         /* Enable device power (and clock) */
         ret = cryp_enable_power(device_data->dev, device_data, false);
         if (ret) {
                 dev_err(dev, "[%s]: cryp_enable_power() failed!", __func__);
-                goto out_clk;
+                goto out_clk_unprepare;
         }
 
         cryp_error = cryp_check(device_data);
@@ -1518,11 +1541,16 @@ static int ux500_cryp_probe(struct platform_device *pdev)
                 goto out_power;
         }
 
+        dev_info(dev, "successfully registered\n");
+
         return 0;
 
 out_power:
         cryp_disable_power(device_data->dev, device_data, false);
 
+out_clk_unprepare:
+        clk_unprepare(device_data->clk);
+
 out_clk:
         clk_put(device_data->clk);
 
@@ -1593,6 +1621,7 @@ static int ux500_cryp_remove(struct platform_device *pdev)
                 dev_err(&pdev->dev, "[%s]: cryp_disable_power() failed",
                         __func__);
 
+        clk_unprepare(device_data->clk);
         clk_put(device_data->clk);
         regulator_put(device_data->pwr_regulator);
 
diff --git a/drivers/crypto/ux500/hash/hash_alg.h b/drivers/crypto/ux500/hash/hash_alg.h
index cd9351cb24df..be6eb54da40f 100644
--- a/drivers/crypto/ux500/hash/hash_alg.h
+++ b/drivers/crypto/ux500/hash/hash_alg.h
@@ -11,6 +11,7 @@
 #include <linux/bitops.h>
 
 #define HASH_BLOCK_SIZE                 64
+#define HASH_DMA_FIFO                   4
 #define HASH_DMA_ALIGN_SIZE             4
 #define HASH_DMA_PERFORMANCE_MIN_SIZE   1024
 #define HASH_BYTES_PER_WORD             4
@@ -347,7 +348,8 @@ struct hash_req_ctx {
 
 /**
  * struct hash_device_data - structure for a hash device.
- * @base:               Pointer to the hardware base address.
+ * @base:               Pointer to virtual base address of the hash device.
+ * @phybase:            Pointer to physical memory location of the hash device.
  * @list_node:          For inclusion in klist.
  * @dev:                Pointer to the device dev structure.
  * @ctx_lock:           Spinlock for current_ctx.
@@ -361,6 +363,7 @@ struct hash_req_ctx {
  */
 struct hash_device_data {
         struct hash_register __iomem    *base;
+        phys_addr_t             phybase;
         struct klist_node       list_node;
         struct device           *dev;
         struct spinlock         ctx_lock;
diff --git a/drivers/crypto/ux500/hash/hash_core.c b/drivers/crypto/ux500/hash/hash_core.c
index 3b8f661d0edf..496ae6aae316 100644
--- a/drivers/crypto/ux500/hash/hash_core.c
+++ b/drivers/crypto/ux500/hash/hash_core.c
@@ -122,6 +122,13 @@ static void hash_dma_setup_channel(struct hash_device_data *device_data,
                                 struct device *dev)
 {
         struct hash_platform_data *platform_data = dev->platform_data;
+        struct dma_slave_config conf = {
+                .direction = DMA_MEM_TO_DEV,
+                .dst_addr = device_data->phybase + HASH_DMA_FIFO,
+                .dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES,
+                .dst_maxburst = 16,
+        };
+
         dma_cap_zero(device_data->dma.mask);
         dma_cap_set(DMA_SLAVE, device_data->dma.mask);
 
@@ -131,6 +138,8 @@ static void hash_dma_setup_channel(struct hash_device_data *device_data,
                                 platform_data->dma_filter,
                                 device_data->dma.cfg_mem2hash);
 
+        dmaengine_slave_config(device_data->dma.chan_mem2hash, &conf);
+
         init_completion(&device_data->dma.complete);
 }
 
@@ -171,9 +180,9 @@ static int hash_set_dma_transfer(struct hash_ctx *ctx, struct scatterlist *sg,
 
         dev_dbg(ctx->device->dev, "[%s]: Setting up DMA for buffer "
                         "(TO_DEVICE)", __func__);
-        desc = channel->device->device_prep_slave_sg(channel,
+        desc = dmaengine_prep_slave_sg(channel,
                         ctx->device->dma.sg, ctx->device->dma.sg_len,
-                        direction, DMA_CTRL_ACK | DMA_PREP_INTERRUPT, NULL);
+                        direction, DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
         if (!desc) {
                 dev_err(ctx->device->dev,
                         "[%s]: device_prep_slave_sg() failed!", __func__);
@@ -183,7 +192,7 @@ static int hash_set_dma_transfer(struct hash_ctx *ctx, struct scatterlist *sg,
         desc->callback = hash_dma_callback;
         desc->callback_param = ctx;
 
-        cookie = desc->tx_submit(desc);
+        cookie = dmaengine_submit(desc);
         dma_async_issue_pending(channel);
 
         return 0;
@@ -194,7 +203,7 @@ static void hash_dma_done(struct hash_ctx *ctx)
         struct dma_chan *chan;
 
         chan = ctx->device->dma.chan_mem2hash;
-        chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
+        dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
         dma_unmap_sg(chan->device->dev, ctx->device->dma.sg,
                         ctx->device->dma.sg_len, DMA_TO_DEVICE);
 
@@ -464,12 +473,12 @@ static void hash_hw_write_key(struct hash_device_data *device_data,
                 HASH_SET_DIN(&word, nwords);
         }
 
-        while (device_data->base->str & HASH_STR_DCAL_MASK)
+        while (readl(&device_data->base->str) & HASH_STR_DCAL_MASK)
                 cpu_relax();
 
         HASH_SET_DCAL;
 
-        while (device_data->base->str & HASH_STR_DCAL_MASK)
+        while (readl(&device_data->base->str) & HASH_STR_DCAL_MASK)
                 cpu_relax();
 }
 
@@ -652,7 +661,7 @@ static void hash_messagepad(struct hash_device_data *device_data,
         if (index_bytes)
                 HASH_SET_DIN(message, nwords);
 
-        while (device_data->base->str & HASH_STR_DCAL_MASK)
+        while (readl(&device_data->base->str) & HASH_STR_DCAL_MASK)
                 cpu_relax();
 
         /* num_of_bytes == 0 => NBLW <- 0 (32 bits valid in DATAIN) */
@@ -667,7 +676,7 @@ static void hash_messagepad(struct hash_device_data *device_data,
                         (int)(readl_relaxed(&device_data->base->str) &
                                 HASH_STR_NBLW_MASK));
 
-        while (device_data->base->str & HASH_STR_DCAL_MASK)
+        while (readl(&device_data->base->str) & HASH_STR_DCAL_MASK)
                 cpu_relax();
 }
 
@@ -767,7 +776,7 @@ void hash_begin(struct hash_device_data *device_data, struct hash_ctx *ctx)
         /* HW and SW initializations */
         /* Note: there is no need to initialize buffer and digest members */
 
-        while (device_data->base->str & HASH_STR_DCAL_MASK)
+        while (readl(&device_data->base->str) & HASH_STR_DCAL_MASK)
                 cpu_relax();
 
         /*
@@ -783,8 +792,7 @@ void hash_begin(struct hash_device_data *device_data, struct hash_ctx *ctx)
         HASH_CLEAR_BITS(&device_data->base->str, HASH_STR_NBLW_MASK);
 }
 
-int hash_process_data(
-                struct hash_device_data *device_data,
+static int hash_process_data(struct hash_device_data *device_data,
                 struct hash_ctx *ctx, struct hash_req_ctx *req_ctx,
                 int msg_length, u8 *data_buffer, u8 *buffer, u8 *index)
 {
@@ -953,7 +961,7 @@ static int hash_dma_final(struct ahash_request *req)
         wait_for_completion(&ctx->device->dma.complete);
         hash_dma_done(ctx);
 
-        while (device_data->base->str & HASH_STR_DCAL_MASK)
+        while (readl(&device_data->base->str) & HASH_STR_DCAL_MASK)
                 cpu_relax();
 
         if (ctx->config.oper_mode == HASH_OPER_MODE_HMAC && ctx->key) {
@@ -983,7 +991,7 @@ out:
  * hash_hw_final - The final hash calculation function
  * @req:        The hash request for the job.
  */
-int hash_hw_final(struct ahash_request *req)
+static int hash_hw_final(struct ahash_request *req)
 {
         int ret = 0;
         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
@@ -1051,7 +1059,7 @@ int hash_hw_final(struct ahash_request *req)
                                 req_ctx->state.index);
         } else {
                 HASH_SET_DCAL;
-                while (device_data->base->str & HASH_STR_DCAL_MASK)
+                while (readl(&device_data->base->str) & HASH_STR_DCAL_MASK)
                         cpu_relax();
         }
 
@@ -1180,7 +1188,7 @@ int hash_resume_state(struct hash_device_data *device_data,
         temp_cr = device_state->temp_cr;
         writel_relaxed(temp_cr & HASH_CR_RESUME_MASK, &device_data->base->cr);
 
-        if (device_data->base->cr & HASH_CR_MODE_MASK)
+        if (readl(&device_data->base->cr) & HASH_CR_MODE_MASK)
                 hash_mode = HASH_OPER_MODE_HMAC;
         else
                 hash_mode = HASH_OPER_MODE_HASH;
@@ -1224,7 +1232,7 @@ int hash_save_state(struct hash_device_data *device_data,
          * actually makes sure that there isn't any ongoing calculation in the
          * hardware.
          */
-        while (device_data->base->str & HASH_STR_DCAL_MASK)
+        while (readl(&device_data->base->str) & HASH_STR_DCAL_MASK)
                 cpu_relax();
 
         temp_cr = readl_relaxed(&device_data->base->cr);
@@ -1233,7 +1241,7 @@ int hash_save_state(struct hash_device_data *device_data,
 
         device_state->din_reg = readl_relaxed(&device_data->base->din);
 
-        if (device_data->base->cr & HASH_CR_MODE_MASK)
+        if (readl(&device_data->base->cr) & HASH_CR_MODE_MASK)
                 hash_mode = HASH_OPER_MODE_HMAC;
         else
                 hash_mode = HASH_OPER_MODE_HASH;
@@ -1699,6 +1707,7 @@ static int ux500_hash_probe(struct platform_device *pdev)
                 goto out_kfree;
         }
 
+        device_data->phybase = res->start;
         device_data->base = ioremap(res->start, resource_size(res));
         if (!device_data->base) {
                 dev_err(dev, "[%s] ioremap() failed!",
@@ -1726,11 +1735,17 @@ static int ux500_hash_probe(struct platform_device *pdev)
                 goto out_regulator;
         }
 
+        ret = clk_prepare(device_data->clk);
+        if (ret) {
+                dev_err(dev, "[%s] clk_prepare() failed!", __func__);
+                goto out_clk;
+        }
+
         /* Enable device power (and clock) */
         ret = hash_enable_power(device_data, false);
         if (ret) {
                 dev_err(dev, "[%s]: hash_enable_power() failed!", __func__);
-                goto out_clk;
+                goto out_clk_unprepare;
         }
 
         ret = hash_check_hw(device_data);
@@ -1756,12 +1771,15 @@ static int ux500_hash_probe(struct platform_device *pdev)
                 goto out_power;
         }
 
-        dev_info(dev, "[%s] successfully probed\n", __func__);
+        dev_info(dev, "successfully registered\n");
         return 0;
 
 out_power:
         hash_disable_power(device_data, false);
 
+out_clk_unprepare:
+        clk_unprepare(device_data->clk);
+
 out_clk:
         clk_put(device_data->clk);
 
@@ -1826,6 +1844,7 @@ static int ux500_hash_remove(struct platform_device *pdev)
                 dev_err(dev, "[%s]: hash_disable_power() failed",
                         __func__);
 
+        clk_unprepare(device_data->clk);
         clk_put(device_data->clk);
         regulator_put(device_data->regulator);