2 * SAA713x ALSA support for V4L
6 * - Volume doesn't work (it's always at max)
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, version 2
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 <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/time.h>
26 #include <linux/wait.h>
27 #include <linux/moduleparam.h>
28 #include <linux/module.h>
29 #include <sound/driver.h>
30 #include <sound/core.h>
31 #include <sound/control.h>
32 #include <sound/pcm.h>
33 #include <sound/pcm_params.h>
34 #include <sound/initval.h>
35 #include <linux/interrupt.h>
38 #include "saa7134-reg.h"
40 static unsigned int debug
= 0;
41 module_param(debug
, int, 0644);
42 MODULE_PARM_DESC(debug
,"enable debug messages [alsa]");
45 * Configuration macros
49 #define MIXER_ADDR_TVTUNER 0
50 #define MIXER_ADDR_LINE1 1
51 #define MIXER_ADDR_LINE2 2
52 #define MIXER_ADDR_LAST 2
55 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
56 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
57 static int enable
[SNDRV_CARDS
] = {1, [1 ... (SNDRV_CARDS
- 1)] = 1};
59 module_param_array(index
, int, NULL
, 0444);
60 module_param_array(enable
, int, NULL
, 0444);
61 MODULE_PARM_DESC(index
, "Index value for SAA7134 capture interface(s).");
62 MODULE_PARM_DESC(enable
, "Enable (or not) the SAA7134 capture interface(s).");
64 #define dprintk(fmt, arg...) if (debug) \
65 printk(KERN_DEBUG "%s/alsa: " fmt, dev->name , ##arg)
73 typedef struct snd_card_saa7134
{
75 spinlock_t mixer_lock
;
76 int mixer_volume
[MIXER_ADDR_LAST
+1][2];
77 int capture_source
[MIXER_ADDR_LAST
+1][2];
79 struct saa7134_dev
*dev
;
93 typedef struct snd_card_saa7134_pcm
{
94 struct saa7134_dev
*dev
;
98 snd_pcm_substream_t
*substream
;
99 } snd_card_saa7134_pcm_t
;
101 static snd_card_t
*snd_saa7134_cards
[SNDRV_CARDS
];
105 * saa7134 DMA audio stop
107 * Called when the capture device is released or the buffer overflows
109 * - Copied verbatim from saa7134-oss's dsp_dma_stop.
113 static void saa7134_dma_stop(struct saa7134_dev
*dev
)
115 dev
->dmasound
.dma_blk
= -1;
116 dev
->dmasound
.dma_running
= 0;
117 saa7134_set_dmabits(dev
);
121 * saa7134 DMA audio start
123 * Called when preparing the capture device for use
125 * - Copied verbatim from saa7134-oss's dsp_dma_start.
129 static void saa7134_dma_start(struct saa7134_dev
*dev
)
131 dev
->dmasound
.dma_blk
= 0;
132 dev
->dmasound
.dma_running
= 1;
133 saa7134_set_dmabits(dev
);
137 * saa7134 audio DMA IRQ handler
139 * Called whenever we get an SAA7134_IRQ_REPORT_DONE_RA3 interrupt
140 * Handles shifting between the 2 buffers, manages the read counters,
141 * and notifies ALSA when periods elapse
143 * - Mostly copied from saa7134-oss's saa7134_irq_oss_done.
147 static void saa7134_irq_alsa_done(struct saa7134_dev
*dev
,
148 unsigned long status
)
150 int next_blk
, reg
= 0;
152 spin_lock(&dev
->slock
);
153 if (UNSET
== dev
->dmasound
.dma_blk
) {
154 dprintk("irq: recording stopped\n");
157 if (0 != (status
& 0x0f000000))
158 dprintk("irq: lost %ld\n", (status
>> 24) & 0x0f);
159 if (0 == (status
& 0x10000000)) {
161 if (0 == (dev
->dmasound
.dma_blk
& 0x01))
162 reg
= SAA7134_RS_BA1(6);
165 if (1 == (dev
->dmasound
.dma_blk
& 0x01))
166 reg
= SAA7134_RS_BA2(6);
169 dprintk("irq: field oops [%s]\n",
170 (status
& 0x10000000) ? "even" : "odd");
174 if (dev
->dmasound
.read_count
>= dev
->dmasound
.blksize
* (dev
->dmasound
.blocks
-2)) {
175 dprintk("irq: overrun [full=%d/%d] - Blocks in %d\n",dev
->dmasound
.read_count
,
176 dev
->dmasound
.bufsize
, dev
->dmasound
.blocks
);
177 spin_unlock(&dev
->slock
);
178 snd_pcm_stop(dev
->dmasound
.substream
,SNDRV_PCM_STATE_XRUN
);
182 /* next block addr */
183 next_blk
= (dev
->dmasound
.dma_blk
+ 2) % dev
->dmasound
.blocks
;
184 saa_writel(reg
,next_blk
* dev
->dmasound
.blksize
);
186 dprintk("irq: ok, %s, next_blk=%d, addr=%x, blocks=%u, size=%u, read=%u\n",
187 (status
& 0x10000000) ? "even" : "odd ", next_blk
,
188 next_blk
* dev
->dmasound
.blksize
, dev
->dmasound
.blocks
, dev
->dmasound
.blksize
, dev
->dmasound
.read_count
);
190 /* update status & wake waiting readers */
191 dev
->dmasound
.dma_blk
= (dev
->dmasound
.dma_blk
+ 1) % dev
->dmasound
.blocks
;
192 dev
->dmasound
.read_count
+= dev
->dmasound
.blksize
;
194 dev
->dmasound
.recording_on
= reg
;
196 if (dev
->dmasound
.read_count
>= snd_pcm_lib_period_bytes(dev
->dmasound
.substream
)) {
197 spin_unlock(&dev
->slock
);
198 snd_pcm_period_elapsed(dev
->dmasound
.substream
);
199 spin_lock(&dev
->slock
);
203 spin_unlock(&dev
->slock
);
208 * IRQ request handler
210 * Runs along with saa7134's IRQ handler, discards anything that isn't
215 static irqreturn_t
saa7134_alsa_irq(int irq
, void *dev_id
, struct pt_regs
*regs
)
217 struct saa7134_dmasound
*dmasound
= dev_id
;
218 struct saa7134_dev
*dev
= dmasound
->priv_data
;
220 unsigned long report
, status
;
221 int loop
, handled
= 0;
223 for (loop
= 0; loop
< 10; loop
++) {
224 report
= saa_readl(SAA7134_IRQ_REPORT
);
225 status
= saa_readl(SAA7134_IRQ_STATUS
);
227 if (report
& SAA7134_IRQ_REPORT_DONE_RA3
) {
229 saa_writel(SAA7134_IRQ_REPORT
,report
);
230 saa7134_irq_alsa_done(dev
, status
);
237 dprintk("error! looping IRQ!");
241 return IRQ_RETVAL(handled
);
245 * ALSA capture trigger
247 * - One of the ALSA capture callbacks.
249 * Called whenever a capture is started or stopped. Must be defined,
250 * but there's nothing we want to do here
254 static int snd_card_saa7134_capture_trigger(snd_pcm_substream_t
* substream
,
257 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
258 snd_card_saa7134_pcm_t
*pcm
= runtime
->private_data
;
259 struct saa7134_dev
*dev
=pcm
->dev
;
262 spin_lock(&dev
->slock
);
263 if (cmd
== SNDRV_PCM_TRIGGER_START
) {
265 saa7134_dma_start(dev
);
266 } else if (cmd
== SNDRV_PCM_TRIGGER_STOP
) {
268 saa7134_dma_stop(dev
);
272 spin_unlock(&dev
->slock
);
278 * DMA buffer initialization
280 * Uses V4L functions to initialize the DMA. Shouldn't be necessary in
281 * ALSA, but I was unable to use ALSA's own DMA, and had to force the
284 * - Copied verbatim from saa7134-oss.
288 static int dsp_buffer_init(struct saa7134_dev
*dev
)
292 BUG_ON(!dev
->dmasound
.bufsize
);
294 videobuf_dma_init(&dev
->dmasound
.dma
);
295 err
= videobuf_dma_init_kernel(&dev
->dmasound
.dma
, PCI_DMA_FROMDEVICE
,
296 (dev
->dmasound
.bufsize
+ PAGE_SIZE
) >> PAGE_SHIFT
);
305 * Called after closing the device, during snd_card_saa7134_capture_close
309 static int dsp_buffer_free(struct saa7134_dev
*dev
)
311 if (!dev
->dmasound
.blksize
)
314 videobuf_dma_free(&dev
->dmasound
.dma
);
316 dev
->dmasound
.blocks
= 0;
317 dev
->dmasound
.blksize
= 0;
318 dev
->dmasound
.bufsize
= 0;
325 * ALSA PCM preparation
327 * - One of the ALSA capture callbacks.
329 * Called right after the capture device is opened, this function configures
330 * the buffer using the previously defined functions, allocates the memory,
331 * sets up the hardware registers, and then starts the DMA. When this function
332 * returns, the audio should be flowing.
336 static int snd_card_saa7134_capture_prepare(snd_pcm_substream_t
* substream
)
338 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
341 snd_card_saa7134_t
*saa7134
= snd_pcm_substream_chip(substream
);
342 struct saa7134_dev
*dev
;
343 snd_card_saa7134_pcm_t
*pcm
= runtime
->private_data
;
345 pcm
->dev
->dmasound
.substream
= substream
;
349 if (snd_pcm_format_width(runtime
->format
) == 8)
354 if (snd_pcm_format_signed(runtime
->format
))
359 if (snd_pcm_format_big_endian(runtime
->format
))
364 switch (dev
->pci
->device
) {
365 case PCI_DEVICE_ID_PHILIPS_SAA7134
:
366 if (1 == runtime
->channels
)
368 if (2 == runtime
->channels
)
373 fmt
|= (MIXER_ADDR_TVTUNER
== dev
->dmasound
.input
) ? 0xc0 : 0x80;
374 saa_writeb(SAA7134_NUM_SAMPLES0
, ((dev
->dmasound
.blksize
- 1) & 0x0000ff));
375 saa_writeb(SAA7134_NUM_SAMPLES1
, ((dev
->dmasound
.blksize
- 1) & 0x00ff00) >> 8);
376 saa_writeb(SAA7134_NUM_SAMPLES2
, ((dev
->dmasound
.blksize
- 1) & 0xff0000) >> 16);
377 saa_writeb(SAA7134_AUDIO_FORMAT_CTRL
, fmt
);
380 case PCI_DEVICE_ID_PHILIPS_SAA7133
:
381 case PCI_DEVICE_ID_PHILIPS_SAA7135
:
382 if (1 == runtime
->channels
)
384 if (2 == runtime
->channels
)
388 saa_writel(SAA7133_NUM_SAMPLES
, dev
->dmasound
.blksize
-1);
389 saa_writel(SAA7133_AUDIO_CHANNEL
, 0x543210 | (fmt
<< 24));
393 dprintk("rec_start: afmt=%d ch=%d => fmt=0x%x swap=%c\n",
394 runtime
->format
, runtime
->channels
, fmt
,
396 /* dma: setup channel 6 (= AUDIO) */
397 control
= SAA7134_RS_CONTROL_BURST_16
|
398 SAA7134_RS_CONTROL_ME
|
399 (dev
->dmasound
.pt
.dma
>> 12);
401 control
|= SAA7134_RS_CONTROL_BSWAP
;
403 saa_writel(SAA7134_RS_BA1(6),0);
404 saa_writel(SAA7134_RS_BA2(6),dev
->dmasound
.blksize
);
405 saa_writel(SAA7134_RS_PITCH(6),0);
406 saa_writel(SAA7134_RS_CONTROL(6),control
);
408 dev
->dmasound
.rate
= runtime
->rate
;
415 * ALSA pointer fetching
417 * - One of the ALSA capture callbacks.
419 * Called whenever a period elapses, it must return the current hardware
420 * position of the buffer.
421 * Also resets the read counter used to prevent overruns
425 static snd_pcm_uframes_t
snd_card_saa7134_capture_pointer(snd_pcm_substream_t
* substream
)
427 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
428 snd_card_saa7134_pcm_t
*pcm
= runtime
->private_data
;
429 struct saa7134_dev
*dev
=pcm
->dev
;
431 if (dev
->dmasound
.read_count
) {
432 dev
->dmasound
.read_count
-= snd_pcm_lib_period_bytes(substream
);
433 dev
->dmasound
.read_offset
+= snd_pcm_lib_period_bytes(substream
);
434 if (dev
->dmasound
.read_offset
== dev
->dmasound
.bufsize
)
435 dev
->dmasound
.read_offset
= 0;
438 return bytes_to_frames(runtime
, dev
->dmasound
.read_offset
);
442 * ALSA hardware capabilities definition
445 static snd_pcm_hardware_t snd_card_saa7134_capture
=
447 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
448 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
449 SNDRV_PCM_INFO_MMAP_VALID
),
450 .formats
= SNDRV_PCM_FMTBIT_S16_LE
| \
451 SNDRV_PCM_FMTBIT_S16_BE
| \
452 SNDRV_PCM_FMTBIT_S8
| \
453 SNDRV_PCM_FMTBIT_U8
| \
454 SNDRV_PCM_FMTBIT_U16_LE
| \
455 SNDRV_PCM_FMTBIT_U16_BE
,
456 .rates
= SNDRV_PCM_RATE_32000
| SNDRV_PCM_RATE_48000
,
461 .buffer_bytes_max
= (256*1024),
462 .period_bytes_min
= 64,
463 .period_bytes_max
= (256*1024),
468 static void snd_card_saa7134_runtime_free(snd_pcm_runtime_t
*runtime
)
470 snd_card_saa7134_pcm_t
*pcm
= runtime
->private_data
;
477 * ALSA hardware params
479 * - One of the ALSA capture callbacks.
481 * Called on initialization, right before the PCM preparation
485 static int snd_card_saa7134_hw_params(snd_pcm_substream_t
* substream
,
486 snd_pcm_hw_params_t
* hw_params
)
488 snd_card_saa7134_t
*saa7134
= snd_pcm_substream_chip(substream
);
489 struct saa7134_dev
*dev
;
490 unsigned int period_size
, periods
;
493 period_size
= params_period_bytes(hw_params
);
494 periods
= params_periods(hw_params
);
496 snd_assert(period_size
>= 0x100 && period_size
<= 0x10000,
498 snd_assert(periods
>= 2, return -EINVAL
);
499 snd_assert(period_size
* periods
<= 1024 * 1024, return -EINVAL
);
503 if (dev
->dmasound
.blocks
== periods
&&
504 dev
->dmasound
.blksize
== period_size
)
507 /* release the old buffer */
508 if (substream
->runtime
->dma_area
) {
509 saa7134_pgtable_free(dev
->pci
, &dev
->dmasound
.pt
);
510 videobuf_dma_pci_unmap(dev
->pci
, &dev
->dmasound
.dma
);
511 dsp_buffer_free(dev
);
512 substream
->runtime
->dma_area
= NULL
;
514 dev
->dmasound
.blocks
= periods
;
515 dev
->dmasound
.blksize
= period_size
;
516 dev
->dmasound
.bufsize
= period_size
* periods
;
518 err
= dsp_buffer_init(dev
);
520 dev
->dmasound
.blocks
= 0;
521 dev
->dmasound
.blksize
= 0;
522 dev
->dmasound
.bufsize
= 0;
526 if (0 != (err
= videobuf_dma_pci_map(dev
->pci
, &dev
->dmasound
.dma
))) {
527 dsp_buffer_free(dev
);
530 if (0 != (err
= saa7134_pgtable_alloc(dev
->pci
,&dev
->dmasound
.pt
))) {
531 videobuf_dma_pci_unmap(dev
->pci
, &dev
->dmasound
.dma
);
532 dsp_buffer_free(dev
);
535 if (0 != (err
= saa7134_pgtable_build(dev
->pci
,&dev
->dmasound
.pt
,
536 dev
->dmasound
.dma
.sglist
,
537 dev
->dmasound
.dma
.sglen
,
539 saa7134_pgtable_free(dev
->pci
, &dev
->dmasound
.pt
);
540 videobuf_dma_pci_unmap(dev
->pci
, &dev
->dmasound
.dma
);
541 dsp_buffer_free(dev
);
545 /* I should be able to use runtime->dma_addr in the control
546 byte, but it doesn't work. So I allocate the DMA using the
547 V4L functions, and force ALSA to use that as the DMA area */
549 substream
->runtime
->dma_area
= dev
->dmasound
.dma
.vmalloc
;
556 * ALSA hardware release
558 * - One of the ALSA capture callbacks.
560 * Called after closing the device, but before snd_card_saa7134_capture_close
561 * It stops the DMA audio and releases the buffers.
565 static int snd_card_saa7134_hw_free(snd_pcm_substream_t
* substream
)
567 snd_card_saa7134_t
*saa7134
= snd_pcm_substream_chip(substream
);
568 struct saa7134_dev
*dev
;
572 if (substream
->runtime
->dma_area
) {
573 saa7134_pgtable_free(dev
->pci
, &dev
->dmasound
.pt
);
574 videobuf_dma_pci_unmap(dev
->pci
, &dev
->dmasound
.dma
);
575 dsp_buffer_free(dev
);
576 substream
->runtime
->dma_area
= NULL
;
583 * ALSA capture finish
585 * - One of the ALSA capture callbacks.
587 * Called after closing the device.
591 static int snd_card_saa7134_capture_close(snd_pcm_substream_t
* substream
)
599 * - One of the ALSA capture callbacks.
601 * Called when opening the device. It creates and populates the PCM
606 static int snd_card_saa7134_capture_open(snd_pcm_substream_t
* substream
)
608 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
609 snd_card_saa7134_pcm_t
*pcm
;
610 snd_card_saa7134_t
*saa7134
= snd_pcm_substream_chip(substream
);
611 struct saa7134_dev
*dev
= saa7134
->dev
;
614 down(&dev
->dmasound
.lock
);
616 dev
->dmasound
.read_count
= 0;
617 dev
->dmasound
.read_offset
= 0;
619 up(&dev
->dmasound
.lock
);
621 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
625 pcm
->dev
=saa7134
->dev
;
627 spin_lock_init(&pcm
->lock
);
629 pcm
->substream
= substream
;
630 runtime
->private_data
= pcm
;
631 runtime
->private_free
= snd_card_saa7134_runtime_free
;
632 runtime
->hw
= snd_card_saa7134_capture
;
634 if ((err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
)) < 0)
641 * ALSA capture callbacks definition
644 static snd_pcm_ops_t snd_card_saa7134_capture_ops
= {
645 .open
= snd_card_saa7134_capture_open
,
646 .close
= snd_card_saa7134_capture_close
,
647 .ioctl
= snd_pcm_lib_ioctl
,
648 .hw_params
= snd_card_saa7134_hw_params
,
649 .hw_free
= snd_card_saa7134_hw_free
,
650 .prepare
= snd_card_saa7134_capture_prepare
,
651 .trigger
= snd_card_saa7134_capture_trigger
,
652 .pointer
= snd_card_saa7134_capture_pointer
,
658 * Called when initializing the board. Sets up the name and hooks up
663 static int snd_card_saa7134_pcm(snd_card_saa7134_t
*saa7134
, int device
)
668 if ((err
= snd_pcm_new(saa7134
->card
, "SAA7134 PCM", device
, 0, 1, &pcm
)) < 0)
670 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_card_saa7134_capture_ops
);
671 pcm
->private_data
= saa7134
;
673 strcpy(pcm
->name
, "SAA7134 PCM");
677 #define SAA713x_VOLUME(xname, xindex, addr) \
678 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
679 .info = snd_saa7134_volume_info, \
680 .get = snd_saa7134_volume_get, .put = snd_saa7134_volume_put, \
681 .private_value = addr }
683 static int snd_saa7134_volume_info(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_info_t
* uinfo
)
685 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
687 uinfo
->value
.integer
.min
= 0;
688 uinfo
->value
.integer
.max
= 20;
692 static int snd_saa7134_volume_get(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
694 snd_card_saa7134_t
*chip
= snd_kcontrol_chip(kcontrol
);
695 int addr
= kcontrol
->private_value
;
697 ucontrol
->value
.integer
.value
[0] = chip
->mixer_volume
[addr
][0];
698 ucontrol
->value
.integer
.value
[1] = chip
->mixer_volume
[addr
][1];
702 static int snd_saa7134_volume_put(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
704 snd_card_saa7134_t
*chip
= snd_kcontrol_chip(kcontrol
);
705 int change
, addr
= kcontrol
->private_value
;
708 left
= ucontrol
->value
.integer
.value
[0];
713 right
= ucontrol
->value
.integer
.value
[1];
718 spin_lock_irq(&chip
->mixer_lock
);
719 change
= chip
->mixer_volume
[addr
][0] != left
||
720 chip
->mixer_volume
[addr
][1] != right
;
721 chip
->mixer_volume
[addr
][0] = left
;
722 chip
->mixer_volume
[addr
][1] = right
;
723 spin_unlock_irq(&chip
->mixer_lock
);
727 #define SAA713x_CAPSRC(xname, xindex, addr) \
728 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
729 .info = snd_saa7134_capsrc_info, \
730 .get = snd_saa7134_capsrc_get, .put = snd_saa7134_capsrc_put, \
731 .private_value = addr }
733 static int snd_saa7134_capsrc_info(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_info_t
* uinfo
)
735 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
737 uinfo
->value
.integer
.min
= 0;
738 uinfo
->value
.integer
.max
= 1;
742 static int snd_saa7134_capsrc_get(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
744 snd_card_saa7134_t
*chip
= snd_kcontrol_chip(kcontrol
);
745 int addr
= kcontrol
->private_value
;
747 spin_lock_irq(&chip
->mixer_lock
);
748 ucontrol
->value
.integer
.value
[0] = chip
->capture_source
[addr
][0];
749 ucontrol
->value
.integer
.value
[1] = chip
->capture_source
[addr
][1];
750 spin_unlock_irq(&chip
->mixer_lock
);
755 static int snd_saa7134_capsrc_put(snd_kcontrol_t
* kcontrol
, snd_ctl_elem_value_t
* ucontrol
)
757 snd_card_saa7134_t
*chip
= snd_kcontrol_chip(kcontrol
);
758 int change
, addr
= kcontrol
->private_value
;
762 struct saa7134_dev
*dev
;
766 left
= ucontrol
->value
.integer
.value
[0] & 1;
767 right
= ucontrol
->value
.integer
.value
[1] & 1;
768 spin_lock_irq(&chip
->mixer_lock
);
770 change
= chip
->capture_source
[addr
][0] != left
||
771 chip
->capture_source
[addr
][1] != right
;
772 chip
->capture_source
[addr
][0] = left
;
773 chip
->capture_source
[addr
][1] = right
;
774 dev
->dmasound
.input
=addr
;
775 spin_unlock_irq(&chip
->mixer_lock
);
779 switch (dev
->pci
->device
) {
781 case PCI_DEVICE_ID_PHILIPS_SAA7134
:
783 case MIXER_ADDR_TVTUNER
:
784 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL
, 0xc0, 0xc0);
785 saa_andorb(SAA7134_SIF_SAMPLE_FREQ
, 0x03, 0x00);
787 case MIXER_ADDR_LINE1
:
788 case MIXER_ADDR_LINE2
:
789 analog_io
= (MIXER_ADDR_LINE1
== addr
) ? 0x00 : 0x08;
790 rate
= (32000 == dev
->dmasound
.rate
) ? 0x01 : 0x03;
791 saa_andorb(SAA7134_ANALOG_IO_SELECT
, 0x08, analog_io
);
792 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL
, 0xc0, 0x80);
793 saa_andorb(SAA7134_SIF_SAMPLE_FREQ
, 0x03, rate
);
798 case PCI_DEVICE_ID_PHILIPS_SAA7133
:
799 case PCI_DEVICE_ID_PHILIPS_SAA7135
:
800 xbarin
= 0x03; // adc
803 case MIXER_ADDR_TVTUNER
:
804 xbarin
= 0; // Demodulator
807 case MIXER_ADDR_LINE1
:
808 anabar
= 0; // aux1, aux1
810 case MIXER_ADDR_LINE2
:
811 anabar
= 9; // aux2, aux2
815 /* output xbar always main channel */
816 saa_dsp_writel(dev
, SAA7133_DIGITAL_OUTPUT_SEL1
, 0xbbbb10);
818 if (left
|| right
) { // We've got data, turn the input on
819 saa_dsp_writel(dev
, SAA7133_DIGITAL_INPUT_XBAR1
, xbarin
);
820 saa_writel(SAA7133_ANALOG_IO_SELECT
, anabar
);
822 saa_dsp_writel(dev
, SAA7133_DIGITAL_INPUT_XBAR1
, 0);
823 saa_writel(SAA7133_ANALOG_IO_SELECT
, 0);
832 static snd_kcontrol_new_t snd_saa7134_controls
[] = {
833 SAA713x_VOLUME("Video Volume", 0, MIXER_ADDR_TVTUNER
),
834 SAA713x_CAPSRC("Video Capture Switch", 0, MIXER_ADDR_TVTUNER
),
835 SAA713x_VOLUME("Line Volume", 1, MIXER_ADDR_LINE1
),
836 SAA713x_CAPSRC("Line Capture Switch", 1, MIXER_ADDR_LINE1
),
837 SAA713x_VOLUME("Line Volume", 2, MIXER_ADDR_LINE2
),
838 SAA713x_CAPSRC("Line Capture Switch", 2, MIXER_ADDR_LINE2
),
844 * Called when initializing the board. Sets up the name and hooks up
849 static int snd_card_saa7134_new_mixer(snd_card_saa7134_t
* chip
)
851 snd_card_t
*card
= chip
->card
;
855 snd_assert(chip
!= NULL
, return -EINVAL
);
856 strcpy(card
->mixername
, "SAA7134 Mixer");
858 for (idx
= 0; idx
< ARRAY_SIZE(snd_saa7134_controls
); idx
++) {
859 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&snd_saa7134_controls
[idx
], chip
))) < 0)
865 static void snd_saa7134_free(snd_card_t
* card
)
867 snd_card_saa7134_t
*chip
= card
->private_data
;
869 if (chip
->dev
->dmasound
.priv_data
== NULL
)
872 if (chip
->irq
>= 0) {
873 synchronize_irq(chip
->irq
);
874 free_irq(chip
->irq
, &chip
->dev
->dmasound
);
877 chip
->dev
->dmasound
.priv_data
= NULL
;
882 * ALSA initialization
884 * Called by the init routine, once for each saa7134 device present,
885 * it creates the basic structures and registers the ALSA devices
889 static int alsa_card_saa7134_create(struct saa7134_dev
*dev
, int devnum
)
893 snd_card_saa7134_t
*chip
;
897 if (devnum
>= SNDRV_CARDS
)
902 card
= snd_card_new(index
[devnum
], id
[devnum
], THIS_MODULE
, sizeof(snd_card_saa7134_t
));
907 strcpy(card
->driver
, "SAA7134");
909 /* Card "creation" */
911 card
->private_free
= snd_saa7134_free
;
912 chip
= (snd_card_saa7134_t
*) card
->private_data
;
914 spin_lock_init(&chip
->lock
);
915 spin_lock_init(&chip
->mixer_lock
);
921 chip
->pci
= dev
->pci
;
922 chip
->iobase
= pci_resource_start(dev
->pci
, 0);
925 err
= request_irq(dev
->pci
->irq
, saa7134_alsa_irq
,
926 SA_SHIRQ
| SA_INTERRUPT
, dev
->name
,
927 (void*) &dev
->dmasound
);
930 printk(KERN_ERR
"%s: can't get IRQ %d for ALSA\n",
931 dev
->name
, dev
->pci
->irq
);
935 chip
->irq
= dev
->pci
->irq
;
937 init_MUTEX(&dev
->dmasound
.lock
);
939 if ((err
= snd_card_saa7134_new_mixer(chip
)) < 0)
942 if ((err
= snd_card_saa7134_pcm(chip
, 0)) < 0)
945 snd_card_set_dev(card
, &chip
->pci
->dev
);
947 /* End of "creation" */
949 strcpy(card
->shortname
, "SAA7134");
950 sprintf(card
->longname
, "%s at 0x%lx irq %d",
951 chip
->dev
->name
, chip
->iobase
, chip
->irq
);
953 printk(KERN_INFO
"%s/alsa: %s registered as card %d\n",dev
->name
,card
->longname
,index
[devnum
]);
955 if ((err
= snd_card_register(card
)) == 0) {
956 snd_saa7134_cards
[devnum
] = card
;
966 static int alsa_device_init(struct saa7134_dev
*dev
)
968 dev
->dmasound
.priv_data
= dev
;
969 alsa_card_saa7134_create(dev
,dev
->nr
);
973 static int alsa_device_exit(struct saa7134_dev
*dev
)
976 snd_card_free(snd_saa7134_cards
[dev
->nr
]);
977 snd_saa7134_cards
[dev
->nr
] = NULL
;
984 * Loops through present saa7134 cards, and assigns an ALSA device
989 static int saa7134_alsa_init(void)
991 struct saa7134_dev
*dev
= NULL
;
992 struct list_head
*list
;
994 if (!saa7134_dmasound_init
&& !saa7134_dmasound_exit
) {
995 saa7134_dmasound_init
= alsa_device_init
;
996 saa7134_dmasound_exit
= alsa_device_exit
;
998 printk(KERN_WARNING
"saa7134 ALSA: can't load, DMA sound handler already assigned (probably to OSS)\n");
1002 printk(KERN_INFO
"saa7134 ALSA driver for DMA sound loaded\n");
1004 list_for_each(list
,&saa7134_devlist
) {
1005 dev
= list_entry(list
, struct saa7134_dev
, devlist
);
1006 if (dev
->dmasound
.priv_data
== NULL
) {
1007 alsa_device_init(dev
);
1009 printk(KERN_ERR
"saa7134 ALSA: DMA sound is being handled by OSS. ignoring %s\n",dev
->name
);
1015 printk(KERN_INFO
"saa7134 ALSA: no saa7134 cards found\n");
1025 static void saa7134_alsa_exit(void)
1029 for (idx
= 0; idx
< SNDRV_CARDS
; idx
++) {
1030 snd_card_free(snd_saa7134_cards
[idx
]);
1033 saa7134_dmasound_init
= NULL
;
1034 saa7134_dmasound_exit
= NULL
;
1035 printk(KERN_INFO
"saa7134 ALSA driver for DMA sound unloaded\n");
1040 /* We initialize this late, to make sure the sound system is up and running */
1041 late_initcall(saa7134_alsa_init
);
1042 module_exit(saa7134_alsa_exit
);
1043 MODULE_LICENSE("GPL");
1044 MODULE_AUTHOR("Ricardo Cerqueira");