2 * Sound driver for Silicon Graphics O2 Workstations A/V board audio.
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>
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.
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.
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
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/spinlock.h>
28 #include <linux/gfp.h>
29 #include <linux/interrupt.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/platform_device.h>
34 #include <asm/ip32/ip32_ints.h>
35 #include <asm/ip32/mace.h>
37 #include <sound/core.h>
38 #include <sound/control.h>
39 #include <sound/pcm.h>
41 #include <sound/initval.h>
42 #include <sound/ad1843.h>
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}}");
50 static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */
51 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */
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.");
59 #define AUDIO_CONTROL_RESET BIT(0) /* 1: reset audio interface */
60 #define AUDIO_CONTROL_CODEC_PRESENT BIT(1) /* 1: codec detected */
62 #define CODEC_CONTROL_WORD_SHIFT 0
63 #define CODEC_CONTROL_READ BIT(16)
64 #define CODEC_CONTROL_ADDRESS_SHIFT 17
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 */
77 #define CHANNEL_RING_SHIFT 12
78 #define CHANNEL_RING_SIZE (1 << CHANNEL_RING_SHIFT)
79 #define CHANNEL_RING_MASK (CHANNEL_RING_SIZE - 1)
81 #define CHANNEL_LEFT_SHIFT 40
82 #define CHANNEL_RIGHT_SHIFT 8
84 struct snd_sgio2audio_chan {
86 struct snd_pcm_substream *substream;
88 snd_pcm_uframes_t size;
92 /* definition of the chip-specific record */
93 struct snd_sgio2audio {
94 struct snd_card *card;
97 struct snd_ad1843 ad1843;
98 spinlock_t ad1843_lock;
101 struct snd_sgio2audio_chan channel[3];
105 dma_addr_t ring_base_dma;
111 * read_ad1843_reg returns the current contents of a 16 bit AD1843 register.
113 * Returns unsigned register value on success, -errno on failure.
115 static int read_ad1843_reg(void *priv, int reg)
117 struct snd_sgio2audio *chip = priv;
121 spin_lock_irqsave(&chip->ad1843_lock, flags);
123 writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) |
124 CODEC_CONTROL_READ, &mace->perif.audio.codec_control);
126 val = readq(&mace->perif.audio.codec_control); /* flush bus */
129 val = readq(&mace->perif.audio.codec_read);
131 spin_unlock_irqrestore(&chip->ad1843_lock, flags);
136 * write_ad1843_reg writes the specified value to a 16 bit AD1843 register.
138 static int write_ad1843_reg(void *priv, int reg, int word)
140 struct snd_sgio2audio *chip = priv;
144 spin_lock_irqsave(&chip->ad1843_lock, flags);
146 writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) |
147 (word << CODEC_CONTROL_WORD_SHIFT),
148 &mace->perif.audio.codec_control);
150 val = readq(&mace->perif.audio.codec_control); /* flush bus */
153 spin_unlock_irqrestore(&chip->ad1843_lock, flags);
157 static int sgio2audio_gain_info(struct snd_kcontrol *kcontrol,
158 struct snd_ctl_elem_info *uinfo)
160 struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
162 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
164 uinfo->value.integer.min = 0;
165 uinfo->value.integer.max = ad1843_get_gain_max(&chip->ad1843,
166 (int)kcontrol->private_value);
170 static int sgio2audio_gain_get(struct snd_kcontrol *kcontrol,
171 struct snd_ctl_elem_value *ucontrol)
173 struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
176 vol = ad1843_get_gain(&chip->ad1843, (int)kcontrol->private_value);
178 ucontrol->value.integer.value[0] = (vol >> 8) & 0xFF;
179 ucontrol->value.integer.value[1] = vol & 0xFF;
184 static int sgio2audio_gain_put(struct snd_kcontrol *kcontrol,
185 struct snd_ctl_elem_value *ucontrol)
187 struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
190 oldvol = ad1843_get_gain(&chip->ad1843, kcontrol->private_value);
191 newvol = (ucontrol->value.integer.value[0] << 8) |
192 ucontrol->value.integer.value[1];
194 newvol = ad1843_set_gain(&chip->ad1843, kcontrol->private_value,
197 return newvol != oldvol;
200 static int sgio2audio_source_info(struct snd_kcontrol *kcontrol,
201 struct snd_ctl_elem_info *uinfo)
203 static const char *texts[3] = {
204 "Cam Mic", "Mic", "Line"
206 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
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]);
216 static int sgio2audio_source_get(struct snd_kcontrol *kcontrol,
217 struct snd_ctl_elem_value *ucontrol)
219 struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
221 ucontrol->value.enumerated.item[0] = ad1843_get_recsrc(&chip->ad1843);
225 static int sgio2audio_source_put(struct snd_kcontrol *kcontrol,
226 struct snd_ctl_elem_value *ucontrol)
228 struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol);
231 oldsrc = ad1843_get_recsrc(&chip->ad1843);
232 newsrc = ad1843_set_recsrc(&chip->ad1843,
233 ucontrol->value.enumerated.item[0]);
235 return newsrc != oldsrc;
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",
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,
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",
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,
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,
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,
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",
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,
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",
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,
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,
319 static int __devinit snd_sgio2audio_new_mixer(struct snd_sgio2audio *chip)
323 err = snd_ctl_add(chip->card,
324 snd_ctl_new1(&sgio2audio_ctrl_pcm0, chip));
328 err = snd_ctl_add(chip->card,
329 snd_ctl_new1(&sgio2audio_ctrl_pcm1, chip));
333 err = snd_ctl_add(chip->card,
334 snd_ctl_new1(&sgio2audio_ctrl_reclevel, chip));
338 err = snd_ctl_add(chip->card,
339 snd_ctl_new1(&sgio2audio_ctrl_recsource, chip));
342 err = snd_ctl_add(chip->card,
343 snd_ctl_new1(&sgio2audio_ctrl_line, chip));
347 err = snd_ctl_add(chip->card,
348 snd_ctl_new1(&sgio2audio_ctrl_cd, chip));
352 err = snd_ctl_add(chip->card,
353 snd_ctl_new1(&sgio2audio_ctrl_mic, chip));
360 /* low-level audio interface DMA */
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)
368 unsigned long src_base, src_pos, dst_mask;
369 unsigned char *dst_base;
375 struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime;
377 spin_lock_irqsave(&chip->channel[ch].lock, flags);
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;
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;
391 src = (u64 *)(src_base + src_pos);
392 dst = (s16 *)(dst_base + dst_pos);
395 dst[0] = (x >> CHANNEL_LEFT_SHIFT) & 0xffff;
396 dst[1] = (x >> CHANNEL_RIGHT_SHIFT) & 0xffff;
398 src_pos = (src_pos + sizeof(u64)) & CHANNEL_RING_MASK;
399 dst_pos = (dst_pos + 2 * sizeof(s16)) & dst_mask;
400 count -= sizeof(u64);
403 writeq(src_pos, &mace->perif.audio.chan[ch].read_ptr); /* in bytes */
404 chip->channel[ch].pos = dst_pos;
406 spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
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)
417 unsigned long dst_base, dst_pos, src_mask;
418 unsigned char *src_base;
423 struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime;
425 spin_lock_irqsave(&chip->channel[ch].lock, flags);
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;
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;
439 src = (s16 *)(src_base + src_pos);
440 dst = (u64 *)(dst_base + dst_pos);
442 l = src[0]; /* sign extend */
443 r = src[1]; /* sign extend */
445 *dst = ((l & 0x00ffffff) << CHANNEL_LEFT_SHIFT) |
446 ((r & 0x00ffffff) << CHANNEL_RIGHT_SHIFT);
448 dst_pos = (dst_pos + sizeof(u64)) & CHANNEL_RING_MASK;
449 src_pos = (src_pos + 2 * sizeof(s16)) & src_mask;
450 count -= sizeof(u64);
453 writeq(dst_pos, &mace->perif.audio.chan[ch].write_ptr); /* in bytes */
454 chip->channel[ch].pos = src_pos;
456 spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
460 static int snd_sgio2audio_dma_start(struct snd_pcm_substream *substream)
462 struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
463 struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
466 /* reset DMA channel */
467 writeq(CHANNEL_CONTROL_RESET, &mace->perif.audio.chan[ch].control);
469 writeq(0, &mace->perif.audio.chan[ch].control);
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);
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);
481 static int snd_sgio2audio_dma_stop(struct snd_pcm_substream *substream)
483 struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
485 writeq(0, &mace->perif.audio.chan[chan->idx].control);
489 static irqreturn_t snd_sgio2audio_dma_in_isr(int irq, void *dev_id)
491 struct snd_sgio2audio_chan *chan = dev_id;
492 struct snd_pcm_substream *substream;
493 struct snd_sgio2audio *chip;
496 substream = chan->substream;
497 chip = snd_pcm_substream_chip(substream);
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);
509 static irqreturn_t snd_sgio2audio_dma_out_isr(int irq, void *dev_id)
511 struct snd_sgio2audio_chan *chan = dev_id;
512 struct snd_pcm_substream *substream;
513 struct snd_sgio2audio *chip;
516 substream = chan->substream;
517 chip = snd_pcm_substream_chip(substream);
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);
528 static irqreturn_t snd_sgio2audio_error_isr(int irq, void *dev_id)
530 struct snd_sgio2audio_chan *chan = dev_id;
531 struct snd_pcm_substream *substream;
533 substream = chan->substream;
534 snd_sgio2audio_dma_stop(substream);
535 snd_sgio2audio_dma_start(substream);
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,
552 .buffer_bytes_max = 65536,
553 .period_bytes_min = 32768,
554 .period_bytes_max = 65536,
559 /* PCM playback open callback */
560 static int snd_sgio2audio_playback1_open(struct snd_pcm_substream *substream)
562 struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
563 struct snd_pcm_runtime *runtime = substream->runtime;
565 runtime->hw = snd_sgio2audio_pcm_hw;
566 runtime->private_data = &chip->channel[1];
570 static int snd_sgio2audio_playback2_open(struct snd_pcm_substream *substream)
572 struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
573 struct snd_pcm_runtime *runtime = substream->runtime;
575 runtime->hw = snd_sgio2audio_pcm_hw;
576 runtime->private_data = &chip->channel[2];
580 /* PCM capture open callback */
581 static int snd_sgio2audio_capture_open(struct snd_pcm_substream *substream)
583 struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
584 struct snd_pcm_runtime *runtime = substream->runtime;
586 runtime->hw = snd_sgio2audio_pcm_hw;
587 runtime->private_data = &chip->channel[0];
591 /* PCM close callback */
592 static int snd_sgio2audio_pcm_close(struct snd_pcm_substream *substream)
594 struct snd_pcm_runtime *runtime = substream->runtime;
596 runtime->private_data = NULL;
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)
605 return snd_pcm_lib_alloc_vmalloc_buffer(substream,
606 params_buffer_bytes(hw_params));
609 /* hw_free callback */
610 static int snd_sgio2audio_pcm_hw_free(struct snd_pcm_substream *substream)
612 return snd_pcm_lib_free_vmalloc_buffer(substream);
615 /* prepare callback */
616 static int snd_sgio2audio_pcm_prepare(struct snd_pcm_substream *substream)
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;
624 spin_lock_irqsave(&chip->channel[ch].lock, flags);
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;
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,
638 SNDRV_PCM_FORMAT_S16_LE,
641 case SNDRV_PCM_STREAM_CAPTURE:
642 ad1843_setup_adc(&chip->ad1843,
644 SNDRV_PCM_FORMAT_S16_LE,
648 spin_unlock_irqrestore(&chip->channel[ch].lock, flags);
652 /* trigger callback */
653 static int snd_sgio2audio_pcm_trigger(struct snd_pcm_substream *substream,
657 case SNDRV_PCM_TRIGGER_START:
658 /* start the PCM engine */
659 snd_sgio2audio_dma_start(substream);
661 case SNDRV_PCM_TRIGGER_STOP:
662 /* stop the PCM engine */
663 snd_sgio2audio_dma_stop(substream);
671 /* pointer callback */
672 static snd_pcm_uframes_t
673 snd_sgio2audio_pcm_pointer(struct snd_pcm_substream *substream)
675 struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream);
676 struct snd_sgio2audio_chan *chan = substream->runtime->private_data;
678 /* get the current hardware pointer */
679 return bytes_to_frames(substream->runtime,
680 chip->channel[chan->idx].pos);
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,
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,
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,
724 * definitions of capture are omitted here...
727 /* create a pcm device */
728 static int __devinit snd_sgio2audio_new_pcm(struct snd_sgio2audio *chip)
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);
738 pcm->private_data = chip;
739 strcpy(pcm->name, "SGI O2 DAC1");
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);
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);
752 pcm->private_data = chip;
753 strcpy(pcm->name, "SGI O2 DAC2");
756 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
757 &snd_sgio2audio_playback2_ops);
765 irqreturn_t (*isr)(int, void *);
767 } snd_sgio2_isr_table[] = {
770 .irq = MACEISA_AUDIO1_DMAT_IRQ,
771 .isr = snd_sgio2audio_dma_in_isr,
772 .desc = "Capture DMA Channel 0"
775 .irq = MACEISA_AUDIO1_OF_IRQ,
776 .isr = snd_sgio2audio_error_isr,
777 .desc = "Capture Overflow"
780 .irq = MACEISA_AUDIO2_DMAT_IRQ,
781 .isr = snd_sgio2audio_dma_out_isr,
782 .desc = "Playback DMA Channel 1"
785 .irq = MACEISA_AUDIO2_MERR_IRQ,
786 .isr = snd_sgio2audio_error_isr,
787 .desc = "Memory Error Channel 1"
790 .irq = MACEISA_AUDIO3_DMAT_IRQ,
791 .isr = snd_sgio2audio_dma_out_isr,
792 .desc = "Playback DMA Channel 2"
795 .irq = MACEISA_AUDIO3_MERR_IRQ,
796 .isr = snd_sgio2audio_error_isr,
797 .desc = "Memory Error Channel 2"
803 static int snd_sgio2audio_free(struct snd_sgio2audio *chip)
807 /* reset interface */
808 writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control);
810 writeq(0, &mace->perif.audio.control);
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]);
817 dma_free_coherent(NULL, MACEISA_RINGBUFFERS_SIZE,
818 chip->ring_base, chip->ring_base_dma);
820 /* release card data */
825 static int snd_sgio2audio_dev_free(struct snd_device *device)
827 struct snd_sgio2audio *chip = device->device_data;
829 return snd_sgio2audio_free(chip);
832 static struct snd_device_ops ops = {
833 .dev_free = snd_sgio2audio_dev_free,
836 static int __devinit snd_sgio2audio_create(struct snd_card *card,
837 struct snd_sgio2audio **rchip)
839 struct snd_sgio2audio *chip;
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))
849 chip = kzalloc(sizeof(struct snd_sgio2audio), GFP_KERNEL);
855 chip->ring_base = dma_alloc_coherent(NULL, MACEISA_RINGBUFFERS_SIZE,
856 &chip->ring_base_dma, GFP_USER);
857 if (chip->ring_base == NULL) {
859 "sgio2audio: could not allocate ring buffers\n");
864 spin_lock_init(&chip->ad1843_lock);
866 /* initialize channels */
867 for (i = 0; i < 3; i++) {
868 spin_lock_init(&chip->channel[i].lock);
869 chip->channel[i].idx = i;
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,
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);
886 /* reset the interface */
887 writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control);
889 writeq(0, &mace->perif.audio.control);
890 msleep_interruptible(1); /* give time to recover */
893 writeq(chip->ring_base_dma, &mace->perif.ctrl.ringbase);
895 /* attach the AD1843 codec */
896 chip->ad1843.read = read_ad1843_reg;
897 chip->ad1843.write = write_ad1843_reg;
898 chip->ad1843.chip = chip;
900 /* initialize the AD1843 codec */
901 err = ad1843_init(&chip->ad1843);
903 snd_sgio2audio_free(chip);
907 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
909 snd_sgio2audio_free(chip);
916 static int __devinit snd_sgio2audio_probe(struct platform_device *pdev)
918 struct snd_card *card;
919 struct snd_sgio2audio *chip;
922 err = snd_card_create(index, id, THIS_MODULE, 0, &card);
926 err = snd_sgio2audio_create(card, &chip);
931 snd_card_set_dev(card, &pdev->dev);
933 err = snd_sgio2audio_new_pcm(chip);
938 err = snd_sgio2audio_new_mixer(chip);
944 strcpy(card->driver, "SGI O2 Audio");
945 strcpy(card->shortname, "SGI O2 Audio");
946 sprintf(card->longname, "%s irq %i-%i",
948 MACEISA_AUDIO1_DMAT_IRQ,
949 MACEISA_AUDIO3_MERR_IRQ);
951 err = snd_card_register(card);
956 platform_set_drvdata(pdev, card);
960 static int __devexit snd_sgio2audio_remove(struct platform_device *pdev)
962 struct snd_card *card = platform_get_drvdata(pdev);
965 platform_set_drvdata(pdev, NULL);
969 static struct platform_driver sgio2audio_driver = {
970 .probe = snd_sgio2audio_probe,
971 .remove = __devexit_p(snd_sgio2audio_remove),
973 .name = "sgio2audio",
974 .owner = THIS_MODULE,
978 static int __init alsa_card_sgio2audio_init(void)
980 return platform_driver_register(&sgio2audio_driver);
983 static void __exit alsa_card_sgio2audio_exit(void)
985 platform_driver_unregister(&sgio2audio_driver);
988 module_init(alsa_card_sgio2audio_init)
989 module_exit(alsa_card_sgio2audio_exit)