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
{
74 struct snd_card
*card
;
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 struct snd_pcm_substream
*substream
;
99 } snd_card_saa7134_pcm_t
;
101 static struct snd_card
*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(struct snd_pcm_substream
* substream
,
257 struct snd_pcm_runtime
*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 BUG_ON(!dev
->dmasound
.blksize
);
313 videobuf_dma_free(&dev
->dmasound
.dma
);
315 dev
->dmasound
.blocks
= 0;
316 dev
->dmasound
.blksize
= 0;
317 dev
->dmasound
.bufsize
= 0;
324 * ALSA PCM preparation
326 * - One of the ALSA capture callbacks.
328 * Called right after the capture device is opened, this function configures
329 * the buffer using the previously defined functions, allocates the memory,
330 * sets up the hardware registers, and then starts the DMA. When this function
331 * returns, the audio should be flowing.
335 static int snd_card_saa7134_capture_prepare(struct snd_pcm_substream
* substream
)
337 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
340 snd_card_saa7134_t
*saa7134
= snd_pcm_substream_chip(substream
);
341 struct saa7134_dev
*dev
;
342 snd_card_saa7134_pcm_t
*pcm
= runtime
->private_data
;
344 pcm
->dev
->dmasound
.substream
= substream
;
348 if (snd_pcm_format_width(runtime
->format
) == 8)
353 if (snd_pcm_format_signed(runtime
->format
))
358 if (snd_pcm_format_big_endian(runtime
->format
))
363 switch (dev
->pci
->device
) {
364 case PCI_DEVICE_ID_PHILIPS_SAA7134
:
365 if (1 == runtime
->channels
)
367 if (2 == runtime
->channels
)
372 fmt
|= (MIXER_ADDR_TVTUNER
== dev
->dmasound
.input
) ? 0xc0 : 0x80;
373 saa_writeb(SAA7134_NUM_SAMPLES0
, ((dev
->dmasound
.blksize
- 1) & 0x0000ff));
374 saa_writeb(SAA7134_NUM_SAMPLES1
, ((dev
->dmasound
.blksize
- 1) & 0x00ff00) >> 8);
375 saa_writeb(SAA7134_NUM_SAMPLES2
, ((dev
->dmasound
.blksize
- 1) & 0xff0000) >> 16);
376 saa_writeb(SAA7134_AUDIO_FORMAT_CTRL
, fmt
);
379 case PCI_DEVICE_ID_PHILIPS_SAA7133
:
380 case PCI_DEVICE_ID_PHILIPS_SAA7135
:
381 if (1 == runtime
->channels
)
383 if (2 == runtime
->channels
)
387 saa_writel(SAA7133_NUM_SAMPLES
, dev
->dmasound
.blksize
-1);
388 saa_writel(SAA7133_AUDIO_CHANNEL
, 0x543210 | (fmt
<< 24));
392 dprintk("rec_start: afmt=%d ch=%d => fmt=0x%x swap=%c\n",
393 runtime
->format
, runtime
->channels
, fmt
,
395 /* dma: setup channel 6 (= AUDIO) */
396 control
= SAA7134_RS_CONTROL_BURST_16
|
397 SAA7134_RS_CONTROL_ME
|
398 (dev
->dmasound
.pt
.dma
>> 12);
400 control
|= SAA7134_RS_CONTROL_BSWAP
;
402 saa_writel(SAA7134_RS_BA1(6),0);
403 saa_writel(SAA7134_RS_BA2(6),dev
->dmasound
.blksize
);
404 saa_writel(SAA7134_RS_PITCH(6),0);
405 saa_writel(SAA7134_RS_CONTROL(6),control
);
407 dev
->dmasound
.rate
= runtime
->rate
;
414 * ALSA pointer fetching
416 * - One of the ALSA capture callbacks.
418 * Called whenever a period elapses, it must return the current hardware
419 * position of the buffer.
420 * Also resets the read counter used to prevent overruns
424 static snd_pcm_uframes_t
425 snd_card_saa7134_capture_pointer(struct snd_pcm_substream
* substream
)
427 struct snd_pcm_runtime
*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 struct snd_pcm_hardware 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(struct snd_pcm_runtime
*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(struct snd_pcm_substream
* substream
,
486 struct snd_pcm_hw_params
* 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_pci_dma_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_pci_dma_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_pci_dma_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_pci_dma_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(struct snd_pcm_substream
* 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_pci_dma_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(struct snd_pcm_substream
* 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(struct snd_pcm_substream
* substream
)
608 struct snd_pcm_runtime
*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 mutex_lock(&dev
->dmasound
.lock
);
616 dev
->dmasound
.read_count
= 0;
617 dev
->dmasound
.read_offset
= 0;
619 mutex_unlock(&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 struct snd_pcm_ops 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(struct snd_kcontrol
* kcontrol
,
684 struct snd_ctl_elem_info
* uinfo
)
686 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
688 uinfo
->value
.integer
.min
= 0;
689 uinfo
->value
.integer
.max
= 20;
693 static int snd_saa7134_volume_get(struct snd_kcontrol
* kcontrol
,
694 struct snd_ctl_elem_value
* ucontrol
)
696 snd_card_saa7134_t
*chip
= snd_kcontrol_chip(kcontrol
);
697 int addr
= kcontrol
->private_value
;
699 ucontrol
->value
.integer
.value
[0] = chip
->mixer_volume
[addr
][0];
700 ucontrol
->value
.integer
.value
[1] = chip
->mixer_volume
[addr
][1];
704 static int snd_saa7134_volume_put(struct snd_kcontrol
* kcontrol
,
705 struct snd_ctl_elem_value
* ucontrol
)
707 snd_card_saa7134_t
*chip
= snd_kcontrol_chip(kcontrol
);
708 int change
, addr
= kcontrol
->private_value
;
711 left
= ucontrol
->value
.integer
.value
[0];
716 right
= ucontrol
->value
.integer
.value
[1];
721 spin_lock_irq(&chip
->mixer_lock
);
722 change
= chip
->mixer_volume
[addr
][0] != left
||
723 chip
->mixer_volume
[addr
][1] != right
;
724 chip
->mixer_volume
[addr
][0] = left
;
725 chip
->mixer_volume
[addr
][1] = right
;
726 spin_unlock_irq(&chip
->mixer_lock
);
730 #define SAA713x_CAPSRC(xname, xindex, addr) \
731 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
732 .info = snd_saa7134_capsrc_info, \
733 .get = snd_saa7134_capsrc_get, .put = snd_saa7134_capsrc_put, \
734 .private_value = addr }
736 static int snd_saa7134_capsrc_info(struct snd_kcontrol
* kcontrol
,
737 struct snd_ctl_elem_info
* uinfo
)
739 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
741 uinfo
->value
.integer
.min
= 0;
742 uinfo
->value
.integer
.max
= 1;
746 static int snd_saa7134_capsrc_get(struct snd_kcontrol
* kcontrol
,
747 struct snd_ctl_elem_value
* ucontrol
)
749 snd_card_saa7134_t
*chip
= snd_kcontrol_chip(kcontrol
);
750 int addr
= kcontrol
->private_value
;
752 spin_lock_irq(&chip
->mixer_lock
);
753 ucontrol
->value
.integer
.value
[0] = chip
->capture_source
[addr
][0];
754 ucontrol
->value
.integer
.value
[1] = chip
->capture_source
[addr
][1];
755 spin_unlock_irq(&chip
->mixer_lock
);
760 static int snd_saa7134_capsrc_put(struct snd_kcontrol
* kcontrol
,
761 struct snd_ctl_elem_value
* ucontrol
)
763 snd_card_saa7134_t
*chip
= snd_kcontrol_chip(kcontrol
);
764 int change
, addr
= kcontrol
->private_value
;
768 struct saa7134_dev
*dev
;
772 left
= ucontrol
->value
.integer
.value
[0] & 1;
773 right
= ucontrol
->value
.integer
.value
[1] & 1;
774 spin_lock_irq(&chip
->mixer_lock
);
776 change
= chip
->capture_source
[addr
][0] != left
||
777 chip
->capture_source
[addr
][1] != right
;
778 chip
->capture_source
[addr
][0] = left
;
779 chip
->capture_source
[addr
][1] = right
;
780 dev
->dmasound
.input
=addr
;
781 spin_unlock_irq(&chip
->mixer_lock
);
785 switch (dev
->pci
->device
) {
787 case PCI_DEVICE_ID_PHILIPS_SAA7134
:
789 case MIXER_ADDR_TVTUNER
:
790 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL
, 0xc0, 0xc0);
791 saa_andorb(SAA7134_SIF_SAMPLE_FREQ
, 0x03, 0x00);
793 case MIXER_ADDR_LINE1
:
794 case MIXER_ADDR_LINE2
:
795 analog_io
= (MIXER_ADDR_LINE1
== addr
) ? 0x00 : 0x08;
796 rate
= (32000 == dev
->dmasound
.rate
) ? 0x01 : 0x03;
797 saa_andorb(SAA7134_ANALOG_IO_SELECT
, 0x08, analog_io
);
798 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL
, 0xc0, 0x80);
799 saa_andorb(SAA7134_SIF_SAMPLE_FREQ
, 0x03, rate
);
804 case PCI_DEVICE_ID_PHILIPS_SAA7133
:
805 case PCI_DEVICE_ID_PHILIPS_SAA7135
:
806 xbarin
= 0x03; // adc
809 case MIXER_ADDR_TVTUNER
:
810 xbarin
= 0; // Demodulator
813 case MIXER_ADDR_LINE1
:
814 anabar
= 0; // aux1, aux1
816 case MIXER_ADDR_LINE2
:
817 anabar
= 9; // aux2, aux2
821 /* output xbar always main channel */
822 saa_dsp_writel(dev
, SAA7133_DIGITAL_OUTPUT_SEL1
, 0xbbbb10);
824 if (left
|| right
) { // We've got data, turn the input on
825 saa_dsp_writel(dev
, SAA7133_DIGITAL_INPUT_XBAR1
, xbarin
);
826 saa_writel(SAA7133_ANALOG_IO_SELECT
, anabar
);
828 saa_dsp_writel(dev
, SAA7133_DIGITAL_INPUT_XBAR1
, 0);
829 saa_writel(SAA7133_ANALOG_IO_SELECT
, 0);
838 static struct snd_kcontrol_new snd_saa7134_controls
[] = {
839 SAA713x_VOLUME("Video Volume", 0, MIXER_ADDR_TVTUNER
),
840 SAA713x_CAPSRC("Video Capture Switch", 0, MIXER_ADDR_TVTUNER
),
841 SAA713x_VOLUME("Line Volume", 1, MIXER_ADDR_LINE1
),
842 SAA713x_CAPSRC("Line Capture Switch", 1, MIXER_ADDR_LINE1
),
843 SAA713x_VOLUME("Line Volume", 2, MIXER_ADDR_LINE2
),
844 SAA713x_CAPSRC("Line Capture Switch", 2, MIXER_ADDR_LINE2
),
850 * Called when initializing the board. Sets up the name and hooks up
855 static int snd_card_saa7134_new_mixer(snd_card_saa7134_t
* chip
)
857 struct snd_card
*card
= chip
->card
;
861 snd_assert(chip
!= NULL
, return -EINVAL
);
862 strcpy(card
->mixername
, "SAA7134 Mixer");
864 for (idx
= 0; idx
< ARRAY_SIZE(snd_saa7134_controls
); idx
++) {
865 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&snd_saa7134_controls
[idx
], chip
))) < 0)
871 static void snd_saa7134_free(struct snd_card
* card
)
873 snd_card_saa7134_t
*chip
= card
->private_data
;
875 if (chip
->dev
->dmasound
.priv_data
== NULL
)
878 if (chip
->irq
>= 0) {
879 synchronize_irq(chip
->irq
);
880 free_irq(chip
->irq
, &chip
->dev
->dmasound
);
883 chip
->dev
->dmasound
.priv_data
= NULL
;
888 * ALSA initialization
890 * Called by the init routine, once for each saa7134 device present,
891 * it creates the basic structures and registers the ALSA devices
895 static int alsa_card_saa7134_create(struct saa7134_dev
*dev
, int devnum
)
898 struct snd_card
*card
;
899 snd_card_saa7134_t
*chip
;
903 if (devnum
>= SNDRV_CARDS
)
908 card
= snd_card_new(index
[devnum
], id
[devnum
], THIS_MODULE
, sizeof(snd_card_saa7134_t
));
913 strcpy(card
->driver
, "SAA7134");
915 /* Card "creation" */
917 card
->private_free
= snd_saa7134_free
;
918 chip
= (snd_card_saa7134_t
*) card
->private_data
;
920 spin_lock_init(&chip
->lock
);
921 spin_lock_init(&chip
->mixer_lock
);
927 chip
->pci
= dev
->pci
;
928 chip
->iobase
= pci_resource_start(dev
->pci
, 0);
931 err
= request_irq(dev
->pci
->irq
, saa7134_alsa_irq
,
932 IRQF_SHARED
| IRQF_DISABLED
, dev
->name
,
933 (void*) &dev
->dmasound
);
936 printk(KERN_ERR
"%s: can't get IRQ %d for ALSA\n",
937 dev
->name
, dev
->pci
->irq
);
941 chip
->irq
= dev
->pci
->irq
;
943 mutex_init(&dev
->dmasound
.lock
);
945 if ((err
= snd_card_saa7134_new_mixer(chip
)) < 0)
948 if ((err
= snd_card_saa7134_pcm(chip
, 0)) < 0)
951 snd_card_set_dev(card
, &chip
->pci
->dev
);
953 /* End of "creation" */
955 strcpy(card
->shortname
, "SAA7134");
956 sprintf(card
->longname
, "%s at 0x%lx irq %d",
957 chip
->dev
->name
, chip
->iobase
, chip
->irq
);
959 printk(KERN_INFO
"%s/alsa: %s registered as card %d\n",dev
->name
,card
->longname
,index
[devnum
]);
961 if ((err
= snd_card_register(card
)) == 0) {
962 snd_saa7134_cards
[devnum
] = card
;
972 static int alsa_device_init(struct saa7134_dev
*dev
)
974 dev
->dmasound
.priv_data
= dev
;
975 alsa_card_saa7134_create(dev
,dev
->nr
);
979 static int alsa_device_exit(struct saa7134_dev
*dev
)
982 snd_card_free(snd_saa7134_cards
[dev
->nr
]);
983 snd_saa7134_cards
[dev
->nr
] = NULL
;
990 * Loops through present saa7134 cards, and assigns an ALSA device
995 static int saa7134_alsa_init(void)
997 struct saa7134_dev
*dev
= NULL
;
998 struct list_head
*list
;
1000 if (!saa7134_dmasound_init
&& !saa7134_dmasound_exit
) {
1001 saa7134_dmasound_init
= alsa_device_init
;
1002 saa7134_dmasound_exit
= alsa_device_exit
;
1004 printk(KERN_WARNING
"saa7134 ALSA: can't load, DMA sound handler already assigned (probably to OSS)\n");
1008 printk(KERN_INFO
"saa7134 ALSA driver for DMA sound loaded\n");
1010 list_for_each(list
,&saa7134_devlist
) {
1011 dev
= list_entry(list
, struct saa7134_dev
, devlist
);
1012 if (dev
->dmasound
.priv_data
== NULL
) {
1013 alsa_device_init(dev
);
1015 printk(KERN_ERR
"saa7134 ALSA: DMA sound is being handled by OSS. ignoring %s\n",dev
->name
);
1021 printk(KERN_INFO
"saa7134 ALSA: no saa7134 cards found\n");
1031 static void saa7134_alsa_exit(void)
1035 for (idx
= 0; idx
< SNDRV_CARDS
; idx
++) {
1036 snd_card_free(snd_saa7134_cards
[idx
]);
1039 saa7134_dmasound_init
= NULL
;
1040 saa7134_dmasound_exit
= NULL
;
1041 printk(KERN_INFO
"saa7134 ALSA driver for DMA sound unloaded\n");
1046 /* We initialize this late, to make sure the sound system is up and running */
1047 late_initcall(saa7134_alsa_init
);
1048 module_exit(saa7134_alsa_exit
);
1049 MODULE_LICENSE("GPL");
1050 MODULE_AUTHOR("Ricardo Cerqueira");