24c378c1e740b0d87821f89f2ae102a2dd67e119
[linux-2.6.git] / sound / soc / sh / fsi.c
1 /*
2  * Fifo-attached Serial Interface (FSI) support for SH7724
3  *
4  * Copyright (C) 2009 Renesas Solutions Corp.
5  * Kuninori Morimoto <morimoto.kuninori@renesas.com>
6  *
7  * Based on ssi.c
8  * Copyright (c) 2007 Manuel Lauss <mano@roarinelk.homelinux.net>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  */
14
15 #include <linux/delay.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/io.h>
18 #include <linux/slab.h>
19 #include <sound/soc.h>
20 #include <sound/sh_fsi.h>
21
22 #define DO_FMT          0x0000
23 #define DOFF_CTL        0x0004
24 #define DOFF_ST         0x0008
25 #define DI_FMT          0x000C
26 #define DIFF_CTL        0x0010
27 #define DIFF_ST         0x0014
28 #define CKG1            0x0018
29 #define CKG2            0x001C
30 #define DIDT            0x0020
31 #define DODT            0x0024
32 #define MUTE_ST         0x0028
33 #define REG_END         MUTE_ST
34
35
36 #define CPU_INT_ST      0x01F4
37 #define CPU_IEMSK       0x01F8
38 #define CPU_IMSK        0x01FC
39 #define INT_ST          0x0200
40 #define IEMSK           0x0204
41 #define IMSK            0x0208
42 #define MUTE            0x020C
43 #define CLK_RST         0x0210
44 #define SOFT_RST        0x0214
45 #define FIFO_SZ         0x0218
46 #define MREG_START      CPU_INT_ST
47 #define MREG_END        FIFO_SZ
48
49 /* DO_FMT */
50 /* DI_FMT */
51 #define CR_MONO         (0x0 << 4)
52 #define CR_MONO_D       (0x1 << 4)
53 #define CR_PCM          (0x2 << 4)
54 #define CR_I2S          (0x3 << 4)
55 #define CR_TDM          (0x4 << 4)
56 #define CR_TDM_D        (0x5 << 4)
57
58 /* DOFF_CTL */
59 /* DIFF_CTL */
60 #define IRQ_HALF        0x00100000
61 #define FIFO_CLR        0x00000001
62
63 /* DOFF_ST */
64 #define ERR_OVER        0x00000010
65 #define ERR_UNDER       0x00000001
66 #define ST_ERR          (ERR_OVER | ERR_UNDER)
67
68 /* CKG1 */
69 #define ACKMD_MASK      0x00007000
70 #define BPFMD_MASK      0x00000700
71
72 /* CLK_RST */
73 #define B_CLK           0x00000010
74 #define A_CLK           0x00000001
75
76 /* INT_ST */
77 #define INT_B_IN        (1 << 12)
78 #define INT_B_OUT       (1 << 8)
79 #define INT_A_IN        (1 << 4)
80 #define INT_A_OUT       (1 << 0)
81
82 /* SOFT_RST */
83 #define PBSR            (1 << 12) /* Port B Software Reset */
84 #define PASR            (1 <<  8) /* Port A Software Reset */
85 #define IR              (1 <<  4) /* Interrupt Reset */
86 #define FSISR           (1 <<  0) /* Software Reset */
87
88 /* FIFO_SZ */
89 #define OUT_SZ_MASK     0x7
90 #define BO_SZ_SHIFT     8
91 #define AO_SZ_SHIFT     0
92
93 #define FSI_RATES SNDRV_PCM_RATE_8000_96000
94
95 #define FSI_FMTS (SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S16_LE)
96
97 /************************************************************************
98
99
100                 struct
101
102
103 ************************************************************************/
104 struct fsi_priv {
105         void __iomem *base;
106         struct snd_pcm_substream *substream;
107         struct fsi_master *master;
108
109         int fifo_max;
110         int chan;
111
112         int byte_offset;
113         int period_len;
114         int buffer_len;
115         int periods;
116 };
117
118 struct fsi_core {
119         int ver;
120
121         u32 int_st;
122         u32 iemsk;
123         u32 imsk;
124 };
125
126 struct fsi_master {
127         void __iomem *base;
128         int irq;
129         struct fsi_priv fsia;
130         struct fsi_priv fsib;
131         struct fsi_core *core;
132         struct sh_fsi_platform_info *info;
133         spinlock_t lock;
134 };
135
136 /************************************************************************
137
138
139                 basic read write function
140
141
142 ************************************************************************/
143 static void __fsi_reg_write(u32 reg, u32 data)
144 {
145         /* valid data area is 24bit */
146         data &= 0x00ffffff;
147
148         __raw_writel(data, reg);
149 }
150
151 static u32 __fsi_reg_read(u32 reg)
152 {
153         return __raw_readl(reg);
154 }
155
156 static void __fsi_reg_mask_set(u32 reg, u32 mask, u32 data)
157 {
158         u32 val = __fsi_reg_read(reg);
159
160         val &= ~mask;
161         val |= data & mask;
162
163         __fsi_reg_write(reg, val);
164 }
165
166 static void fsi_reg_write(struct fsi_priv *fsi, u32 reg, u32 data)
167 {
168         if (reg > REG_END) {
169                 pr_err("fsi: register access err (%s)\n", __func__);
170                 return;
171         }
172
173         __fsi_reg_write((u32)(fsi->base + reg), data);
174 }
175
176 static u32 fsi_reg_read(struct fsi_priv *fsi, u32 reg)
177 {
178         if (reg > REG_END) {
179                 pr_err("fsi: register access err (%s)\n", __func__);
180                 return 0;
181         }
182
183         return __fsi_reg_read((u32)(fsi->base + reg));
184 }
185
186 static void fsi_reg_mask_set(struct fsi_priv *fsi, u32 reg, u32 mask, u32 data)
187 {
188         if (reg > REG_END) {
189                 pr_err("fsi: register access err (%s)\n", __func__);
190                 return;
191         }
192
193         __fsi_reg_mask_set((u32)(fsi->base + reg), mask, data);
194 }
195
196 static void fsi_master_write(struct fsi_master *master, u32 reg, u32 data)
197 {
198         unsigned long flags;
199
200         if ((reg < MREG_START) ||
201             (reg > MREG_END)) {
202                 pr_err("fsi: register access err (%s)\n", __func__);
203                 return;
204         }
205
206         spin_lock_irqsave(&master->lock, flags);
207         __fsi_reg_write((u32)(master->base + reg), data);
208         spin_unlock_irqrestore(&master->lock, flags);
209 }
210
211 static u32 fsi_master_read(struct fsi_master *master, u32 reg)
212 {
213         u32 ret;
214         unsigned long flags;
215
216         if ((reg < MREG_START) ||
217             (reg > MREG_END)) {
218                 pr_err("fsi: register access err (%s)\n", __func__);
219                 return 0;
220         }
221
222         spin_lock_irqsave(&master->lock, flags);
223         ret = __fsi_reg_read((u32)(master->base + reg));
224         spin_unlock_irqrestore(&master->lock, flags);
225
226         return ret;
227 }
228
229 static void fsi_master_mask_set(struct fsi_master *master,
230                                u32 reg, u32 mask, u32 data)
231 {
232         unsigned long flags;
233
234         if ((reg < MREG_START) ||
235             (reg > MREG_END)) {
236                 pr_err("fsi: register access err (%s)\n", __func__);
237                 return;
238         }
239
240         spin_lock_irqsave(&master->lock, flags);
241         __fsi_reg_mask_set((u32)(master->base + reg), mask, data);
242         spin_unlock_irqrestore(&master->lock, flags);
243 }
244
245 /************************************************************************
246
247
248                 basic function
249
250
251 ************************************************************************/
252 static struct fsi_master *fsi_get_master(struct fsi_priv *fsi)
253 {
254         return fsi->master;
255 }
256
257 static int fsi_is_port_a(struct fsi_priv *fsi)
258 {
259         return fsi->master->base == fsi->base;
260 }
261
262 static struct snd_soc_dai *fsi_get_dai(struct snd_pcm_substream *substream)
263 {
264         struct snd_soc_pcm_runtime *rtd = substream->private_data;
265         struct snd_soc_dai_link *machine = rtd->dai;
266
267         return  machine->cpu_dai;
268 }
269
270 static struct fsi_priv *fsi_get_priv(struct snd_pcm_substream *substream)
271 {
272         struct snd_soc_dai *dai = fsi_get_dai(substream);
273
274         return dai->private_data;
275 }
276
277 static u32 fsi_get_info_flags(struct fsi_priv *fsi)
278 {
279         int is_porta = fsi_is_port_a(fsi);
280         struct fsi_master *master = fsi_get_master(fsi);
281
282         return is_porta ? master->info->porta_flags :
283                 master->info->portb_flags;
284 }
285
286 static int fsi_is_master_mode(struct fsi_priv *fsi, int is_play)
287 {
288         u32 mode;
289         u32 flags = fsi_get_info_flags(fsi);
290
291         mode = is_play ? SH_FSI_OUT_SLAVE_MODE : SH_FSI_IN_SLAVE_MODE;
292
293         /* return
294          * 1 : master mode
295          * 0 : slave mode
296          */
297
298         return (mode & flags) != mode;
299 }
300
301 static u32 fsi_port_ab_io_bit(struct fsi_priv *fsi, int is_play)
302 {
303         int is_porta = fsi_is_port_a(fsi);
304         u32 data;
305
306         if (is_porta)
307                 data = is_play ? (1 << 0) : (1 << 4);
308         else
309                 data = is_play ? (1 << 8) : (1 << 12);
310
311         return data;
312 }
313
314 static void fsi_stream_push(struct fsi_priv *fsi,
315                             struct snd_pcm_substream *substream,
316                             u32 buffer_len,
317                             u32 period_len)
318 {
319         fsi->substream          = substream;
320         fsi->buffer_len         = buffer_len;
321         fsi->period_len         = period_len;
322         fsi->byte_offset        = 0;
323         fsi->periods            = 0;
324 }
325
326 static void fsi_stream_pop(struct fsi_priv *fsi)
327 {
328         fsi->substream          = NULL;
329         fsi->buffer_len         = 0;
330         fsi->period_len         = 0;
331         fsi->byte_offset        = 0;
332         fsi->periods            = 0;
333 }
334
335 static int fsi_get_fifo_residue(struct fsi_priv *fsi, int is_play)
336 {
337         u32 status;
338         u32 reg = is_play ? DOFF_ST : DIFF_ST;
339         int residue;
340
341         status = fsi_reg_read(fsi, reg);
342         residue = 0x1ff & (status >> 8);
343         residue *= fsi->chan;
344
345         return residue;
346 }
347
348 /************************************************************************
349
350
351                 irq function
352
353
354 ************************************************************************/
355 static void fsi_irq_enable(struct fsi_priv *fsi, int is_play)
356 {
357         u32 data = fsi_port_ab_io_bit(fsi, is_play);
358         struct fsi_master *master = fsi_get_master(fsi);
359
360         fsi_master_mask_set(master, master->core->imsk,  data, data);
361         fsi_master_mask_set(master, master->core->iemsk, data, data);
362 }
363
364 static void fsi_irq_disable(struct fsi_priv *fsi, int is_play)
365 {
366         u32 data = fsi_port_ab_io_bit(fsi, is_play);
367         struct fsi_master *master = fsi_get_master(fsi);
368
369         fsi_master_mask_set(master, master->core->imsk,  data, 0);
370         fsi_master_mask_set(master, master->core->iemsk, data, 0);
371 }
372
373 static u32 fsi_irq_get_status(struct fsi_master *master)
374 {
375         return fsi_master_read(master, master->core->int_st);
376 }
377
378 static void fsi_irq_clear_all_status(struct fsi_master *master)
379 {
380         fsi_master_write(master, master->core->int_st, 0);
381 }
382
383 static void fsi_irq_clear_status(struct fsi_priv *fsi)
384 {
385         u32 data = 0;
386         struct fsi_master *master = fsi_get_master(fsi);
387
388         data |= fsi_port_ab_io_bit(fsi, 0);
389         data |= fsi_port_ab_io_bit(fsi, 1);
390
391         /* clear interrupt factor */
392         fsi_master_mask_set(master, master->core->int_st, data, 0);
393 }
394
395 /************************************************************************
396
397
398                 ctrl function
399
400
401 ************************************************************************/
402 static void fsi_clk_ctrl(struct fsi_priv *fsi, int enable)
403 {
404         u32 val = fsi_is_port_a(fsi) ? (1 << 0) : (1 << 4);
405         struct fsi_master *master = fsi_get_master(fsi);
406
407         if (enable)
408                 fsi_master_mask_set(master, CLK_RST, val, val);
409         else
410                 fsi_master_mask_set(master, CLK_RST, val, 0);
411 }
412
413 static void fsi_fifo_init(struct fsi_priv *fsi,
414                           int is_play,
415                           struct snd_soc_dai *dai)
416 {
417         struct fsi_master *master = fsi_get_master(fsi);
418         u32 ctrl, shift, i;
419
420         /* get on-chip RAM capacity */
421         shift = fsi_master_read(master, FIFO_SZ);
422         shift >>= fsi_is_port_a(fsi) ? AO_SZ_SHIFT : BO_SZ_SHIFT;
423         shift &= OUT_SZ_MASK;
424         fsi->fifo_max = 256 << shift;
425         dev_dbg(dai->dev, "fifo = %d words\n", fsi->fifo_max);
426
427         /*
428          * The maximum number of sample data varies depending
429          * on the number of channels selected for the format.
430          *
431          * FIFOs are used in 4-channel units in 3-channel mode
432          * and in 8-channel units in 5- to 7-channel mode
433          * meaning that more FIFOs than the required size of DPRAM
434          * are used.
435          *
436          * ex) if 256 words of DP-RAM is connected
437          * 1 channel:  256 (256 x 1 = 256)
438          * 2 channels: 128 (128 x 2 = 256)
439          * 3 channels:  64 ( 64 x 3 = 192)
440          * 4 channels:  64 ( 64 x 4 = 256)
441          * 5 channels:  32 ( 32 x 5 = 160)
442          * 6 channels:  32 ( 32 x 6 = 192)
443          * 7 channels:  32 ( 32 x 7 = 224)
444          * 8 channels:  32 ( 32 x 8 = 256)
445          */
446         for (i = 1; i < fsi->chan; i <<= 1)
447                 fsi->fifo_max >>= 1;
448         dev_dbg(dai->dev, "%d channel %d store\n", fsi->chan, fsi->fifo_max);
449
450         ctrl = is_play ? DOFF_CTL : DIFF_CTL;
451
452         /* set interrupt generation factor */
453         fsi_reg_write(fsi, ctrl, IRQ_HALF);
454
455         /* clear FIFO */
456         fsi_reg_mask_set(fsi, ctrl, FIFO_CLR, FIFO_CLR);
457 }
458
459 static void fsi_soft_all_reset(struct fsi_master *master)
460 {
461         /* port AB reset */
462         fsi_master_mask_set(master, SOFT_RST, PASR | PBSR, 0);
463         mdelay(10);
464
465         /* soft reset */
466         fsi_master_mask_set(master, SOFT_RST, FSISR, 0);
467         fsi_master_mask_set(master, SOFT_RST, FSISR, FSISR);
468         mdelay(10);
469 }
470
471 /* playback interrupt */
472 static int fsi_data_push(struct fsi_priv *fsi, int startup)
473 {
474         struct snd_pcm_runtime *runtime;
475         struct snd_pcm_substream *substream = NULL;
476         u32 status;
477         int send;
478         int fifo_free;
479         int width;
480         u8 *start;
481         int i, over_period;
482
483         if (!fsi                        ||
484             !fsi->substream             ||
485             !fsi->substream->runtime)
486                 return -EINVAL;
487
488         over_period     = 0;
489         substream       = fsi->substream;
490         runtime         = substream->runtime;
491
492         /* FSI FIFO has limit.
493          * So, this driver can not send periods data at a time
494          */
495         if (fsi->byte_offset >=
496             fsi->period_len * (fsi->periods + 1)) {
497
498                 over_period = 1;
499                 fsi->periods = (fsi->periods + 1) % runtime->periods;
500
501                 if (0 == fsi->periods)
502                         fsi->byte_offset = 0;
503         }
504
505         /* get 1 channel data width */
506         width = frames_to_bytes(runtime, 1) / fsi->chan;
507
508         /* get send size for alsa */
509         send = (fsi->buffer_len - fsi->byte_offset) / width;
510
511         /*  get FIFO free size */
512         fifo_free = (fsi->fifo_max * fsi->chan) - fsi_get_fifo_residue(fsi, 1);
513
514         /* size check */
515         if (fifo_free < send)
516                 send = fifo_free;
517
518         start = runtime->dma_area;
519         start += fsi->byte_offset;
520
521         switch (width) {
522         case 2:
523                 for (i = 0; i < send; i++)
524                         fsi_reg_write(fsi, DODT,
525                                       ((u32)*((u16 *)start + i) << 8));
526                 break;
527         case 4:
528                 for (i = 0; i < send; i++)
529                         fsi_reg_write(fsi, DODT, *((u32 *)start + i));
530                 break;
531         default:
532                 return -EINVAL;
533         }
534
535         fsi->byte_offset += send * width;
536
537         status = fsi_reg_read(fsi, DOFF_ST);
538         if (!startup) {
539                 struct snd_soc_dai *dai = fsi_get_dai(substream);
540
541                 if (status & ERR_OVER)
542                         dev_err(dai->dev, "over run\n");
543                 if (status & ERR_UNDER)
544                         dev_err(dai->dev, "under run\n");
545         }
546         fsi_reg_write(fsi, DOFF_ST, 0);
547
548         fsi_irq_enable(fsi, 1);
549
550         if (over_period)
551                 snd_pcm_period_elapsed(substream);
552
553         return 0;
554 }
555
556 static int fsi_data_pop(struct fsi_priv *fsi, int startup)
557 {
558         struct snd_pcm_runtime *runtime;
559         struct snd_pcm_substream *substream = NULL;
560         u32 status;
561         int free;
562         int fifo_fill;
563         int width;
564         u8 *start;
565         int i, over_period;
566
567         if (!fsi                        ||
568             !fsi->substream             ||
569             !fsi->substream->runtime)
570                 return -EINVAL;
571
572         over_period     = 0;
573         substream       = fsi->substream;
574         runtime         = substream->runtime;
575
576         /* FSI FIFO has limit.
577          * So, this driver can not send periods data at a time
578          */
579         if (fsi->byte_offset >=
580             fsi->period_len * (fsi->periods + 1)) {
581
582                 over_period = 1;
583                 fsi->periods = (fsi->periods + 1) % runtime->periods;
584
585                 if (0 == fsi->periods)
586                         fsi->byte_offset = 0;
587         }
588
589         /* get 1 channel data width */
590         width = frames_to_bytes(runtime, 1) / fsi->chan;
591
592         /* get free space for alsa */
593         free = (fsi->buffer_len - fsi->byte_offset) / width;
594
595         /* get recv size */
596         fifo_fill = fsi_get_fifo_residue(fsi, 0);
597
598         if (free < fifo_fill)
599                 fifo_fill = free;
600
601         start = runtime->dma_area;
602         start += fsi->byte_offset;
603
604         switch (width) {
605         case 2:
606                 for (i = 0; i < fifo_fill; i++)
607                         *((u16 *)start + i) =
608                                 (u16)(fsi_reg_read(fsi, DIDT) >> 8);
609                 break;
610         case 4:
611                 for (i = 0; i < fifo_fill; i++)
612                         *((u32 *)start + i) = fsi_reg_read(fsi, DIDT);
613                 break;
614         default:
615                 return -EINVAL;
616         }
617
618         fsi->byte_offset += fifo_fill * width;
619
620         status = fsi_reg_read(fsi, DIFF_ST);
621         if (!startup) {
622                 struct snd_soc_dai *dai = fsi_get_dai(substream);
623
624                 if (status & ERR_OVER)
625                         dev_err(dai->dev, "over run\n");
626                 if (status & ERR_UNDER)
627                         dev_err(dai->dev, "under run\n");
628         }
629         fsi_reg_write(fsi, DIFF_ST, 0);
630
631         fsi_irq_enable(fsi, 0);
632
633         if (over_period)
634                 snd_pcm_period_elapsed(substream);
635
636         return 0;
637 }
638
639 static irqreturn_t fsi_interrupt(int irq, void *data)
640 {
641         struct fsi_master *master = data;
642         u32 int_st = fsi_irq_get_status(master);
643
644         /* clear irq status */
645         fsi_master_mask_set(master, SOFT_RST, IR, 0);
646         fsi_master_mask_set(master, SOFT_RST, IR, IR);
647
648         if (int_st & INT_A_OUT)
649                 fsi_data_push(&master->fsia, 0);
650         if (int_st & INT_B_OUT)
651                 fsi_data_push(&master->fsib, 0);
652         if (int_st & INT_A_IN)
653                 fsi_data_pop(&master->fsia, 0);
654         if (int_st & INT_B_IN)
655                 fsi_data_pop(&master->fsib, 0);
656
657         fsi_irq_clear_all_status(master);
658
659         return IRQ_HANDLED;
660 }
661
662 /************************************************************************
663
664
665                 dai ops
666
667
668 ************************************************************************/
669 static int fsi_dai_startup(struct snd_pcm_substream *substream,
670                            struct snd_soc_dai *dai)
671 {
672         struct fsi_priv *fsi = fsi_get_priv(substream);
673         u32 flags = fsi_get_info_flags(fsi);
674         u32 fmt;
675         u32 reg;
676         u32 data;
677         int is_play = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
678         int is_master;
679         int ret = 0;
680
681         pm_runtime_get_sync(dai->dev);
682
683         /* CKG1 */
684         data = is_play ? (1 << 0) : (1 << 4);
685         is_master = fsi_is_master_mode(fsi, is_play);
686         if (is_master)
687                 fsi_reg_mask_set(fsi, CKG1, data, data);
688         else
689                 fsi_reg_mask_set(fsi, CKG1, data, 0);
690
691         /* clock inversion (CKG2) */
692         data = 0;
693         if (SH_FSI_LRM_INV & flags)
694                 data |= 1 << 12;
695         if (SH_FSI_BRM_INV & flags)
696                 data |= 1 << 8;
697         if (SH_FSI_LRS_INV & flags)
698                 data |= 1 << 4;
699         if (SH_FSI_BRS_INV & flags)
700                 data |= 1 << 0;
701
702         fsi_reg_write(fsi, CKG2, data);
703
704         /* do fmt, di fmt */
705         data = 0;
706         reg = is_play ? DO_FMT : DI_FMT;
707         fmt = is_play ? SH_FSI_GET_OFMT(flags) : SH_FSI_GET_IFMT(flags);
708         switch (fmt) {
709         case SH_FSI_FMT_MONO:
710                 data = CR_MONO;
711                 fsi->chan = 1;
712                 break;
713         case SH_FSI_FMT_MONO_DELAY:
714                 data = CR_MONO_D;
715                 fsi->chan = 1;
716                 break;
717         case SH_FSI_FMT_PCM:
718                 data = CR_PCM;
719                 fsi->chan = 2;
720                 break;
721         case SH_FSI_FMT_I2S:
722                 data = CR_I2S;
723                 fsi->chan = 2;
724                 break;
725         case SH_FSI_FMT_TDM:
726                 fsi->chan = is_play ?
727                         SH_FSI_GET_CH_O(flags) : SH_FSI_GET_CH_I(flags);
728                 data = CR_TDM | (fsi->chan - 1);
729                 break;
730         case SH_FSI_FMT_TDM_DELAY:
731                 fsi->chan = is_play ?
732                         SH_FSI_GET_CH_O(flags) : SH_FSI_GET_CH_I(flags);
733                 data = CR_TDM_D | (fsi->chan - 1);
734                 break;
735         default:
736                 dev_err(dai->dev, "unknown format.\n");
737                 return -EINVAL;
738         }
739         fsi_reg_write(fsi, reg, data);
740
741         /* irq clear */
742         fsi_irq_disable(fsi, is_play);
743         fsi_irq_clear_status(fsi);
744
745         /* fifo init */
746         fsi_fifo_init(fsi, is_play, dai);
747
748         return ret;
749 }
750
751 static void fsi_dai_shutdown(struct snd_pcm_substream *substream,
752                              struct snd_soc_dai *dai)
753 {
754         struct fsi_priv *fsi = fsi_get_priv(substream);
755         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
756
757         fsi_irq_disable(fsi, is_play);
758         fsi_clk_ctrl(fsi, 0);
759
760         pm_runtime_put_sync(dai->dev);
761 }
762
763 static int fsi_dai_trigger(struct snd_pcm_substream *substream, int cmd,
764                            struct snd_soc_dai *dai)
765 {
766         struct fsi_priv *fsi = fsi_get_priv(substream);
767         struct snd_pcm_runtime *runtime = substream->runtime;
768         int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
769         int ret = 0;
770
771         switch (cmd) {
772         case SNDRV_PCM_TRIGGER_START:
773                 fsi_stream_push(fsi, substream,
774                                 frames_to_bytes(runtime, runtime->buffer_size),
775                                 frames_to_bytes(runtime, runtime->period_size));
776                 ret = is_play ? fsi_data_push(fsi, 1) : fsi_data_pop(fsi, 1);
777                 break;
778         case SNDRV_PCM_TRIGGER_STOP:
779                 fsi_irq_disable(fsi, is_play);
780                 fsi_stream_pop(fsi);
781                 break;
782         }
783
784         return ret;
785 }
786
787 static int fsi_dai_hw_params(struct snd_pcm_substream *substream,
788                              struct snd_pcm_hw_params *params,
789                              struct snd_soc_dai *dai)
790 {
791         struct fsi_priv *fsi = fsi_get_priv(substream);
792         struct fsi_master *master = fsi_get_master(fsi);
793         int (*set_rate)(int is_porta, int rate) = master->info->set_rate;
794         int fsi_ver = master->core->ver;
795         int is_play = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
796         int ret;
797
798         /* if slave mode, set_rate is not needed */
799         if (!fsi_is_master_mode(fsi, is_play))
800                 return 0;
801
802         /* it is error if no set_rate */
803         if (!set_rate)
804                 return -EIO;
805
806         ret = set_rate(fsi_is_port_a(fsi), params_rate(params));
807         if (ret > 0) {
808                 u32 data = 0;
809
810                 switch (ret & SH_FSI_ACKMD_MASK) {
811                 default:
812                         /* FALL THROUGH */
813                 case SH_FSI_ACKMD_512:
814                         data |= (0x0 << 12);
815                         break;
816                 case SH_FSI_ACKMD_256:
817                         data |= (0x1 << 12);
818                         break;
819                 case SH_FSI_ACKMD_128:
820                         data |= (0x2 << 12);
821                         break;
822                 case SH_FSI_ACKMD_64:
823                         data |= (0x3 << 12);
824                         break;
825                 case SH_FSI_ACKMD_32:
826                         if (fsi_ver < 2)
827                                 dev_err(dai->dev, "unsupported ACKMD\n");
828                         else
829                                 data |= (0x4 << 12);
830                         break;
831                 }
832
833                 switch (ret & SH_FSI_BPFMD_MASK) {
834                 default:
835                         /* FALL THROUGH */
836                 case SH_FSI_BPFMD_32:
837                         data |= (0x0 << 8);
838                         break;
839                 case SH_FSI_BPFMD_64:
840                         data |= (0x1 << 8);
841                         break;
842                 case SH_FSI_BPFMD_128:
843                         data |= (0x2 << 8);
844                         break;
845                 case SH_FSI_BPFMD_256:
846                         data |= (0x3 << 8);
847                         break;
848                 case SH_FSI_BPFMD_512:
849                         data |= (0x4 << 8);
850                         break;
851                 case SH_FSI_BPFMD_16:
852                         if (fsi_ver < 2)
853                                 dev_err(dai->dev, "unsupported ACKMD\n");
854                         else
855                                 data |= (0x7 << 8);
856                         break;
857                 }
858
859                 fsi_reg_mask_set(fsi, CKG1, (ACKMD_MASK | BPFMD_MASK) , data);
860                 udelay(10);
861                 fsi_clk_ctrl(fsi, 1);
862                 ret = 0;
863         }
864
865         return ret;
866
867 }
868
869 static struct snd_soc_dai_ops fsi_dai_ops = {
870         .startup        = fsi_dai_startup,
871         .shutdown       = fsi_dai_shutdown,
872         .trigger        = fsi_dai_trigger,
873         .hw_params      = fsi_dai_hw_params,
874 };
875
876 /************************************************************************
877
878
879                 pcm ops
880
881
882 ************************************************************************/
883 static struct snd_pcm_hardware fsi_pcm_hardware = {
884         .info =         SNDRV_PCM_INFO_INTERLEAVED      |
885                         SNDRV_PCM_INFO_MMAP             |
886                         SNDRV_PCM_INFO_MMAP_VALID       |
887                         SNDRV_PCM_INFO_PAUSE,
888         .formats                = FSI_FMTS,
889         .rates                  = FSI_RATES,
890         .rate_min               = 8000,
891         .rate_max               = 192000,
892         .channels_min           = 1,
893         .channels_max           = 2,
894         .buffer_bytes_max       = 64 * 1024,
895         .period_bytes_min       = 32,
896         .period_bytes_max       = 8192,
897         .periods_min            = 1,
898         .periods_max            = 32,
899         .fifo_size              = 256,
900 };
901
902 static int fsi_pcm_open(struct snd_pcm_substream *substream)
903 {
904         struct snd_pcm_runtime *runtime = substream->runtime;
905         int ret = 0;
906
907         snd_soc_set_runtime_hwparams(substream, &fsi_pcm_hardware);
908
909         ret = snd_pcm_hw_constraint_integer(runtime,
910                                             SNDRV_PCM_HW_PARAM_PERIODS);
911
912         return ret;
913 }
914
915 static int fsi_hw_params(struct snd_pcm_substream *substream,
916                          struct snd_pcm_hw_params *hw_params)
917 {
918         return snd_pcm_lib_malloc_pages(substream,
919                                         params_buffer_bytes(hw_params));
920 }
921
922 static int fsi_hw_free(struct snd_pcm_substream *substream)
923 {
924         return snd_pcm_lib_free_pages(substream);
925 }
926
927 static snd_pcm_uframes_t fsi_pointer(struct snd_pcm_substream *substream)
928 {
929         struct snd_pcm_runtime *runtime = substream->runtime;
930         struct fsi_priv *fsi = fsi_get_priv(substream);
931         long location;
932
933         location = (fsi->byte_offset - 1);
934         if (location < 0)
935                 location = 0;
936
937         return bytes_to_frames(runtime, location);
938 }
939
940 static struct snd_pcm_ops fsi_pcm_ops = {
941         .open           = fsi_pcm_open,
942         .ioctl          = snd_pcm_lib_ioctl,
943         .hw_params      = fsi_hw_params,
944         .hw_free        = fsi_hw_free,
945         .pointer        = fsi_pointer,
946 };
947
948 /************************************************************************
949
950
951                 snd_soc_platform
952
953
954 ************************************************************************/
955 #define PREALLOC_BUFFER         (32 * 1024)
956 #define PREALLOC_BUFFER_MAX     (32 * 1024)
957
958 static void fsi_pcm_free(struct snd_pcm *pcm)
959 {
960         snd_pcm_lib_preallocate_free_for_all(pcm);
961 }
962
963 static int fsi_pcm_new(struct snd_card *card,
964                        struct snd_soc_dai *dai,
965                        struct snd_pcm *pcm)
966 {
967         /*
968          * dont use SNDRV_DMA_TYPE_DEV, since it will oops the SH kernel
969          * in MMAP mode (i.e. aplay -M)
970          */
971         return snd_pcm_lib_preallocate_pages_for_all(
972                 pcm,
973                 SNDRV_DMA_TYPE_CONTINUOUS,
974                 snd_dma_continuous_data(GFP_KERNEL),
975                 PREALLOC_BUFFER, PREALLOC_BUFFER_MAX);
976 }
977
978 /************************************************************************
979
980
981                 alsa struct
982
983
984 ************************************************************************/
985 struct snd_soc_dai fsi_soc_dai[] = {
986         {
987                 .name                   = "FSIA",
988                 .id                     = 0,
989                 .playback = {
990                         .rates          = FSI_RATES,
991                         .formats        = FSI_FMTS,
992                         .channels_min   = 1,
993                         .channels_max   = 8,
994                 },
995                 .capture = {
996                         .rates          = FSI_RATES,
997                         .formats        = FSI_FMTS,
998                         .channels_min   = 1,
999                         .channels_max   = 8,
1000                 },
1001                 .ops = &fsi_dai_ops,
1002         },
1003         {
1004                 .name                   = "FSIB",
1005                 .id                     = 1,
1006                 .playback = {
1007                         .rates          = FSI_RATES,
1008                         .formats        = FSI_FMTS,
1009                         .channels_min   = 1,
1010                         .channels_max   = 8,
1011                 },
1012                 .capture = {
1013                         .rates          = FSI_RATES,
1014                         .formats        = FSI_FMTS,
1015                         .channels_min   = 1,
1016                         .channels_max   = 8,
1017                 },
1018                 .ops = &fsi_dai_ops,
1019         },
1020 };
1021 EXPORT_SYMBOL_GPL(fsi_soc_dai);
1022
1023 struct snd_soc_platform fsi_soc_platform = {
1024         .name           = "fsi-pcm",
1025         .pcm_ops        = &fsi_pcm_ops,
1026         .pcm_new        = fsi_pcm_new,
1027         .pcm_free       = fsi_pcm_free,
1028 };
1029 EXPORT_SYMBOL_GPL(fsi_soc_platform);
1030
1031 /************************************************************************
1032
1033
1034                 platform function
1035
1036
1037 ************************************************************************/
1038 static int fsi_probe(struct platform_device *pdev)
1039 {
1040         struct fsi_master *master;
1041         const struct platform_device_id *id_entry;
1042         struct resource *res;
1043         unsigned int irq;
1044         int ret;
1045
1046         if (0 != pdev->id) {
1047                 dev_err(&pdev->dev, "current fsi support id 0 only now\n");
1048                 return -ENODEV;
1049         }
1050
1051         id_entry = pdev->id_entry;
1052         if (!id_entry) {
1053                 dev_err(&pdev->dev, "unknown fsi device\n");
1054                 return -ENODEV;
1055         }
1056
1057         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1058         irq = platform_get_irq(pdev, 0);
1059         if (!res || (int)irq <= 0) {
1060                 dev_err(&pdev->dev, "Not enough FSI platform resources.\n");
1061                 ret = -ENODEV;
1062                 goto exit;
1063         }
1064
1065         master = kzalloc(sizeof(*master), GFP_KERNEL);
1066         if (!master) {
1067                 dev_err(&pdev->dev, "Could not allocate master\n");
1068                 ret = -ENOMEM;
1069                 goto exit;
1070         }
1071
1072         master->base = ioremap_nocache(res->start, resource_size(res));
1073         if (!master->base) {
1074                 ret = -ENXIO;
1075                 dev_err(&pdev->dev, "Unable to ioremap FSI registers.\n");
1076                 goto exit_kfree;
1077         }
1078
1079         master->irq             = irq;
1080         master->info            = pdev->dev.platform_data;
1081         master->fsia.base       = master->base;
1082         master->fsia.master     = master;
1083         master->fsib.base       = master->base + 0x40;
1084         master->fsib.master     = master;
1085         master->core            = (struct fsi_core *)id_entry->driver_data;
1086         spin_lock_init(&master->lock);
1087
1088         pm_runtime_enable(&pdev->dev);
1089         pm_runtime_resume(&pdev->dev);
1090
1091         fsi_soc_dai[0].dev              = &pdev->dev;
1092         fsi_soc_dai[0].private_data     = &master->fsia;
1093         fsi_soc_dai[1].dev              = &pdev->dev;
1094         fsi_soc_dai[1].private_data     = &master->fsib;
1095
1096         fsi_soft_all_reset(master);
1097
1098         ret = request_irq(irq, &fsi_interrupt, IRQF_DISABLED,
1099                           id_entry->name, master);
1100         if (ret) {
1101                 dev_err(&pdev->dev, "irq request err\n");
1102                 goto exit_iounmap;
1103         }
1104
1105         ret = snd_soc_register_platform(&fsi_soc_platform);
1106         if (ret < 0) {
1107                 dev_err(&pdev->dev, "cannot snd soc register\n");
1108                 goto exit_free_irq;
1109         }
1110
1111         return snd_soc_register_dais(fsi_soc_dai, ARRAY_SIZE(fsi_soc_dai));
1112
1113 exit_free_irq:
1114         free_irq(irq, master);
1115 exit_iounmap:
1116         iounmap(master->base);
1117         pm_runtime_disable(&pdev->dev);
1118 exit_kfree:
1119         kfree(master);
1120         master = NULL;
1121 exit:
1122         return ret;
1123 }
1124
1125 static int fsi_remove(struct platform_device *pdev)
1126 {
1127         struct fsi_master *master;
1128
1129         master = fsi_get_master(fsi_soc_dai[0].private_data);
1130
1131         snd_soc_unregister_dais(fsi_soc_dai, ARRAY_SIZE(fsi_soc_dai));
1132         snd_soc_unregister_platform(&fsi_soc_platform);
1133
1134         pm_runtime_disable(&pdev->dev);
1135
1136         free_irq(master->irq, master);
1137
1138         iounmap(master->base);
1139         kfree(master);
1140
1141         fsi_soc_dai[0].dev              = NULL;
1142         fsi_soc_dai[0].private_data     = NULL;
1143         fsi_soc_dai[1].dev              = NULL;
1144         fsi_soc_dai[1].private_data     = NULL;
1145
1146         return 0;
1147 }
1148
1149 static int fsi_runtime_nop(struct device *dev)
1150 {
1151         /* Runtime PM callback shared between ->runtime_suspend()
1152          * and ->runtime_resume(). Simply returns success.
1153          *
1154          * This driver re-initializes all registers after
1155          * pm_runtime_get_sync() anyway so there is no need
1156          * to save and restore registers here.
1157          */
1158         return 0;
1159 }
1160
1161 static struct dev_pm_ops fsi_pm_ops = {
1162         .runtime_suspend        = fsi_runtime_nop,
1163         .runtime_resume         = fsi_runtime_nop,
1164 };
1165
1166 static struct fsi_core fsi1_core = {
1167         .ver    = 1,
1168
1169         /* Interrupt */
1170         .int_st = INT_ST,
1171         .iemsk  = IEMSK,
1172         .imsk   = IMSK,
1173 };
1174
1175 static struct fsi_core fsi2_core = {
1176         .ver    = 2,
1177
1178         /* Interrupt */
1179         .int_st = CPU_INT_ST,
1180         .iemsk  = CPU_IEMSK,
1181         .imsk   = CPU_IMSK,
1182 };
1183
1184 static struct platform_device_id fsi_id_table[] = {
1185         { "sh_fsi",     (kernel_ulong_t)&fsi1_core },
1186         { "sh_fsi2",    (kernel_ulong_t)&fsi2_core },
1187 };
1188
1189 static struct platform_driver fsi_driver = {
1190         .driver         = {
1191                 .name   = "sh_fsi",
1192                 .pm     = &fsi_pm_ops,
1193         },
1194         .probe          = fsi_probe,
1195         .remove         = fsi_remove,
1196         .id_table       = fsi_id_table,
1197 };
1198
1199 static int __init fsi_mobile_init(void)
1200 {
1201         return platform_driver_register(&fsi_driver);
1202 }
1203
1204 static void __exit fsi_mobile_exit(void)
1205 {
1206         platform_driver_unregister(&fsi_driver);
1207 }
1208 module_init(fsi_mobile_init);
1209 module_exit(fsi_mobile_exit);
1210
1211 MODULE_LICENSE("GPL");
1212 MODULE_DESCRIPTION("SuperH onchip FSI audio driver");
1213 MODULE_AUTHOR("Kuninori Morimoto <morimoto.kuninori@renesas.com>");