Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

1 files changed, 267 insertions, 216 deletions

diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c
index 44123248b630..8dc966f45c36 100644
--- a/sound/soc/sh/fsi.c
+++ b/sound/soc/sh/fsi.c
@@ -17,8 +17,9 @@
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/list.h>
-#include <linux/clk.h>
+#include <linux/pm_runtime.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/initval.h>
@@ -26,8 +27,6 @@
 #include <sound/pcm_params.h>
 #include <sound/sh_fsi.h>
 #include <asm/atomic.h>
-#include <asm/dma.h>
-#include <asm/dma-sh.h>
 
 #define DO_FMT          0x0000
 #define DOFF_CTL        0x0004
@@ -69,6 +68,7 @@
 /* DOFF_ST */
 #define ERR_OVER        0x00000010
 #define ERR_UNDER       0x00000001
+#define ST_ERR          (ERR_OVER | ERR_UNDER)
 
 /* CLK_RST */
 #define B_CLK           0x00000010
@@ -94,10 +94,10 @@
 struct fsi_priv {
         void __iomem *base;
         struct snd_pcm_substream *substream;
+        struct fsi_master *master;
 
         int fifo_max;
         int chan;
-        int dma_chan;
 
         int byte_offset;
         int period_len;
@@ -108,14 +108,12 @@ struct fsi_priv {
 struct fsi_master {
         void __iomem *base;
         int irq;
-        struct clk *clk;
         struct fsi_priv fsia;
         struct fsi_priv fsib;
         struct sh_fsi_platform_info *info;
+        spinlock_t lock;
 };
 
-static struct fsi_master *master;
-
 /************************************************************************
 
 
@@ -123,35 +121,35 @@ static struct fsi_master *master;
 
 
 ************************************************************************/
-static int __fsi_reg_write(u32 reg, u32 data)
+static void __fsi_reg_write(u32 reg, u32 data)
 {
         /* valid data area is 24bit */
         data &= 0x00ffffff;
 
-        return ctrl_outl(data, reg);
+        __raw_writel(data, reg);
 }
 
 static u32 __fsi_reg_read(u32 reg)
 {
-        return ctrl_inl(reg);
+        return __raw_readl(reg);
 }
 
-static int __fsi_reg_mask_set(u32 reg, u32 mask, u32 data)
+static void __fsi_reg_mask_set(u32 reg, u32 mask, u32 data)
 {
         u32 val = __fsi_reg_read(reg);
 
         val &= ~mask;
         val |= data & mask;
 
-        return __fsi_reg_write(reg, val);
+        __fsi_reg_write(reg, val);
 }
 
-static int fsi_reg_write(struct fsi_priv *fsi, u32 reg, u32 data)
+static void fsi_reg_write(struct fsi_priv *fsi, u32 reg, u32 data)
 {
         if (reg > REG_END)
-                return -1;
+                return;
 
-        return __fsi_reg_write((u32)(fsi->base + reg), data);
+        __fsi_reg_write((u32)(fsi->base + reg), data);
 }
 
 static u32 fsi_reg_read(struct fsi_priv *fsi, u32 reg)
@@ -162,39 +160,55 @@ static u32 fsi_reg_read(struct fsi_priv *fsi, u32 reg)
         return __fsi_reg_read((u32)(fsi->base + reg));
 }
 
-static int fsi_reg_mask_set(struct fsi_priv *fsi, u32 reg, u32 mask, u32 data)
+static void fsi_reg_mask_set(struct fsi_priv *fsi, u32 reg, u32 mask, u32 data)
 {
         if (reg > REG_END)
-                return -1;
+                return;
 
-        return __fsi_reg_mask_set((u32)(fsi->base + reg), mask, data);
+        __fsi_reg_mask_set((u32)(fsi->base + reg), mask, data);
 }
 
-static int fsi_master_write(u32 reg, u32 data)
+static void fsi_master_write(struct fsi_master *master, u32 reg, u32 data)
 {
+        unsigned long flags;
+
         if ((reg < MREG_START) ||
             (reg > MREG_END))
-                return -1;
+                return;
 
-        return __fsi_reg_write((u32)(master->base + reg), data);
+        spin_lock_irqsave(&master->lock, flags);
+        __fsi_reg_write((u32)(master->base + reg), data);
+        spin_unlock_irqrestore(&master->lock, flags);
 }
 
-static u32 fsi_master_read(u32 reg)
+static u32 fsi_master_read(struct fsi_master *master, u32 reg)
 {
+        u32 ret;
+        unsigned long flags;
+
         if ((reg < MREG_START) ||
             (reg > MREG_END))
                 return 0;
 
-        return __fsi_reg_read((u32)(master->base + reg));
+        spin_lock_irqsave(&master->lock, flags);
+        ret = __fsi_reg_read((u32)(master->base + reg));
+        spin_unlock_irqrestore(&master->lock, flags);
+
+        return ret;
 }
 
-static int fsi_master_mask_set(u32 reg, u32 mask, u32 data)
+static void fsi_master_mask_set(struct fsi_master *master,
+                               u32 reg, u32 mask, u32 data)
 {
+        unsigned long flags;
+
         if ((reg < MREG_START) ||
             (reg > MREG_END))
-                return -1;
+                return;
 
-        return __fsi_reg_mask_set((u32)(master->base + reg), mask, data);
+        spin_lock_irqsave(&master->lock, flags);
+        __fsi_reg_mask_set((u32)(master->base + reg), mask, data);
+        spin_unlock_irqrestore(&master->lock, flags);
 }
 
 /************************************************************************
@@ -204,43 +218,35 @@ static int fsi_master_mask_set(u32 reg, u32 mask, u32 data)
 
 
 ************************************************************************/
-static struct fsi_priv *fsi_get(struct snd_pcm_substream *substream)
+static struct fsi_master *fsi_get_master(struct fsi_priv *fsi)
 {
-        struct snd_soc_pcm_runtime *rtd;
-        struct fsi_priv *fsi = NULL;
+        return fsi->master;
+}
 
-        if (!substream || !master)
-                return NULL;
+static int fsi_is_port_a(struct fsi_priv *fsi)
+{
+        return fsi->master->base == fsi->base;
+}
 
-        rtd = substream->private_data;
-        switch (rtd->dai->cpu_dai->id) {
-        case 0:
-                fsi = &master->fsia;
-                break;
-        case 1:
-                fsi = &master->fsib;
-                break;
-        }
+static struct snd_soc_dai *fsi_get_dai(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai_link *machine = rtd->dai;
 
-        return fsi;
+        return  machine->cpu_dai;
 }
 
-static int fsi_is_port_a(struct fsi_priv *fsi)
+static struct fsi_priv *fsi_get_priv(struct snd_pcm_substream *substream)
 {
-        /* return
-         * 1 : port a
-         * 0 : port b
-         */
-
-        if (fsi == &master->fsia)
-                return 1;
+        struct snd_soc_dai *dai = fsi_get_dai(substream);
 
-        return 0;
+        return dai->private_data;
 }
 
 static u32 fsi_get_info_flags(struct fsi_priv *fsi)
 {
         int is_porta = fsi_is_port_a(fsi);
+        struct fsi_master *master = fsi_get_master(fsi);
 
         return is_porta ? master->info->porta_flags :
                 master->info->portb_flags;
@@ -308,62 +314,6 @@ static int fsi_get_fifo_residue(struct fsi_priv *fsi, int is_play)
         return residue;
 }
 
-static int fsi_get_residue(struct fsi_priv *fsi, int is_play)
-{
-        int residue;
-        int width;
-        struct snd_pcm_runtime *runtime;
-
-        runtime = fsi->substream->runtime;
-
-        /* get 1 channel data width */
-        width = frames_to_bytes(runtime, 1) / fsi->chan;
-
-        if (2 == width)
-                residue = fsi_get_fifo_residue(fsi, is_play);
-        else
-                residue = get_dma_residue(fsi->dma_chan);
-
-        return residue;
-}
-
-/************************************************************************
-
-
-                basic dma function
-
-
-************************************************************************/
-#define PORTA_DMA 0
-#define PORTB_DMA 1
-
-static int fsi_get_dma_chan(void)
-{
-        if (0 != request_dma(PORTA_DMA, "fsia"))
-                return -EIO;
-
-        if (0 != request_dma(PORTB_DMA, "fsib")) {
-                free_dma(PORTA_DMA);
-                return -EIO;
-        }
-
-        master->fsia.dma_chan = PORTA_DMA;
-        master->fsib.dma_chan = PORTB_DMA;
-
-        return 0;
-}
-
-static void fsi_free_dma_chan(void)
-{
-        dma_wait_for_completion(PORTA_DMA);
-        dma_wait_for_completion(PORTB_DMA);
-        free_dma(PORTA_DMA);
-        free_dma(PORTB_DMA);
-
-        master->fsia.dma_chan = -1;
-        master->fsib.dma_chan = -1;
-}
-
 /************************************************************************
 
 
@@ -374,27 +324,30 @@ static void fsi_free_dma_chan(void)
 static void fsi_irq_enable(struct fsi_priv *fsi, int is_play)
 {
         u32 data = fsi_port_ab_io_bit(fsi, is_play);
+        struct fsi_master *master = fsi_get_master(fsi);
 
-        fsi_master_mask_set(IMSK,  data, data);
-        fsi_master_mask_set(IEMSK, data, data);
+        fsi_master_mask_set(master, IMSK,  data, data);
+        fsi_master_mask_set(master, IEMSK, data, data);
 }
 
 static void fsi_irq_disable(struct fsi_priv *fsi, int is_play)
 {
         u32 data = fsi_port_ab_io_bit(fsi, is_play);
+        struct fsi_master *master = fsi_get_master(fsi);
 
-        fsi_master_mask_set(IMSK,  data, 0);
-        fsi_master_mask_set(IEMSK, data, 0);
+        fsi_master_mask_set(master, IMSK,  data, 0);
+        fsi_master_mask_set(master, IEMSK, data, 0);
 }
 
 static void fsi_clk_ctrl(struct fsi_priv *fsi, int enable)
 {
         u32 val = fsi_is_port_a(fsi) ? (1 << 0) : (1 << 4);
+        struct fsi_master *master = fsi_get_master(fsi);
 
         if (enable)
-                fsi_master_mask_set(CLK_RST, val, val);
+                fsi_master_mask_set(master, CLK_RST, val, val);
         else
-                fsi_master_mask_set(CLK_RST, val, 0);
+                fsi_master_mask_set(master, CLK_RST, val, 0);
 }
 
 static void fsi_irq_init(struct fsi_priv *fsi, int is_play)
@@ -415,79 +368,46 @@ static void fsi_irq_init(struct fsi_priv *fsi, int is_play)
         fsi_reg_mask_set(fsi, ctrl, FIFO_CLR, FIFO_CLR);
 
         /* clear interrupt factor */
-        fsi_master_mask_set(INT_ST, data, 0);
+        fsi_master_mask_set(fsi_get_master(fsi), INT_ST, data, 0);
 }
 
