Merge tag 'drivers-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

Pull ARM SoC driver specific changes from Arnd Bergmann:
 "These changes are all driver specific and cross over between arm-soc
  contents and some other subsystem, in these cases cpufreq, crypto,
  dma, pinctrl, mailbox and usb, and the subsystem owners agreed to have
  these changes merged through arm-soc.

  As we proceed to untangle the dependencies between platform code and
  driver code, the amount of changes in this category is fortunately
  shrinking, for 3.11 we have 16 branches here and 101 non-merge
  changesets, the majority of which are for the stedma40 dma engine
  driver used in the ux500 platform.  Cleaning up that code touches
  multiple subsystems, but gets rid of the dependency in the end.

  The mailbox code moved out from mach-omap2 to drivers/mailbox is an
  intermediate step and is still omap specific at the moment.  Patches
  exist to generalize the subsystem and add other drivers with the same
  API, but those did not make it for 3.11."

* tag 'drivers-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc: (101 commits)
  crypto: ux500: use dmaengine_submit API
  crypto: ux500: use dmaengine_prep_slave_sg API
  crypto: ux500: use dmaengine_device_control API
  crypto: ux500/crypt: add missing __iomem qualifiers
  crypto: ux500/hash: add missing static qualifiers
  crypto: ux500/hash: use readl on iomem addresses
  dmaengine: ste_dma40: Declare memcpy config as static
  ARM: ux500: Remove mop500_snowball_ethernet_clock_enable()
  ARM: ux500: Correct the EN_3v3 regulator's on/off GPIO
  ARM: ux500: Provide a AB8500 GPIO Device Tree node
  gpio: rcar: fix gpio_rcar_of_table
  gpio-rcar: Remove #ifdef CONFIG_OF around OF-specific sections
  gpio-rcar: Reference core gpio documentation in the DT bindings
  clk: exynos5250: Add enum entries for divider clock of i2s1 and i2s2
  ARM: dts: Update Samsung I2S documentation
  ARM: dts: add clock provider information for i2s controllers in Exynos5250
  ARM: dts: add Exynos audio subsystem clock controller node
  clk: samsung: register audio subsystem clocks using common clock framework
  ARM: dts: use #include for all device trees for Samsung
  pinctrl: s3c24xx: use correct header for chained_irq functions
  ...

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);