sound: Add missing spin_unlock
[linux-2.6.git] / sound / mips / sgio2audio.c
1 /*
2  *   Sound driver for Silicon Graphics O2 Workstations A/V board audio.
3  *
4  *   Copyright 2003 Vivien Chappelier <vivien.chappelier@linux-mips.org>
5  *   Copyright 2008 Thomas Bogendoerfer <tsbogend@alpha.franken.de>
6  *   Mxier part taken from mace_audio.c:
7  *   Copyright 2007 Thorben J√§ndling <tj.trevelyan@gmail.com>
8  *
9  *   This program is free software; you can redistribute it and/or modify
10  *   it under the terms of the GNU General Public License as published by
11  *   the Free Software Foundation; either version 2 of the License, or
12  *   (at your option) any later version.
13  *
14  *   This program is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *   GNU General Public License for more details.
18  *
19  *   You should have received a copy of the GNU General Public License
20  *   along with this program; if not, write to the Free Software
21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22  *
23  */
24
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/spinlock.h>
28 #include <linux/interrupt.h>
29 #include <linux/dma-mapping.h>
30 #include <linux/platform_device.h>
31 #include <linux/io.h>
32 #include <linux/slab.h>
33
34 #include <asm/ip32/ip32_ints.h>
35 #include <asm/ip32/mace.h>
36
37 #include <sound/core.h>
38 #include <sound/control.h>
39 #include <sound/pcm.h>
40 #define SNDRV_GET_ID
41 #include <sound/initval.h>
42 #include <sound/ad1843.h>
43
44
45 MODULE_AUTHOR("Vivien Chappelier <vivien.chappelier@linux-mips.org>");
46 MODULE_DESCRIPTION("SGI O2 Audio");
47 MODULE_LICENSE("GPL");
48 MODULE_SUPPORTED_DEVICE("{{Silicon Graphics, O2 Audio}}");
49
50 static int index = SNDRV_DEFAULT_IDX1;  /* Index 0-MAX */
51 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
52
53 module_param(index, int, 0444);
54 MODULE_PARM_DESC(index, "Index value for SGI O2 soundcard.");
55 module_param(id, charp, 0444);
56 MODULE_PARM_DESC(id, "ID string for SGI O2 soundcard.");
57
58
59 #define AUDIO_CONTROL_RESET              BIT(0) /* 1: reset audio interface */
60 #define AUDIO_CONTROL_CODEC_PRESENT      BIT(1) /* 1: codec detected */
61
62 #define CODEC_CONTROL_WORD_SHIFT        0
63 #define CODEC_CONTROL_READ              BIT(16)
64 #define CODEC_CONTROL_ADDRESS_SHIFT     17
65
66 #define CHANNEL_CONTROL_RESET           BIT(10) /* 1: reset channel */
67 #define CHANNEL_DMA_ENABLE              BIT(9)  /* 1: enable DMA transfer */
68 #define CHANNEL_INT_THRESHOLD_DISABLED  (0 << 5) /* interrupt disabled */
69 #define CHANNEL_INT_THRESHOLD_25        (1 << 5) /* int on buffer >25% full */
70 #define CHANNEL_INT_THRESHOLD_50        (2 << 5) /* int on buffer >50% full */
71 #define CHANNEL_INT_THRESHOLD_75        (3 << 5) /* int on buffer >75% full */
72 #define CHANNEL_INT_THRESHOLD_EMPTY     (4 << 5) /* int on buffer empty */
73 #define CHANNEL_INT_THRESHOLD_NOT_EMPTY (5 << 5) /* int on buffer !empty */
74 #define CHANNEL_INT_THRESHOLD_FULL      (6 << 5) /* int on buffer empty */
75 #define CHANNEL_INT_THRESHOLD_NOT_FULL  (7 << 5) /* int on buffer !empty */
76
77 #define CHANNEL_RING_SHIFT              12
78 #define CHANNEL_RING_SIZE               (1 << CHANNEL_RING_SHIFT)
79 #define CHANNEL_RING_MASK               (CHANNEL_RING_SIZE - 1)
80
81 #define CHANNEL_LEFT_SHIFT 40
82 #define CHANNEL_RIGHT_SHIFT 8
83
84 struct snd_sgio2audio_chan {
85         int idx;
86         struct snd_pcm_substream *substream;
87         int pos;
88         snd_pcm_uframes_t size;
89         spinlock_t lock;
90 };
91
92 /* definition of the chip-specific record */
93 struct snd_sgio2audio {
94         struct snd_card *card;
95
96         /* codec */
97         struct snd_ad1843 ad1843;
98         spinlock_t ad1843_lock;
99
100         /* channels */
101         struct snd_sgio2audio_chan channel[3];
102
103         /* resources */
104         void *ring_base;
105         dma_addr_t ring_base_dma;
106 };
107
108 /* AD1843 access */
109
110 /*
111  * read_ad1843_reg returns the current contents of a 16 bit AD1843 register.
112  *
113  * Returns unsigned register value on success, -errno on failure.
114  */
115 static int read_ad1843_reg(void *priv, int reg)
116 {
117         struct snd_sgio2audio *chip = priv;
118         int val;
119         unsigned long flags;
120
121         spin_lock_irqsave(&chip->ad1843_lock, flags);
122
123         writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) |
124                CODEC_CONTROL_READ, &mace->perif.audio.codec_control);
125         wmb();
126         val = readq(&mace->perif.audio.codec_control); /* flush bus */
127         udelay(200);
128
129         val = readq(&mace->perif.audio.codec_read);
130
131         spin_unlock_irqrestore(&chip->ad1843_lock, flags);
132         return val;
133 }
134
135 /*
136  * write_ad1843_reg writes the specified value to a 16 bit AD1843 register.
137  */
138 static int write_ad1843_reg(void *priv, int reg, int word)
139 {
140         struct snd_sgio2audio *chip = priv;
141         int val;
142         unsigned long flags;
143
144         spin_lock_irqsave(&chip->ad1843_lock, flags);
145
146         writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) |
147                (word << CODEC_CONTROL_WORD_SHIFT),
148                &mace->perif.audio.codec_control);
149         wmb();
150         val = readq(&mace->perif.audio.codec_control); /* flush bus */
151         udelay(200);
152
153         spin_unlock_irqrestore(&chip->ad1843_lock, flags);
154         return 0;
155 }
156
157 static int sgio2audio_gain_info(struct snd_kcontrol *kcontrol,
158                                struct snd_ctl_elem_info *uinfo)
159 {
160         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
161
162         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
163         uinfo->count = 2;
164         uinfo->value.integer.min = 0;
165         uinfo->value.integer.max = ad1843_get_gain_max(&chip->ad1843,
166                                              (int)kcontrol->private_value);
167         return 0;
168 }
169
170 static int sgio2audio_gain_get(struct snd_kcontrol *kcontrol,
171                                struct snd_ctl_elem_value *ucontrol)
172 {
173         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
174         int vol;
175
176         vol = ad1843_get_gain(&chip->ad1843, (int)kcontrol->private_value);
177
178         ucontrol->value.integer.value[0] = (vol >> 8) & 0xFF;
179         ucontrol->value.integer.value[1] = vol & 0xFF;
180
181         return 0;
182 }
183
184 static int sgio2audio_gain_put(struct snd_kcontrol *kcontrol,
185                         struct snd_ctl_elem_value *ucontrol)
186 {
187         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
188         int newvol, oldvol;
189
190         oldvol = ad1843_get_gain(&chip->ad1843, kcontrol->private_value);
191         newvol = (ucontrol->value.integer.value[0] << 8) |
192                 ucontrol->value.integer.value[1];
193
194         newvol = ad1843_set_gain(&chip->ad1843, kcontrol->private_value,
195                 newvol);
196
197         return newvol != oldvol;
198 }
199
200 static int sgio2audio_source_info(struct snd_kcontrol *kcontrol,
201                                struct snd_ctl_elem_info *uinfo)
202 {
203         static const char *texts[3] = {
204                 "Cam Mic", "Mic", "Line"
205         };
206         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
207         uinfo->count = 1;
208         uinfo->value.enumerated.items = 3;
209         if (uinfo->value.enumerated.item >= 3)
210                 uinfo->value.enumerated.item = 1;
211         strcpy(uinfo->value.enumerated.name,
212                texts[uinfo->value.enumerated.item]);
213         return 0;
214 }
215
216 static int sgio2audio_source_get(struct snd_kcontrol *kcontrol,
217                                struct snd_ctl_elem_value *ucontrol)
218 {
219         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
220
221         ucontrol->value.enumerated.item[0] = ad1843_get_recsrc(&chip->ad1843);
222         return 0;
223 }
224
225 static int sgio2audio_source_put(struct snd_kcontrol *kcontrol,
226                         struct snd_ctl_elem_value *ucontrol)
227 {
228         struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
229         int newsrc, oldsrc;
230
231         oldsrc = ad1843_get_recsrc(&chip->ad1843);
232         newsrc = ad1843_set_recsrc(&chip->ad1843,
233                                    ucontrol->value.enumerated.item[0]);
234
235         return newsrc != oldsrc;
236 }
237
238 /* dac1/pcm0 mixer control */
239 static struct snd_kcontrol_new sgio2audio_ctrl_pcm0 __devinitdata = {
240         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
241         .name           = "PCM Playback Volume",
242         .index          = 0,
243         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
244         .private_value  = AD1843_GAIN_PCM_0,
245         .info           = sgio2audio_gain_info,
246         .get            = sgio2audio_gain_get,
247         .put            = sgio2audio_gain_put,
248 };
249
250 /* dac2/pcm1 mixer control */
251 static struct snd_kcontrol_new sgio2audio_ctrl_pcm1 __devinitdata = {
252         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
253         .name           = "PCM Playback Volume",
254         .index          = 1,
255         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
256         .private_value  = AD1843_GAIN_PCM_1,
257         .info           = sgio2audio_gain_info,
258         .get            = sgio2audio_gain_get,
259         .put            = sgio2audio_gain_put,
260 };
261
262 /* record level mixer control */
263 static struct snd_kcontrol_new sgio2audio_ctrl_reclevel __devinitdata = {
264         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
265         .name           = "Capture Volume",
266         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
267         .private_value  = AD1843_GAIN_RECLEV,
268         .info           = sgio2audio_gain_info,
269         .get            = sgio2audio_gain_get,
270         .put            = sgio2audio_gain_put,
271 };
272
273 /* record level source control */
274 static struct snd_kcontrol_new sgio2audio_ctrl_recsource __devinitdata = {
275         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
276         .name           = "Capture Source",
277         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
278         .info           = sgio2audio_source_info,
279         .get            = sgio2audio_source_get,
280         .put            = sgio2audio_source_put,
281 };
282
283 /* line mixer control */
284 static struct snd_kcontrol_new sgio2audio_ctrl_line __devinitdata = {
285         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
286         .name           = "Line Playback Volume",
287         .index          = 0,
288         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
289         .private_value  = AD1843_GAIN_LINE,
290         .info           = sgio2audio_gain_info,
291         .get            = sgio2audio_gain_get,
292         .put            = sgio2audio_gain_put,
293 };
294
295 /* cd mixer control */
296 static struct snd_kcontrol_new sgio2audio_ctrl_cd __devinitdata = {
297         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
298         .name           = "Line Playback Volume",
299         .index          = 1,
300         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
301         .private_value  = AD1843_GAIN_LINE_2,
302         .info           = sgio2audio_gain_info,
303         .get            = sgio2audio_gain_get,
304         .put            = sgio2audio_gain_put,
305 };
306
307 /* mic mixer control */
308 static struct snd_kcontrol_new sgio2audio_ctrl_mic __devinitdata = {
309         .iface          = SNDRV_CTL_ELEM_IFACE_MIXER,
310         .name           = "Mic Playback Volume",
311         .access         = SNDRV_CTL_ELEM_ACCESS_READWRITE,
312         .private_value  = AD1843_GAIN_MIC,
313         .info           = sgio2audio_gain_info,
314         .get            = sgio2audio_gain_get,
315         .put            = sgio2audio_gain_put,
316 };
317
318
319 static int __devinit snd_sgio2audio_new_mixer(struct snd_sgio2audio *chip)
320 {
321         int err;
322
323         err = snd_ctl_add(chip->card,
324                           snd_ctl_new1(&sgio2audio_ctrl_pcm0, chip));
325         if (err < 0)
326                 return err;
327
328         err = snd_ctl_add(chip->card,
329                           snd_ctl_new1(&sgio2audio_ctrl_pcm1, chip));
330         if (err < 0)
331                 return err;
332
333         err = snd_ctl_add(chip->card,
334                           snd_ctl_new1(&sgio2audio_ctrl_reclevel, chip));
335         if (err < 0)
336                 return err;
337
338         err = snd_ctl_add(chip->card,
339                           snd_ctl_new1(&sgio2audio_ctrl_recsource, chip));
340         if (err < 0)
341                 return err;
342         err = snd_ctl_add(chip->card,
343                           snd_ctl_new1(&sgio2audio_ctrl_line, chip));
344         if (err < 0)
345                 return err;
346
347         err = snd_ctl_add(chip->card,
348                           snd_ctl_new1(&sgio2audio_ctrl_cd, chip));
349         if (err < 0)
350                 return err;
351
352         err = snd_ctl_add(chip->card,
353                           snd_ctl_new1(&sgio2audio_ctrl_mic, chip));
354         if (err < 0)
355                 return err;
356
357         return 0;
358 }
359
360 /* low-level audio interface DMA */
361
362 /* get data out of bounce buffer, count must be a multiple of 32 */
363 /* returns 1 if a period has elapsed */
364 static int snd_sgio2audio_dma_pull_frag(struct snd_sgio2audio *chip,
365                                         unsigned int ch, unsigned int count)
366 {
367         int ret;
368         unsigned long src_base, src_pos, dst_mask;
369         unsigned char *dst_base;
370         int dst_pos;
371         u64 *src;
372         s16 *dst;
373         u64 x;
374         unsigned long flags;
375         struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime;
376
377         spin_lock_irqsave(&chip->channel[ch].lock, flags);
378
379         src_base = (unsigned long) chip->ring_base | (ch << CHANNEL_RING_SHIFT);
380         src_pos = readq(&mace->perif.audio.chan[ch].read_ptr);
381         dst_base = runtime->dma_area;
382         dst_pos = chip->channel[ch].pos;
383         dst_mask = frames_to_bytes(runtime, runtime->buffer_size) - 1;
384
385         /* check if a period has elapsed */
386         chip->channel[ch].size += (count >> 3); /* in frames */
387         ret = chip->channel[ch].size >= runtime->period_size;
388         chip->channel[ch].size %= runtime->period_size;
389
390         while (count) {
391                 src = (u64 *)(src_base + src_pos);
392                 dst = (s16 *)(dst_base + dst_pos);
393
394                 x = *src;
395                 dst[0] = (x >> CHANNEL_LEFT_SHIFT) & 0xffff;
396                 dst[1] = (x >> CHANNEL_RIGHT_SHIFT) & 0xffff;
397
398                 src_pos = (src_pos + sizeof(u64)) & CHANNEL_RING_MASK;
399                 dst_pos = (dst_pos + 2 * sizeof(s16)) & dst_mask;
400                 count -= sizeof(u64);
401         }
402
403         writeq(src_pos, &mace->perif.audio.chan[ch].read_ptr); /* in bytes */
404         chip->channel[ch].pos = dst_pos;
405
406         spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
407         return ret;
408 }
409
410 /* put some DMA data in bounce buffer, count must be a multiple of 32 */
411 /* returns 1 if a period has elapsed */
412 static int snd_sgio2audio_dma_push_frag(struct snd_sgio2audio *chip,
413                                         unsigned int ch, unsigned int count)
414 {
415         int ret;
416         s64 l, r;
417         unsigned long dst_base, dst_pos, src_mask;
418         unsigned char *src_base;
419         int src_pos;
420         u64 *dst;
421         s16 *src;
422         unsigned long flags;
423         struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime;
424
425         spin_lock_irqsave(&chip->channel[ch].lock, flags);
426
427         dst_base = (unsigned long)chip->ring_base | (ch << CHANNEL_RING_SHIFT);
428         dst_pos = readq(&mace->perif.audio.chan[ch].write_ptr);
429         src_base = runtime->dma_area;
430         src_pos = chip->channel[ch].pos;
431         src_mask = frames_to_bytes(runtime, runtime->buffer_size) - 1;
432
433         /* check if a period has elapsed */
434         chip->channel[ch].size += (count >> 3); /* in frames */
435         ret = chip->channel[ch].size >= runtime->period_size;
436         chip->channel[ch].size %= runtime->period_size;
437
438         while (count) {
439                 src = (s16 *)(src_base + src_pos);
440                 dst = (u64 *)(dst_base + dst_pos);
441
442                 l = src[0]; /* sign extend */
443                 r = src[1]; /* sign extend */
444
445                 *dst = ((l & 0x00ffffff) << CHANNEL_LEFT_SHIFT) |
446                         ((r & 0x00ffffff) << CHANNEL_RIGHT_SHIFT);
447
448                 dst_pos = (dst_pos + sizeof(u64)) & CHANNEL_RING_MASK;
449                 src_pos = (src_pos + 2 * sizeof(s16)) & src_mask;
450                 count -= sizeof(u64);
451         }
452
453         writeq(dst_pos, &mace->perif.audio.chan[ch].write_ptr); /* in bytes */
454         chip->channel[ch].pos = src_pos;
455
456         spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
457         return ret;
458 }
459
460 static int snd_sgio2audio_dma_start(struct snd_pcm_substream *substream)
461 {
462         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
463         struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
464         int ch = chan->idx;
465
466         /* reset DMA channel */
467         writeq(CHANNEL_CONTROL_RESET, &mace->perif.audio.chan[ch].control);
468         udelay(10);
469         writeq(0, &mace->perif.audio.chan[ch].control);
470
471         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
472                 /* push a full buffer */
473                 snd_sgio2audio_dma_push_frag(chip, ch, CHANNEL_RING_SIZE - 32);
474         }
475         /* set DMA to wake on 50% empty and enable interrupt */
476         writeq(CHANNEL_DMA_ENABLE | CHANNEL_INT_THRESHOLD_50,
477                &mace->perif.audio.chan[ch].control);
478         return 0;
479 }
480
481 static int snd_sgio2audio_dma_stop(struct snd_pcm_substream *substream)
482 {
483         struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
484
485         writeq(0, &mace->perif.audio.chan[chan->idx].control);
486         return 0;
487 }
488
489 static irqreturn_t snd_sgio2audio_dma_in_isr(int irq, void *dev_id)
490 {
491         struct snd_sgio2audio_chan *chan = dev_id;
492         struct snd_pcm_substream *substream;
493         struct snd_sgio2audio *chip;
494         int count, ch;
495
496         substream = chan->substream;
497         chip = snd_pcm_substream_chip(substream);
498         ch = chan->idx;
499
500         /* empty the ring */
501         count = CHANNEL_RING_SIZE -
502                 readq(&mace->perif.audio.chan[ch].depth) - 32;
503         if (snd_sgio2audio_dma_pull_frag(chip, ch, count))
504                 snd_pcm_period_elapsed(substream);
505
506         return IRQ_HANDLED;
507 }
508
509 static irqreturn_t snd_sgio2audio_dma_out_isr(int irq, void *dev_id)
510 {
511         struct snd_sgio2audio_chan *chan = dev_id;
512         struct snd_pcm_substream *substream;
513         struct snd_sgio2audio *chip;
514         int count, ch;
515
516         substream = chan->substream;
517         chip = snd_pcm_substream_chip(substream);
518         ch = chan->idx;
519         /* fill the ring */
520         count = CHANNEL_RING_SIZE -
521                 readq(&mace->perif.audio.chan[ch].depth) - 32;
522         if (snd_sgio2audio_dma_push_frag(chip, ch, count))
523                 snd_pcm_period_elapsed(substream);
524
525         return IRQ_HANDLED;
526 }
527
528 static irqreturn_t snd_sgio2audio_error_isr(int irq, void *dev_id)
529 {
530         struct snd_sgio2audio_chan *chan = dev_id;
531         struct snd_pcm_substream *substream;
532
533         substream = chan->substream;
534         snd_sgio2audio_dma_stop(substream);
535         snd_sgio2audio_dma_start(substream);
536         return IRQ_HANDLED;
537 }
538
539 /* PCM part */
540 /* PCM hardware definition */
541 static struct snd_pcm_hardware snd_sgio2audio_pcm_hw = {
542         .info = (SNDRV_PCM_INFO_MMAP |
543                  SNDRV_PCM_INFO_MMAP_VALID |
544                  SNDRV_PCM_INFO_INTERLEAVED |
545                  SNDRV_PCM_INFO_BLOCK_TRANSFER),
546         .formats =          SNDRV_PCM_FMTBIT_S16_BE,
547         .rates =            SNDRV_PCM_RATE_8000_48000,
548         .rate_min =         8000,
549         .rate_max =         48000,
550         .channels_min =     2,
551         .channels_max =     2,
552         .buffer_bytes_max = 65536,
553         .period_bytes_min = 32768,
554         .period_bytes_max = 65536,
555         .periods_min =      1,
556         .periods_max =      1024,
557 };
558
559 /* PCM playback open callback */
560 static int snd_sgio2audio_playback1_open(struct snd_pcm_substream *substream)
561 {
562         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
563         struct snd_pcm_runtime *runtime = substream->runtime;
564
565         runtime->hw = snd_sgio2audio_pcm_hw;
566         runtime->private_data = &chip->channel[1];
567         return 0;
568 }
569
570 static int snd_sgio2audio_playback2_open(struct snd_pcm_substream *substream)
571 {
572         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
573         struct snd_pcm_runtime *runtime = substream->runtime;
574
575         runtime->hw = snd_sgio2audio_pcm_hw;
576         runtime->private_data = &chip->channel[2];
577         return 0;
578 }
579
580 /* PCM capture open callback */
581 static int snd_sgio2audio_capture_open(struct snd_pcm_substream *substream)
582 {
583         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
584         struct snd_pcm_runtime *runtime = substream->runtime;
585
586         runtime->hw = snd_sgio2audio_pcm_hw;
587         runtime->private_data = &chip->channel[0];
588         return 0;
589 }
590
591 /* PCM close callback */
592 static int snd_sgio2audio_pcm_close(struct snd_pcm_substream *substream)
593 {
594         struct snd_pcm_runtime *runtime = substream->runtime;
595
596         runtime->private_data = NULL;
597         return 0;
598 }
599
600
601 /* hw_params callback */
602 static int snd_sgio2audio_pcm_hw_params(struct snd_pcm_substream *substream,
603                                         struct snd_pcm_hw_params *hw_params)
604 {
605         return snd_pcm_lib_alloc_vmalloc_buffer(substream,
606                                                 params_buffer_bytes(hw_params));
607 }
608
609 /* hw_free callback */
610 static int snd_sgio2audio_pcm_hw_free(struct snd_pcm_substream *substream)
611 {
612         return snd_pcm_lib_free_vmalloc_buffer(substream);
613 }
614
615 /* prepare callback */
616 static int snd_sgio2audio_pcm_prepare(struct snd_pcm_substream *substream)
617 {
618         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
619         struct snd_pcm_runtime *runtime = substream->runtime;
620         struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
621         int ch = chan->idx;
622         unsigned long flags;
623
624         spin_lock_irqsave(&chip->channel[ch].lock, flags);
625
626         /* Setup the pseudo-dma transfer pointers.  */
627         chip->channel[ch].pos = 0;
628         chip->channel[ch].size = 0;
629         chip->channel[ch].substream = substream;
630
631         /* set AD1843 format */
632         /* hardware format is always S16_LE */
633         switch (substream->stream) {
634         case SNDRV_PCM_STREAM_PLAYBACK:
635                 ad1843_setup_dac(&chip->ad1843,
636                                  ch - 1,
637                                  runtime->rate,
638                                  SNDRV_PCM_FORMAT_S16_LE,
639                                  runtime->channels);
640                 break;
641         case SNDRV_PCM_STREAM_CAPTURE:
642                 ad1843_setup_adc(&chip->ad1843,
643                                  runtime->rate,
644                                  SNDRV_PCM_FORMAT_S16_LE,
645                                  runtime->channels);
646                 break;
647         }
648         spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
649         return 0;
650 }
651
652 /* trigger callback */
653 static int snd_sgio2audio_pcm_trigger(struct snd_pcm_substream *substream,
654                                       int cmd)
655 {
656         switch (cmd) {
657         case SNDRV_PCM_TRIGGER_START:
658                 /* start the PCM engine */
659                 snd_sgio2audio_dma_start(substream);
660                 break;
661         case SNDRV_PCM_TRIGGER_STOP:
662                 /* stop the PCM engine */
663                 snd_sgio2audio_dma_stop(substream);
664                 break;
665         default:
666                 return -EINVAL;
667         }
668         return 0;
669 }
670
671 /* pointer callback */
672 static snd_pcm_uframes_t
673 snd_sgio2audio_pcm_pointer(struct snd_pcm_substream *substream)
674 {
675         struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
676         struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
677
678         /* get the current hardware pointer */
679         return bytes_to_frames(substream->runtime,
680                                chip->channel[chan->idx].pos);
681 }
682
683 /* operators */
684 static struct snd_pcm_ops snd_sgio2audio_playback1_ops = {
685         .open =        snd_sgio2audio_playback1_open,
686         .close =       snd_sgio2audio_pcm_close,
687         .ioctl =       snd_pcm_lib_ioctl,
688         .hw_params =   snd_sgio2audio_pcm_hw_params,
689         .hw_free =     snd_sgio2audio_pcm_hw_free,
690         .prepare =     snd_sgio2audio_pcm_prepare,
691         .trigger =     snd_sgio2audio_pcm_trigger,
692         .pointer =     snd_sgio2audio_pcm_pointer,
693         .page =        snd_pcm_lib_get_vmalloc_page,
694         .mmap =        snd_pcm_lib_mmap_vmalloc,
695 };
696
697 static struct snd_pcm_ops snd_sgio2audio_playback2_ops = {
698         .open =        snd_sgio2audio_playback2_open,
699         .close =       snd_sgio2audio_pcm_close,
700         .ioctl =       snd_pcm_lib_ioctl,
701         .hw_params =   snd_sgio2audio_pcm_hw_params,
702         .hw_free =     snd_sgio2audio_pcm_hw_free,
703         .prepare =     snd_sgio2audio_pcm_prepare,
704         .trigger =     snd_sgio2audio_pcm_trigger,
705         .pointer =     snd_sgio2audio_pcm_pointer,
706         .page =        snd_pcm_lib_get_vmalloc_page,
707         .mmap =        snd_pcm_lib_mmap_vmalloc,
708 };
709
710 static struct snd_pcm_ops snd_sgio2audio_capture_ops = {
711         .open =        snd_sgio2audio_capture_open,
712         .close =       snd_sgio2audio_pcm_close,
713         .ioctl =       snd_pcm_lib_ioctl,
714         .hw_params =   snd_sgio2audio_pcm_hw_params,
715         .hw_free =     snd_sgio2audio_pcm_hw_free,
716         .prepare =     snd_sgio2audio_pcm_prepare,
717         .trigger =     snd_sgio2audio_pcm_trigger,
718         .pointer =     snd_sgio2audio_pcm_pointer,
719         .page =        snd_pcm_lib_get_vmalloc_page,
720         .mmap =        snd_pcm_lib_mmap_vmalloc,
721 };
722
723 /*
724  *  definitions of capture are omitted here...
725  */
726
727 /* create a pcm device */
728 static int __devinit snd_sgio2audio_new_pcm(struct snd_sgio2audio *chip)
729 {
730         struct snd_pcm *pcm;
731         int err;
732
733         /* create first pcm device with one outputs and one input */
734         err = snd_pcm_new(chip->card, "SGI O2 Audio", 0, 1, 1, &pcm);
735         if (err < 0)
736                 return err;
737
738         pcm->private_data = chip;
739         strcpy(pcm->name, "SGI O2 DAC1");
740
741         /* set operators */
742         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
743                         &snd_sgio2audio_playback1_ops);
744         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
745                         &snd_sgio2audio_capture_ops);
746
747         /* create second  pcm device with one outputs and no input */
748         err = snd_pcm_new(chip->card, "SGI O2 Audio", 1, 1, 0, &pcm);
749         if (err < 0)
750                 return err;
751
752         pcm->private_data = chip;
753         strcpy(pcm->name, "SGI O2 DAC2");
754
755         /* set operators */
756         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
757                         &snd_sgio2audio_playback2_ops);
758
759         return 0;
760 }
761
762 static struct {
763         int idx;
764         int irq;
765         irqreturn_t (*isr)(int, void *);
766         const char *desc;
767 } snd_sgio2_isr_table[] = {
768         {
769                 .idx = 0,
770                 .irq = MACEISA_AUDIO1_DMAT_IRQ,
771                 .isr = snd_sgio2audio_dma_in_isr,
772                 .desc = "Capture DMA Channel 0"
773         }, {
774                 .idx = 0,
775                 .irq = MACEISA_AUDIO1_OF_IRQ,
776                 .isr = snd_sgio2audio_error_isr,
777                 .desc = "Capture Overflow"
778         }, {
779                 .idx = 1,
780                 .irq = MACEISA_AUDIO2_DMAT_IRQ,
781                 .isr = snd_sgio2audio_dma_out_isr,
782                 .desc = "Playback DMA Channel 1"
783         }, {
784                 .idx = 1,
785                 .irq = MACEISA_AUDIO2_MERR_IRQ,
786                 .isr = snd_sgio2audio_error_isr,
787                 .desc = "Memory Error Channel 1"
788         }, {
789                 .idx = 2,
790                 .irq = MACEISA_AUDIO3_DMAT_IRQ,
791                 .isr = snd_sgio2audio_dma_out_isr,
792                 .desc = "Playback DMA Channel 2"
793         }, {
794                 .idx = 2,
795                 .irq = MACEISA_AUDIO3_MERR_IRQ,
796                 .isr = snd_sgio2audio_error_isr,
797                 .desc = "Memory Error Channel 2"
798         }
799 };
800
801 /* ALSA driver */
802
803 static int snd_sgio2audio_free(struct snd_sgio2audio *chip)
804 {
805         int i;
806
807         /* reset interface */
808         writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control);
809         udelay(1);
810         writeq(0, &mace->perif.audio.control);
811
812         /* release IRQ's */
813         for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++)
814                 free_irq(snd_sgio2_isr_table[i].irq,
815                          &chip->channel[snd_sgio2_isr_table[i].idx]);
816
817         dma_free_coherent(NULL, MACEISA_RINGBUFFERS_SIZE,
818                           chip->ring_base, chip->ring_base_dma);
819
820         /* release card data */
821         kfree(chip);
822         return 0;
823 }
824
825 static int snd_sgio2audio_dev_free(struct snd_device *device)
826 {
827         struct snd_sgio2audio *chip = device->device_data;
828
829         return snd_sgio2audio_free(chip);
830 }
831
832 static struct snd_device_ops ops = {
833         .dev_free = snd_sgio2audio_dev_free,
834 };
835
836 static int __devinit snd_sgio2audio_create(struct snd_card *card,
837                                            struct snd_sgio2audio **rchip)
838 {
839         struct snd_sgio2audio *chip;
840         int i, err;
841
842         *rchip = NULL;
843
844         /* check if a codec is attached to the interface */
845         /* (Audio or Audio/Video board present) */
846         if (!(readq(&mace->perif.audio.control) & AUDIO_CONTROL_CODEC_PRESENT))
847                 return -ENOENT;
848
849         chip = kzalloc(sizeof(struct snd_sgio2audio), GFP_KERNEL);
850         if (chip == NULL)
851                 return -ENOMEM;
852
853         chip->card = card;
854
855         chip->ring_base = dma_alloc_coherent(NULL, MACEISA_RINGBUFFERS_SIZE,
856                                              &chip->ring_base_dma, GFP_USER);
857         if (chip->ring_base == NULL) {
858                 printk(KERN_ERR
859                        "sgio2audio: could not allocate ring buffers\n");
860                 kfree(chip);
861                 return -ENOMEM;
862         }
863
864         spin_lock_init(&chip->ad1843_lock);
865
866         /* initialize channels */
867         for (i = 0; i < 3; i++) {
868                 spin_lock_init(&chip->channel[i].lock);
869                 chip->channel[i].idx = i;
870         }
871
872         /* allocate IRQs */
873         for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++) {
874                 if (request_irq(snd_sgio2_isr_table[i].irq,
875                                 snd_sgio2_isr_table[i].isr,
876                                 0,
877                                 snd_sgio2_isr_table[i].desc,
878                                 &chip->channel[snd_sgio2_isr_table[i].idx])) {
879                         snd_sgio2audio_free(chip);
880                         printk(KERN_ERR "sgio2audio: cannot allocate irq %d\n",
881                                snd_sgio2_isr_table[i].irq);
882                         return -EBUSY;
883                 }
884         }
885
886         /* reset the interface */
887         writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control);
888         udelay(1);
889         writeq(0, &mace->perif.audio.control);
890         msleep_interruptible(1); /* give time to recover */
891
892         /* set ring base */
893         writeq(chip->ring_base_dma, &mace->perif.ctrl.ringbase);
894
895         /* attach the AD1843 codec */
896         chip->ad1843.read = read_ad1843_reg;
897         chip->ad1843.write = write_ad1843_reg;
898         chip->ad1843.chip = chip;
899
900         /* initialize the AD1843 codec */
901         err = ad1843_init(&chip->ad1843);
902         if (err < 0) {
903                 snd_sgio2audio_free(chip);
904                 return err;
905         }
906
907         err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
908         if (err < 0) {
909                 snd_sgio2audio_free(chip);
910                 return err;
911         }
912         *rchip = chip;
913         return 0;
914 }
915
916 static int __devinit snd_sgio2audio_probe(struct platform_device *pdev)
917 {
918         struct snd_card *card;
919         struct snd_sgio2audio *chip;
920         int err;
921
922         err = snd_card_create(index, id, THIS_MODULE, 0, &card);
923         if (err < 0)
924                 return err;
925
926         err = snd_sgio2audio_create(card, &chip);
927         if (err < 0) {
928                 snd_card_free(card);
929                 return err;
930         }
931         snd_card_set_dev(card, &pdev->dev);
932
933         err = snd_sgio2audio_new_pcm(chip);
934         if (err < 0) {
935                 snd_card_free(card);
936                 return err;
937         }
938         err = snd_sgio2audio_new_mixer(chip);
939         if (err < 0) {
940                 snd_card_free(card);
941                 return err;
942         }
943
944         strcpy(card->driver, "SGI O2 Audio");
945         strcpy(card->shortname, "SGI O2 Audio");
946         sprintf(card->longname, "%s irq %i-%i",
947                 card->shortname,
948                 MACEISA_AUDIO1_DMAT_IRQ,
949                 MACEISA_AUDIO3_MERR_IRQ);
950
951         err = snd_card_register(card);
952         if (err < 0) {
953                 snd_card_free(card);
954                 return err;
955         }
956         platform_set_drvdata(pdev, card);
957         return 0;
958 }
959
960 static int __devexit snd_sgio2audio_remove(struct platform_device *pdev)
961 {
962         struct snd_card *card = platform_get_drvdata(pdev);
963
964         snd_card_free(card);
965         platform_set_drvdata(pdev, NULL);
966         return 0;
967 }
968
969 static struct platform_driver sgio2audio_driver = {
970         .probe  = snd_sgio2audio_probe,
971         .remove = __devexit_p(snd_sgio2audio_remove),
972         .driver = {
973                 .name   = "sgio2audio",
974                 .owner  = THIS_MODULE,
975         }
976 };
977
978 static int __init alsa_card_sgio2audio_init(void)
979 {
980         return platform_driver_register(&sgio2audio_driver);
981 }
982
983 static void __exit alsa_card_sgio2audio_exit(void)
984 {
985         platform_driver_unregister(&sgio2audio_driver);
986 }
987
988 module_init(alsa_card_sgio2audio_init)
989 module_exit(alsa_card_sgio2audio_exit)