-static void fsi_soft_all_reset(void)
+static void fsi_soft_all_reset(struct fsi_master *master)
 {
-        u32 status = fsi_master_read(SOFT_RST);
+        u32 status = fsi_master_read(master, SOFT_RST);
 
         /* port AB reset */
         status &= 0x000000ff;
-        fsi_master_write(SOFT_RST, status);
+        fsi_master_write(master, SOFT_RST, status);
         mdelay(10);
 
         /* soft reset */
         status &= 0x000000f0;
-        fsi_master_write(SOFT_RST, status);
+        fsi_master_write(master, SOFT_RST, status);
         status |= 0x00000001;
-        fsi_master_write(SOFT_RST, status);
+        fsi_master_write(master, SOFT_RST, status);
         mdelay(10);
 }
 
-static void fsi_16data_push(struct fsi_priv *fsi,
-                           struct snd_pcm_runtime *runtime,
-                           int send)
-{
-        u16 *dma_start;
-        u32 snd;
-        int i;
-
-        /* get dma start position for FSI */
-        dma_start = (u16 *)runtime->dma_area;
-        dma_start += fsi->byte_offset / 2;
-
-        /*
-         * soft dma
-         * FSI can not use DMA when 16bpp
-         */
-        for (i = 0; i < send; i++) {
-                snd = (u32)dma_start[i];
-                fsi_reg_write(fsi, DODT, snd << 8);
-        }
-}
-
-static void fsi_32data_push(struct fsi_priv *fsi,
-                           struct snd_pcm_runtime *runtime,
-                           int send)
-{
-        u32 *dma_start;
-
-        /* get dma start position for FSI */
-        dma_start = (u32 *)runtime->dma_area;
-        dma_start += fsi->byte_offset / 4;
-
-        dma_wait_for_completion(fsi->dma_chan);
-        dma_configure_channel(fsi->dma_chan, (SM_INC|0x400|TS_32|TM_BUR));
-        dma_write(fsi->dma_chan, (u32)dma_start,
-                  (u32)(fsi->base + DODT), send * 4);
-}
-
 /* playback interrupt */
