ALSA: Add missing SNDRV_PCM_INFO_BATCH flag to some drivers
[linux-2.6.git] / sound / soc / fsl / mpc5200_psc_i2s.c
1 /*
2  * Freescale MPC5200 PSC in I2S mode
3  * ALSA SoC Digital Audio Interface (DAI) driver
4  *
5  * Copyright (C) 2008 Secret Lab Technologies Ltd.
6  */
7
8 #include <linux/init.h>
9 #include <linux/module.h>
10 #include <linux/interrupt.h>
11 #include <linux/device.h>
12 #include <linux/delay.h>
13 #include <linux/of_device.h>
14 #include <linux/of_platform.h>
15 #include <linux/dma-mapping.h>
16
17 #include <sound/core.h>
18 #include <sound/pcm.h>
19 #include <sound/pcm_params.h>
20 #include <sound/initval.h>
21 #include <sound/soc.h>
22 #include <sound/soc-of-simple.h>
23
24 #include <sysdev/bestcomm/bestcomm.h>
25 #include <sysdev/bestcomm/gen_bd.h>
26 #include <asm/mpc52xx_psc.h>
27
28 MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
29 MODULE_DESCRIPTION("Freescale MPC5200 PSC in I2S mode ASoC Driver");
30 MODULE_LICENSE("GPL");
31
32 /**
33  * PSC_I2S_RATES: sample rates supported by the I2S
34  *
35  * This driver currently only supports the PSC running in I2S slave mode,
36  * which means the codec determines the sample rate.  Therefore, we tell
37  * ALSA that we support all rates and let the codec driver decide what rates
38  * are really supported.
39  */
40 #define PSC_I2S_RATES (SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_192000 | \
41                         SNDRV_PCM_RATE_CONTINUOUS)
42
43 /**
44  * PSC_I2S_FORMATS: audio formats supported by the PSC I2S mode
45  */
46 #define PSC_I2S_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE | \
47                          SNDRV_PCM_FMTBIT_S24_BE | SNDRV_PCM_FMTBIT_S24_BE | \
48                          SNDRV_PCM_FMTBIT_S32_BE)
49
50 /**
51  * psc_i2s_stream - Data specific to a single stream (playback or capture)
52  * @active:             flag indicating if the stream is active
53  * @psc_i2s:            pointer back to parent psc_i2s data structure
54  * @bcom_task:          bestcomm task structure
55  * @irq:                irq number for bestcomm task
56  * @period_start:       physical address of start of DMA region
57  * @period_end:         physical address of end of DMA region
58  * @period_next_pt:     physical address of next DMA buffer to enqueue
59  * @period_bytes:       size of DMA period in bytes
60  */
61 struct psc_i2s_stream {
62         int active;
63         struct psc_i2s *psc_i2s;
64         struct bcom_task *bcom_task;
65         int irq;
66         struct snd_pcm_substream *stream;
67         dma_addr_t period_start;
68         dma_addr_t period_end;
69         dma_addr_t period_next_pt;
70         dma_addr_t period_current_pt;
71         int period_bytes;
72 };
73
74 /**
75  * psc_i2s - Private driver data
76  * @name: short name for this device ("PSC0", "PSC1", etc)
77  * @psc_regs: pointer to the PSC's registers
78  * @fifo_regs: pointer to the PSC's FIFO registers
79  * @irq: IRQ of this PSC
80  * @dev: struct device pointer
81  * @dai: the CPU DAI for this device
82  * @sicr: Base value used in serial interface control register; mode is ORed
83  *        with this value.
84  * @playback: Playback stream context data
85  * @capture: Capture stream context data
86  */
87 struct psc_i2s {
88         char name[32];
89         struct mpc52xx_psc __iomem *psc_regs;
90         struct mpc52xx_psc_fifo __iomem *fifo_regs;
91         unsigned int irq;
92         struct device *dev;
93         struct snd_soc_dai dai;
94         spinlock_t lock;
95         u32 sicr;
96
97         /* per-stream data */
98         struct psc_i2s_stream playback;
99         struct psc_i2s_stream capture;
100
101         /* Statistics */
102         struct {
103                 int overrun_count;
104                 int underrun_count;
105         } stats;
106 };
107
108 /*
109  * Interrupt handlers
110  */
111 static irqreturn_t psc_i2s_status_irq(int irq, void *_psc_i2s)
112 {
113         struct psc_i2s *psc_i2s = _psc_i2s;
114         struct mpc52xx_psc __iomem *regs = psc_i2s->psc_regs;
115         u16 isr;
116
117         isr = in_be16(&regs->mpc52xx_psc_isr);
118
119         /* Playback underrun error */
120         if (psc_i2s->playback.active && (isr & MPC52xx_PSC_IMR_TXEMP))
121                 psc_i2s->stats.underrun_count++;
122
123         /* Capture overrun error */
124         if (psc_i2s->capture.active && (isr & MPC52xx_PSC_IMR_ORERR))
125                 psc_i2s->stats.overrun_count++;
126
127         out_8(&regs->command, 4 << 4);  /* reset the error status */
128
129         return IRQ_HANDLED;
130 }
131
132 /**
133  * psc_i2s_bcom_enqueue_next_buffer - Enqueue another audio buffer
134  * @s: pointer to stream private data structure
135  *
136  * Enqueues another audio period buffer into the bestcomm queue.
137  *
138  * Note: The routine must only be called when there is space available in
139  * the queue.  Otherwise the enqueue will fail and the audio ring buffer
140  * will get out of sync
141  */
142 static void psc_i2s_bcom_enqueue_next_buffer(struct psc_i2s_stream *s)
143 {
144         struct bcom_bd *bd;
145
146         /* Prepare and enqueue the next buffer descriptor */
147         bd = bcom_prepare_next_buffer(s->bcom_task);
148         bd->status = s->period_bytes;
149         bd->data[0] = s->period_next_pt;
150         bcom_submit_next_buffer(s->bcom_task, NULL);
151
152         /* Update for next period */
153         s->period_next_pt += s->period_bytes;
154         if (s->period_next_pt >= s->period_end)
155                 s->period_next_pt = s->period_start;
156 }
157
158 /* Bestcomm DMA irq handler */
159 static irqreturn_t psc_i2s_bcom_irq(int irq, void *_psc_i2s_stream)
160 {
161         struct psc_i2s_stream *s = _psc_i2s_stream;
162
163         /* For each finished period, dequeue the completed period buffer
164          * and enqueue a new one in it's place. */
165         while (bcom_buffer_done(s->bcom_task)) {
166                 bcom_retrieve_buffer(s->bcom_task, NULL, NULL);
167                 s->period_current_pt += s->period_bytes;
168                 if (s->period_current_pt >= s->period_end)
169                         s->period_current_pt = s->period_start;
170                 psc_i2s_bcom_enqueue_next_buffer(s);
171                 bcom_enable(s->bcom_task);
172         }
173
174         /* If the stream is active, then also inform the PCM middle layer
175          * of the period finished event. */
176         if (s->active)
177                 snd_pcm_period_elapsed(s->stream);
178
179         return IRQ_HANDLED;
180 }
181
182 /**
183  * psc_i2s_startup: create a new substream
184  *
185  * This is the first function called when a stream is opened.
186  *
187  * If this is the first stream open, then grab the IRQ and program most of
188  * the PSC registers.
189  */
190 static int psc_i2s_startup(struct snd_pcm_substream *substream,
191                            struct snd_soc_dai *dai)
192 {
193         struct snd_soc_pcm_runtime *rtd = substream->private_data;
194         struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
195         int rc;
196
197         dev_dbg(psc_i2s->dev, "psc_i2s_startup(substream=%p)\n", substream);
198
199         if (!psc_i2s->playback.active &&
200             !psc_i2s->capture.active) {
201                 /* Setup the IRQs */
202                 rc = request_irq(psc_i2s->irq, &psc_i2s_status_irq, IRQF_SHARED,
203                                  "psc-i2s-status", psc_i2s);
204                 rc |= request_irq(psc_i2s->capture.irq,
205                                   &psc_i2s_bcom_irq, IRQF_SHARED,
206                                   "psc-i2s-capture", &psc_i2s->capture);
207                 rc |= request_irq(psc_i2s->playback.irq,
208                                   &psc_i2s_bcom_irq, IRQF_SHARED,
209                                   "psc-i2s-playback", &psc_i2s->playback);
210                 if (rc) {
211                         free_irq(psc_i2s->irq, psc_i2s);
212                         free_irq(psc_i2s->capture.irq,
213                                  &psc_i2s->capture);
214                         free_irq(psc_i2s->playback.irq,
215                                  &psc_i2s->playback);
216                         return -ENODEV;
217                 }
218         }
219
220         return 0;
221 }
222
223 static int psc_i2s_hw_params(struct snd_pcm_substream *substream,
224                                  struct snd_pcm_hw_params *params,
225                                  struct snd_soc_dai *dai)
226 {
227         struct snd_soc_pcm_runtime *rtd = substream->private_data;
228         struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
229         u32 mode;
230
231         dev_dbg(psc_i2s->dev, "%s(substream=%p) p_size=%i p_bytes=%i"
232                 " periods=%i buffer_size=%i  buffer_bytes=%i\n",
233                 __func__, substream, params_period_size(params),
234                 params_period_bytes(params), params_periods(params),
235                 params_buffer_size(params), params_buffer_bytes(params));
236
237         switch (params_format(params)) {
238         case SNDRV_PCM_FORMAT_S8:
239                 mode = MPC52xx_PSC_SICR_SIM_CODEC_8;
240                 break;
241         case SNDRV_PCM_FORMAT_S16_BE:
242                 mode = MPC52xx_PSC_SICR_SIM_CODEC_16;
243                 break;
244         case SNDRV_PCM_FORMAT_S24_BE:
245                 mode = MPC52xx_PSC_SICR_SIM_CODEC_24;
246                 break;
247         case SNDRV_PCM_FORMAT_S32_BE:
248                 mode = MPC52xx_PSC_SICR_SIM_CODEC_32;
249                 break;
250         default:
251                 dev_dbg(psc_i2s->dev, "invalid format\n");
252                 return -EINVAL;
253         }
254         out_be32(&psc_i2s->psc_regs->sicr, psc_i2s->sicr | mode);
255
256         snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
257
258         return 0;
259 }
260
261 static int psc_i2s_hw_free(struct snd_pcm_substream *substream,
262                            struct snd_soc_dai *dai)
263 {
264         snd_pcm_set_runtime_buffer(substream, NULL);
265         return 0;
266 }
267
268 /**
269  * psc_i2s_trigger: start and stop the DMA transfer.
270  *
271  * This function is called by ALSA to start, stop, pause, and resume the DMA
272  * transfer of data.
273  */
274 static int psc_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
275                            struct snd_soc_dai *dai)
276 {
277         struct snd_soc_pcm_runtime *rtd = substream->private_data;
278         struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
279         struct snd_pcm_runtime *runtime = substream->runtime;
280         struct psc_i2s_stream *s;
281         struct mpc52xx_psc __iomem *regs = psc_i2s->psc_regs;
282         u16 imr;
283         u8 psc_cmd;
284         unsigned long flags;
285
286         if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
287                 s = &psc_i2s->capture;
288         else
289                 s = &psc_i2s->playback;
290
291         dev_dbg(psc_i2s->dev, "psc_i2s_trigger(substream=%p, cmd=%i)"
292                 " stream_id=%i\n",
293                 substream, cmd, substream->pstr->stream);
294
295         switch (cmd) {
296         case SNDRV_PCM_TRIGGER_START:
297                 s->period_bytes = frames_to_bytes(runtime,
298                                                   runtime->period_size);
299                 s->period_start = virt_to_phys(runtime->dma_area);
300                 s->period_end = s->period_start +
301                                 (s->period_bytes * runtime->periods);
302                 s->period_next_pt = s->period_start;
303                 s->period_current_pt = s->period_start;
304                 s->active = 1;
305
306                 /* First; reset everything */
307                 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE) {
308                         out_8(&regs->command, MPC52xx_PSC_RST_RX);
309                         out_8(&regs->command, MPC52xx_PSC_RST_ERR_STAT);
310                 } else {
311                         out_8(&regs->command, MPC52xx_PSC_RST_TX);
312                         out_8(&regs->command, MPC52xx_PSC_RST_ERR_STAT);
313                 }
314
315                 /* Next, fill up the bestcomm bd queue and enable DMA.
316                  * This will begin filling the PSC's fifo. */
317                 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
318                         bcom_gen_bd_rx_reset(s->bcom_task);
319                 else
320                         bcom_gen_bd_tx_reset(s->bcom_task);
321                 while (!bcom_queue_full(s->bcom_task))
322                         psc_i2s_bcom_enqueue_next_buffer(s);
323                 bcom_enable(s->bcom_task);
324
325                 /* Due to errata in the i2s mode; need to line up enabling
326                  * the transmitter with a transition on the frame sync
327                  * line */
328
329                 spin_lock_irqsave(&psc_i2s->lock, flags);
330                 /* first make sure it is low */
331                 while ((in_8(&regs->ipcr_acr.ipcr) & 0x80) != 0)
332                         ;
333                 /* then wait for the transition to high */
334                 while ((in_8(&regs->ipcr_acr.ipcr) & 0x80) == 0)
335                         ;
336                 /* Finally, enable the PSC.
337                  * Receiver must always be enabled; even when we only want
338                  * transmit.  (see 15.3.2.3 of MPC5200B User's Guide) */
339                 psc_cmd = MPC52xx_PSC_RX_ENABLE;
340                 if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK)
341                         psc_cmd |= MPC52xx_PSC_TX_ENABLE;
342                 out_8(&regs->command, psc_cmd);
343                 spin_unlock_irqrestore(&psc_i2s->lock, flags);
344
345                 break;
346
347         case SNDRV_PCM_TRIGGER_STOP:
348                 /* Turn off the PSC */
349                 s->active = 0;
350                 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE) {
351                         if (!psc_i2s->playback.active) {
352                                 out_8(&regs->command, 2 << 4);  /* reset rx */
353                                 out_8(&regs->command, 3 << 4);  /* reset tx */
354                                 out_8(&regs->command, 4 << 4);  /* reset err */
355                         }
356                 } else {
357                         out_8(&regs->command, 3 << 4);  /* reset tx */
358                         out_8(&regs->command, 4 << 4);  /* reset err */
359                         if (!psc_i2s->capture.active)
360                                 out_8(&regs->command, 2 << 4);  /* reset rx */
361                 }
362
363                 bcom_disable(s->bcom_task);
364                 while (!bcom_queue_empty(s->bcom_task))
365                         bcom_retrieve_buffer(s->bcom_task, NULL, NULL);
366
367                 break;
368
369         default:
370                 dev_dbg(psc_i2s->dev, "invalid command\n");
371                 return -EINVAL;
372         }
373
374         /* Update interrupt enable settings */
375         imr = 0;
376         if (psc_i2s->playback.active)
377                 imr |= MPC52xx_PSC_IMR_TXEMP;
378         if (psc_i2s->capture.active)
379                 imr |= MPC52xx_PSC_IMR_ORERR;
380         out_be16(&regs->isr_imr.imr, imr);
381
382         return 0;
383 }
384
385 /**
386  * psc_i2s_shutdown: shutdown the data transfer on a stream
387  *
388  * Shutdown the PSC if there are no other substreams open.
389  */
390 static void psc_i2s_shutdown(struct snd_pcm_substream *substream,
391                              struct snd_soc_dai *dai)
392 {
393         struct snd_soc_pcm_runtime *rtd = substream->private_data;
394         struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
395
396         dev_dbg(psc_i2s->dev, "psc_i2s_shutdown(substream=%p)\n", substream);
397
398         /*
399          * If this is the last active substream, disable the PSC and release
400          * the IRQ.
401          */
402         if (!psc_i2s->playback.active &&
403             !psc_i2s->capture.active) {
404
405                 /* Disable all interrupts and reset the PSC */
406                 out_be16(&psc_i2s->psc_regs->isr_imr.imr, 0);
407                 out_8(&psc_i2s->psc_regs->command, 3 << 4); /* reset tx */
408                 out_8(&psc_i2s->psc_regs->command, 2 << 4); /* reset rx */
409                 out_8(&psc_i2s->psc_regs->command, 1 << 4); /* reset mode */
410                 out_8(&psc_i2s->psc_regs->command, 4 << 4); /* reset error */
411
412                 /* Release irqs */
413                 free_irq(psc_i2s->irq, psc_i2s);
414                 free_irq(psc_i2s->capture.irq, &psc_i2s->capture);
415                 free_irq(psc_i2s->playback.irq, &psc_i2s->playback);
416         }
417 }
418
419 /**
420  * psc_i2s_set_sysclk: set the clock frequency and direction
421  *
422  * This function is called by the machine driver to tell us what the clock
423  * frequency and direction are.
424  *
425  * Currently, we only support operating as a clock slave (SND_SOC_CLOCK_IN),
426  * and we don't care about the frequency.  Return an error if the direction
427  * is not SND_SOC_CLOCK_IN.
428  *
429  * @clk_id: reserved, should be zero
430  * @freq: the frequency of the given clock ID, currently ignored
431  * @dir: SND_SOC_CLOCK_IN (clock slave) or SND_SOC_CLOCK_OUT (clock master)
432  */
433 static int psc_i2s_set_sysclk(struct snd_soc_dai *cpu_dai,
434                               int clk_id, unsigned int freq, int dir)
435 {
436         struct psc_i2s *psc_i2s = cpu_dai->private_data;
437         dev_dbg(psc_i2s->dev, "psc_i2s_set_sysclk(cpu_dai=%p, dir=%i)\n",
438                                 cpu_dai, dir);
439         return (dir == SND_SOC_CLOCK_IN) ? 0 : -EINVAL;
440 }
441
442 /**
443  * psc_i2s_set_fmt: set the serial format.
444  *
445  * This function is called by the machine driver to tell us what serial
446  * format to use.
447  *
448  * This driver only supports I2S mode.  Return an error if the format is
449  * not SND_SOC_DAIFMT_I2S.
450  *
451  * @format: one of SND_SOC_DAIFMT_xxx
452  */
453 static int psc_i2s_set_fmt(struct snd_soc_dai *cpu_dai, unsigned int format)
454 {
455         struct psc_i2s *psc_i2s = cpu_dai->private_data;
456         dev_dbg(psc_i2s->dev, "psc_i2s_set_fmt(cpu_dai=%p, format=%i)\n",
457                                 cpu_dai, format);
458         return (format == SND_SOC_DAIFMT_I2S) ? 0 : -EINVAL;
459 }
460
461 /* ---------------------------------------------------------------------
462  * ALSA SoC Bindings
463  *
464  * - Digital Audio Interface (DAI) template
465  * - create/destroy dai hooks
466  */
467
468 /**
469  * psc_i2s_dai_template: template CPU Digital Audio Interface
470  */
471 static struct snd_soc_dai_ops psc_i2s_dai_ops = {
472         .startup        = psc_i2s_startup,
473         .hw_params      = psc_i2s_hw_params,
474         .hw_free        = psc_i2s_hw_free,
475         .shutdown       = psc_i2s_shutdown,
476         .trigger        = psc_i2s_trigger,
477         .set_sysclk     = psc_i2s_set_sysclk,
478         .set_fmt        = psc_i2s_set_fmt,
479 };
480
481 static struct snd_soc_dai psc_i2s_dai_template = {
482         .playback = {
483                 .channels_min = 2,
484                 .channels_max = 2,
485                 .rates = PSC_I2S_RATES,
486                 .formats = PSC_I2S_FORMATS,
487         },
488         .capture = {
489                 .channels_min = 2,
490                 .channels_max = 2,
491                 .rates = PSC_I2S_RATES,
492                 .formats = PSC_I2S_FORMATS,
493         },
494         .ops = &psc_i2s_dai_ops,
495 };
496
497 /* ---------------------------------------------------------------------
498  * The PSC I2S 'ASoC platform' driver
499  *
500  * Can be referenced by an 'ASoC machine' driver
501  * This driver only deals with the audio bus; it doesn't have any
502  * interaction with the attached codec
503  */
504
505 static const struct snd_pcm_hardware psc_i2s_pcm_hardware = {
506         .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
507                 SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
508                 SNDRV_PCM_INFO_BATCH,
509         .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE |
510                    SNDRV_PCM_FMTBIT_S24_BE | SNDRV_PCM_FMTBIT_S32_BE,
511         .rate_min = 8000,
512         .rate_max = 48000,
513         .channels_min = 2,
514         .channels_max = 2,
515         .period_bytes_max       = 1024 * 1024,
516         .period_bytes_min       = 32,
517         .periods_min            = 2,
518         .periods_max            = 256,
519         .buffer_bytes_max       = 2 * 1024 * 1024,
520         .fifo_size              = 0,
521 };
522
523 static int psc_i2s_pcm_open(struct snd_pcm_substream *substream)
524 {
525         struct snd_soc_pcm_runtime *rtd = substream->private_data;
526         struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
527         struct psc_i2s_stream *s;
528
529         dev_dbg(psc_i2s->dev, "psc_i2s_pcm_open(substream=%p)\n", substream);
530
531         if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
532                 s = &psc_i2s->capture;
533         else
534                 s = &psc_i2s->playback;
535
536         snd_soc_set_runtime_hwparams(substream, &psc_i2s_pcm_hardware);
537
538         s->stream = substream;
539         return 0;
540 }
541
542 static int psc_i2s_pcm_close(struct snd_pcm_substream *substream)
543 {
544         struct snd_soc_pcm_runtime *rtd = substream->private_data;
545         struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
546         struct psc_i2s_stream *s;
547
548         dev_dbg(psc_i2s->dev, "psc_i2s_pcm_close(substream=%p)\n", substream);
549
550         if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
551                 s = &psc_i2s->capture;
552         else
553                 s = &psc_i2s->playback;
554
555         s->stream = NULL;
556         return 0;
557 }
558
559 static snd_pcm_uframes_t
560 psc_i2s_pcm_pointer(struct snd_pcm_substream *substream)
561 {
562         struct snd_soc_pcm_runtime *rtd = substream->private_data;
563         struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
564         struct psc_i2s_stream *s;
565         dma_addr_t count;
566
567         if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
568                 s = &psc_i2s->capture;
569         else
570                 s = &psc_i2s->playback;
571
572         count = s->period_current_pt - s->period_start;
573
574         return bytes_to_frames(substream->runtime, count);
575 }
576
577 static struct snd_pcm_ops psc_i2s_pcm_ops = {
578         .open           = psc_i2s_pcm_open,
579         .close          = psc_i2s_pcm_close,
580         .ioctl          = snd_pcm_lib_ioctl,
581         .pointer        = psc_i2s_pcm_pointer,
582 };
583
584 static u64 psc_i2s_pcm_dmamask = 0xffffffff;
585 static int psc_i2s_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
586                            struct snd_pcm *pcm)
587 {
588         struct snd_soc_pcm_runtime *rtd = pcm->private_data;
589         size_t size = psc_i2s_pcm_hardware.buffer_bytes_max;
590         int rc = 0;
591
592         dev_dbg(rtd->socdev->dev, "psc_i2s_pcm_new(card=%p, dai=%p, pcm=%p)\n",
593                 card, dai, pcm);
594
595         if (!card->dev->dma_mask)
596                 card->dev->dma_mask = &psc_i2s_pcm_dmamask;
597         if (!card->dev->coherent_dma_mask)
598                 card->dev->coherent_dma_mask = 0xffffffff;
599
600         if (pcm->streams[0].substream) {
601                 rc = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->dev, size,
602                                         &pcm->streams[0].substream->dma_buffer);
603                 if (rc)
604                         goto playback_alloc_err;
605         }
606
607         if (pcm->streams[1].substream) {
608                 rc = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->dev, size,
609                                         &pcm->streams[1].substream->dma_buffer);
610                 if (rc)
611                         goto capture_alloc_err;
612         }
613
614         return 0;
615
616  capture_alloc_err:
617         if (pcm->streams[0].substream)
618                 snd_dma_free_pages(&pcm->streams[0].substream->dma_buffer);
619  playback_alloc_err:
620         dev_err(card->dev, "Cannot allocate buffer(s)\n");
621         return -ENOMEM;
622 }
623
624 static void psc_i2s_pcm_free(struct snd_pcm *pcm)
625 {
626         struct snd_soc_pcm_runtime *rtd = pcm->private_data;
627         struct snd_pcm_substream *substream;
628         int stream;
629
630         dev_dbg(rtd->socdev->dev, "psc_i2s_pcm_free(pcm=%p)\n", pcm);
631
632         for (stream = 0; stream < 2; stream++) {
633                 substream = pcm->streams[stream].substream;
634                 if (substream) {
635                         snd_dma_free_pages(&substream->dma_buffer);
636                         substream->dma_buffer.area = NULL;
637                         substream->dma_buffer.addr = 0;
638                 }
639         }
640 }
641
642 struct snd_soc_platform psc_i2s_pcm_soc_platform = {
643         .name           = "mpc5200-psc-audio",
644         .pcm_ops        = &psc_i2s_pcm_ops,
645         .pcm_new        = &psc_i2s_pcm_new,
646         .pcm_free       = &psc_i2s_pcm_free,
647 };
648
649 /* ---------------------------------------------------------------------
650  * Sysfs attributes for debugging
651  */
652
653 static ssize_t psc_i2s_status_show(struct device *dev,
654                            struct device_attribute *attr, char *buf)
655 {
656         struct psc_i2s *psc_i2s = dev_get_drvdata(dev);
657
658         return sprintf(buf, "status=%.4x sicr=%.8x rfnum=%i rfstat=0x%.4x "
659                         "tfnum=%i tfstat=0x%.4x\n",
660                         in_be16(&psc_i2s->psc_regs->sr_csr.status),
661                         in_be32(&psc_i2s->psc_regs->sicr),
662                         in_be16(&psc_i2s->fifo_regs->rfnum) & 0x1ff,
663                         in_be16(&psc_i2s->fifo_regs->rfstat),
664                         in_be16(&psc_i2s->fifo_regs->tfnum) & 0x1ff,
665                         in_be16(&psc_i2s->fifo_regs->tfstat));
666 }
667
668 static int *psc_i2s_get_stat_attr(struct psc_i2s *psc_i2s, const char *name)
669 {
670         if (strcmp(name, "playback_underrun") == 0)
671                 return &psc_i2s->stats.underrun_count;
672         if (strcmp(name, "capture_overrun") == 0)
673                 return &psc_i2s->stats.overrun_count;
674
675         return NULL;
676 }
677
678 static ssize_t psc_i2s_stat_show(struct device *dev,
679                                  struct device_attribute *attr, char *buf)
680 {
681         struct psc_i2s *psc_i2s = dev_get_drvdata(dev);
682         int *attrib;
683
684         attrib = psc_i2s_get_stat_attr(psc_i2s, attr->attr.name);
685         if (!attrib)
686                 return 0;
687
688         return sprintf(buf, "%i\n", *attrib);
689 }
690
691 static ssize_t psc_i2s_stat_store(struct device *dev,
692                                   struct device_attribute *attr,
693                                   const char *buf,
694                                   size_t count)
695 {
696         struct psc_i2s *psc_i2s = dev_get_drvdata(dev);
697         int *attrib;
698
699         attrib = psc_i2s_get_stat_attr(psc_i2s, attr->attr.name);
700         if (!attrib)
701                 return 0;
702
703         *attrib = simple_strtoul(buf, NULL, 0);
704         return count;
705 }
706
707 static DEVICE_ATTR(status, 0644, psc_i2s_status_show, NULL);
708 static DEVICE_ATTR(playback_underrun, 0644, psc_i2s_stat_show,
709                         psc_i2s_stat_store);
710 static DEVICE_ATTR(capture_overrun, 0644, psc_i2s_stat_show,
711                         psc_i2s_stat_store);
712
713 /* ---------------------------------------------------------------------
714  * OF platform bus binding code:
715  * - Probe/remove operations
716  * - OF device match table
717  */
718 static int __devinit psc_i2s_of_probe(struct of_device *op,
719                                       const struct of_device_id *match)
720 {
721         phys_addr_t fifo;
722         struct psc_i2s *psc_i2s;
723         struct resource res;
724         int size, psc_id, irq, rc;
725         const __be32 *prop;
726         void __iomem *regs;
727
728         dev_dbg(&op->dev, "probing psc i2s device\n");
729
730         /* Get the PSC ID */
731         prop = of_get_property(op->node, "cell-index", &size);
732         if (!prop || size < sizeof *prop)
733                 return -ENODEV;
734         psc_id = be32_to_cpu(*prop);
735
736         /* Fetch the registers and IRQ of the PSC */
737         irq = irq_of_parse_and_map(op->node, 0);
738         if (of_address_to_resource(op->node, 0, &res)) {
739                 dev_err(&op->dev, "Missing reg property\n");
740                 return -ENODEV;
741         }
742         regs = ioremap(res.start, 1 + res.end - res.start);
743         if (!regs) {
744                 dev_err(&op->dev, "Could not map registers\n");
745                 return -ENODEV;
746         }
747
748         /* Allocate and initialize the driver private data */
749         psc_i2s = kzalloc(sizeof *psc_i2s, GFP_KERNEL);
750         if (!psc_i2s) {
751                 iounmap(regs);
752                 return -ENOMEM;
753         }
754         spin_lock_init(&psc_i2s->lock);
755         psc_i2s->irq = irq;
756         psc_i2s->psc_regs = regs;
757         psc_i2s->fifo_regs = regs + sizeof *psc_i2s->psc_regs;
758         psc_i2s->dev = &op->dev;
759         psc_i2s->playback.psc_i2s = psc_i2s;
760         psc_i2s->capture.psc_i2s = psc_i2s;
761         snprintf(psc_i2s->name, sizeof psc_i2s->name, "PSC%u", psc_id+1);
762
763         /* Fill out the CPU DAI structure */
764         memcpy(&psc_i2s->dai, &psc_i2s_dai_template, sizeof psc_i2s->dai);
765         psc_i2s->dai.private_data = psc_i2s;
766         psc_i2s->dai.name = psc_i2s->name;
767         psc_i2s->dai.id = psc_id;
768
769         /* Find the address of the fifo data registers and setup the
770          * DMA tasks */
771         fifo = res.start + offsetof(struct mpc52xx_psc, buffer.buffer_32);
772         psc_i2s->capture.bcom_task =
773                 bcom_psc_gen_bd_rx_init(psc_id, 10, fifo, 512);
774         psc_i2s->playback.bcom_task =
775                 bcom_psc_gen_bd_tx_init(psc_id, 10, fifo);
776         if (!psc_i2s->capture.bcom_task ||
777             !psc_i2s->playback.bcom_task) {
778                 dev_err(&op->dev, "Could not allocate bestcomm tasks\n");
779                 iounmap(regs);
780                 kfree(psc_i2s);
781                 return -ENODEV;
782         }
783
784         /* Disable all interrupts and reset the PSC */
785         out_be16(&psc_i2s->psc_regs->isr_imr.imr, 0);
786         out_8(&psc_i2s->psc_regs->command, 3 << 4); /* reset transmitter */
787         out_8(&psc_i2s->psc_regs->command, 2 << 4); /* reset receiver */
788         out_8(&psc_i2s->psc_regs->command, 1 << 4); /* reset mode */
789         out_8(&psc_i2s->psc_regs->command, 4 << 4); /* reset error */
790
791         /* Configure the serial interface mode; defaulting to CODEC8 mode */
792         psc_i2s->sicr = MPC52xx_PSC_SICR_DTS1 | MPC52xx_PSC_SICR_I2S |
793                         MPC52xx_PSC_SICR_CLKPOL;
794         if (of_get_property(op->node, "fsl,cellslave", NULL))
795                 psc_i2s->sicr |= MPC52xx_PSC_SICR_CELLSLAVE |
796                                  MPC52xx_PSC_SICR_GENCLK;
797         out_be32(&psc_i2s->psc_regs->sicr,
798                  psc_i2s->sicr | MPC52xx_PSC_SICR_SIM_CODEC_8);
799
800         /* Check for the codec handle.  If it is not present then we
801          * are done */
802         if (!of_get_property(op->node, "codec-handle", NULL))
803                 return 0;
804
805         /* Set up mode register;
806          * First write: RxRdy (FIFO Alarm) generates rx FIFO irq
807          * Second write: register Normal mode for non loopback
808          */
809         out_8(&psc_i2s->psc_regs->mode, 0);
810         out_8(&psc_i2s->psc_regs->mode, 0);
811
812         /* Set the TX and RX fifo alarm thresholds */
813         out_be16(&psc_i2s->fifo_regs->rfalarm, 0x100);
814         out_8(&psc_i2s->fifo_regs->rfcntl, 0x4);
815         out_be16(&psc_i2s->fifo_regs->tfalarm, 0x100);
816         out_8(&psc_i2s->fifo_regs->tfcntl, 0x7);
817
818         /* Lookup the IRQ numbers */
819         psc_i2s->playback.irq =
820                 bcom_get_task_irq(psc_i2s->playback.bcom_task);
821         psc_i2s->capture.irq =
822                 bcom_get_task_irq(psc_i2s->capture.bcom_task);
823
824         /* Save what we've done so it can be found again later */
825         dev_set_drvdata(&op->dev, psc_i2s);
826
827         /* Register the SYSFS files */
828         rc = device_create_file(psc_i2s->dev, &dev_attr_status);
829         rc |= device_create_file(psc_i2s->dev, &dev_attr_capture_overrun);
830         rc |= device_create_file(psc_i2s->dev, &dev_attr_playback_underrun);
831         if (rc)
832                 dev_info(psc_i2s->dev, "error creating sysfs files\n");
833
834         snd_soc_register_platform(&psc_i2s_pcm_soc_platform);
835
836         /* Tell the ASoC OF helpers about it */
837         of_snd_soc_register_platform(&psc_i2s_pcm_soc_platform, op->node,
838                                      &psc_i2s->dai);
839
840         return 0;
841 }
842
843 static int __devexit psc_i2s_of_remove(struct of_device *op)
844 {
845         struct psc_i2s *psc_i2s = dev_get_drvdata(&op->dev);
846
847         dev_dbg(&op->dev, "psc_i2s_remove()\n");
848
849         snd_soc_unregister_platform(&psc_i2s_pcm_soc_platform);
850
851         bcom_gen_bd_rx_release(psc_i2s->capture.bcom_task);
852         bcom_gen_bd_tx_release(psc_i2s->playback.bcom_task);
853
854         iounmap(psc_i2s->psc_regs);
855         iounmap(psc_i2s->fifo_regs);
856         kfree(psc_i2s);
857         dev_set_drvdata(&op->dev, NULL);
858
859         return 0;
860 }
861
862 /* Match table for of_platform binding */
863 static struct of_device_id psc_i2s_match[] __devinitdata = {
864         { .compatible = "fsl,mpc5200-psc-i2s", },
865         {}
866 };
867 MODULE_DEVICE_TABLE(of, psc_i2s_match);
868
869 static struct of_platform_driver psc_i2s_driver = {
870         .match_table = psc_i2s_match,
871         .probe = psc_i2s_of_probe,
872         .remove = __devexit_p(psc_i2s_of_remove),
873         .driver = {
874                 .name = "mpc5200-psc-i2s",
875                 .owner = THIS_MODULE,
876         },
877 };
878
879 /* ---------------------------------------------------------------------
880  * Module setup and teardown; simply register the of_platform driver
881  * for the PSC in I2S mode.
882  */
883 static int __init psc_i2s_init(void)
884 {
885         return of_register_platform_driver(&psc_i2s_driver);
886 }
887 module_init(psc_i2s_init);
888
889 static void __exit psc_i2s_exit(void)
890 {
891         of_unregister_platform_driver(&psc_i2s_driver);
892 }
893 module_exit(psc_i2s_exit);
894
895