2 * PMac DBDMA lowlevel functions
4 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
5 * code based on dmasound.c.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <sound/driver.h>
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/interrupt.h>
30 #include <linux/pci.h>
31 #include <linux/dma-mapping.h>
32 #include <sound/core.h>
34 #include <sound/pcm_params.h>
35 #include <asm/pmac_feature.h>
36 #include <asm/pci-bridge.h>
39 /* fixed frequency table for awacs, screamer, burgundy, DACA (44100 max) */
40 static int awacs_freqs
[8] = {
41 44100, 29400, 22050, 17640, 14700, 11025, 8820, 7350
43 /* fixed frequency table for tumbler */
44 static int tumbler_freqs
[1] = {
49 * allocate DBDMA command arrays
51 static int snd_pmac_dbdma_alloc(struct snd_pmac
*chip
, struct pmac_dbdma
*rec
, int size
)
53 unsigned int rsize
= sizeof(struct dbdma_cmd
) * (size
+ 1);
55 rec
->space
= dma_alloc_coherent(&chip
->pdev
->dev
, rsize
,
56 &rec
->dma_base
, GFP_KERNEL
);
57 if (rec
->space
== NULL
)
60 memset(rec
->space
, 0, rsize
);
61 rec
->cmds
= (void __iomem
*)DBDMA_ALIGN(rec
->space
);
62 rec
->addr
= rec
->dma_base
+ (unsigned long)((char *)rec
->cmds
- (char *)rec
->space
);
67 static void snd_pmac_dbdma_free(struct snd_pmac
*chip
, struct pmac_dbdma
*rec
)
70 unsigned int rsize
= sizeof(struct dbdma_cmd
) * (rec
->size
+ 1);
72 dma_free_coherent(&chip
->pdev
->dev
, rsize
, rec
->space
, rec
->dma_base
);
82 * look up frequency table
85 unsigned int snd_pmac_rate_index(struct snd_pmac
*chip
, struct pmac_stream
*rec
, unsigned int rate
)
90 if (rate
> chip
->freq_table
[0])
93 for (i
= 0; i
< chip
->num_freqs
; i
++, ok
>>= 1) {
94 if (! (ok
& 1)) continue;
96 if (rate
>= chip
->freq_table
[i
])
103 * check whether another stream is active
105 static inline int another_stream(int stream
)
107 return (stream
== SNDRV_PCM_STREAM_PLAYBACK
) ?
108 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
;
114 static int snd_pmac_pcm_hw_params(struct snd_pcm_substream
*subs
,
115 struct snd_pcm_hw_params
*hw_params
)
117 return snd_pcm_lib_malloc_pages(subs
, params_buffer_bytes(hw_params
));
123 static int snd_pmac_pcm_hw_free(struct snd_pcm_substream
*subs
)
125 snd_pcm_lib_free_pages(subs
);
130 * get a stream of the opposite direction
132 static struct pmac_stream
*snd_pmac_get_stream(struct snd_pmac
*chip
, int stream
)
135 case SNDRV_PCM_STREAM_PLAYBACK
:
136 return &chip
->playback
;
137 case SNDRV_PCM_STREAM_CAPTURE
:
138 return &chip
->capture
;
146 * wait while run status is on
149 snd_pmac_wait_ack(struct pmac_stream
*rec
)
152 while ((in_le32(&rec
->dma
->status
) & RUN
) && timeout
-- > 0)
157 * set the format and rate to the chip.
158 * call the lowlevel function if defined (e.g. for AWACS).
160 static void snd_pmac_pcm_set_format(struct snd_pmac
*chip
)
162 /* set up frequency and format */
163 out_le32(&chip
->awacs
->control
, chip
->control_mask
| (chip
->rate_index
<< 8));
164 out_le32(&chip
->awacs
->byteswap
, chip
->format
== SNDRV_PCM_FORMAT_S16_LE
? 1 : 0);
165 if (chip
->set_format
)
166 chip
->set_format(chip
);
170 * stop the DMA transfer
172 static inline void snd_pmac_dma_stop(struct pmac_stream
*rec
)
174 out_le32(&rec
->dma
->control
, (RUN
|WAKE
|FLUSH
|PAUSE
) << 16);
175 snd_pmac_wait_ack(rec
);
179 * set the command pointer address
181 static inline void snd_pmac_dma_set_command(struct pmac_stream
*rec
, struct pmac_dbdma
*cmd
)
183 out_le32(&rec
->dma
->cmdptr
, cmd
->addr
);
189 static inline void snd_pmac_dma_run(struct pmac_stream
*rec
, int status
)
191 out_le32(&rec
->dma
->control
, status
| (status
<< 16));
196 * prepare playback/capture stream
198 static int snd_pmac_pcm_prepare(struct snd_pmac
*chip
, struct pmac_stream
*rec
, struct snd_pcm_substream
*subs
)
201 volatile struct dbdma_cmd __iomem
*cp
;
202 struct snd_pcm_runtime
*runtime
= subs
->runtime
;
205 struct pmac_stream
*astr
;
207 rec
->dma_size
= snd_pcm_lib_buffer_bytes(subs
);
208 rec
->period_size
= snd_pcm_lib_period_bytes(subs
);
209 rec
->nperiods
= rec
->dma_size
/ rec
->period_size
;
211 rate_index
= snd_pmac_rate_index(chip
, rec
, runtime
->rate
);
213 /* set up constraints */
214 astr
= snd_pmac_get_stream(chip
, another_stream(rec
->stream
));
217 astr
->cur_freqs
= 1 << rate_index
;
218 astr
->cur_formats
= 1 << runtime
->format
;
219 chip
->rate_index
= rate_index
;
220 chip
->format
= runtime
->format
;
222 /* We really want to execute a DMA stop command, after the AWACS
224 * For reasons I don't understand, it stops the hissing noise
225 * common to many PowerBook G3 systems and random noise otherwise
226 * captured on iBook2's about every third time. -ReneR
228 spin_lock_irq(&chip
->reg_lock
);
229 snd_pmac_dma_stop(rec
);
230 st_le16(&chip
->extra_dma
.cmds
->command
, DBDMA_STOP
);
231 snd_pmac_dma_set_command(rec
, &chip
->extra_dma
);
232 snd_pmac_dma_run(rec
, RUN
);
233 spin_unlock_irq(&chip
->reg_lock
);
235 spin_lock_irq(&chip
->reg_lock
);
236 /* continuous DMA memory type doesn't provide the physical address,
237 * so we need to resolve the address here...
239 offset
= runtime
->dma_addr
;
240 for (i
= 0, cp
= rec
->cmd
.cmds
; i
< rec
->nperiods
; i
++, cp
++) {
241 st_le32(&cp
->phy_addr
, offset
);
242 st_le16(&cp
->req_count
, rec
->period_size
);
243 /*st_le16(&cp->res_count, 0);*/
244 st_le16(&cp
->xfer_status
, 0);
245 offset
+= rec
->period_size
;
248 st_le16(&cp
->command
, DBDMA_NOP
+ BR_ALWAYS
);
249 st_le32(&cp
->cmd_dep
, rec
->cmd
.addr
);
251 snd_pmac_dma_stop(rec
);
252 snd_pmac_dma_set_command(rec
, &rec
->cmd
);
253 spin_unlock_irq(&chip
->reg_lock
);
262 static int snd_pmac_pcm_trigger(struct snd_pmac
*chip
, struct pmac_stream
*rec
,
263 struct snd_pcm_substream
*subs
, int cmd
)
265 volatile struct dbdma_cmd __iomem
*cp
;
269 case SNDRV_PCM_TRIGGER_START
:
270 case SNDRV_PCM_TRIGGER_RESUME
:
273 command
= (subs
->stream
== SNDRV_PCM_STREAM_PLAYBACK
?
274 OUTPUT_MORE
: INPUT_MORE
) + INTR_ALWAYS
;
275 spin_lock(&chip
->reg_lock
);
276 snd_pmac_beep_stop(chip
);
277 snd_pmac_pcm_set_format(chip
);
278 for (i
= 0, cp
= rec
->cmd
.cmds
; i
< rec
->nperiods
; i
++, cp
++)
279 out_le16(&cp
->command
, command
);
280 snd_pmac_dma_set_command(rec
, &rec
->cmd
);
281 (void)in_le32(&rec
->dma
->status
);
282 snd_pmac_dma_run(rec
, RUN
|WAKE
);
284 spin_unlock(&chip
->reg_lock
);
287 case SNDRV_PCM_TRIGGER_STOP
:
288 case SNDRV_PCM_TRIGGER_SUSPEND
:
289 spin_lock(&chip
->reg_lock
);
291 /*printk("stopped!!\n");*/
292 snd_pmac_dma_stop(rec
);
293 for (i
= 0, cp
= rec
->cmd
.cmds
; i
< rec
->nperiods
; i
++, cp
++)
294 out_le16(&cp
->command
, DBDMA_STOP
);
295 spin_unlock(&chip
->reg_lock
);
306 * return the current pointer
309 static snd_pcm_uframes_t
snd_pmac_pcm_pointer(struct snd_pmac
*chip
,
310 struct pmac_stream
*rec
,
311 struct snd_pcm_substream
*subs
)
315 #if 1 /* hmm.. how can we get the current dma pointer?? */
317 volatile struct dbdma_cmd __iomem
*cp
= &rec
->cmd
.cmds
[rec
->cur_period
];
318 stat
= ld_le16(&cp
->xfer_status
);
319 if (stat
& (ACTIVE
|DEAD
)) {
320 count
= in_le16(&cp
->res_count
);
322 count
= rec
->period_size
- count
;
325 count
+= rec
->cur_period
* rec
->period_size
;
326 /*printk("pointer=%d\n", count);*/
327 return bytes_to_frames(subs
->runtime
, count
);
334 static int snd_pmac_playback_prepare(struct snd_pcm_substream
*subs
)
336 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
337 return snd_pmac_pcm_prepare(chip
, &chip
->playback
, subs
);
340 static int snd_pmac_playback_trigger(struct snd_pcm_substream
*subs
,
343 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
344 return snd_pmac_pcm_trigger(chip
, &chip
->playback
, subs
, cmd
);
347 static snd_pcm_uframes_t
snd_pmac_playback_pointer(struct snd_pcm_substream
*subs
)
349 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
350 return snd_pmac_pcm_pointer(chip
, &chip
->playback
, subs
);
358 static int snd_pmac_capture_prepare(struct snd_pcm_substream
*subs
)
360 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
361 return snd_pmac_pcm_prepare(chip
, &chip
->capture
, subs
);
364 static int snd_pmac_capture_trigger(struct snd_pcm_substream
*subs
,
367 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
368 return snd_pmac_pcm_trigger(chip
, &chip
->capture
, subs
, cmd
);
371 static snd_pcm_uframes_t
snd_pmac_capture_pointer(struct snd_pcm_substream
*subs
)
373 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
374 return snd_pmac_pcm_pointer(chip
, &chip
->capture
, subs
);
379 * update playback/capture pointer from interrupts
381 static void snd_pmac_pcm_update(struct snd_pmac
*chip
, struct pmac_stream
*rec
)
383 volatile struct dbdma_cmd __iomem
*cp
;
387 spin_lock(&chip
->reg_lock
);
389 cp
= &rec
->cmd
.cmds
[rec
->cur_period
];
390 for (c
= 0; c
< rec
->nperiods
; c
++) { /* at most all fragments */
391 stat
= ld_le16(&cp
->xfer_status
);
392 if (! (stat
& ACTIVE
))
394 /*printk("update frag %d\n", rec->cur_period);*/
395 st_le16(&cp
->xfer_status
, 0);
396 st_le16(&cp
->req_count
, rec
->period_size
);
397 /*st_le16(&cp->res_count, 0);*/
399 if (rec
->cur_period
>= rec
->nperiods
) {
404 spin_unlock(&chip
->reg_lock
);
405 snd_pcm_period_elapsed(rec
->substream
);
406 spin_lock(&chip
->reg_lock
);
409 spin_unlock(&chip
->reg_lock
);
417 static struct snd_pcm_hardware snd_pmac_playback
=
419 .info
= (SNDRV_PCM_INFO_INTERLEAVED
|
420 SNDRV_PCM_INFO_MMAP
|
421 SNDRV_PCM_INFO_MMAP_VALID
|
422 SNDRV_PCM_INFO_RESUME
),
423 .formats
= SNDRV_PCM_FMTBIT_S16_BE
| SNDRV_PCM_FMTBIT_S16_LE
,
424 .rates
= SNDRV_PCM_RATE_8000_44100
,
429 .buffer_bytes_max
= 131072,
430 .period_bytes_min
= 256,
431 .period_bytes_max
= 16384,
433 .periods_max
= PMAC_MAX_FRAGS
,
436 static struct snd_pcm_hardware snd_pmac_capture
=
438 .info
= (SNDRV_PCM_INFO_INTERLEAVED
|
439 SNDRV_PCM_INFO_MMAP
|
440 SNDRV_PCM_INFO_MMAP_VALID
|
441 SNDRV_PCM_INFO_RESUME
),
442 .formats
= SNDRV_PCM_FMTBIT_S16_BE
| SNDRV_PCM_FMTBIT_S16_LE
,
443 .rates
= SNDRV_PCM_RATE_8000_44100
,
448 .buffer_bytes_max
= 131072,
449 .period_bytes_min
= 256,
450 .period_bytes_max
= 16384,
452 .periods_max
= PMAC_MAX_FRAGS
,
457 static int snd_pmac_hw_rule_rate(struct snd_pcm_hw_params
*params
,
458 struct snd_pcm_hw_rule
*rule
)
460 struct snd_pmac
*chip
= rule
->private;
461 struct pmac_stream
*rec
= snd_pmac_get_stream(chip
, rule
->deps
[0]);
462 int i
, freq_table
[8], num_freqs
;
467 for (i
= chip
->num_freqs
- 1; i
>= 0; i
--) {
468 if (rec
->cur_freqs
& (1 << i
))
469 freq_table
[num_freqs
++] = chip
->freq_table
[i
];
472 return snd_interval_list(hw_param_interval(params
, rule
->var
),
473 num_freqs
, freq_table
, 0);
476 static int snd_pmac_hw_rule_format(struct snd_pcm_hw_params
*params
,
477 struct snd_pcm_hw_rule
*rule
)
479 struct snd_pmac
*chip
= rule
->private;
480 struct pmac_stream
*rec
= snd_pmac_get_stream(chip
, rule
->deps
[0]);
484 return snd_mask_refine_set(hw_param_mask(params
, SNDRV_PCM_HW_PARAM_FORMAT
),
489 static int snd_pmac_pcm_open(struct snd_pmac
*chip
, struct pmac_stream
*rec
,
490 struct snd_pcm_substream
*subs
)
492 struct snd_pcm_runtime
*runtime
= subs
->runtime
;
494 static int typical_freqs
[] = {
500 static int typical_freq_flags
[] = {
501 SNDRV_PCM_RATE_44100
,
502 SNDRV_PCM_RATE_22050
,
503 SNDRV_PCM_RATE_11025
,
507 /* look up frequency table and fill bit mask */
508 runtime
->hw
.rates
= 0;
509 fflags
= chip
->freqs_ok
;
510 for (i
= 0; typical_freqs
[i
]; i
++) {
511 for (j
= 0; j
< chip
->num_freqs
; j
++) {
512 if ((chip
->freqs_ok
& (1 << j
)) &&
513 chip
->freq_table
[j
] == typical_freqs
[i
]) {
514 runtime
->hw
.rates
|= typical_freq_flags
[i
];
520 if (fflags
) /* rest */
521 runtime
->hw
.rates
|= SNDRV_PCM_RATE_KNOT
;
523 /* check for minimum and maximum rates */
524 for (i
= 0; i
< chip
->num_freqs
; i
++) {
525 if (chip
->freqs_ok
& (1 << i
)) {
526 runtime
->hw
.rate_max
= chip
->freq_table
[i
];
530 for (i
= chip
->num_freqs
- 1; i
>= 0; i
--) {
531 if (chip
->freqs_ok
& (1 << i
)) {
532 runtime
->hw
.rate_min
= chip
->freq_table
[i
];
536 runtime
->hw
.formats
= chip
->formats_ok
;
537 if (chip
->can_capture
) {
538 if (! chip
->can_duplex
)
539 runtime
->hw
.info
|= SNDRV_PCM_INFO_HALF_DUPLEX
;
540 runtime
->hw
.info
|= SNDRV_PCM_INFO_JOINT_DUPLEX
;
542 runtime
->private_data
= rec
;
543 rec
->substream
= subs
;
545 #if 0 /* FIXME: still under development.. */
546 snd_pcm_hw_rule_add(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
,
547 snd_pmac_hw_rule_rate
, chip
, rec
->stream
, -1);
548 snd_pcm_hw_rule_add(runtime
, 0, SNDRV_PCM_HW_PARAM_FORMAT
,
549 snd_pmac_hw_rule_format
, chip
, rec
->stream
, -1);
552 runtime
->hw
.periods_max
= rec
->cmd
.size
- 1;
554 if (chip
->can_duplex
)
555 snd_pcm_set_sync(subs
);
557 /* constraints to fix choppy sound */
558 snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
562 static int snd_pmac_pcm_close(struct snd_pmac
*chip
, struct pmac_stream
*rec
,
563 struct snd_pcm_substream
*subs
)
565 struct pmac_stream
*astr
;
567 snd_pmac_dma_stop(rec
);
569 astr
= snd_pmac_get_stream(chip
, another_stream(rec
->stream
));
573 /* reset constraints */
574 astr
->cur_freqs
= chip
->freqs_ok
;
575 astr
->cur_formats
= chip
->formats_ok
;
580 static int snd_pmac_playback_open(struct snd_pcm_substream
*subs
)
582 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
584 subs
->runtime
->hw
= snd_pmac_playback
;
585 return snd_pmac_pcm_open(chip
, &chip
->playback
, subs
);
588 static int snd_pmac_capture_open(struct snd_pcm_substream
*subs
)
590 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
592 subs
->runtime
->hw
= snd_pmac_capture
;
593 return snd_pmac_pcm_open(chip
, &chip
->capture
, subs
);
596 static int snd_pmac_playback_close(struct snd_pcm_substream
*subs
)
598 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
600 return snd_pmac_pcm_close(chip
, &chip
->playback
, subs
);
603 static int snd_pmac_capture_close(struct snd_pcm_substream
*subs
)
605 struct snd_pmac
*chip
= snd_pcm_substream_chip(subs
);
607 return snd_pmac_pcm_close(chip
, &chip
->capture
, subs
);
613 static struct snd_pcm_ops snd_pmac_playback_ops
= {
614 .open
= snd_pmac_playback_open
,
615 .close
= snd_pmac_playback_close
,
616 .ioctl
= snd_pcm_lib_ioctl
,
617 .hw_params
= snd_pmac_pcm_hw_params
,
618 .hw_free
= snd_pmac_pcm_hw_free
,
619 .prepare
= snd_pmac_playback_prepare
,
620 .trigger
= snd_pmac_playback_trigger
,
621 .pointer
= snd_pmac_playback_pointer
,
624 static struct snd_pcm_ops snd_pmac_capture_ops
= {
625 .open
= snd_pmac_capture_open
,
626 .close
= snd_pmac_capture_close
,
627 .ioctl
= snd_pcm_lib_ioctl
,
628 .hw_params
= snd_pmac_pcm_hw_params
,
629 .hw_free
= snd_pmac_pcm_hw_free
,
630 .prepare
= snd_pmac_capture_prepare
,
631 .trigger
= snd_pmac_capture_trigger
,
632 .pointer
= snd_pmac_capture_pointer
,
635 int __init
snd_pmac_pcm_new(struct snd_pmac
*chip
)
639 int num_captures
= 1;
641 if (! chip
->can_capture
)
643 err
= snd_pcm_new(chip
->card
, chip
->card
->driver
, 0, 1, num_captures
, &pcm
);
647 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_pmac_playback_ops
);
648 if (chip
->can_capture
)
649 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_pmac_capture_ops
);
651 pcm
->private_data
= chip
;
652 pcm
->info_flags
= SNDRV_PCM_INFO_JOINT_DUPLEX
;
653 strcpy(pcm
->name
, chip
->card
->shortname
);
656 chip
->formats_ok
= SNDRV_PCM_FMTBIT_S16_BE
;
657 if (chip
->can_byte_swap
)
658 chip
->formats_ok
|= SNDRV_PCM_FMTBIT_S16_LE
;
660 chip
->playback
.cur_formats
= chip
->formats_ok
;
661 chip
->capture
.cur_formats
= chip
->formats_ok
;
662 chip
->playback
.cur_freqs
= chip
->freqs_ok
;
663 chip
->capture
.cur_freqs
= chip
->freqs_ok
;
665 /* preallocate 64k buffer */
666 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
668 64 * 1024, 64 * 1024);
674 static void snd_pmac_dbdma_reset(struct snd_pmac
*chip
)
676 out_le32(&chip
->playback
.dma
->control
, (RUN
|PAUSE
|FLUSH
|WAKE
|DEAD
) << 16);
677 snd_pmac_wait_ack(&chip
->playback
);
678 out_le32(&chip
->capture
.dma
->control
, (RUN
|PAUSE
|FLUSH
|WAKE
|DEAD
) << 16);
679 snd_pmac_wait_ack(&chip
->capture
);
686 void snd_pmac_beep_dma_start(struct snd_pmac
*chip
, int bytes
, unsigned long addr
, int speed
)
688 struct pmac_stream
*rec
= &chip
->playback
;
690 snd_pmac_dma_stop(rec
);
691 st_le16(&chip
->extra_dma
.cmds
->req_count
, bytes
);
692 st_le16(&chip
->extra_dma
.cmds
->xfer_status
, 0);
693 st_le32(&chip
->extra_dma
.cmds
->cmd_dep
, chip
->extra_dma
.addr
);
694 st_le32(&chip
->extra_dma
.cmds
->phy_addr
, addr
);
695 st_le16(&chip
->extra_dma
.cmds
->command
, OUTPUT_MORE
+ BR_ALWAYS
);
696 out_le32(&chip
->awacs
->control
,
697 (in_le32(&chip
->awacs
->control
) & ~0x1f00)
699 out_le32(&chip
->awacs
->byteswap
, 0);
700 snd_pmac_dma_set_command(rec
, &chip
->extra_dma
);
701 snd_pmac_dma_run(rec
, RUN
);
704 void snd_pmac_beep_dma_stop(struct snd_pmac
*chip
)
706 snd_pmac_dma_stop(&chip
->playback
);
707 st_le16(&chip
->extra_dma
.cmds
->command
, DBDMA_STOP
);
708 snd_pmac_pcm_set_format(chip
); /* reset format */
716 snd_pmac_tx_intr(int irq
, void *devid
, struct pt_regs
*regs
)
718 struct snd_pmac
*chip
= devid
;
719 snd_pmac_pcm_update(chip
, &chip
->playback
);
725 snd_pmac_rx_intr(int irq
, void *devid
, struct pt_regs
*regs
)
727 struct snd_pmac
*chip
= devid
;
728 snd_pmac_pcm_update(chip
, &chip
->capture
);
734 snd_pmac_ctrl_intr(int irq
, void *devid
, struct pt_regs
*regs
)
736 struct snd_pmac
*chip
= devid
;
737 int ctrl
= in_le32(&chip
->awacs
->control
);
739 /*printk("pmac: control interrupt.. 0x%x\n", ctrl);*/
740 if (ctrl
& MASK_PORTCHG
) {
741 /* do something when headphone is plugged/unplugged? */
742 if (chip
->update_automute
)
743 chip
->update_automute(chip
, 1);
745 if (ctrl
& MASK_CNTLERR
) {
746 int err
= (in_le32(&chip
->awacs
->codec_stat
) & MASK_ERRCODE
) >> 16;
747 if (err
&& chip
->model
<= PMAC_SCREAMER
)
748 snd_printk(KERN_DEBUG
"error %x\n", err
);
750 /* Writing 1s to the CNTLERR and PORTCHG bits clears them... */
751 out_le32(&chip
->awacs
->control
, ctrl
);
757 * a wrapper to feature call for compatibility
759 static void snd_pmac_sound_feature(struct snd_pmac
*chip
, int enable
)
761 if (ppc_md
.feature_call
)
762 ppc_md
.feature_call(PMAC_FTR_SOUND_CHIP_ENABLE
, chip
->node
, 0, enable
);
769 static int snd_pmac_free(struct snd_pmac
*chip
)
772 if (chip
->initialized
) {
773 snd_pmac_dbdma_reset(chip
);
774 /* disable interrupts from awacs interface */
775 out_le32(&chip
->awacs
->control
, in_le32(&chip
->awacs
->control
) & 0xfff);
778 snd_pmac_sound_feature(chip
, 0);
780 /* clean up mixer if any */
781 if (chip
->mixer_free
)
782 chip
->mixer_free(chip
);
784 snd_pmac_detach_beep(chip
);
786 /* release resources */
788 free_irq(chip
->irq
, (void*)chip
);
789 if (chip
->tx_irq
>= 0)
790 free_irq(chip
->tx_irq
, (void*)chip
);
791 if (chip
->rx_irq
>= 0)
792 free_irq(chip
->rx_irq
, (void*)chip
);
793 snd_pmac_dbdma_free(chip
, &chip
->playback
.cmd
);
794 snd_pmac_dbdma_free(chip
, &chip
->capture
.cmd
);
795 snd_pmac_dbdma_free(chip
, &chip
->extra_dma
);
796 if (chip
->macio_base
)
797 iounmap(chip
->macio_base
);
798 if (chip
->latch_base
)
799 iounmap(chip
->latch_base
);
801 iounmap(chip
->awacs
);
802 if (chip
->playback
.dma
)
803 iounmap(chip
->playback
.dma
);
804 if (chip
->capture
.dma
)
805 iounmap(chip
->capture
.dma
);
809 for (i
= 0; i
< 3; i
++) {
810 if (chip
->requested
& (1 << i
))
811 release_mem_region(chip
->rsrc
[i
].start
,
813 chip
->rsrc
[i
].start
+ 1);
818 pci_dev_put(chip
->pdev
);
827 static int snd_pmac_dev_free(struct snd_device
*device
)
829 struct snd_pmac
*chip
= device
->device_data
;
830 return snd_pmac_free(chip
);
835 * check the machine support byteswap (little-endian)
838 static void __init
detect_byte_swap(struct snd_pmac
*chip
)
840 struct device_node
*mio
;
842 /* if seems that Keylargo can't byte-swap */
843 for (mio
= chip
->node
->parent
; mio
; mio
= mio
->parent
) {
844 if (strcmp(mio
->name
, "mac-io") == 0) {
845 if (device_is_compatible(mio
, "Keylargo"))
846 chip
->can_byte_swap
= 0;
851 /* it seems the Pismo & iBook can't byte-swap in hardware. */
852 if (machine_is_compatible("PowerBook3,1") ||
853 machine_is_compatible("PowerBook2,1"))
854 chip
->can_byte_swap
= 0 ;
856 if (machine_is_compatible("PowerBook2,1"))
857 chip
->can_duplex
= 0;
862 * detect a sound chip
864 static int __init
snd_pmac_detect(struct snd_pmac
*chip
)
866 struct device_node
*sound
= NULL
;
867 unsigned int *prop
, l
;
868 struct macio_chip
* macio
;
870 if (!machine_is(powermac
))
875 chip
->freqs_ok
= 0xff; /* all ok */
876 chip
->model
= PMAC_AWACS
;
877 chip
->can_byte_swap
= 1;
878 chip
->can_duplex
= 1;
879 chip
->can_capture
= 1;
880 chip
->num_freqs
= ARRAY_SIZE(awacs_freqs
);
881 chip
->freq_table
= awacs_freqs
;
884 chip
->control_mask
= MASK_IEPC
| MASK_IEE
| 0x11; /* default */
886 /* check machine type */
887 if (machine_is_compatible("AAPL,3400/2400")
888 || machine_is_compatible("AAPL,3500"))
889 chip
->is_pbook_3400
= 1;
890 else if (machine_is_compatible("PowerBook1,1")
891 || machine_is_compatible("AAPL,PowerBook1998"))
892 chip
->is_pbook_G3
= 1;
893 chip
->node
= find_devices("awacs");
898 * powermac G3 models have a node called "davbus"
899 * with a child called "sound".
902 chip
->node
= find_devices("davbus");
904 * if we didn't find a davbus device, try 'i2s-a' since
905 * this seems to be what iBooks have
908 chip
->node
= find_devices("i2s-a");
909 if (chip
->node
&& chip
->node
->parent
&&
910 chip
->node
->parent
->parent
) {
911 if (device_is_compatible(chip
->node
->parent
->parent
,
920 sound
= find_devices("sound");
921 while (sound
&& sound
->parent
!= chip
->node
)
926 prop
= (unsigned int *) get_property(sound
, "sub-frame", NULL
);
927 if (prop
&& *prop
< 16)
928 chip
->subframe
= *prop
;
929 prop
= (unsigned int *) get_property(sound
, "layout-id", NULL
);
931 /* partly deprecate snd-powermac, for those machines
932 * that have a layout-id property for now */
933 printk(KERN_INFO
"snd-powermac no longer handles any "
934 "machines with a layout-id property "
935 "in the device-tree, use snd-aoa.\n");
938 /* This should be verified on older screamers */
939 if (device_is_compatible(sound
, "screamer")) {
940 chip
->model
= PMAC_SCREAMER
;
941 // chip->can_byte_swap = 0; /* FIXME: check this */
943 if (device_is_compatible(sound
, "burgundy")) {
944 chip
->model
= PMAC_BURGUNDY
;
945 chip
->control_mask
= MASK_IEPC
| 0x11; /* disable IEE */
947 if (device_is_compatible(sound
, "daca")) {
948 chip
->model
= PMAC_DACA
;
949 chip
->can_capture
= 0; /* no capture */
950 chip
->can_duplex
= 0;
951 // chip->can_byte_swap = 0; /* FIXME: check this */
952 chip
->control_mask
= MASK_IEPC
| 0x11; /* disable IEE */
954 if (device_is_compatible(sound
, "tumbler")) {
955 chip
->model
= PMAC_TUMBLER
;
956 chip
->can_capture
= 0; /* no capture */
957 chip
->can_duplex
= 0;
958 // chip->can_byte_swap = 0; /* FIXME: check this */
959 chip
->num_freqs
= ARRAY_SIZE(tumbler_freqs
);
960 chip
->freq_table
= tumbler_freqs
;
961 chip
->control_mask
= MASK_IEPC
| 0x11; /* disable IEE */
963 if (device_is_compatible(sound
, "snapper")) {
964 chip
->model
= PMAC_SNAPPER
;
965 // chip->can_byte_swap = 0; /* FIXME: check this */
966 chip
->num_freqs
= ARRAY_SIZE(tumbler_freqs
);
967 chip
->freq_table
= tumbler_freqs
;
968 chip
->control_mask
= MASK_IEPC
| 0x11; /* disable IEE */
970 prop
= (unsigned int *)get_property(sound
, "device-id", NULL
);
972 chip
->device_id
= *prop
;
973 chip
->has_iic
= (find_devices("perch") != NULL
);
975 /* We need the PCI device for DMA allocations, let's use a crude method
978 macio
= macio_find(chip
->node
, macio_unknown
);
980 printk(KERN_WARNING
"snd-powermac: can't locate macio !\n");
982 struct pci_dev
*pdev
= NULL
;
984 for_each_pci_dev(pdev
) {
985 struct device_node
*np
= pci_device_to_OF_node(pdev
);
986 if (np
&& np
== macio
->of_node
) {
992 if (chip
->pdev
== NULL
)
993 printk(KERN_WARNING
"snd-powermac: can't locate macio PCI"
996 detect_byte_swap(chip
);
998 /* look for a property saying what sample rates
1000 prop
= (unsigned int *) get_property(sound
, "sample-rates", &l
);
1002 prop
= (unsigned int *) get_property(sound
,
1003 "output-frame-rates", &l
);
1007 for (l
/= sizeof(int); l
> 0; --l
) {
1008 unsigned int r
= *prop
++;
1009 /* Apple 'Fixed' format */
1012 for (i
= 0; i
< chip
->num_freqs
; ++i
) {
1013 if (r
== chip
->freq_table
[i
]) {
1014 chip
->freqs_ok
|= (1 << i
);
1020 /* assume only 44.1khz */
1028 * exported - boolean info callbacks for ease of programming
1030 int snd_pmac_boolean_stereo_info(struct snd_kcontrol
*kcontrol
,
1031 struct snd_ctl_elem_info
*uinfo
)
1033 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1035 uinfo
->value
.integer
.min
= 0;
1036 uinfo
->value
.integer
.max
= 1;
1040 int snd_pmac_boolean_mono_info(struct snd_kcontrol
*kcontrol
,
1041 struct snd_ctl_elem_info
*uinfo
)
1043 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1045 uinfo
->value
.integer
.min
= 0;
1046 uinfo
->value
.integer
.max
= 1;
1050 #ifdef PMAC_SUPPORT_AUTOMUTE
1054 static int pmac_auto_mute_get(struct snd_kcontrol
*kcontrol
,
1055 struct snd_ctl_elem_value
*ucontrol
)
1057 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
1058 ucontrol
->value
.integer
.value
[0] = chip
->auto_mute
;
1062 static int pmac_auto_mute_put(struct snd_kcontrol
*kcontrol
,
1063 struct snd_ctl_elem_value
*ucontrol
)
1065 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
1066 if (ucontrol
->value
.integer
.value
[0] != chip
->auto_mute
) {
1067 chip
->auto_mute
= ucontrol
->value
.integer
.value
[0];
1068 if (chip
->update_automute
)
1069 chip
->update_automute(chip
, 1);
1075 static int pmac_hp_detect_get(struct snd_kcontrol
*kcontrol
,
1076 struct snd_ctl_elem_value
*ucontrol
)
1078 struct snd_pmac
*chip
= snd_kcontrol_chip(kcontrol
);
1079 if (chip
->detect_headphone
)
1080 ucontrol
->value
.integer
.value
[0] = chip
->detect_headphone(chip
);
1082 ucontrol
->value
.integer
.value
[0] = 0;
1086 static struct snd_kcontrol_new auto_mute_controls
[] __initdata
= {
1087 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1088 .name
= "Auto Mute Switch",
1089 .info
= snd_pmac_boolean_mono_info
,
1090 .get
= pmac_auto_mute_get
,
1091 .put
= pmac_auto_mute_put
,
1093 { .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1094 .name
= "Headphone Detection",
1095 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1096 .info
= snd_pmac_boolean_mono_info
,
1097 .get
= pmac_hp_detect_get
,
1101 int __init
snd_pmac_add_automute(struct snd_pmac
*chip
)
1104 chip
->auto_mute
= 1;
1105 err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&auto_mute_controls
[0], chip
));
1107 printk(KERN_ERR
"snd-powermac: Failed to add automute control\n");
1110 chip
->hp_detect_ctl
= snd_ctl_new1(&auto_mute_controls
[1], chip
);
1111 return snd_ctl_add(chip
->card
, chip
->hp_detect_ctl
);
1113 #endif /* PMAC_SUPPORT_AUTOMUTE */
1116 * create and detect a pmac chip record
1118 int __init
snd_pmac_new(struct snd_card
*card
, struct snd_pmac
**chip_return
)
1120 struct snd_pmac
*chip
;
1121 struct device_node
*np
;
1123 unsigned long ctrl_addr
, txdma_addr
, rxdma_addr
;
1124 static struct snd_device_ops ops
= {
1125 .dev_free
= snd_pmac_dev_free
,
1128 *chip_return
= NULL
;
1130 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1135 spin_lock_init(&chip
->reg_lock
);
1136 chip
->irq
= chip
->tx_irq
= chip
->rx_irq
= -1;
1138 chip
->playback
.stream
= SNDRV_PCM_STREAM_PLAYBACK
;
1139 chip
->capture
.stream
= SNDRV_PCM_STREAM_CAPTURE
;
1141 if ((err
= snd_pmac_detect(chip
)) < 0)
1144 if (snd_pmac_dbdma_alloc(chip
, &chip
->playback
.cmd
, PMAC_MAX_FRAGS
+ 1) < 0 ||
1145 snd_pmac_dbdma_alloc(chip
, &chip
->capture
.cmd
, PMAC_MAX_FRAGS
+ 1) < 0 ||
1146 snd_pmac_dbdma_alloc(chip
, &chip
->extra_dma
, 2) < 0) {
1152 chip
->requested
= 0;
1154 static char *rnames
[] = {
1155 "Sound Control", "Sound DMA" };
1156 if (np
->n_intrs
< 3) {
1160 for (i
= 0; i
< 2; i
++) {
1161 if (of_address_to_resource(np
->parent
, i
,
1163 printk(KERN_ERR
"snd: can't translate rsrc "
1164 " %d (%s)\n", i
, rnames
[i
]);
1168 if (request_mem_region(chip
->rsrc
[i
].start
,
1170 chip
->rsrc
[i
].start
+ 1,
1171 rnames
[i
]) == NULL
) {
1172 printk(KERN_ERR
"snd: can't request rsrc "
1173 " %d (%s: 0x%08lx:%08lx)\n",
1174 i
, rnames
[i
], chip
->rsrc
[i
].start
,
1179 chip
->requested
|= (1 << i
);
1181 ctrl_addr
= chip
->rsrc
[0].start
;
1182 txdma_addr
= chip
->rsrc
[1].start
;
1183 rxdma_addr
= txdma_addr
+ 0x100;
1185 static char *rnames
[] = {
1186 "Sound Control", "Sound Tx DMA", "Sound Rx DMA" };
1187 if (np
->n_intrs
< 3) {
1191 for (i
= 0; i
< 3; i
++) {
1192 if (of_address_to_resource(np
, i
,
1194 printk(KERN_ERR
"snd: can't translate rsrc "
1195 " %d (%s)\n", i
, rnames
[i
]);
1199 if (request_mem_region(chip
->rsrc
[i
].start
,
1201 chip
->rsrc
[i
].start
+ 1,
1202 rnames
[i
]) == NULL
) {
1203 printk(KERN_ERR
"snd: can't request rsrc "
1204 " %d (%s: 0x%08lx:%08lx)\n",
1205 i
, rnames
[i
], chip
->rsrc
[i
].start
,
1210 chip
->requested
|= (1 << i
);
1212 ctrl_addr
= chip
->rsrc
[0].start
;
1213 txdma_addr
= chip
->rsrc
[1].start
;
1214 rxdma_addr
= chip
->rsrc
[2].start
;
1217 chip
->awacs
= ioremap(ctrl_addr
, 0x1000);
1218 chip
->playback
.dma
= ioremap(txdma_addr
, 0x100);
1219 chip
->capture
.dma
= ioremap(rxdma_addr
, 0x100);
1220 if (chip
->model
<= PMAC_BURGUNDY
) {
1221 if (request_irq(np
->intrs
[0].line
, snd_pmac_ctrl_intr
, 0,
1222 "PMac", (void*)chip
)) {
1223 snd_printk(KERN_ERR
"pmac: unable to grab IRQ %d\n", np
->intrs
[0].line
);
1227 chip
->irq
= np
->intrs
[0].line
;
1229 if (request_irq(np
->intrs
[1].line
, snd_pmac_tx_intr
, 0,
1230 "PMac Output", (void*)chip
)) {
1231 snd_printk(KERN_ERR
"pmac: unable to grab IRQ %d\n", np
->intrs
[1].line
);
1235 chip
->tx_irq
= np
->intrs
[1].line
;
1236 if (request_irq(np
->intrs
[2].line
, snd_pmac_rx_intr
, 0,
1237 "PMac Input", (void*)chip
)) {
1238 snd_printk(KERN_ERR
"pmac: unable to grab IRQ %d\n", np
->intrs
[2].line
);
1242 chip
->rx_irq
= np
->intrs
[2].line
;
1244 snd_pmac_sound_feature(chip
, 1);
1247 if (chip
->model
== PMAC_AWACS
)
1248 out_le32(&chip
->awacs
->control
, 0x11);
1250 /* Powerbooks have odd ways of enabling inputs such as
1251 an expansion-bay CD or sound from an internal modem
1252 or a PC-card modem. */
1253 if (chip
->is_pbook_3400
) {
1254 /* Enable CD and PC-card sound inputs. */
1255 /* This is done by reading from address
1256 * f301a000, + 0x10 to enable the expansion-bay
1257 * CD sound input, + 0x80 to enable the PC-card
1258 * sound input. The 0x100 enables the SCSI bus
1261 chip
->latch_base
= ioremap (0xf301a000, 0x1000);
1262 in_8(chip
->latch_base
+ 0x190);
1263 } else if (chip
->is_pbook_G3
) {
1264 struct device_node
* mio
;
1265 for (mio
= chip
->node
->parent
; mio
; mio
= mio
->parent
) {
1266 if (strcmp(mio
->name
, "mac-io") == 0) {
1268 if (of_address_to_resource(mio
, 0, &r
) == 0)
1270 ioremap(r
.start
, 0x40);
1274 /* Enable CD sound input. */
1275 /* The relevant bits for writing to this byte are 0x8f.
1276 * I haven't found out what the 0x80 bit does.
1277 * For the 0xf bits, writing 3 or 7 enables the CD
1278 * input, any other value disables it. Values
1279 * 1, 3, 5, 7 enable the microphone. Values 0, 2,
1280 * 4, 6, 8 - f enable the input from the modem.
1282 if (chip
->macio_base
)
1283 out_8(chip
->macio_base
+ 0x37, 3);
1286 /* Reset dbdma channels */
1287 snd_pmac_dbdma_reset(chip
);
1289 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
)) < 0)
1292 *chip_return
= chip
;
1297 pci_dev_put(chip
->pdev
);
1298 snd_pmac_free(chip
);
1304 * sleep notify for powerbook
1310 * Save state when going to sleep, restore it afterwards.
1313 void snd_pmac_suspend(struct snd_pmac
*chip
)
1315 unsigned long flags
;
1317 snd_power_change_state(chip
->card
, SNDRV_CTL_POWER_D3hot
);
1319 chip
->suspend(chip
);
1320 snd_pcm_suspend_all(chip
->pcm
);
1321 spin_lock_irqsave(&chip
->reg_lock
, flags
);
1322 snd_pmac_beep_stop(chip
);
1323 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
1325 disable_irq(chip
->irq
);
1326 if (chip
->tx_irq
>= 0)
1327 disable_irq(chip
->tx_irq
);
1328 if (chip
->rx_irq
>= 0)
1329 disable_irq(chip
->rx_irq
);
1330 snd_pmac_sound_feature(chip
, 0);
1333 void snd_pmac_resume(struct snd_pmac
*chip
)
1335 snd_pmac_sound_feature(chip
, 1);
1338 /* enable CD sound input */
1339 if (chip
->macio_base
&& chip
->is_pbook_G3
)
1340 out_8(chip
->macio_base
+ 0x37, 3);
1341 else if (chip
->is_pbook_3400
)
1342 in_8(chip
->latch_base
+ 0x190);
1344 snd_pmac_pcm_set_format(chip
);
1347 enable_irq(chip
->irq
);
1348 if (chip
->tx_irq
>= 0)
1349 enable_irq(chip
->tx_irq
);
1350 if (chip
->rx_irq
>= 0)
1351 enable_irq(chip
->rx_irq
);
1353 snd_power_change_state(chip
->card
, SNDRV_CTL_POWER_D0
);
1356 #endif /* CONFIG_PM */