-static int fsi_data_push(struct fsi_priv *fsi)
+static int fsi_data_push(struct fsi_priv *fsi, int startup)
 {
         struct snd_pcm_runtime *runtime;
         struct snd_pcm_substream *substream = NULL;
+        u32 status;
         int send;
         int fifo_free;
         int width;
+        u8 *start;
+        int i, over_period;
 
         if (!fsi                        ||
             !fsi->substream             ||
             !fsi->substream->runtime)
                 return -EINVAL;
 
-        runtime = fsi->substream->runtime;
+        over_period     = 0;
+        substream       = fsi->substream;
+        runtime         = substream->runtime;
 
         /* FSI FIFO has limit.
          * So, this driver can not send periods data at a time
@@ -495,7 +415,7 @@ static int fsi_data_push(struct fsi_priv *fsi)
         if (fsi->byte_offset >=
             fsi->period_len * (fsi->periods + 1)) {
 
-                substream = fsi->substream;
+                over_period = 1;
                 fsi->periods = (fsi->periods + 1) % runtime->periods;
 
                 if (0 == fsi->periods)
@@ -515,18 +435,122 @@ static int fsi_data_push(struct fsi_priv *fsi)
         if (fifo_free < send)
                 send = fifo_free;
 
-        if (2 == width)
-                fsi_16data_push(fsi, runtime, send);
-        else if (4 == width)
-                fsi_32data_push(fsi, runtime, send);
-        else
+        start = runtime->dma_area;
+        start += fsi->byte_offset;
+
+        switch (width) {
+        case 2:
+                for (i = 0; i < send; i++)
+                        fsi_reg_write(fsi, DODT,
+                                      ((u32)*((u16 *)start + i) << 8));
+                break;
+        case 4:
+                for (i = 0; i < send; i++)
+                        fsi_reg_write(fsi, DODT, *((u32 *)start + i));
+                break;
+        default:
                 return -EINVAL;
+        }
 
         fsi->byte_offset += send * width;
 
+        status = fsi_reg_read(fsi, DOFF_ST);
+        if (!startup) {
+                struct snd_soc_dai *dai = fsi_get_dai(substream);
+
+                if (status & ERR_OVER)
+                        dev_err(dai->dev, "over run\n");
+                if (status & ERR_UNDER)
+                        dev_err(dai->dev, "under run\n");
+        }
+        fsi_reg_write(fsi, DOFF_ST, 0);
+
         fsi_irq_enable(fsi, 1);
 
-        if (substream)
+        if (over_period)
+                snd_pcm_period_elapsed(substream);
+
+        return 0;
+}
+
+static int fsi_data_pop(struct fsi_priv *fsi, int startup)
+{
+        struct snd_pcm_runtime *runtime;
+        struct snd_pcm_substream *substream = NULL;
+        u32 status;
+        int free;
+        int fifo_fill;
+        int width;
+        u8 *start;
+        int i, over_period;
+
+        if (!fsi                        ||
+            !fsi->substream             ||
+            !fsi->substream->runtime)
+                return -EINVAL;
+
+        over_period     = 0;
+        substream       = fsi->substream;
+        runtime         = substream->runtime;
+
+        /* FSI FIFO has limit.
+         * So, this driver can not send periods data at a time
+         */
+        if (fsi->byte_offset >=
+            fsi->period_len * (fsi->periods + 1)) {
+
+                over_period = 1;
+                fsi->periods = (fsi->periods + 1) % runtime->periods;
+
+                if (0 == fsi->periods)
+                        fsi->byte_offset = 0;
+        }
+
+        /* get 1 channel data width */
+        width = frames_to_bytes(runtime, 1) / fsi->chan;
+
+        /* get free space for alsa */
+        free = (fsi->buffer_len - fsi->byte_offset) / width;
+
+        /* get recv size */
+        fifo_fill = fsi_get_fifo_residue(fsi, 0);
+
+        if (free < fifo_fill)
+                fifo_fill = free;
+
+        start = runtime->dma_area;
+        start += fsi->byte_offset;
+
+        switch (width) {
+        case 2:
+                for (i = 0; i < fifo_fill; i++)
+                        *((u16 *)start + i) =
+                                (u16)(fsi_reg_read(fsi, DIDT) >> 8);
+                break;
+        case 4:
+                for (i = 0; i < fifo_fill; i++)
+                        *((u32 *)start + i) = fsi_reg_read(fsi, DIDT);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        fsi->byte_offset += fifo_fill * width;
+
+        status = fsi_reg_read(fsi, DIFF_ST);
+        if (!startup) {
+                struct snd_soc_dai *dai = fsi_get_dai(substream);
+
+                if (status & ERR_OVER)
+                        dev_err(dai->dev, "over run\n");
+                if (status & ERR_UNDER)
+                        dev_err(dai->dev, "under run\n");
+        }
+        fsi_reg_write(fsi, DIFF_ST, 0);
+
+        fsi_irq_enable(fsi, 0);
+
+        if (over_period)
                 snd_pcm_period_elapsed(substream);
 
         return 0;
@@ -534,19 +558,24 @@ static int fsi_data_push(struct fsi_priv *fsi)
 
 static irqreturn_t fsi_interrupt(int irq, void *data)
 {
-        u32 status = fsi_master_read(SOFT_RST) & ~0x00000010;
-        u32 int_st = fsi_master_read(INT_ST);
+        struct fsi_master *master = data;
+        u32 status = fsi_master_read(master, SOFT_RST) & ~0x00000010;
+        u32 int_st = fsi_master_read(master, INT_ST);
 
         /* clear irq status */
-        fsi_master_write(SOFT_RST, status);
-        fsi_master_write(SOFT_RST, status | 0x00000010);
+        fsi_master_write(master, SOFT_RST, status);
+        fsi_master_write(master, SOFT_RST, status | 0x00000010);
 
         if (int_st & INT_A_OUT)
-                fsi_data_push(&master->fsia);
+                fsi_data_push(&master->fsia, 0);
         if (int_st & INT_B_OUT)
-                fsi_data_push(&master->fsib);
+                fsi_data_push(&master->fsib, 0);
+        if (int_st & INT_A_IN)
+                fsi_data_pop(&master->fsia, 0);
+        if (int_st & INT_B_IN)
+                fsi_data_pop(&master->fsib, 0);
 
-        fsi_master_write(INT_ST, 0x0000000);
+        fsi_master_write(master, INT_ST, 0x0000000);
 
         return IRQ_HANDLED;
 }
@@ -561,7 +590,7 @@ static irqreturn_t fsi_interrupt(int irq, void *data)
 static int fsi_dai_startup(struct snd_pcm_substream *substream,
                            struct snd_soc_dai *dai)
 {
-        struct fsi_priv *fsi = fsi_get(substream);
+        struct fsi_priv *fsi = fsi_get_priv(substream);
         const char *msg;
         u32 flags = fsi_get_info_flags(fsi);
         u32 fmt;
@@ -571,7 +600,7 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
         int is_master;
         int ret = 0;
 
-        clk_enable(master->clk);
+        pm_runtime_get_sync(dai->dev);
 
         /* CKG1 */
         data = is_play ? (1 << 0) : (1 << 4);
@@ -664,8 +693,6 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
         }
 
         fsi_reg_write(fsi, reg, data);
-        dev_dbg(dai->dev, "use %s format (%d channel) use %d DMAC\n",
-                msg, fsi->chan, fsi->dma_chan);
 
         /*
          * clear clk reset if master mode
@@ -682,33 +709,29 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream,
 static void fsi_dai_shutdown(struct snd_pcm_substream *substream,
                              struct snd_soc_dai *dai)
 {
-        struct fsi_priv *fsi = fsi_get(substream);
+        struct fsi_priv *fsi = fsi_get_priv(substream);
         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 
         fsi_irq_disable(fsi, is_play);
         fsi_clk_ctrl(fsi, 0);
 
-        clk_disable(master->clk);
+        pm_runtime_put_sync(dai->dev);
 }
 
 static int fsi_dai_trigger(struct snd_pcm_substream *substream, int cmd,
                            struct snd_soc_dai *dai)
 {
-        struct fsi_priv *fsi = fsi_get(substream);
+        struct fsi_priv *fsi = fsi_get_priv(substream);
         struct snd_pcm_runtime *runtime = substream->runtime;
         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
         int ret = 0;
 
-        /* capture not supported */
-        if (!is_play)
-                return -ENODEV;
-
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
                 fsi_stream_push(fsi, substream,
                                 frames_to_bytes(runtime, runtime->buffer_size),
                                 frames_to_bytes(runtime, runtime->period_size));
-                ret = fsi_data_push(fsi);
+                ret = is_play ? fsi_data_push(fsi, 1) : fsi_data_pop(fsi, 1);
                 break;
         case SNDRV_PCM_TRIGGER_STOP:
                 fsi_irq_disable(fsi, is_play);
@@ -779,11 +802,10 @@ static int fsi_hw_free(struct snd_pcm_substream *substream)
 static snd_pcm_uframes_t fsi_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        struct fsi_priv *fsi = fsi_get(substream);
-        int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
+        struct fsi_priv *fsi = fsi_get_priv(substream);
         long location;
 
-        location = (fsi->byte_offset - 1) - fsi_get_residue(fsi, is_play);
+        location = (fsi->byte_offset - 1);
         if (location < 0)
                 location = 0;
 
@@ -845,7 +867,12 @@ struct snd_soc_dai fsi_soc_dai[] = {
                         .channels_min   = 1,
                         .channels_max   = 8,
                 },
-                /* capture not supported */
+                .capture = {
+                        .rates          = FSI_RATES,
+                        .formats        = FSI_FMTS,
+                        .channels_min   = 1,
+                        .channels_max   = 8,
+                },
                 .ops = &fsi_dai_ops,
         },
         {
@@ -857,7 +884,12 @@ struct snd_soc_dai fsi_soc_dai[] = {
                         .channels_min   = 1,
                         .channels_max   = 8,
                 },
-                /* capture not supported */
+                .capture = {
+                        .rates          = FSI_RATES,
+                        .formats        = FSI_FMTS,
+                        .channels_min   = 1,
+                        .channels_max   = 8,
+                },
                 .ops = &fsi_dai_ops,
         },
 };
