2 * BRIEF MODULE DESCRIPTION
3 * Driver for AMD Au1000 MIPS Processor, AC'97 Sound Port
5 * Copyright 2004 Cooper Street Innovations Inc.
6 * Author: Charles Eidsness <charles@cooper-street.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
13 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
14 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
16 * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
19 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 * You should have received a copy of the GNU General Public License along
25 * with this program; if not, write to the Free Software Foundation, Inc.,
26 * 675 Mass Ave, Cambridge, MA 02139, USA.
30 * 2004-09-09 Charles Eidsness -- Original verion -- based on
31 * sa11xx-uda1341.c ALSA driver and the
32 * au1000.c OSS driver.
33 * 2004-09-09 Matt Porter -- Added support for ALSA 1.0.6
37 #include <linux/ioport.h>
38 #include <linux/interrupt.h>
39 #include <sound/driver.h>
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/version.h>
43 #include <sound/core.h>
44 #include <sound/initval.h>
45 #include <sound/pcm.h>
46 #include <sound/ac97_codec.h>
47 #include <asm/mach-au1x00/au1000.h>
48 #include <asm/mach-au1x00/au1000_dma.h>
50 MODULE_AUTHOR("Charles Eidsness <charles@cooper-street.com>");
51 MODULE_DESCRIPTION("Au1000 AC'97 ALSA Driver");
52 MODULE_LICENSE("GPL");
53 MODULE_SUPPORTED_DEVICE("{{AMD,Au1000 AC'97}}");
57 #define AC97_SLOT_3 0x01
58 #define AC97_SLOT_4 0x02
59 #define AC97_SLOT_6 0x08
60 #define AC97_CMD_IRQ 31
66 typedef struct au1000_period au1000_period_t;
70 u32 relative_end; /*realtive to start of buffer*/
71 au1000_period_t * next;
74 /*Au1000 AC97 Port Control Reisters*/
75 typedef struct au1000_ac97_reg au1000_ac97_reg_t;
76 struct au1000_ac97_reg {
84 typedef struct audio_stream audio_stream_t;
86 snd_pcm_substream_t * substream;
89 au1000_period_t * buffer;
90 unsigned int period_size;
94 typedef struct snd_card_au1000 {
96 au1000_ac97_reg_t volatile *ac97_ioport;
98 struct resource *ac97_res_port;
103 audio_stream_t *stream[2]; /* playback & capture */
106 /*--------------------------- Local Functions --------------------------------*/
108 au1000_set_ac97_xmit_slots(au1000_t *au1000, long xmit_slots)
110 u32 volatile ac97_config;
112 spin_lock(&au1000->ac97_lock);
113 ac97_config = au1000->ac97_ioport->config;
114 ac97_config = ac97_config & ~AC97C_XMIT_SLOTS_MASK;
115 ac97_config |= (xmit_slots << AC97C_XMIT_SLOTS_BIT);
116 au1000->ac97_ioport->config = ac97_config;
117 spin_unlock(&au1000->ac97_lock);
121 au1000_set_ac97_recv_slots(au1000_t *au1000, long recv_slots)
123 u32 volatile ac97_config;
125 spin_lock(&au1000->ac97_lock);
126 ac97_config = au1000->ac97_ioport->config;
127 ac97_config = ac97_config & ~AC97C_RECV_SLOTS_MASK;
128 ac97_config |= (recv_slots << AC97C_RECV_SLOTS_BIT);
129 au1000->ac97_ioport->config = ac97_config;
130 spin_unlock(&au1000->ac97_lock);
135 au1000_release_dma_link(audio_stream_t *stream)
137 au1000_period_t * pointer;
138 au1000_period_t * pointer_next;
140 stream->period_size = 0;
142 pointer = stream->buffer;
146 pointer_next = pointer->next;
148 pointer = pointer_next;
149 } while (pointer != stream->buffer);
150 stream->buffer = NULL;
154 au1000_setup_dma_link(audio_stream_t *stream, unsigned int period_bytes,
155 unsigned int periods)
157 snd_pcm_substream_t *substream = stream->substream;
158 snd_pcm_runtime_t *runtime = substream->runtime;
159 unsigned long dma_start;
162 dma_start = virt_to_phys(runtime->dma_area);
164 if (stream->period_size == period_bytes &&
165 stream->periods == periods)
166 return 0; /* not changed */
168 au1000_release_dma_link(stream);
170 stream->period_size = period_bytes;
171 stream->periods = periods;
173 stream->buffer = kmalloc(sizeof(au1000_period_t), GFP_KERNEL);
174 if (! stream->buffer)
176 pointer = stream->buffer;
177 for (i = 0; i < periods; i++) {
178 pointer->start = (u32)(dma_start + (i * period_bytes));
179 pointer->relative_end = (u32) (((i+1) * period_bytes) - 0x1);
180 if (i < periods - 1) {
181 pointer->next = kmalloc(sizeof(struct au1000_period), GFP_KERNEL);
182 if (! pointer->next) {
183 au1000_release_dma_link(stream);
186 pointer = pointer->next;
189 pointer->next = stream->buffer;
194 au1000_dma_stop(audio_stream_t *stream)
196 snd_assert(stream->buffer, return);
197 disable_dma(stream->dma);
201 au1000_dma_start(audio_stream_t *stream)
203 snd_assert(stream->buffer, return);
205 init_dma(stream->dma);
206 if (get_dma_active_buffer(stream->dma) == 0) {
207 clear_dma_done0(stream->dma);
208 set_dma_addr0(stream->dma, stream->buffer->start);
209 set_dma_count0(stream->dma, stream->period_size >> 1);
210 set_dma_addr1(stream->dma, stream->buffer->next->start);
211 set_dma_count1(stream->dma, stream->period_size >> 1);
213 clear_dma_done1(stream->dma);
214 set_dma_addr1(stream->dma, stream->buffer->start);
215 set_dma_count1(stream->dma, stream->period_size >> 1);
216 set_dma_addr0(stream->dma, stream->buffer->next->start);
217 set_dma_count0(stream->dma, stream->period_size >> 1);
219 enable_dma_buffers(stream->dma);
220 start_dma(stream->dma);
224 au1000_dma_interrupt(int irq, void *dev_id, struct pt_regs *regs)
226 audio_stream_t *stream = (audio_stream_t *) dev_id;
227 snd_pcm_substream_t *substream = stream->substream;
229 spin_lock(&stream->dma_lock);
230 switch (get_dma_buffer_done(stream->dma)) {
232 stream->buffer = stream->buffer->next;
233 clear_dma_done0(stream->dma);
234 set_dma_addr0(stream->dma, stream->buffer->next->start);
235 set_dma_count0(stream->dma, stream->period_size >> 1);
236 enable_dma_buffer0(stream->dma);
239 stream->buffer = stream->buffer->next;
240 clear_dma_done1(stream->dma);
241 set_dma_addr1(stream->dma, stream->buffer->next->start);
242 set_dma_count1(stream->dma, stream->period_size >> 1);
243 enable_dma_buffer1(stream->dma);
245 case (DMA_D0 | DMA_D1):
246 printk(KERN_ERR "DMA %d missed interrupt.\n",stream->dma);
247 au1000_dma_stop(stream);
248 au1000_dma_start(stream);
250 case (~DMA_D0 & ~DMA_D1):
251 printk(KERN_ERR "DMA %d empty irq.\n",stream->dma);
253 spin_unlock(&stream->dma_lock);
254 snd_pcm_period_elapsed(substream);
258 /*-------------------------- PCM Audio Streams -------------------------------*/
260 static unsigned int rates[] = {8000, 11025, 16000, 22050};
261 static snd_pcm_hw_constraint_list_t hw_constraints_rates = {
262 .count = sizeof(rates) / sizeof(rates[0]),
267 static snd_pcm_hardware_t snd_au1000_hw =
269 .info = (SNDRV_PCM_INFO_INTERLEAVED | \
270 SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID),
271 .formats = SNDRV_PCM_FMTBIT_S16_LE,
272 .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |
273 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050),
278 .buffer_bytes_max = 128*1024,
279 .period_bytes_min = 32,
280 .period_bytes_max = 16*1024,
287 snd_au1000_playback_open(snd_pcm_substream_t * substream)
289 au1000_t *au1000 = substream->pcm->private_data;
291 au1000->stream[PLAYBACK]->substream = substream;
292 au1000->stream[PLAYBACK]->buffer = NULL;
293 substream->private_data = au1000->stream[PLAYBACK];
294 substream->runtime->hw = snd_au1000_hw;
295 return (snd_pcm_hw_constraint_list(substream->runtime, 0,
296 SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates) < 0);
300 snd_au1000_capture_open(snd_pcm_substream_t * substream)
302 au1000_t *au1000 = substream->pcm->private_data;
304 au1000->stream[CAPTURE]->substream = substream;
305 au1000->stream[CAPTURE]->buffer = NULL;
306 substream->private_data = au1000->stream[CAPTURE];
307 substream->runtime->hw = snd_au1000_hw;
308 return (snd_pcm_hw_constraint_list(substream->runtime, 0,
309 SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates) < 0);
314 snd_au1000_playback_close(snd_pcm_substream_t * substream)
316 au1000_t *au1000 = substream->pcm->private_data;
318 au1000->stream[PLAYBACK]->substream = NULL;
323 snd_au1000_capture_close(snd_pcm_substream_t * substream)
325 au1000_t *au1000 = substream->pcm->private_data;
327 au1000->stream[CAPTURE]->substream = NULL;
332 snd_au1000_hw_params(snd_pcm_substream_t * substream,
333 snd_pcm_hw_params_t * hw_params)
335 audio_stream_t *stream = substream->private_data;
338 err = snd_pcm_lib_malloc_pages(substream,
339 params_buffer_bytes(hw_params));
342 return au1000_setup_dma_link(stream,
343 params_period_bytes(hw_params),
344 params_periods(hw_params));
348 snd_au1000_hw_free(snd_pcm_substream_t * substream)
350 audio_stream_t *stream = substream->private_data;
351 au1000_release_dma_link(stream);
352 return snd_pcm_lib_free_pages(substream);
356 snd_au1000_playback_prepare(snd_pcm_substream_t * substream)
358 au1000_t *au1000 = substream->pcm->private_data;
359 snd_pcm_runtime_t *runtime = substream->runtime;
361 if (runtime->channels == 1)
362 au1000_set_ac97_xmit_slots(au1000, AC97_SLOT_4);
364 au1000_set_ac97_xmit_slots(au1000, AC97_SLOT_3 | AC97_SLOT_4);
365 snd_ac97_set_rate(au1000->ac97, AC97_PCM_FRONT_DAC_RATE, runtime->rate);
370 snd_au1000_capture_prepare(snd_pcm_substream_t * substream)
372 au1000_t *au1000 = substream->pcm->private_data;
373 snd_pcm_runtime_t *runtime = substream->runtime;
375 if (runtime->channels == 1)
376 au1000_set_ac97_recv_slots(au1000, AC97_SLOT_4);
378 au1000_set_ac97_recv_slots(au1000, AC97_SLOT_3 | AC97_SLOT_4);
379 snd_ac97_set_rate(au1000->ac97, AC97_PCM_LR_ADC_RATE, runtime->rate);
384 snd_au1000_trigger(snd_pcm_substream_t * substream, int cmd)
386 audio_stream_t *stream = substream->private_data;
389 spin_lock(&stream->dma_lock);
391 case SNDRV_PCM_TRIGGER_START:
392 au1000_dma_start(stream);
394 case SNDRV_PCM_TRIGGER_STOP:
395 au1000_dma_stop(stream);
401 spin_unlock(&stream->dma_lock);
405 static snd_pcm_uframes_t
406 snd_au1000_pointer(snd_pcm_substream_t * substream)
408 audio_stream_t *stream = substream->private_data;
409 snd_pcm_runtime_t *runtime = substream->runtime;
412 spin_lock(&stream->dma_lock);
413 location = get_dma_residue(stream->dma);
414 spin_unlock(&stream->dma_lock);
415 location = stream->buffer->relative_end - location;
418 return bytes_to_frames(runtime,location);
421 static snd_pcm_ops_t snd_card_au1000_playback_ops = {
422 .open = snd_au1000_playback_open,
423 .close = snd_au1000_playback_close,
424 .ioctl = snd_pcm_lib_ioctl,
425 .hw_params = snd_au1000_hw_params,
426 .hw_free = snd_au1000_hw_free,
427 .prepare = snd_au1000_playback_prepare,
428 .trigger = snd_au1000_trigger,
429 .pointer = snd_au1000_pointer,
432 static snd_pcm_ops_t snd_card_au1000_capture_ops = {
433 .open = snd_au1000_capture_open,
434 .close = snd_au1000_capture_close,
435 .ioctl = snd_pcm_lib_ioctl,
436 .hw_params = snd_au1000_hw_params,
437 .hw_free = snd_au1000_hw_free,
438 .prepare = snd_au1000_capture_prepare,
439 .trigger = snd_au1000_trigger,
440 .pointer = snd_au1000_pointer,
444 snd_au1000_pcm_new(void)
450 if ((err = snd_pcm_new(au1000->card, "AU1000 AC97 PCM", 0, 1, 1, &pcm)) < 0)
453 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
454 snd_dma_continuous_data(GFP_KERNEL), 128*1024, 128*1024);
456 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
457 &snd_card_au1000_playback_ops);
458 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
459 &snd_card_au1000_capture_ops);
461 pcm->private_data = au1000;
463 strcpy(pcm->name, "Au1000 AC97 PCM");
465 spin_lock_init(&au1000->stream[PLAYBACK]->dma_lock);
466 spin_lock_init(&au1000->stream[CAPTURE]->dma_lock);
468 flags = claim_dma_lock();
469 if ((au1000->stream[PLAYBACK]->dma = request_au1000_dma(DMA_ID_AC97C_TX,
470 "AC97 TX", au1000_dma_interrupt, SA_INTERRUPT,
471 au1000->stream[PLAYBACK])) < 0) {
472 release_dma_lock(flags);
475 if ((au1000->stream[CAPTURE]->dma = request_au1000_dma(DMA_ID_AC97C_RX,
476 "AC97 RX", au1000_dma_interrupt, SA_INTERRUPT,
477 au1000->stream[CAPTURE])) < 0){
478 release_dma_lock(flags);
481 /* enable DMA coherency in read/write DMA channels */
482 set_dma_mode(au1000->stream[PLAYBACK]->dma,
483 get_dma_mode(au1000->stream[PLAYBACK]->dma) & ~DMA_NC);
484 set_dma_mode(au1000->stream[CAPTURE]->dma,
485 get_dma_mode(au1000->stream[CAPTURE]->dma) & ~DMA_NC);
486 release_dma_lock(flags);
492 /*-------------------------- AC97 CODEC Control ------------------------------*/
494 static unsigned short
495 snd_au1000_ac97_read(ac97_t *ac97, unsigned short reg)
497 au1000_t *au1000 = ac97->private_data;
502 spin_lock(&au1000->ac97_lock);
503 /* would rather use the interupt than this polling but it works and I can't
504 get the interupt driven case to work efficiently */
505 for (i = 0; i < 0x5000; i++)
506 if (!(au1000->ac97_ioport->status & AC97C_CP))
509 printk(KERN_ERR "au1000 AC97: AC97 command read timeout\n");
511 cmd = (u32) reg & AC97C_INDEX_MASK;
513 au1000->ac97_ioport->cmd = cmd;
515 /* now wait for the data */
516 for (i = 0; i < 0x5000; i++)
517 if (!(au1000->ac97_ioport->status & AC97C_CP))
520 printk(KERN_ERR "au1000 AC97: AC97 command read timeout\n");
524 data = au1000->ac97_ioport->cmd & 0xffff;
525 spin_unlock(&au1000->ac97_lock);
533 snd_au1000_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val)
535 au1000_t *au1000 = ac97->private_data;
539 spin_lock(&au1000->ac97_lock);
540 /* would rather use the interupt than this polling but it works and I can't
541 get the interupt driven case to work efficiently */
542 for (i = 0; i < 0x5000; i++)
543 if (!(au1000->ac97_ioport->status & AC97C_CP))
546 printk(KERN_ERR "au1000 AC97: AC97 command write timeout\n");
548 cmd = (u32) reg & AC97C_INDEX_MASK;
550 cmd |= ((u32) val << AC97C_WD_BIT);
551 au1000->ac97_ioport->cmd = cmd;
552 spin_unlock(&au1000->ac97_lock);
556 snd_au1000_ac97_new(au1000_t *au1000)
559 ac97_bus_t bus, *pbus;
562 if ((au1000->ac97_res_port = request_region(AC97C_CONFIG,
563 sizeof(au1000_ac97_reg_t), "Au1x00 AC97")) == NULL) {
564 snd_printk(KERN_ERR "ALSA AC97: can't grap AC97 port\n");
567 au1000->ac97_ioport = (au1000_ac97_reg_t *) au1000->ac97_res_port->start;
569 spin_lock_init(&au1000->ac97_lock);
571 /* configure pins for AC'97
572 TODO: move to board_setup.c */
573 au_writel(au_readl(SYS_PINFUNC) & ~0x02, SYS_PINFUNC);
575 /* Initialise Au1000's AC'97 Control Block */
576 au1000->ac97_ioport->cntrl = AC97C_RS | AC97C_CE;
578 au1000->ac97_ioport->cntrl = AC97C_CE;
581 /* Initialise External CODEC -- cold reset */
582 au1000->ac97_ioport->config = AC97C_RESET;
584 au1000->ac97_ioport->config = 0x0;
587 /* Initialise AC97 middle-layer */
588 if ((err = snd_ac97_bus(au1000->card, 0, &ops, au1000, &pbus)) < 0)
591 memset(&ac97, 0, sizeof(ac97));
592 ac97.private_data = au1000;
593 if ((err = snd_ac97_mixer(pbus, &ac97, &au1000->ac97)) < 0)
599 /*------------------------------ Setup / Destroy ----------------------------*/
602 snd_au1000_free(snd_card_t *card)
604 au1000_t *au1000 = card->private_data;
606 if (au1000->ac97_res_port) {
607 /* put internal AC97 block into reset */
608 au1000->ac97_ioport->cntrl = AC97C_RS;
609 au1000->ac97_ioport = NULL;
610 release_and_free_resource(au1000->ac97_res_port);
613 if (au1000->stream[PLAYBACK]->dma >= 0)
614 free_au1000_dma(au1000->stream[PLAYBACK]->dma);
616 if (au1000->stream[CAPTURE]->dma >= 0)
617 free_au1000_dma(au1000->stream[CAPTURE]->dma);
619 kfree(au1000->stream[PLAYBACK]);
620 kfree(au1000->stream[CAPTURE]);
624 static snd_card_t *au1000_card;
633 card = snd_card_new(-1, "AC97", THIS_MODULE, sizeof(au1000_t));
637 card->private_free = snd_au1000_free;
638 au1000 = card->private_data;
639 /* so that snd_au1000_free will work as intended */
641 au1000->stream[PLAYBACK]->dma = -1;
642 au1000->stream[CAPTURE]->dma = -1;
643 au1000->ac97_res_port = NULL;
644 au1000->stream[PLAYBACK] = kmalloc(sizeof(audio_stream_t), GFP_KERNEL);
645 au1000->stream[CAPTURE] = kmalloc(sizeof(audio_stream_t), GFP_KERNEL);
646 if (au1000->stream[PLAYBACK] == NULL ||
647 au1000->stream[CAPTURE] == NULL) {
652 if ((err = snd_au1000_ac97_new(au1000)) < 0 ) {
657 if ((err = snd_au1000_pcm_new(au1000)) < 0) {
662 strcpy(card->driver, "Au1000-AC97");
663 strcpy(card->shortname, "AMD Au1000-AC97");
664 sprintf(card->longname, "AMD Au1000--AC97 ALSA Driver");
666 if ((err = snd_card_set_generic_dev(card)) < 0) {
671 if ((err = snd_card_register(card)) < 0) {
676 printk( KERN_INFO "ALSA AC97: Driver Initialized\n" );
681 static void __exit au1000_exit(void)
683 snd_card_free(au1000_card);
686 module_init(au1000_init);
687 module_exit(au1000_exit);