[ALSA] PCM resume cleanups
[linux-3.10.git] / sound / pci / au88x0 / au88x0_pcm.c
1 /*
2  *  This program is free software; you can redistribute it and/or modify
3  *  it under the terms of the GNU General Public License as published by
4  *  the Free Software Foundation; either version 2 of the License, or
5  *  (at your option) any later version.
6  *
7  *  This program is distributed in the hope that it will be useful,
8  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *  GNU Library General Public License for more details.
11  *
12  *  You should have received a copy of the GNU General Public License
13  *  along with this program; if not, write to the Free Software
14  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
15  */
16  
17 /*
18  * Vortex PCM ALSA driver.
19  *
20  * Supports ADB and WT DMA. Unfortunately, WT channels do not run yet.
21  * It remains stuck,and DMA transfers do not happen. 
22  */
23 #include <sound/asoundef.h>
24 #include <sound/driver.h>
25 #include <linux/time.h>
26 #include <sound/core.h>
27 #include <sound/pcm.h>
28 #include <sound/pcm_params.h>
29 #include "au88x0.h"
30
31 #define VORTEX_PCM_TYPE(x) (x->name[40])
32
33 /* hardware definition */
34 static snd_pcm_hardware_t snd_vortex_playback_hw_adb = {
35         .info =
36             (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */
37              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
38              SNDRV_PCM_INFO_MMAP_VALID),
39         .formats =
40             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
41             SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW,
42         .rates = SNDRV_PCM_RATE_CONTINUOUS,
43         .rate_min = 5000,
44         .rate_max = 48000,
45         .channels_min = 1,
46 #ifdef CHIP_AU8830
47         .channels_max = 4,
48 #else
49         .channels_max = 2,
50 #endif
51         .buffer_bytes_max = 0x10000,
52         .period_bytes_min = 0x1,
53         .period_bytes_max = 0x1000,
54         .periods_min = 2,
55         .periods_max = 32,
56 };
57
58 #ifndef CHIP_AU8820
59 static snd_pcm_hardware_t snd_vortex_playback_hw_a3d = {
60         .info =
61             (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */
62              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
63              SNDRV_PCM_INFO_MMAP_VALID),
64         .formats =
65             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
66             SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW,
67         .rates = SNDRV_PCM_RATE_CONTINUOUS,
68         .rate_min = 5000,
69         .rate_max = 48000,
70         .channels_min = 1,
71         .channels_max = 1,
72         .buffer_bytes_max = 0x10000,
73         .period_bytes_min = 0x100,
74         .period_bytes_max = 0x1000,
75         .periods_min = 2,
76         .periods_max = 64,
77 };
78 #endif
79 static snd_pcm_hardware_t snd_vortex_playback_hw_spdif = {
80         .info =
81             (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */
82              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
83              SNDRV_PCM_INFO_MMAP_VALID),
84         .formats =
85             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
86             SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE | SNDRV_PCM_FMTBIT_MU_LAW |
87             SNDRV_PCM_FMTBIT_A_LAW,
88         .rates =
89             SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
90         .rate_min = 32000,
91         .rate_max = 48000,
92         .channels_min = 1,
93         .channels_max = 2,
94         .buffer_bytes_max = 0x10000,
95         .period_bytes_min = 0x100,
96         .period_bytes_max = 0x1000,
97         .periods_min = 2,
98         .periods_max = 64,
99 };
100
101 #ifndef CHIP_AU8810
102 static snd_pcm_hardware_t snd_vortex_playback_hw_wt = {
103         .info = (SNDRV_PCM_INFO_MMAP |
104                  SNDRV_PCM_INFO_INTERLEAVED |
105                  SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
106         .formats = SNDRV_PCM_FMTBIT_S16_LE,
107         .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_CONTINUOUS, // SNDRV_PCM_RATE_48000,
108         .rate_min = 8000,
109         .rate_max = 48000,
110         .channels_min = 1,
111         .channels_max = 2,
112         .buffer_bytes_max = 0x10000,
113         .period_bytes_min = 0x0400,
114         .period_bytes_max = 0x1000,
115         .periods_min = 2,
116         .periods_max = 64,
117 };
118 #endif
119 /* open callback */
120 static int snd_vortex_pcm_open(snd_pcm_substream_t * substream)
121 {
122         vortex_t *vortex = snd_pcm_substream_chip(substream);
123         snd_pcm_runtime_t *runtime = substream->runtime;
124         int err;
125         
126         /* Force equal size periods */
127         if ((err =
128              snd_pcm_hw_constraint_integer(runtime,
129                                            SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
130                 return err;
131         /* Avoid PAGE_SIZE boundary to fall inside of a period. */
132         if ((err =
133              snd_pcm_hw_constraint_pow2(runtime, 0,
134                                         SNDRV_PCM_HW_PARAM_PERIOD_BYTES)) < 0)
135                 return err;
136
137         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
138 #ifndef CHIP_AU8820
139                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_A3D) {
140                         runtime->hw = snd_vortex_playback_hw_a3d;
141                 }
142 #endif
143                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_SPDIF) {
144                         runtime->hw = snd_vortex_playback_hw_spdif;
145                         switch (vortex->spdif_sr) {
146                         case 32000:
147                                 runtime->hw.rates = SNDRV_PCM_RATE_32000;
148                                 break;
149                         case 44100:
150                                 runtime->hw.rates = SNDRV_PCM_RATE_44100;
151                                 break;
152                         case 48000:
153                                 runtime->hw.rates = SNDRV_PCM_RATE_48000;
154                                 break;
155                         }
156                 }
157                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB
158                     || VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_I2S)
159                         runtime->hw = snd_vortex_playback_hw_adb;
160                 substream->runtime->private_data = NULL;
161         }
162 #ifndef CHIP_AU8810
163         else {
164                 runtime->hw = snd_vortex_playback_hw_wt;
165                 substream->runtime->private_data = NULL;
166         }
167 #endif
168         return 0;
169 }
170
171 /* close callback */
172 static int snd_vortex_pcm_close(snd_pcm_substream_t * substream)
173 {
174         //vortex_t *chip = snd_pcm_substream_chip(substream);
175         stream_t *stream = (stream_t *) substream->runtime->private_data;
176
177         // the hardware-specific codes will be here
178         if (stream != NULL) {
179                 stream->substream = NULL;
180                 stream->nr_ch = 0;
181         }
182         substream->runtime->private_data = NULL;
183         return 0;
184 }
185
186 /* hw_params callback */
187 static int
188 snd_vortex_pcm_hw_params(snd_pcm_substream_t * substream,
189                          snd_pcm_hw_params_t * hw_params)
190 {
191         vortex_t *chip = snd_pcm_substream_chip(substream);
192         stream_t *stream = (stream_t *) (substream->runtime->private_data);
193         snd_pcm_sgbuf_t *sgbuf;
194         int err;
195
196         // Alloc buffer memory.
197         err =
198             snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
199         if (err < 0) {
200                 printk(KERN_ERR "Vortex: pcm page alloc failed!\n");
201                 return err;
202         }
203         //sgbuf = (snd_pcm_sgbuf_t *) substream->runtime->dma_private;
204         sgbuf = snd_pcm_substream_sgbuf(substream);
205         /*
206            printk(KERN_INFO "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params),
207            params_period_bytes(hw_params), params_channels(hw_params));
208          */
209         spin_lock_irq(&chip->lock);
210         // Make audio routes and config buffer DMA.
211         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
212                 int dma, type = VORTEX_PCM_TYPE(substream->pcm);
213                 /* Dealloc any routes. */
214                 if (stream != NULL)
215                         vortex_adb_allocroute(chip, stream->dma,
216                                               stream->nr_ch, stream->dir,
217                                               stream->type);
218                 /* Alloc routes. */
219                 dma =
220                     vortex_adb_allocroute(chip, -1,
221                                           params_channels(hw_params),
222                                           substream->stream, type);
223                 if (dma < 0)
224                         return dma;
225                 stream = substream->runtime->private_data = &chip->dma_adb[dma];
226                 stream->substream = substream;
227                 /* Setup Buffers. */
228                 vortex_adbdma_setbuffers(chip, dma, sgbuf,
229                                          params_period_bytes(hw_params),
230                                          params_periods(hw_params));
231         }
232 #ifndef CHIP_AU8810
233         else {
234                 /* if (stream != NULL)
235                    vortex_wt_allocroute(chip, substream->number, 0); */
236                 vortex_wt_allocroute(chip, substream->number,
237                                      params_channels(hw_params));
238                 stream = substream->runtime->private_data =
239                     &chip->dma_wt[substream->number];
240                 stream->dma = substream->number;
241                 stream->substream = substream;
242                 vortex_wtdma_setbuffers(chip, substream->number, sgbuf,
243                                         params_period_bytes(hw_params),
244                                         params_periods(hw_params));
245         }
246 #endif
247         spin_unlock_irq(&chip->lock);
248         return 0;
249 }
250
251 /* hw_free callback */
252 static int snd_vortex_pcm_hw_free(snd_pcm_substream_t * substream)
253 {
254         vortex_t *chip = snd_pcm_substream_chip(substream);
255         stream_t *stream = (stream_t *) (substream->runtime->private_data);
256
257         spin_lock_irq(&chip->lock);
258         // Delete audio routes.
259         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
260                 if (stream != NULL)
261                         vortex_adb_allocroute(chip, stream->dma,
262                                               stream->nr_ch, stream->dir,
263                                               stream->type);
264         }
265 #ifndef CHIP_AU8810
266         else {
267                 if (stream != NULL)
268                         vortex_wt_allocroute(chip, stream->dma, 0);
269         }
270 #endif
271         substream->runtime->private_data = NULL;
272         spin_unlock_irq(&chip->lock);
273
274         return snd_pcm_lib_free_pages(substream);
275 }
276
277 /* prepare callback */
278 static int snd_vortex_pcm_prepare(snd_pcm_substream_t * substream)
279 {
280         vortex_t *chip = snd_pcm_substream_chip(substream);
281         snd_pcm_runtime_t *runtime = substream->runtime;
282         stream_t *stream = (stream_t *) substream->runtime->private_data;
283         int dma = stream->dma, fmt, dir;
284
285         // set up the hardware with the current configuration.
286         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
287                 dir = 1;
288         else
289                 dir = 0;
290         fmt = vortex_alsafmt_aspfmt(runtime->format);
291         spin_lock_irq(&chip->lock);
292         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
293                 vortex_adbdma_setmode(chip, dma, 1, dir, fmt, 0 /*? */ ,
294                                       0);
295                 vortex_adbdma_setstartbuffer(chip, dma, 0);
296                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_SPDIF)
297                         vortex_adb_setsrc(chip, dma, runtime->rate, dir);
298         }
299 #ifndef CHIP_AU8810
300         else {
301                 vortex_wtdma_setmode(chip, dma, 1, fmt, 0, 0);
302                 // FIXME: Set rate (i guess using vortex_wt_writereg() somehow).
303                 vortex_wtdma_setstartbuffer(chip, dma, 0);
304         }
305 #endif
306         spin_unlock_irq(&chip->lock);
307         return 0;
308 }
309
310 /* trigger callback */
311 static int snd_vortex_pcm_trigger(snd_pcm_substream_t * substream, int cmd)
312 {
313         vortex_t *chip = snd_pcm_substream_chip(substream);
314         stream_t *stream = (stream_t *) substream->runtime->private_data;
315         int dma = stream->dma;
316
317         spin_lock(&chip->lock);
318         switch (cmd) {
319         case SNDRV_PCM_TRIGGER_START:
320                 // do something to start the PCM engine
321                 //printk(KERN_INFO "vortex: start %d\n", dma);
322                 stream->fifo_enabled = 1;
323                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
324                         vortex_adbdma_resetup(chip, dma);
325                         vortex_adbdma_startfifo(chip, dma);
326                 }
327 #ifndef CHIP_AU8810
328                 else {
329                         printk(KERN_INFO "vortex: wt start %d\n", dma);
330                         vortex_wtdma_startfifo(chip, dma);
331                 }
332 #endif
333                 break;
334         case SNDRV_PCM_TRIGGER_STOP:
335                 // do something to stop the PCM engine
336                 //printk(KERN_INFO "vortex: stop %d\n", dma);
337                 stream->fifo_enabled = 0;
338                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
339                         vortex_adbdma_pausefifo(chip, dma);
340                 //vortex_adbdma_stopfifo(chip, dma);
341 #ifndef CHIP_AU8810
342                 else {
343                         printk(KERN_INFO "vortex: wt stop %d\n", dma);
344                         vortex_wtdma_stopfifo(chip, dma);
345                 }
346 #endif
347                 break;
348         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
349                 //printk(KERN_INFO "vortex: pause %d\n", dma);
350                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
351                         vortex_adbdma_pausefifo(chip, dma);
352 #ifndef CHIP_AU8810
353                 else
354                         vortex_wtdma_pausefifo(chip, dma);
355 #endif
356                 break;
357         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
358                 //printk(KERN_INFO "vortex: resume %d\n", dma);
359                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
360                         vortex_adbdma_resumefifo(chip, dma);
361 #ifndef CHIP_AU8810
362                 else
363                         vortex_wtdma_resumefifo(chip, dma);
364 #endif
365                 break;
366         default:
367                 spin_unlock(&chip->lock);
368                 return -EINVAL;
369         }
370         spin_unlock(&chip->lock);
371         return 0;
372 }
373
374 /* pointer callback */
375 static snd_pcm_uframes_t snd_vortex_pcm_pointer(snd_pcm_substream_t * substream)
376 {
377         vortex_t *chip = snd_pcm_substream_chip(substream);
378         stream_t *stream = (stream_t *) substream->runtime->private_data;
379         int dma = stream->dma;
380         snd_pcm_uframes_t current_ptr = 0;
381
382         spin_lock(&chip->lock);
383         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
384                 current_ptr = vortex_adbdma_getlinearpos(chip, dma);
385 #ifndef CHIP_AU8810
386         else
387                 current_ptr = vortex_wtdma_getlinearpos(chip, dma);
388 #endif
389         //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr);
390         spin_unlock(&chip->lock);
391         return (bytes_to_frames(substream->runtime, current_ptr));
392 }
393
394 /* Page callback. */
395 /*
396 static struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset) {
397         
398         
399 }
400 */
401 /* operators */
402 static snd_pcm_ops_t snd_vortex_playback_ops = {
403         .open = snd_vortex_pcm_open,
404         .close = snd_vortex_pcm_close,
405         .ioctl = snd_pcm_lib_ioctl,
406         .hw_params = snd_vortex_pcm_hw_params,
407         .hw_free = snd_vortex_pcm_hw_free,
408         .prepare = snd_vortex_pcm_prepare,
409         .trigger = snd_vortex_pcm_trigger,
410         .pointer = snd_vortex_pcm_pointer,
411         .page = snd_pcm_sgbuf_ops_page,
412 };
413
414 /*
415 *  definitions of capture are omitted here...
416 */
417
418 static char *vortex_pcm_prettyname[VORTEX_PCM_LAST] = {
419         "AU88x0 ADB",
420         "AU88x0 SPDIF",
421         "AU88x0 A3D",
422         "AU88x0 WT",
423         "AU88x0 I2S",
424 };
425 static char *vortex_pcm_name[VORTEX_PCM_LAST] = {
426         "adb",
427         "spdif",
428         "a3d",
429         "wt",
430         "i2s",
431 };
432
433 /* SPDIF kcontrol */
434
435 static int snd_vortex_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
436 {
437         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
438         uinfo->count = 1;
439         return 0;
440 }
441
442 static int snd_vortex_spdif_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
443 {
444         ucontrol->value.iec958.status[0] = 0xff;
445         ucontrol->value.iec958.status[1] = 0xff;
446         ucontrol->value.iec958.status[2] = 0xff;
447         ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
448         return 0;
449 }
450
451 static int snd_vortex_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
452 {
453         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
454         ucontrol->value.iec958.status[0] = 0x00;
455         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_ORIGINAL|IEC958_AES1_CON_DIGDIGCONV_ID;
456         ucontrol->value.iec958.status[2] = 0x00;
457         switch (vortex->spdif_sr) {
458         case 32000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_32000; break;
459         case 44100: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_44100; break;
460         case 48000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_48000; break;
461         }
462         return 0;
463 }
464
465 static int snd_vortex_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
466 {
467         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
468         int spdif_sr = 48000;
469         switch (ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) {
470         case IEC958_AES3_CON_FS_32000: spdif_sr = 32000; break;
471         case IEC958_AES3_CON_FS_44100: spdif_sr = 44100; break;
472         case IEC958_AES3_CON_FS_48000: spdif_sr = 48000; break;
473         }
474         if (spdif_sr == vortex->spdif_sr)
475                 return 0;
476         vortex->spdif_sr = spdif_sr;
477         vortex_spdif_init(vortex, vortex->spdif_sr, 1);
478         return 1;
479 }
480
481 /* spdif controls */
482 static snd_kcontrol_new_t snd_vortex_mixer_spdif[] __devinitdata = {
483         {
484                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
485                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
486                 .info =         snd_vortex_spdif_info,
487                 .get =          snd_vortex_spdif_get,
488                 .put =          snd_vortex_spdif_put,
489         },
490         {
491                 .access =       SNDRV_CTL_ELEM_ACCESS_READ,
492                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
493                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
494                 .info =         snd_vortex_spdif_info,
495                 .get =          snd_vortex_spdif_mask_get
496         },
497 };
498
499 /* create a pcm device */
500 static int __devinit snd_vortex_new_pcm(vortex_t * chip, int idx, int nr)
501 {
502         snd_pcm_t *pcm;
503         snd_kcontrol_t *kctl;
504         int i;
505         int err, nr_capt;
506
507         if ((chip == 0) || (idx < 0) || (idx > VORTEX_PCM_LAST))
508                 return -ENODEV;
509
510         /* idx indicates which kind of PCM device. ADB, SPDIF, I2S and A3D share the 
511          * same dma engine. WT uses it own separate dma engine whcih cant capture. */
512         if (idx == VORTEX_PCM_ADB)
513                 nr_capt = nr;
514         else
515                 nr_capt = 0;
516         if ((err =
517              snd_pcm_new(chip->card, vortex_pcm_prettyname[idx], idx, nr,
518                          nr_capt, &pcm)) < 0)
519                 return err;
520         strcpy(pcm->name, vortex_pcm_name[idx]);
521         chip->pcm[idx] = pcm;
522         // This is an evil hack, but it saves a lot of duplicated code.
523         VORTEX_PCM_TYPE(pcm) = idx;
524         pcm->private_data = chip;
525         /* set operators */
526         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
527                         &snd_vortex_playback_ops);
528         if (idx == VORTEX_PCM_ADB)
529                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
530                                 &snd_vortex_playback_ops);
531         
532         /* pre-allocation of Scatter-Gather buffers */
533         
534         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
535                                               snd_dma_pci_data(chip->pci_dev),
536                                               0x10000, 0x10000);
537
538         if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_SPDIF) {
539                 for (i = 0; i < ARRAY_SIZE(snd_vortex_mixer_spdif); i++) {
540                         kctl = snd_ctl_new1(&snd_vortex_mixer_spdif[i], chip);
541                         if (!kctl)
542                                 return -ENOMEM;
543                         if ((err = snd_ctl_add(chip->card, kctl)) < 0)
544                                 return err;
545                 }
546         }
547         return 0;
548 }