@@ -880,14 +912,19 @@ EXPORT_SYMBOL_GPL(fsi_soc_platform);
 ************************************************************************/
 static int fsi_probe(struct platform_device *pdev)
 {
+        struct fsi_master *master;
         struct resource *res;
-        char clk_name[8];
         unsigned int irq;
         int ret;
 
+        if (0 != pdev->id) {
+                dev_err(&pdev->dev, "current fsi support id 0 only now\n");
+                return -ENODEV;
+        }
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_irq(pdev, 0);
-        if (!res || !irq) {
+        if (!res || (int)irq <= 0) {
                 dev_err(&pdev->dev, "Not enough FSI platform resources.\n");
                 ret = -ENODEV;
                 goto exit;
@@ -910,35 +947,25 @@ static int fsi_probe(struct platform_device *pdev)
         master->irq             = irq;
         master->info            = pdev->dev.platform_data;
         master->fsia.base       = master->base;
+        master->fsia.master     = master;
         master->fsib.base       = master->base + 0x40;
+        master->fsib.master     = master;
+        spin_lock_init(&master->lock);
 
-        master->fsia.dma_chan = -1;
-        master->fsib.dma_chan = -1;
-
-        ret = fsi_get_dma_chan();
-        if (ret < 0) {
-                dev_err(&pdev->dev, "cannot get dma api\n");
-                goto exit_iounmap;
-        }
-
-        /* FSI is based on SPU mstp */
-        snprintf(clk_name, sizeof(clk_name), "spu%d", pdev->id);
-        master->clk = clk_get(NULL, clk_name);
-        if (IS_ERR(master->clk)) {
-                dev_err(&pdev->dev, "cannot get %s mstp\n", clk_name);
-                ret = -EIO;
-                goto exit_free_dma;
-        }
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_resume(&pdev->dev);
 
         fsi_soc_dai[0].dev              = &pdev->dev;
+        fsi_soc_dai[0].private_data     = &master->fsia;
         fsi_soc_dai[1].dev              = &pdev->dev;
+        fsi_soc_dai[1].private_data     = &master->fsib;
 
-        fsi_soft_all_reset();
+        fsi_soft_all_reset(master);
 
         ret = request_irq(irq, &fsi_interrupt, IRQF_DISABLED, "fsi", master);
         if (ret) {
                 dev_err(&pdev->dev, "irq request err\n");
-                goto exit_free_dma;
+                goto exit_iounmap;
         }
 
         ret = snd_soc_register_platform(&fsi_soc_platform);
@@ -951,10 +978,9 @@ static int fsi_probe(struct platform_device *pdev)
 
 exit_free_irq:
         free_irq(irq, master);
-exit_free_dma:
-        fsi_free_dma_chan();
 exit_iounmap:
         iounmap(master->base);
+        pm_runtime_disable(&pdev->dev);
 exit_kfree:
         kfree(master);
         master = NULL;
@@ -964,24 +990,49 @@ exit:
 
 static int fsi_remove(struct platform_device *pdev)
 {
+        struct fsi_master *master;
+
+        master = fsi_get_master(fsi_soc_dai[0].private_data);
+
         snd_soc_unregister_dais(fsi_soc_dai, ARRAY_SIZE(fsi_soc_dai));
         snd_soc_unregister_platform(&fsi_soc_platform);
 
-        clk_put(master->clk);
-
-        fsi_free_dma_chan();
+        pm_runtime_disable(&pdev->dev);
 
         free_irq(master->irq, master);
 
         iounmap(master->base);
         kfree(master);
-        master = NULL;
+
+        fsi_soc_dai[0].dev              = NULL;
+        fsi_soc_dai[0].private_data     = NULL;
+        fsi_soc_dai[1].dev              = NULL;
+        fsi_soc_dai[1].private_data     = NULL;
+
+        return 0;
+}
+
+static int fsi_runtime_nop(struct device *dev)
+{
+        /* Runtime PM callback shared between ->runtime_suspend()
+         * and ->runtime_resume(). Simply returns success.
+         *
+         * This driver re-initializes all registers after
+         * pm_runtime_get_sync() anyway so there is no need
+         * to save and restore registers here.
+         */
         return 0;
 }
 
+static struct dev_pm_ops fsi_pm_ops = {
+        .runtime_suspend        = fsi_runtime_nop,
+        .runtime_resume         = fsi_runtime_nop,
+};
+
 static struct platform_driver fsi_driver = {
         .driver         = {
                 .name   = "sh_fsi",
+                .pm     = &fsi_pm_ops,
         },
         .probe          = fsi_probe,
         .remove         = fsi_remove,