2005-11-08 22:37:04 -07:00
|
|
|
/*
|
2005-11-08 22:37:11 -07:00
|
|
|
* SAA713x ALSA support for V4L
|
2005-11-08 22:37:04 -07:00
|
|
|
*
|
2005-11-08 22:37:11 -07:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, version 2
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
2005-11-08 22:37:04 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2015-04-30 03:44:56 -06:00
|
|
|
#include "saa7134.h"
|
|
|
|
#include "saa7134-reg.h"
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/module.h>
|
2005-11-08 22:37:04 -07:00
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/control.h>
|
2005-11-08 22:37:11 -07:00
|
|
|
#include <sound/pcm.h>
|
2005-11-13 17:08:10 -07:00
|
|
|
#include <sound/pcm_params.h>
|
2005-11-08 22:37:04 -07:00
|
|
|
#include <sound/initval.h>
|
2005-11-13 17:07:51 -07:00
|
|
|
#include <linux/interrupt.h>
|
2014-05-13 20:02:14 -06:00
|
|
|
#include <linux/vmalloc.h>
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* Configuration macros
|
|
|
|
*/
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
/* defaults */
|
2009-08-22 12:13:51 -06:00
|
|
|
#define MIXER_ADDR_UNSELECTED -1
|
2005-11-08 22:37:14 -07:00
|
|
|
#define MIXER_ADDR_TVTUNER 0
|
|
|
|
#define MIXER_ADDR_LINE1 1
|
|
|
|
#define MIXER_ADDR_LINE2 2
|
|
|
|
#define MIXER_ADDR_LAST 2
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-12-12 01:37:28 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
|
|
|
|
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
|
2006-02-26 20:08:11 -07:00
|
|
|
static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1};
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
module_param_array(index, int, NULL, 0444);
|
2006-02-26 20:08:11 -07:00
|
|
|
module_param_array(enable, int, NULL, 0444);
|
2005-11-08 22:38:54 -07:00
|
|
|
MODULE_PARM_DESC(index, "Index value for SAA7134 capture interface(s).");
|
2006-02-26 20:08:11 -07:00
|
|
|
MODULE_PARM_DESC(enable, "Enable (or not) the SAA7134 capture interface(s).");
|
2005-11-08 22:38:54 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* Main chip structure
|
|
|
|
*/
|
2005-12-12 01:37:28 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
typedef struct snd_card_saa7134 {
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_card *card;
|
2005-11-08 22:37:11 -07:00
|
|
|
spinlock_t mixer_lock;
|
|
|
|
int mixer_volume[MIXER_ADDR_LAST+1][2];
|
2009-08-22 12:13:51 -06:00
|
|
|
int capture_source_addr;
|
|
|
|
int capture_source[2];
|
|
|
|
struct snd_kcontrol *capture_ctl[MIXER_ADDR_LAST+1];
|
2005-11-08 22:37:43 -07:00
|
|
|
struct pci_dev *pci;
|
2005-11-13 17:08:00 -07:00
|
|
|
struct saa7134_dev *dev;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-08 22:37:43 -07:00
|
|
|
unsigned long iobase;
|
2007-06-20 02:36:26 -06:00
|
|
|
s16 irq;
|
|
|
|
u16 mute_was_on;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
|
|
|
spinlock_t lock;
|
|
|
|
} snd_card_saa7134_t;
|
|
|
|
|
2005-11-08 22:38:14 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* PCM structure
|
|
|
|
*/
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
typedef struct snd_card_saa7134_pcm {
|
2005-11-13 17:08:00 -07:00
|
|
|
struct saa7134_dev *dev;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
|
|
|
spinlock_t lock;
|
2005-11-13 17:08:00 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_pcm_substream *substream;
|
2005-11-08 22:37:11 -07:00
|
|
|
} snd_card_saa7134_pcm_t;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static struct snd_card *snd_saa7134_cards[SNDRV_CARDS];
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:53 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* saa7134 DMA audio stop
|
|
|
|
*
|
|
|
|
* Called when the capture device is released or the buffer overflows
|
|
|
|
*
|
2005-11-13 17:07:47 -07:00
|
|
|
* - Copied verbatim from saa7134-oss's dsp_dma_stop.
|
2005-11-08 22:37:14 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
static void saa7134_dma_stop(struct saa7134_dev *dev)
|
|
|
|
{
|
2005-11-08 22:38:54 -07:00
|
|
|
dev->dmasound.dma_blk = -1;
|
|
|
|
dev->dmasound.dma_running = 0;
|
2005-11-08 22:37:43 -07:00
|
|
|
saa7134_set_dmabits(dev);
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* saa7134 DMA audio start
|
|
|
|
*
|
|
|
|
* Called when preparing the capture device for use
|
|
|
|
*
|
2005-11-13 17:07:47 -07:00
|
|
|
* - Copied verbatim from saa7134-oss's dsp_dma_start.
|
2005-11-08 22:37:14 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
static void saa7134_dma_start(struct saa7134_dev *dev)
|
|
|
|
{
|
2005-11-08 22:38:54 -07:00
|
|
|
dev->dmasound.dma_blk = 0;
|
|
|
|
dev->dmasound.dma_running = 1;
|
2005-11-08 22:37:43 -07:00
|
|
|
saa7134_set_dmabits(dev);
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* saa7134 audio DMA IRQ handler
|
|
|
|
*
|
|
|
|
* Called whenever we get an SAA7134_IRQ_REPORT_DONE_RA3 interrupt
|
|
|
|
* Handles shifting between the 2 buffers, manages the read counters,
|
|
|
|
* and notifies ALSA when periods elapse
|
|
|
|
*
|
|
|
|
* - Mostly copied from saa7134-oss's saa7134_irq_oss_done.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2005-12-01 01:51:35 -07:00
|
|
|
static void saa7134_irq_alsa_done(struct saa7134_dev *dev,
|
|
|
|
unsigned long status)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
|
|
|
int next_blk, reg = 0;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
spin_lock(&dev->slock);
|
2005-11-08 22:38:54 -07:00
|
|
|
if (UNSET == dev->dmasound.dma_blk) {
|
2015-04-30 03:59:53 -06:00
|
|
|
pr_debug("irq: recording stopped\n");
|
2005-11-08 22:37:11 -07:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
if (0 != (status & 0x0f000000))
|
2015-04-30 03:59:53 -06:00
|
|
|
pr_debug("irq: lost %ld\n", (status >> 24) & 0x0f);
|
2005-11-08 22:37:11 -07:00
|
|
|
if (0 == (status & 0x10000000)) {
|
|
|
|
/* odd */
|
2005-11-08 22:38:54 -07:00
|
|
|
if (0 == (dev->dmasound.dma_blk & 0x01))
|
2005-11-08 22:37:11 -07:00
|
|
|
reg = SAA7134_RS_BA1(6);
|
|
|
|
} else {
|
|
|
|
/* even */
|
2005-11-08 22:38:54 -07:00
|
|
|
if (1 == (dev->dmasound.dma_blk & 0x01))
|
2005-11-08 22:37:11 -07:00
|
|
|
reg = SAA7134_RS_BA2(6);
|
|
|
|
}
|
|
|
|
if (0 == reg) {
|
2015-04-30 03:59:53 -06:00
|
|
|
pr_debug("irq: field oops [%s]\n",
|
2005-11-08 22:37:11 -07:00
|
|
|
(status & 0x10000000) ? "even" : "odd");
|
|
|
|
goto done;
|
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
if (dev->dmasound.read_count >= dev->dmasound.blksize * (dev->dmasound.blocks-2)) {
|
2015-05-13 11:09:42 -06:00
|
|
|
pr_debug("irq: overrun [full=%d/%d] - Blocks in %d\n",
|
|
|
|
dev->dmasound.read_count,
|
2005-11-08 22:38:54 -07:00
|
|
|
dev->dmasound.bufsize, dev->dmasound.blocks);
|
2005-11-13 17:08:10 -07:00
|
|
|
spin_unlock(&dev->slock);
|
2014-11-07 09:08:28 -07:00
|
|
|
snd_pcm_stop_xrun(dev->dmasound.substream);
|
2005-11-13 17:08:10 -07:00
|
|
|
return;
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:43 -07:00
|
|
|
/* next block addr */
|
2005-11-08 22:38:54 -07:00
|
|
|
next_blk = (dev->dmasound.dma_blk + 2) % dev->dmasound.blocks;
|
|
|
|
saa_writel(reg,next_blk * dev->dmasound.blksize);
|
2015-04-30 03:59:53 -06:00
|
|
|
pr_debug("irq: ok, %s, next_blk=%d, addr=%x, blocks=%u, size=%u, read=%u\n",
|
|
|
|
(status & 0x10000000) ? "even" : "odd ", next_blk,
|
2015-05-13 11:09:42 -06:00
|
|
|
next_blk * dev->dmasound.blksize, dev->dmasound.blocks,
|
|
|
|
dev->dmasound.blksize, dev->dmasound.read_count);
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:43 -07:00
|
|
|
/* update status & wake waiting readers */
|
2005-11-08 22:38:54 -07:00
|
|
|
dev->dmasound.dma_blk = (dev->dmasound.dma_blk + 1) % dev->dmasound.blocks;
|
|
|
|
dev->dmasound.read_count += dev->dmasound.blksize;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
dev->dmasound.recording_on = reg;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
if (dev->dmasound.read_count >= snd_pcm_lib_period_bytes(dev->dmasound.substream)) {
|
2005-11-08 22:37:43 -07:00
|
|
|
spin_unlock(&dev->slock);
|
2005-11-08 22:38:54 -07:00
|
|
|
snd_pcm_period_elapsed(dev->dmasound.substream);
|
2005-11-08 22:37:43 -07:00
|
|
|
spin_lock(&dev->slock);
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-13 17:08:00 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
done:
|
2005-11-08 22:37:43 -07:00
|
|
|
spin_unlock(&dev->slock);
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:53 -07:00
|
|
|
/*
|
|
|
|
* IRQ request handler
|
|
|
|
*
|
|
|
|
* Runs along with saa7134's IRQ handler, discards anything that isn't
|
|
|
|
* DMA sound
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
static irqreturn_t saa7134_alsa_irq(int irq, void *dev_id)
|
2005-11-08 22:38:53 -07:00
|
|
|
{
|
2005-12-12 01:37:27 -07:00
|
|
|
struct saa7134_dmasound *dmasound = dev_id;
|
|
|
|
struct saa7134_dev *dev = dmasound->priv_data;
|
2005-11-13 17:08:00 -07:00
|
|
|
|
2005-11-08 22:38:53 -07:00
|
|
|
unsigned long report, status;
|
|
|
|
int loop, handled = 0;
|
|
|
|
|
|
|
|
for (loop = 0; loop < 10; loop++) {
|
|
|
|
report = saa_readl(SAA7134_IRQ_REPORT);
|
|
|
|
status = saa_readl(SAA7134_IRQ_STATUS);
|
|
|
|
|
|
|
|
if (report & SAA7134_IRQ_REPORT_DONE_RA3) {
|
|
|
|
handled = 1;
|
2007-11-30 09:27:26 -07:00
|
|
|
saa_writel(SAA7134_IRQ_REPORT,
|
|
|
|
SAA7134_IRQ_REPORT_DONE_RA3);
|
2005-11-08 22:38:53 -07:00
|
|
|
saa7134_irq_alsa_done(dev, status);
|
|
|
|
} else {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (loop == 10) {
|
2015-04-30 03:59:53 -06:00
|
|
|
pr_debug("error! looping IRQ!");
|
2005-11-08 22:38:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return IRQ_RETVAL(handled);
|
|
|
|
}
|
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA capture trigger
|
|
|
|
*
|
|
|
|
* - One of the ALSA capture callbacks.
|
|
|
|
*
|
|
|
|
* Called whenever a capture is started or stopped. Must be defined,
|
|
|
|
* but there's nothing we want to do here
|
|
|
|
*
|
|
|
|
*/
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_card_saa7134_capture_trigger(struct snd_pcm_substream * substream,
|
2005-11-08 22:37:11 -07:00
|
|
|
int cmd)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
2005-11-13 17:08:00 -07:00
|
|
|
snd_card_saa7134_pcm_t *pcm = runtime->private_data;
|
|
|
|
struct saa7134_dev *dev=pcm->dev;
|
2005-11-08 22:38:54 -07:00
|
|
|
int err = 0;
|
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
spin_lock(&dev->slock);
|
2005-11-13 17:07:47 -07:00
|
|
|
if (cmd == SNDRV_PCM_TRIGGER_START) {
|
2005-11-08 22:38:54 -07:00
|
|
|
/* start dma */
|
|
|
|
saa7134_dma_start(dev);
|
2005-11-13 17:07:47 -07:00
|
|
|
} else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
|
2005-11-08 22:38:54 -07:00
|
|
|
/* stop dma */
|
|
|
|
saa7134_dma_stop(dev);
|
2005-11-13 17:07:47 -07:00
|
|
|
} else {
|
|
|
|
err = -EINVAL;
|
|
|
|
}
|
2005-11-13 17:08:10 -07:00
|
|
|
spin_unlock(&dev->slock);
|
2005-11-08 22:38:54 -07:00
|
|
|
|
2005-11-13 17:07:47 -07:00
|
|
|
return err;
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
|
|
|
|
2014-04-17 00:57:14 -06:00
|
|
|
static int saa7134_alsa_dma_init(struct saa7134_dev *dev, int nr_pages)
|
|
|
|
{
|
|
|
|
struct saa7134_dmasound *dma = &dev->dmasound;
|
|
|
|
struct page *pg;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
dma->vaddr = vmalloc_32(nr_pages << PAGE_SHIFT);
|
|
|
|
if (NULL == dma->vaddr) {
|
2015-04-30 03:59:53 -06:00
|
|
|
pr_debug("vmalloc_32(%d pages) failed\n", nr_pages);
|
2014-04-17 00:57:14 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2015-04-30 03:59:53 -06:00
|
|
|
pr_debug("vmalloc is at addr 0x%08lx, size=%d\n",
|
2014-04-17 00:57:14 -06:00
|
|
|
(unsigned long)dma->vaddr,
|
|
|
|
nr_pages << PAGE_SHIFT);
|
|
|
|
|
|
|
|
memset(dma->vaddr, 0, nr_pages << PAGE_SHIFT);
|
|
|
|
dma->nr_pages = nr_pages;
|
|
|
|
|
|
|
|
dma->sglist = vzalloc(dma->nr_pages * sizeof(*dma->sglist));
|
|
|
|
if (NULL == dma->sglist)
|
|
|
|
goto vzalloc_err;
|
|
|
|
|
|
|
|
sg_init_table(dma->sglist, dma->nr_pages);
|
|
|
|
for (i = 0; i < dma->nr_pages; i++) {
|
|
|
|
pg = vmalloc_to_page(dma->vaddr + i * PAGE_SIZE);
|
|
|
|
if (NULL == pg)
|
|
|
|
goto vmalloc_to_page_err;
|
|
|
|
sg_set_page(&dma->sglist[i], pg, PAGE_SIZE, 0);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
vmalloc_to_page_err:
|
|
|
|
vfree(dma->sglist);
|
|
|
|
dma->sglist = NULL;
|
|
|
|
vzalloc_err:
|
|
|
|
vfree(dma->vaddr);
|
|
|
|
dma->vaddr = NULL;
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int saa7134_alsa_dma_map(struct saa7134_dev *dev)
|
|
|
|
{
|
|
|
|
struct saa7134_dmasound *dma = &dev->dmasound;
|
|
|
|
|
|
|
|
dma->sglen = dma_map_sg(&dev->pci->dev, dma->sglist,
|
|
|
|
dma->nr_pages, PCI_DMA_FROMDEVICE);
|
|
|
|
|
|
|
|
if (0 == dma->sglen) {
|
|
|
|
pr_warn("%s: saa7134_alsa_map_sg failed\n", __func__);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int saa7134_alsa_dma_unmap(struct saa7134_dev *dev)
|
|
|
|
{
|
|
|
|
struct saa7134_dmasound *dma = &dev->dmasound;
|
|
|
|
|
|
|
|
if (!dma->sglen)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dma_unmap_sg(&dev->pci->dev, dma->sglist, dma->sglen, PCI_DMA_FROMDEVICE);
|
|
|
|
dma->sglen = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int saa7134_alsa_dma_free(struct saa7134_dmasound *dma)
|
|
|
|
{
|
|
|
|
vfree(dma->sglist);
|
|
|
|
dma->sglist = NULL;
|
|
|
|
vfree(dma->vaddr);
|
|
|
|
dma->vaddr = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* DMA buffer initialization
|
|
|
|
*
|
|
|
|
* Uses V4L functions to initialize the DMA. Shouldn't be necessary in
|
|
|
|
* ALSA, but I was unable to use ALSA's own DMA, and had to force the
|
|
|
|
* usage of V4L's
|
|
|
|
*
|
2005-11-13 17:07:47 -07:00
|
|
|
* - Copied verbatim from saa7134-oss.
|
|
|
|
*
|
2005-11-08 22:37:14 -07:00
|
|
|
*/
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
static int dsp_buffer_init(struct saa7134_dev *dev)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2005-11-08 22:37:43 -07:00
|
|
|
int err;
|
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
BUG_ON(!dev->dmasound.bufsize);
|
|
|
|
|
2014-04-17 00:57:14 -06:00
|
|
|
err = saa7134_alsa_dma_init(dev,
|
|
|
|
(dev->dmasound.bufsize + PAGE_SIZE) >> PAGE_SHIFT);
|
2005-11-08 22:37:43 -07:00
|
|
|
if (0 != err)
|
|
|
|
return err;
|
|
|
|
return 0;
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
/*
|
|
|
|
* DMA buffer release
|
|
|
|
*
|
|
|
|
* Called after closing the device, during snd_card_saa7134_capture_close
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int dsp_buffer_free(struct saa7134_dev *dev)
|
|
|
|
{
|
2006-03-13 09:17:11 -07:00
|
|
|
BUG_ON(!dev->dmasound.blksize);
|
2005-11-13 17:08:10 -07:00
|
|
|
|
2014-04-17 00:57:14 -06:00
|
|
|
saa7134_alsa_dma_free(&dev->dmasound);
|
2005-11-13 17:08:10 -07:00
|
|
|
|
|
|
|
dev->dmasound.blocks = 0;
|
|
|
|
dev->dmasound.blksize = 0;
|
|
|
|
dev->dmasound.bufsize = 0;
|
|
|
|
|
2007-08-27 15:16:54 -06:00
|
|
|
return 0;
|
2005-11-13 17:08:10 -07:00
|
|
|
}
|
|
|
|
|
2009-08-22 12:13:51 -06:00
|
|
|
/*
|
|
|
|
* Setting the capture source and updating the ALSA controls
|
|
|
|
*/
|
|
|
|
static int snd_saa7134_capsrc_set(struct snd_kcontrol *kcontrol,
|
|
|
|
int left, int right, bool force_notify)
|
|
|
|
{
|
|
|
|
snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol);
|
|
|
|
int change = 0, addr = kcontrol->private_value;
|
|
|
|
int active, old_addr;
|
|
|
|
u32 anabar, xbarin;
|
|
|
|
int analog_io, rate;
|
|
|
|
struct saa7134_dev *dev;
|
|
|
|
|
|
|
|
dev = chip->dev;
|
|
|
|
|
|
|
|
spin_lock_irq(&chip->mixer_lock);
|
|
|
|
|
|
|
|
active = left != 0 || right != 0;
|
|
|
|
old_addr = chip->capture_source_addr;
|
|
|
|
|
|
|
|
/* The active capture source cannot be deactivated */
|
|
|
|
if (active) {
|
|
|
|
change = old_addr != addr ||
|
|
|
|
chip->capture_source[0] != left ||
|
|
|
|
chip->capture_source[1] != right;
|
|
|
|
|
|
|
|
chip->capture_source[0] = left;
|
|
|
|
chip->capture_source[1] = right;
|
|
|
|
chip->capture_source_addr = addr;
|
|
|
|
dev->dmasound.input = addr;
|
|
|
|
}
|
|
|
|
spin_unlock_irq(&chip->mixer_lock);
|
|
|
|
|
|
|
|
if (change) {
|
|
|
|
switch (dev->pci->device) {
|
|
|
|
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7134:
|
|
|
|
switch (addr) {
|
|
|
|
case MIXER_ADDR_TVTUNER:
|
|
|
|
saa_andorb(SAA7134_AUDIO_FORMAT_CTRL,
|
|
|
|
0xc0, 0xc0);
|
|
|
|
saa_andorb(SAA7134_SIF_SAMPLE_FREQ,
|
|
|
|
0x03, 0x00);
|
|
|
|
break;
|
|
|
|
case MIXER_ADDR_LINE1:
|
|
|
|
case MIXER_ADDR_LINE2:
|
|
|
|
analog_io = (MIXER_ADDR_LINE1 == addr) ?
|
|
|
|
0x00 : 0x08;
|
|
|
|
rate = (32000 == dev->dmasound.rate) ?
|
|
|
|
0x01 : 0x03;
|
|
|
|
saa_andorb(SAA7134_ANALOG_IO_SELECT,
|
|
|
|
0x08, analog_io);
|
|
|
|
saa_andorb(SAA7134_AUDIO_FORMAT_CTRL,
|
|
|
|
0xc0, 0x80);
|
|
|
|
saa_andorb(SAA7134_SIF_SAMPLE_FREQ,
|
|
|
|
0x03, rate);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7133:
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7135:
|
|
|
|
xbarin = 0x03; /* adc */
|
|
|
|
anabar = 0;
|
|
|
|
switch (addr) {
|
|
|
|
case MIXER_ADDR_TVTUNER:
|
|
|
|
xbarin = 0; /* Demodulator */
|
|
|
|
anabar = 2; /* DACs */
|
|
|
|
break;
|
|
|
|
case MIXER_ADDR_LINE1:
|
|
|
|
anabar = 0; /* aux1, aux1 */
|
|
|
|
break;
|
|
|
|
case MIXER_ADDR_LINE2:
|
|
|
|
anabar = 9; /* aux2, aux2 */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* output xbar always main channel */
|
|
|
|
saa_dsp_writel(dev, SAA7133_DIGITAL_OUTPUT_SEL1,
|
|
|
|
0xbbbb10);
|
|
|
|
|
|
|
|
if (left || right) {
|
|
|
|
/* We've got data, turn the input on */
|
|
|
|
saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1,
|
|
|
|
xbarin);
|
|
|
|
saa_writel(SAA7133_ANALOG_IO_SELECT, anabar);
|
|
|
|
} else {
|
|
|
|
saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1,
|
|
|
|
0);
|
|
|
|
saa_writel(SAA7133_ANALOG_IO_SELECT, 0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (change) {
|
|
|
|
if (force_notify)
|
|
|
|
snd_ctl_notify(chip->card,
|
|
|
|
SNDRV_CTL_EVENT_MASK_VALUE,
|
|
|
|
&chip->capture_ctl[addr]->id);
|
|
|
|
|
|
|
|
if (old_addr != MIXER_ADDR_UNSELECTED && old_addr != addr)
|
|
|
|
snd_ctl_notify(chip->card,
|
|
|
|
SNDRV_CTL_EVENT_MASK_VALUE,
|
|
|
|
&chip->capture_ctl[old_addr]->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
return change;
|
|
|
|
}
|
2005-11-13 17:08:10 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA PCM preparation
|
|
|
|
*
|
|
|
|
* - One of the ALSA capture callbacks.
|
|
|
|
*
|
|
|
|
* Called right after the capture device is opened, this function configures
|
|
|
|
* the buffer using the previously defined functions, allocates the memory,
|
|
|
|
* sets up the hardware registers, and then starts the DMA. When this function
|
|
|
|
* returns, the audio should be flowing.
|
|
|
|
*
|
|
|
|
*/
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_card_saa7134_capture_prepare(struct snd_pcm_substream * substream)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
2005-11-13 17:08:10 -07:00
|
|
|
int bswap, sign;
|
2005-11-08 22:37:43 -07:00
|
|
|
u32 fmt, control;
|
2005-11-08 22:37:11 -07:00
|
|
|
snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream);
|
2005-11-08 22:37:43 -07:00
|
|
|
struct saa7134_dev *dev;
|
2005-11-13 17:08:00 -07:00
|
|
|
snd_card_saa7134_pcm_t *pcm = runtime->private_data;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
pcm->dev->dmasound.substream = substream;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
dev = saa7134->dev;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
if (snd_pcm_format_width(runtime->format) == 8)
|
2005-11-08 22:37:11 -07:00
|
|
|
fmt = 0x00;
|
2005-11-13 17:08:10 -07:00
|
|
|
else
|
2005-11-08 22:37:11 -07:00
|
|
|
fmt = 0x01;
|
2005-11-08 22:37:43 -07:00
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
if (snd_pcm_format_signed(runtime->format))
|
2005-11-08 22:37:11 -07:00
|
|
|
sign = 1;
|
2005-11-13 17:08:10 -07:00
|
|
|
else
|
2005-11-08 22:37:11 -07:00
|
|
|
sign = 0;
|
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
if (snd_pcm_format_big_endian(runtime->format))
|
|
|
|
bswap = 1;
|
|
|
|
else
|
|
|
|
bswap = 0;
|
2005-11-08 22:37:43 -07:00
|
|
|
|
|
|
|
switch (dev->pci->device) {
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7134:
|
|
|
|
if (1 == runtime->channels)
|
|
|
|
fmt |= (1 << 3);
|
|
|
|
if (2 == runtime->channels)
|
|
|
|
fmt |= (3 << 3);
|
|
|
|
if (sign)
|
|
|
|
fmt |= 0x04;
|
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
fmt |= (MIXER_ADDR_TVTUNER == dev->dmasound.input) ? 0xc0 : 0x80;
|
|
|
|
saa_writeb(SAA7134_NUM_SAMPLES0, ((dev->dmasound.blksize - 1) & 0x0000ff));
|
|
|
|
saa_writeb(SAA7134_NUM_SAMPLES1, ((dev->dmasound.blksize - 1) & 0x00ff00) >> 8);
|
|
|
|
saa_writeb(SAA7134_NUM_SAMPLES2, ((dev->dmasound.blksize - 1) & 0xff0000) >> 16);
|
2005-11-08 22:37:43 -07:00
|
|
|
saa_writeb(SAA7134_AUDIO_FORMAT_CTRL, fmt);
|
|
|
|
|
|
|
|
break;
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7133:
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7135:
|
|
|
|
if (1 == runtime->channels)
|
|
|
|
fmt |= (1 << 4);
|
|
|
|
if (2 == runtime->channels)
|
|
|
|
fmt |= (2 << 4);
|
|
|
|
if (!sign)
|
|
|
|
fmt |= 0x04;
|
2005-11-08 22:38:54 -07:00
|
|
|
saa_writel(SAA7133_NUM_SAMPLES, dev->dmasound.blksize -1);
|
2005-11-08 22:37:43 -07:00
|
|
|
saa_writel(SAA7133_AUDIO_CHANNEL, 0x543210 | (fmt << 24));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-04-30 03:59:53 -06:00
|
|
|
pr_debug("rec_start: afmt=%d ch=%d => fmt=0x%x swap=%c\n",
|
2005-11-08 22:37:43 -07:00
|
|
|
runtime->format, runtime->channels, fmt,
|
|
|
|
bswap ? 'b' : '-');
|
|
|
|
/* dma: setup channel 6 (= AUDIO) */
|
|
|
|
control = SAA7134_RS_CONTROL_BURST_16 |
|
|
|
|
SAA7134_RS_CONTROL_ME |
|
2005-11-08 22:38:54 -07:00
|
|
|
(dev->dmasound.pt.dma >> 12);
|
2005-11-08 22:37:43 -07:00
|
|
|
if (bswap)
|
|
|
|
control |= SAA7134_RS_CONTROL_BSWAP;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-08 22:37:43 -07:00
|
|
|
saa_writel(SAA7134_RS_BA1(6),0);
|
2005-11-08 22:38:54 -07:00
|
|
|
saa_writel(SAA7134_RS_BA2(6),dev->dmasound.blksize);
|
2005-11-08 22:37:43 -07:00
|
|
|
saa_writel(SAA7134_RS_PITCH(6),0);
|
|
|
|
saa_writel(SAA7134_RS_CONTROL(6),control);
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
dev->dmasound.rate = runtime->rate;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2009-08-22 12:13:51 -06:00
|
|
|
/* Setup and update the card/ALSA controls */
|
|
|
|
snd_saa7134_capsrc_set(saa7134->capture_ctl[dev->dmasound.input], 1, 1,
|
|
|
|
true);
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
return 0;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA pointer fetching
|
|
|
|
*
|
|
|
|
* - One of the ALSA capture callbacks.
|
|
|
|
*
|
|
|
|
* Called whenever a period elapses, it must return the current hardware
|
|
|
|
* position of the buffer.
|
|
|
|
* Also resets the read counter used to prevent overruns
|
|
|
|
*
|
|
|
|
*/
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static snd_pcm_uframes_t
|
|
|
|
snd_card_saa7134_capture_pointer(struct snd_pcm_substream * substream)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
2005-11-13 17:08:00 -07:00
|
|
|
snd_card_saa7134_pcm_t *pcm = runtime->private_data;
|
|
|
|
struct saa7134_dev *dev=pcm->dev;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
if (dev->dmasound.read_count) {
|
|
|
|
dev->dmasound.read_count -= snd_pcm_lib_period_bytes(substream);
|
|
|
|
dev->dmasound.read_offset += snd_pcm_lib_period_bytes(substream);
|
|
|
|
if (dev->dmasound.read_offset == dev->dmasound.bufsize)
|
|
|
|
dev->dmasound.read_offset = 0;
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
return bytes_to_frames(runtime, dev->dmasound.read_offset);
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA hardware capabilities definition
|
2009-08-18 13:24:54 -06:00
|
|
|
*
|
|
|
|
* Report only 32kHz for ALSA:
|
|
|
|
*
|
|
|
|
* - SAA7133/35 uses DDEP (DemDec Easy Programming mode), which works in 32kHz
|
|
|
|
* only
|
|
|
|
* - SAA7134 for TV mode uses DemDec mode (32kHz)
|
|
|
|
* - Radio works in 32kHz only
|
|
|
|
* - When recording 48kHz from Line1/Line2, switching of capture source to TV
|
|
|
|
* means
|
|
|
|
* switching to 32kHz without any frequency translation
|
2005-11-08 22:37:14 -07:00
|
|
|
*/
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static struct snd_pcm_hardware snd_card_saa7134_capture =
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2005-11-08 22:37:43 -07:00
|
|
|
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
|
2005-11-08 22:37:45 -07:00
|
|
|
SNDRV_PCM_INFO_BLOCK_TRANSFER |
|
|
|
|
SNDRV_PCM_INFO_MMAP_VALID),
|
2005-11-08 22:38:54 -07:00
|
|
|
.formats = SNDRV_PCM_FMTBIT_S16_LE | \
|
|
|
|
SNDRV_PCM_FMTBIT_S16_BE | \
|
|
|
|
SNDRV_PCM_FMTBIT_S8 | \
|
|
|
|
SNDRV_PCM_FMTBIT_U8 | \
|
|
|
|
SNDRV_PCM_FMTBIT_U16_LE | \
|
|
|
|
SNDRV_PCM_FMTBIT_U16_BE,
|
2009-08-18 13:24:54 -06:00
|
|
|
.rates = SNDRV_PCM_RATE_32000,
|
2005-11-08 22:38:54 -07:00
|
|
|
.rate_min = 32000,
|
2009-08-18 13:24:54 -06:00
|
|
|
.rate_max = 32000,
|
2005-11-08 22:38:54 -07:00
|
|
|
.channels_min = 1,
|
|
|
|
.channels_max = 2,
|
|
|
|
.buffer_bytes_max = (256*1024),
|
2005-11-08 22:37:11 -07:00
|
|
|
.period_bytes_min = 64,
|
2005-11-08 22:38:54 -07:00
|
|
|
.period_bytes_max = (256*1024),
|
2007-11-23 14:59:18 -07:00
|
|
|
.periods_min = 4,
|
2005-11-08 22:38:54 -07:00
|
|
|
.periods_max = 1024,
|
2005-11-08 22:37:11 -07:00
|
|
|
};
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static void snd_card_saa7134_runtime_free(struct snd_pcm_runtime *runtime)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
2005-11-13 17:08:00 -07:00
|
|
|
snd_card_saa7134_pcm_t *pcm = runtime->private_data;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
kfree(pcm);
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA hardware params
|
|
|
|
*
|
|
|
|
* - One of the ALSA capture callbacks.
|
|
|
|
*
|
|
|
|
* Called on initialization, right before the PCM preparation
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_card_saa7134_hw_params(struct snd_pcm_substream * substream,
|
|
|
|
struct snd_pcm_hw_params * hw_params)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2005-11-13 17:08:10 -07:00
|
|
|
snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream);
|
|
|
|
struct saa7134_dev *dev;
|
|
|
|
unsigned int period_size, periods;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
period_size = params_period_bytes(hw_params);
|
|
|
|
periods = params_periods(hw_params);
|
|
|
|
|
2008-08-08 09:12:47 -06:00
|
|
|
if (period_size < 0x100 || period_size > 0x10000)
|
|
|
|
return -EINVAL;
|
|
|
|
if (periods < 4)
|
|
|
|
return -EINVAL;
|
|
|
|
if (period_size * periods > 1024 * 1024)
|
|
|
|
return -EINVAL;
|
2005-11-13 17:08:10 -07:00
|
|
|
|
|
|
|
dev = saa7134->dev;
|
|
|
|
|
|
|
|
if (dev->dmasound.blocks == periods &&
|
|
|
|
dev->dmasound.blksize == period_size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* release the old buffer */
|
|
|
|
if (substream->runtime->dma_area) {
|
|
|
|
saa7134_pgtable_free(dev->pci, &dev->dmasound.pt);
|
2014-04-17 00:57:14 -06:00
|
|
|
saa7134_alsa_dma_unmap(dev);
|
2005-11-13 17:08:10 -07:00
|
|
|
dsp_buffer_free(dev);
|
|
|
|
substream->runtime->dma_area = NULL;
|
|
|
|
}
|
|
|
|
dev->dmasound.blocks = periods;
|
|
|
|
dev->dmasound.blksize = period_size;
|
|
|
|
dev->dmasound.bufsize = period_size * periods;
|
|
|
|
|
|
|
|
err = dsp_buffer_init(dev);
|
|
|
|
if (0 != err) {
|
|
|
|
dev->dmasound.blocks = 0;
|
|
|
|
dev->dmasound.blksize = 0;
|
|
|
|
dev->dmasound.bufsize = 0;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-04-17 00:57:14 -06:00
|
|
|
err = saa7134_alsa_dma_map(dev);
|
2014-04-17 00:48:50 -06:00
|
|
|
if (err) {
|
2005-11-13 17:08:10 -07:00
|
|
|
dsp_buffer_free(dev);
|
|
|
|
return err;
|
|
|
|
}
|
2014-04-17 00:48:50 -06:00
|
|
|
err = saa7134_pgtable_alloc(dev->pci, &dev->dmasound.pt);
|
|
|
|
if (err) {
|
2014-04-17 00:57:14 -06:00
|
|
|
saa7134_alsa_dma_unmap(dev);
|
2005-11-13 17:08:10 -07:00
|
|
|
dsp_buffer_free(dev);
|
|
|
|
return err;
|
|
|
|
}
|
2014-04-17 00:48:50 -06:00
|
|
|
err = saa7134_pgtable_build(dev->pci, &dev->dmasound.pt,
|
|
|
|
dev->dmasound.sglist, dev->dmasound.sglen, 0);
|
|
|
|
if (err) {
|
2005-11-13 17:08:10 -07:00
|
|
|
saa7134_pgtable_free(dev->pci, &dev->dmasound.pt);
|
2014-04-17 00:57:14 -06:00
|
|
|
saa7134_alsa_dma_unmap(dev);
|
2005-11-13 17:08:10 -07:00
|
|
|
dsp_buffer_free(dev);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* I should be able to use runtime->dma_addr in the control
|
|
|
|
byte, but it doesn't work. So I allocate the DMA using the
|
|
|
|
V4L functions, and force ALSA to use that as the DMA area */
|
|
|
|
|
2014-04-17 00:57:14 -06:00
|
|
|
substream->runtime->dma_area = dev->dmasound.vaddr;
|
2007-10-31 08:40:09 -06:00
|
|
|
substream->runtime->dma_bytes = dev->dmasound.bufsize;
|
|
|
|
substream->runtime->dma_addr = 0;
|
2005-11-13 17:08:10 -07:00
|
|
|
|
2007-10-31 08:40:09 -06:00
|
|
|
return 0;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA hardware release
|
|
|
|
*
|
|
|
|
* - One of the ALSA capture callbacks.
|
|
|
|
*
|
|
|
|
* Called after closing the device, but before snd_card_saa7134_capture_close
|
2005-11-13 17:08:10 -07:00
|
|
|
* It stops the DMA audio and releases the buffers.
|
2005-11-08 22:37:14 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_card_saa7134_hw_free(struct snd_pcm_substream * substream)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2005-11-13 17:08:10 -07:00
|
|
|
snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream);
|
|
|
|
struct saa7134_dev *dev;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
dev = saa7134->dev;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
if (substream->runtime->dma_area) {
|
|
|
|
saa7134_pgtable_free(dev->pci, &dev->dmasound.pt);
|
2014-04-17 00:57:14 -06:00
|
|
|
saa7134_alsa_dma_unmap(dev);
|
2005-11-13 17:08:10 -07:00
|
|
|
dsp_buffer_free(dev);
|
|
|
|
substream->runtime->dma_area = NULL;
|
|
|
|
}
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-08 22:37:43 -07:00
|
|
|
return 0;
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA capture finish
|
|
|
|
*
|
|
|
|
* - One of the ALSA capture callbacks.
|
|
|
|
*
|
2005-11-13 17:08:10 -07:00
|
|
|
* Called after closing the device.
|
2005-11-08 22:37:14 -07:00
|
|
|
*
|
|
|
|
*/
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_card_saa7134_capture_close(struct snd_pcm_substream * substream)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2006-09-06 03:25:38 -06:00
|
|
|
snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream);
|
|
|
|
struct saa7134_dev *dev = saa7134->dev;
|
|
|
|
|
2007-06-20 02:36:26 -06:00
|
|
|
if (saa7134->mute_was_on) {
|
|
|
|
dev->ctl_mute = 1;
|
|
|
|
saa7134_tvaudio_setmute(dev);
|
|
|
|
}
|
2005-11-08 22:37:43 -07:00
|
|
|
return 0;
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA capture start
|
|
|
|
*
|
|
|
|
* - One of the ALSA capture callbacks.
|
|
|
|
*
|
|
|
|
* Called when opening the device. It creates and populates the PCM
|
|
|
|
* structure
|
|
|
|
*
|
|
|
|
*/
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_card_saa7134_capture_open(struct snd_pcm_substream * substream)
|
2005-11-08 22:37:14 -07:00
|
|
|
{
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
2005-11-13 17:08:00 -07:00
|
|
|
snd_card_saa7134_pcm_t *pcm;
|
2005-11-08 22:37:43 -07:00
|
|
|
snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream);
|
2008-06-14 06:41:18 -06:00
|
|
|
struct saa7134_dev *dev;
|
2006-11-21 15:59:27 -07:00
|
|
|
int amux, err;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2008-06-14 06:41:18 -06:00
|
|
|
if (!saa7134) {
|
[media] saa7134: instead of using printk KERN_foo, use pr_foo
Replaces all occurrences of printk with KERN_INFO, KERN_WARNING
and KERN_ERR to pr_info/pr_warning, pr_err, using this small
shell script:
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_INFO ','pr_info(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_ERR ','pr_err(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_WARNING ','pr_warn(',g <$i >a && mv a $i; done
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-04-30 03:46:34 -06:00
|
|
|
pr_err("BUG: saa7134 can't find device struct."
|
2008-06-14 06:41:18 -06:00
|
|
|
" Can't proceed with open\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
dev = saa7134->dev;
|
2006-02-07 01:49:14 -07:00
|
|
|
mutex_lock(&dev->dmasound.lock);
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:54 -07:00
|
|
|
dev->dmasound.read_count = 0;
|
|
|
|
dev->dmasound.read_offset = 0;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2006-11-21 15:59:27 -07:00
|
|
|
amux = dev->input->amux;
|
|
|
|
if ((amux < 1) || (amux > 3))
|
|
|
|
amux = 1;
|
|
|
|
dev->dmasound.input = amux - 1;
|
|
|
|
|
2006-02-07 01:49:14 -07:00
|
|
|
mutex_unlock(&dev->dmasound.lock);
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
|
|
|
|
if (pcm == NULL)
|
2005-11-08 22:37:11 -07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
pcm->dev=saa7134->dev;
|
|
|
|
|
|
|
|
spin_lock_init(&pcm->lock);
|
2005-11-08 22:37:11 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
pcm->substream = substream;
|
|
|
|
runtime->private_data = pcm;
|
2005-11-08 22:37:11 -07:00
|
|
|
runtime->private_free = snd_card_saa7134_runtime_free;
|
|
|
|
runtime->hw = snd_card_saa7134_capture;
|
|
|
|
|
2007-06-20 02:36:26 -06:00
|
|
|
if (dev->ctl_mute != 0) {
|
|
|
|
saa7134->mute_was_on = 1;
|
|
|
|
dev->ctl_mute = 0;
|
|
|
|
saa7134_tvaudio_setmute(dev);
|
|
|
|
}
|
2006-09-06 03:25:38 -06:00
|
|
|
|
2007-11-23 14:59:18 -07:00
|
|
|
err = snd_pcm_hw_constraint_integer(runtime,
|
|
|
|
SNDRV_PCM_HW_PARAM_PERIODS);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = snd_pcm_hw_constraint_step(runtime, 0,
|
|
|
|
SNDRV_PCM_HW_PARAM_PERIODS, 2);
|
|
|
|
if (err < 0)
|
2005-11-08 22:37:43 -07:00
|
|
|
return err;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-10-31 08:40:09 -06:00
|
|
|
/*
|
|
|
|
* page callback (needed for mmap)
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct page *snd_card_saa7134_page(struct snd_pcm_substream *substream,
|
|
|
|
unsigned long offset)
|
|
|
|
{
|
|
|
|
void *pageptr = substream->runtime->dma_area + offset;
|
|
|
|
return vmalloc_to_page(pageptr);
|
|
|
|
}
|
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA capture callbacks definition
|
|
|
|
*/
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static struct snd_pcm_ops snd_card_saa7134_capture_ops = {
|
2005-11-08 22:37:11 -07:00
|
|
|
.open = snd_card_saa7134_capture_open,
|
|
|
|
.close = snd_card_saa7134_capture_close,
|
|
|
|
.ioctl = snd_pcm_lib_ioctl,
|
|
|
|
.hw_params = snd_card_saa7134_hw_params,
|
|
|
|
.hw_free = snd_card_saa7134_hw_free,
|
|
|
|
.prepare = snd_card_saa7134_capture_prepare,
|
|
|
|
.trigger = snd_card_saa7134_capture_trigger,
|
|
|
|
.pointer = snd_card_saa7134_capture_pointer,
|
2007-10-31 08:40:09 -06:00
|
|
|
.page = snd_card_saa7134_page,
|
2005-11-08 22:37:04 -07:00
|
|
|
};
|
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA PCM setup
|
|
|
|
*
|
|
|
|
* Called when initializing the board. Sets up the name and hooks up
|
|
|
|
* the callbacks
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int snd_card_saa7134_pcm(snd_card_saa7134_t *saa7134, int device)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_pcm *pcm;
|
2005-11-08 22:37:11 -07:00
|
|
|
int err;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
if ((err = snd_pcm_new(saa7134->card, "SAA7134 PCM", device, 0, 1, &pcm)) < 0)
|
|
|
|
return err;
|
|
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_saa7134_capture_ops);
|
|
|
|
pcm->private_data = saa7134;
|
|
|
|
pcm->info_flags = 0;
|
|
|
|
strcpy(pcm->name, "SAA7134 PCM");
|
|
|
|
return 0;
|
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
#define SAA713x_VOLUME(xname, xindex, addr) \
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
|
|
|
|
.info = snd_saa7134_volume_info, \
|
|
|
|
.get = snd_saa7134_volume_get, .put = snd_saa7134_volume_put, \
|
|
|
|
.private_value = addr }
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_saa7134_volume_info(struct snd_kcontrol * kcontrol,
|
|
|
|
struct snd_ctl_elem_info * uinfo)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
uinfo->count = 2;
|
|
|
|
uinfo->value.integer.min = 0;
|
|
|
|
uinfo->value.integer.max = 20;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_saa7134_volume_get(struct snd_kcontrol * kcontrol,
|
|
|
|
struct snd_ctl_elem_value * ucontrol)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
|
|
|
snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol);
|
|
|
|
int addr = kcontrol->private_value;
|
|
|
|
|
|
|
|
ucontrol->value.integer.value[0] = chip->mixer_volume[addr][0];
|
|
|
|
ucontrol->value.integer.value[1] = chip->mixer_volume[addr][1];
|
|
|
|
return 0;
|
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_saa7134_volume_put(struct snd_kcontrol * kcontrol,
|
|
|
|
struct snd_ctl_elem_value * ucontrol)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2005-11-08 22:37:11 -07:00
|
|
|
snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol);
|
2006-11-21 15:59:27 -07:00
|
|
|
struct saa7134_dev *dev = chip->dev;
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
int change, addr = kcontrol->private_value;
|
|
|
|
int left, right;
|
|
|
|
|
|
|
|
left = ucontrol->value.integer.value[0];
|
|
|
|
if (left < 0)
|
|
|
|
left = 0;
|
|
|
|
if (left > 20)
|
|
|
|
left = 20;
|
|
|
|
right = ucontrol->value.integer.value[1];
|
|
|
|
if (right < 0)
|
|
|
|
right = 0;
|
|
|
|
if (right > 20)
|
|
|
|
right = 20;
|
2005-11-13 17:08:10 -07:00
|
|
|
spin_lock_irq(&chip->mixer_lock);
|
2006-11-21 15:59:27 -07:00
|
|
|
change = 0;
|
|
|
|
if (chip->mixer_volume[addr][0] != left) {
|
|
|
|
change = 1;
|
|
|
|
right = left;
|
|
|
|
}
|
|
|
|
if (chip->mixer_volume[addr][1] != right) {
|
|
|
|
change = 1;
|
|
|
|
left = right;
|
|
|
|
}
|
|
|
|
if (change) {
|
|
|
|
switch (dev->pci->device) {
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7134:
|
|
|
|
switch (addr) {
|
|
|
|
case MIXER_ADDR_TVTUNER:
|
|
|
|
left = 20;
|
|
|
|
break;
|
|
|
|
case MIXER_ADDR_LINE1:
|
|
|
|
saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x10,
|
|
|
|
(left > 10) ? 0x00 : 0x10);
|
|
|
|
break;
|
|
|
|
case MIXER_ADDR_LINE2:
|
|
|
|
saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x20,
|
|
|
|
(left > 10) ? 0x00 : 0x20);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7133:
|
|
|
|
case PCI_DEVICE_ID_PHILIPS_SAA7135:
|
|
|
|
switch (addr) {
|
|
|
|
case MIXER_ADDR_TVTUNER:
|
|
|
|
left = 20;
|
|
|
|
break;
|
|
|
|
case MIXER_ADDR_LINE1:
|
|
|
|
saa_andorb(0x0594, 0x10,
|
|
|
|
(left > 10) ? 0x00 : 0x10);
|
|
|
|
break;
|
|
|
|
case MIXER_ADDR_LINE2:
|
|
|
|
saa_andorb(0x0594, 0x20,
|
|
|
|
(left > 10) ? 0x00 : 0x20);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
chip->mixer_volume[addr][0] = left;
|
|
|
|
chip->mixer_volume[addr][1] = right;
|
|
|
|
}
|
2005-11-13 17:08:10 -07:00
|
|
|
spin_unlock_irq(&chip->mixer_lock);
|
2005-11-08 22:37:11 -07:00
|
|
|
return change;
|
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
#define SAA713x_CAPSRC(xname, xindex, addr) \
|
|
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
|
|
|
|
.info = snd_saa7134_capsrc_info, \
|
|
|
|
.get = snd_saa7134_capsrc_get, .put = snd_saa7134_capsrc_put, \
|
|
|
|
.private_value = addr }
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_saa7134_capsrc_info(struct snd_kcontrol * kcontrol,
|
|
|
|
struct snd_ctl_elem_info * uinfo)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
|
2005-11-08 22:37:14 -07:00
|
|
|
uinfo->count = 2;
|
2005-11-08 22:37:11 -07:00
|
|
|
uinfo->value.integer.min = 0;
|
|
|
|
uinfo->value.integer.max = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_saa7134_capsrc_get(struct snd_kcontrol * kcontrol,
|
|
|
|
struct snd_ctl_elem_value * ucontrol)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
|
|
|
snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol);
|
|
|
|
int addr = kcontrol->private_value;
|
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
spin_lock_irq(&chip->mixer_lock);
|
2009-08-22 12:13:51 -06:00
|
|
|
if (chip->capture_source_addr == addr) {
|
|
|
|
ucontrol->value.integer.value[0] = chip->capture_source[0];
|
|
|
|
ucontrol->value.integer.value[1] = chip->capture_source[1];
|
|
|
|
} else {
|
|
|
|
ucontrol->value.integer.value[0] = 0;
|
|
|
|
ucontrol->value.integer.value[1] = 0;
|
|
|
|
}
|
2005-11-13 17:08:10 -07:00
|
|
|
spin_unlock_irq(&chip->mixer_lock);
|
2005-11-13 17:08:00 -07:00
|
|
|
|
2005-11-08 22:37:04 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static int snd_saa7134_capsrc_put(struct snd_kcontrol * kcontrol,
|
|
|
|
struct snd_ctl_elem_value * ucontrol)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2005-11-08 22:37:11 -07:00
|
|
|
int left, right;
|
|
|
|
left = ucontrol->value.integer.value[0] & 1;
|
|
|
|
right = ucontrol->value.integer.value[1] & 1;
|
|
|
|
|
2009-08-22 12:13:51 -06:00
|
|
|
return snd_saa7134_capsrc_set(kcontrol, left, right, false);
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
|
|
|
|
2009-08-22 12:13:51 -06:00
|
|
|
static struct snd_kcontrol_new snd_saa7134_volume_controls[] = {
|
2005-11-08 22:37:11 -07:00
|
|
|
SAA713x_VOLUME("Video Volume", 0, MIXER_ADDR_TVTUNER),
|
|
|
|
SAA713x_VOLUME("Line Volume", 1, MIXER_ADDR_LINE1),
|
|
|
|
SAA713x_VOLUME("Line Volume", 2, MIXER_ADDR_LINE2),
|
2009-08-22 12:13:51 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct snd_kcontrol_new snd_saa7134_capture_controls[] = {
|
|
|
|
SAA713x_CAPSRC("Video Capture Switch", 0, MIXER_ADDR_TVTUNER),
|
|
|
|
SAA713x_CAPSRC("Line Capture Switch", 1, MIXER_ADDR_LINE1),
|
2005-11-08 22:37:11 -07:00
|
|
|
SAA713x_CAPSRC("Line Capture Switch", 2, MIXER_ADDR_LINE2),
|
|
|
|
};
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA mixer setup
|
|
|
|
*
|
|
|
|
* Called when initializing the board. Sets up the name and hooks up
|
|
|
|
* the callbacks
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int snd_card_saa7134_new_mixer(snd_card_saa7134_t * chip)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_card *card = chip->card;
|
2009-08-22 12:13:51 -06:00
|
|
|
struct snd_kcontrol *kcontrol;
|
2005-11-08 22:37:11 -07:00
|
|
|
unsigned int idx;
|
2009-08-22 12:13:51 -06:00
|
|
|
int err, addr;
|
2005-11-08 22:37:11 -07:00
|
|
|
|
|
|
|
strcpy(card->mixername, "SAA7134 Mixer");
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2009-08-22 12:13:51 -06:00
|
|
|
for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_volume_controls); idx++) {
|
|
|
|
kcontrol = snd_ctl_new1(&snd_saa7134_volume_controls[idx],
|
|
|
|
chip);
|
|
|
|
err = snd_ctl_add(card, kcontrol);
|
|
|
|
if (err < 0)
|
2005-11-08 22:37:11 -07:00
|
|
|
return err;
|
|
|
|
}
|
2009-08-22 12:13:51 -06:00
|
|
|
|
|
|
|
for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_capture_controls); idx++) {
|
|
|
|
kcontrol = snd_ctl_new1(&snd_saa7134_capture_controls[idx],
|
|
|
|
chip);
|
|
|
|
addr = snd_saa7134_capture_controls[idx].private_value;
|
|
|
|
chip->capture_ctl[addr] = kcontrol;
|
|
|
|
err = snd_ctl_add(card, kcontrol);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
chip->capture_source_addr = MIXER_ADDR_UNSELECTED;
|
2005-11-08 22:37:11 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
static void snd_saa7134_free(struct snd_card * card)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2005-11-13 17:08:10 -07:00
|
|
|
snd_card_saa7134_t *chip = card->private_data;
|
2005-11-13 17:07:47 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
if (chip->dev->dmasound.priv_data == NULL)
|
2005-11-13 17:08:10 -07:00
|
|
|
return;
|
2005-11-13 17:08:00 -07:00
|
|
|
|
2008-04-22 05:50:34 -06:00
|
|
|
if (chip->irq >= 0)
|
2005-11-13 17:08:00 -07:00
|
|
|
free_irq(chip->irq, &chip->dev->dmasound);
|
2005-11-13 17:07:47 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
chip->dev->dmasound.priv_data = NULL;
|
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:14 -07:00
|
|
|
/*
|
|
|
|
* ALSA initialization
|
|
|
|
*
|
2005-11-13 17:07:47 -07:00
|
|
|
* Called by the init routine, once for each saa7134 device present,
|
|
|
|
* it creates the basic structures and registers the ALSA devices
|
2005-11-08 22:37:14 -07:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2005-12-01 01:51:35 -07:00
|
|
|
static int alsa_card_saa7134_create(struct saa7134_dev *dev, int devnum)
|
2005-11-08 22:37:11 -07:00
|
|
|
{
|
2005-11-08 22:38:53 -07:00
|
|
|
|
2006-01-13 10:48:06 -07:00
|
|
|
struct snd_card *card;
|
2005-11-08 22:37:14 -07:00
|
|
|
snd_card_saa7134_t *chip;
|
2005-11-08 22:37:11 -07:00
|
|
|
int err;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:38:53 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
if (devnum >= SNDRV_CARDS)
|
2005-11-08 22:37:43 -07:00
|
|
|
return -ENODEV;
|
2005-11-13 17:08:00 -07:00
|
|
|
if (!enable[devnum])
|
2005-11-08 22:37:11 -07:00
|
|
|
return -ENODEV;
|
2005-11-08 22:37:14 -07:00
|
|
|
|
2014-01-29 06:48:43 -07:00
|
|
|
err = snd_card_new(&dev->pci->dev, index[devnum], id[devnum],
|
|
|
|
THIS_MODULE, sizeof(snd_card_saa7134_t), &card);
|
2009-01-12 07:17:09 -07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
strcpy(card->driver, "SAA7134");
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
/* Card "creation" */
|
2005-11-08 22:37:14 -07:00
|
|
|
|
2005-11-13 17:07:47 -07:00
|
|
|
card->private_free = snd_saa7134_free;
|
2010-07-12 14:50:03 -06:00
|
|
|
chip = card->private_data;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:43 -07:00
|
|
|
spin_lock_init(&chip->lock);
|
2005-11-08 22:38:54 -07:00
|
|
|
spin_lock_init(&chip->mixer_lock);
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
chip->dev = dev;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:43 -07:00
|
|
|
chip->card = card;
|
2005-11-08 22:37:14 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
chip->pci = dev->pci;
|
|
|
|
chip->iobase = pci_resource_start(dev->pci, 0);
|
|
|
|
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
err = request_irq(dev->pci->irq, saa7134_alsa_irq,
|
2013-10-12 23:49:29 -06:00
|
|
|
IRQF_SHARED, dev->name,
|
2005-11-13 17:08:00 -07:00
|
|
|
(void*) &dev->dmasound);
|
2005-11-08 22:38:53 -07:00
|
|
|
|
|
|
|
if (err < 0) {
|
[media] saa7134: instead of using printk KERN_foo, use pr_foo
Replaces all occurrences of printk with KERN_INFO, KERN_WARNING
and KERN_ERR to pr_info/pr_warning, pr_err, using this small
shell script:
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_INFO ','pr_info(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_ERR ','pr_err(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_WARNING ','pr_warn(',g <$i >a && mv a $i; done
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-04-30 03:46:34 -06:00
|
|
|
pr_err("%s: can't get IRQ %d for ALSA\n",
|
2005-11-13 17:08:00 -07:00
|
|
|
dev->name, dev->pci->irq);
|
2005-11-08 22:38:54 -07:00
|
|
|
goto __nodev;
|
2005-11-08 22:38:53 -07:00
|
|
|
}
|
|
|
|
|
2005-11-13 17:08:10 -07:00
|
|
|
chip->irq = dev->pci->irq;
|
2005-11-13 17:08:00 -07:00
|
|
|
|
2006-02-07 01:49:14 -07:00
|
|
|
mutex_init(&dev->dmasound.lock);
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
if ((err = snd_card_saa7134_new_mixer(chip)) < 0)
|
|
|
|
goto __nodev;
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
if ((err = snd_card_saa7134_pcm(chip, 0)) < 0)
|
|
|
|
goto __nodev;
|
2005-11-08 22:37:14 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
/* End of "creation" */
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
strcpy(card->shortname, "SAA7134");
|
2005-11-08 22:37:43 -07:00
|
|
|
sprintf(card->longname, "%s at 0x%lx irq %d",
|
2005-11-13 17:08:00 -07:00
|
|
|
chip->dev->name, chip->iobase, chip->irq);
|
2005-11-08 22:37:04 -07:00
|
|
|
|
2015-05-13 11:09:42 -06:00
|
|
|
pr_info("%s/alsa: %s registered as card %d\n",
|
|
|
|
dev->name, card->longname, index[devnum]);
|
2005-12-01 01:51:20 -07:00
|
|
|
|
2005-11-08 22:37:11 -07:00
|
|
|
if ((err = snd_card_register(card)) == 0) {
|
2005-11-13 17:08:00 -07:00
|
|
|
snd_saa7134_cards[devnum] = card;
|
2005-11-08 22:37:11 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
__nodev:
|
|
|
|
snd_card_free(card);
|
|
|
|
return err;
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
|
|
|
|
2005-12-01 01:51:20 -07:00
|
|
|
|
|
|
|
static int alsa_device_init(struct saa7134_dev *dev)
|
|
|
|
{
|
|
|
|
dev->dmasound.priv_data = dev;
|
|
|
|
alsa_card_saa7134_create(dev,dev->nr);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int alsa_device_exit(struct saa7134_dev *dev)
|
|
|
|
{
|
|
|
|
|
|
|
|
snd_card_free(snd_saa7134_cards[dev->nr]);
|
|
|
|
snd_saa7134_cards[dev->nr] = NULL;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-11-08 22:38:53 -07:00
|
|
|
/*
|
|
|
|
* Module initializer
|
|
|
|
*
|
|
|
|
* Loops through present saa7134 cards, and assigns an ALSA device
|
|
|
|
* to each one
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int saa7134_alsa_init(void)
|
|
|
|
{
|
2005-11-13 17:08:00 -07:00
|
|
|
struct saa7134_dev *dev = NULL;
|
2005-11-13 17:07:47 -07:00
|
|
|
struct list_head *list;
|
2005-11-08 22:38:53 -07:00
|
|
|
|
2007-11-21 15:55:52 -07:00
|
|
|
saa7134_dmasound_init = alsa_device_init;
|
|
|
|
saa7134_dmasound_exit = alsa_device_exit;
|
2005-12-20 13:26:26 -07:00
|
|
|
|
[media] saa7134: instead of using printk KERN_foo, use pr_foo
Replaces all occurrences of printk with KERN_INFO, KERN_WARNING
and KERN_ERR to pr_info/pr_warning, pr_err, using this small
shell script:
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_INFO ','pr_info(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_ERR ','pr_err(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_WARNING ','pr_warn(',g <$i >a && mv a $i; done
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-04-30 03:46:34 -06:00
|
|
|
pr_info("saa7134 ALSA driver for DMA sound loaded\n");
|
2005-11-13 17:07:47 -07:00
|
|
|
|
|
|
|
list_for_each(list,&saa7134_devlist) {
|
2005-11-13 17:08:00 -07:00
|
|
|
dev = list_entry(list, struct saa7134_dev, devlist);
|
2009-01-31 04:09:33 -07:00
|
|
|
if (dev->pci->device == PCI_DEVICE_ID_PHILIPS_SAA7130)
|
[media] saa7134: instead of using printk KERN_foo, use pr_foo
Replaces all occurrences of printk with KERN_INFO, KERN_WARNING
and KERN_ERR to pr_info/pr_warning, pr_err, using this small
shell script:
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_INFO ','pr_info(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_ERR ','pr_err(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_WARNING ','pr_warn(',g <$i >a && mv a $i; done
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-04-30 03:46:34 -06:00
|
|
|
pr_info("%s/alsa: %s doesn't support digital audio\n",
|
2009-01-31 04:09:33 -07:00
|
|
|
dev->name, saa7134_boards[dev->board].name);
|
|
|
|
else
|
|
|
|
alsa_device_init(dev);
|
2005-11-13 17:07:47 -07:00
|
|
|
}
|
2005-11-08 22:38:53 -07:00
|
|
|
|
2005-11-13 17:08:00 -07:00
|
|
|
if (dev == NULL)
|
[media] saa7134: instead of using printk KERN_foo, use pr_foo
Replaces all occurrences of printk with KERN_INFO, KERN_WARNING
and KERN_ERR to pr_info/pr_warning, pr_err, using this small
shell script:
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_INFO ','pr_info(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_ERR ','pr_err(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_WARNING ','pr_warn(',g <$i >a && mv a $i; done
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-04-30 03:46:34 -06:00
|
|
|
pr_info("saa7134 ALSA: no saa7134 cards found\n");
|
2005-11-08 22:38:53 -07:00
|
|
|
|
|
|
|
return 0;
|
2005-12-12 01:37:28 -07:00
|
|
|
|
2005-11-08 22:38:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Module destructor
|
|
|
|
*/
|
|
|
|
|
2005-12-01 01:51:35 -07:00
|
|
|
static void saa7134_alsa_exit(void)
|
2005-11-08 22:37:04 -07:00
|
|
|
{
|
2005-11-08 22:37:43 -07:00
|
|
|
int idx;
|
2005-11-08 22:38:54 -07:00
|
|
|
|
2005-11-08 22:38:53 -07:00
|
|
|
for (idx = 0; idx < SNDRV_CARDS; idx++) {
|
2005-11-08 22:37:43 -07:00
|
|
|
snd_card_free(snd_saa7134_cards[idx]);
|
2005-11-08 22:37:11 -07:00
|
|
|
}
|
2005-11-08 22:38:54 -07:00
|
|
|
|
2006-07-15 12:19:56 -06:00
|
|
|
saa7134_dmasound_init = NULL;
|
|
|
|
saa7134_dmasound_exit = NULL;
|
[media] saa7134: instead of using printk KERN_foo, use pr_foo
Replaces all occurrences of printk with KERN_INFO, KERN_WARNING
and KERN_ERR to pr_info/pr_warning, pr_err, using this small
shell script:
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_INFO ','pr_info(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_ERR ','pr_err(',g <$i >a && mv a $i; done
for i in drivers/media/pci/saa7134/*.[ch]; do sed s,'printk(KERN_WARNING ','pr_warn(',g <$i >a && mv a $i; done
Signed-off-by: Mauro Carvalho Chehab <mchehab@osg.samsung.com>
2015-04-30 03:46:34 -06:00
|
|
|
pr_info("saa7134 ALSA driver for DMA sound unloaded\n");
|
2005-11-08 22:38:54 -07:00
|
|
|
|
2005-11-08 22:38:53 -07:00
|
|
|
return;
|
2005-11-08 22:37:04 -07:00
|
|
|
}
|
2005-11-08 22:38:53 -07:00
|
|
|
|
2005-12-21 15:52:32 -07:00
|
|
|
/* We initialize this late, to make sure the sound system is up and running */
|
|
|
|
late_initcall(saa7134_alsa_init);
|
2005-11-08 22:38:53 -07:00
|
|
|
module_exit(saa7134_alsa_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_AUTHOR("Ricardo Cerqueira");
|