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