2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* bt87x.c - Brooktree Bt878/Bt879 driver for ALSA
|
|
|
|
*
|
|
|
|
* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
|
|
|
|
*
|
|
|
|
* based on btaudio.c by Gerd Knorr <kraxel@bytesex.org>
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* This driver 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; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This driver 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/slab.h>
|
2011-07-15 11:13:37 -06:00
|
|
|
#include <linux/module.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/pcm_params.h>
|
|
|
|
#include <sound/control.h>
|
|
|
|
#include <sound/initval.h>
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
|
|
|
|
MODULE_DESCRIPTION("Brooktree Bt87x audio driver");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_SUPPORTED_DEVICE("{{Brooktree,Bt878},"
|
|
|
|
"{Brooktree,Bt879}}");
|
|
|
|
|
|
|
|
static int index[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = -2}; /* Exclude the first card */
|
|
|
|
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
|
2011-12-14 20:19:36 -07:00
|
|
|
static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
|
2006-05-17 09:14:51 -06:00
|
|
|
static int digital_rate[SNDRV_CARDS]; /* digital input rate */
|
2011-12-14 20:19:36 -07:00
|
|
|
static bool load_all; /* allow to load the non-whitelisted cards */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
module_param_array(index, int, NULL, 0444);
|
|
|
|
MODULE_PARM_DESC(index, "Index value for Bt87x soundcard");
|
|
|
|
module_param_array(id, charp, NULL, 0444);
|
|
|
|
MODULE_PARM_DESC(id, "ID string for Bt87x soundcard");
|
|
|
|
module_param_array(enable, bool, NULL, 0444);
|
|
|
|
MODULE_PARM_DESC(enable, "Enable Bt87x soundcard");
|
|
|
|
module_param_array(digital_rate, int, NULL, 0444);
|
|
|
|
MODULE_PARM_DESC(digital_rate, "Digital input rate for Bt87x soundcard");
|
|
|
|
module_param(load_all, bool, 0444);
|
|
|
|
MODULE_PARM_DESC(load_all, "Allow to load the non-whitelisted cards");
|
|
|
|
|
|
|
|
|
|
|
|
/* register offsets */
|
|
|
|
#define REG_INT_STAT 0x100 /* interrupt status */
|
|
|
|
#define REG_INT_MASK 0x104 /* interrupt mask */
|
|
|
|
#define REG_GPIO_DMA_CTL 0x10c /* audio control */
|
|
|
|
#define REG_PACKET_LEN 0x110 /* audio packet lengths */
|
|
|
|
#define REG_RISC_STRT_ADD 0x114 /* RISC program start address */
|
|
|
|
#define REG_RISC_COUNT 0x120 /* RISC program counter */
|
|
|
|
|
|
|
|
/* interrupt bits */
|
|
|
|
#define INT_OFLOW (1 << 3) /* audio A/D overflow */
|
|
|
|
#define INT_RISCI (1 << 11) /* RISC instruction IRQ bit set */
|
|
|
|
#define INT_FBUS (1 << 12) /* FIFO overrun due to bus access latency */
|
|
|
|
#define INT_FTRGT (1 << 13) /* FIFO overrun due to target latency */
|
|
|
|
#define INT_FDSR (1 << 14) /* FIFO data stream resynchronization */
|
|
|
|
#define INT_PPERR (1 << 15) /* PCI parity error */
|
|
|
|
#define INT_RIPERR (1 << 16) /* RISC instruction parity error */
|
|
|
|
#define INT_PABORT (1 << 17) /* PCI master or target abort */
|
|
|
|
#define INT_OCERR (1 << 18) /* invalid opcode */
|
|
|
|
#define INT_SCERR (1 << 19) /* sync counter overflow */
|
|
|
|
#define INT_RISC_EN (1 << 27) /* DMA controller running */
|
|
|
|
#define INT_RISCS_SHIFT 28 /* RISC status bits */
|
|
|
|
|
|
|
|
/* audio control bits */
|
|
|
|
#define CTL_FIFO_ENABLE (1 << 0) /* enable audio data FIFO */
|
|
|
|
#define CTL_RISC_ENABLE (1 << 1) /* enable audio DMA controller */
|
|
|
|
#define CTL_PKTP_4 (0 << 2) /* packet mode FIFO trigger point - 4 DWORDs */
|
|
|
|
#define CTL_PKTP_8 (1 << 2) /* 8 DWORDs */
|
|
|
|
#define CTL_PKTP_16 (2 << 2) /* 16 DWORDs */
|
|
|
|
#define CTL_ACAP_EN (1 << 4) /* enable audio capture */
|
|
|
|
#define CTL_DA_APP (1 << 5) /* GPIO input */
|
|
|
|
#define CTL_DA_IOM_AFE (0 << 6) /* audio A/D input */
|
|
|
|
#define CTL_DA_IOM_DA (1 << 6) /* digital audio input */
|
|
|
|
#define CTL_DA_SDR_SHIFT 8 /* DDF first stage decimation rate */
|
|
|
|
#define CTL_DA_SDR_MASK (0xf<< 8)
|
|
|
|
#define CTL_DA_LMT (1 << 12) /* limit audio data values */
|
|
|
|
#define CTL_DA_ES2 (1 << 13) /* enable DDF stage 2 */
|
|
|
|
#define CTL_DA_SBR (1 << 14) /* samples rounded to 8 bits */
|
|
|
|
#define CTL_DA_DPM (1 << 15) /* data packet mode */
|
|
|
|
#define CTL_DA_LRD_SHIFT 16 /* ALRCK delay */
|
|
|
|
#define CTL_DA_MLB (1 << 21) /* MSB/LSB format */
|
|
|
|
#define CTL_DA_LRI (1 << 22) /* left/right indication */
|
|
|
|
#define CTL_DA_SCE (1 << 23) /* sample clock edge */
|
|
|
|
#define CTL_A_SEL_STV (0 << 24) /* TV tuner audio input */
|
|
|
|
#define CTL_A_SEL_SFM (1 << 24) /* FM audio input */
|
|
|
|
#define CTL_A_SEL_SML (2 << 24) /* mic/line audio input */
|
|
|
|
#define CTL_A_SEL_SMXC (3 << 24) /* MUX bypass */
|
|
|
|
#define CTL_A_SEL_SHIFT 24
|
|
|
|
#define CTL_A_SEL_MASK (3 << 24)
|
|
|
|
#define CTL_A_PWRDN (1 << 26) /* analog audio power-down */
|
|
|
|
#define CTL_A_G2X (1 << 27) /* audio gain boost */
|
|
|
|
#define CTL_A_GAIN_SHIFT 28 /* audio input gain */
|
|
|
|
#define CTL_A_GAIN_MASK (0xf<<28)
|
|
|
|
|
|
|
|
/* RISC instruction opcodes */
|
|
|
|
#define RISC_WRITE (0x1 << 28) /* write FIFO data to memory at address */
|
|
|
|
#define RISC_WRITEC (0x5 << 28) /* write FIFO data to memory at current address */
|
|
|
|
#define RISC_SKIP (0x2 << 28) /* skip FIFO data */
|
|
|
|
#define RISC_JUMP (0x7 << 28) /* jump to address */
|
|
|
|
#define RISC_SYNC (0x8 << 28) /* synchronize with FIFO */
|
|
|
|
|
|
|
|
/* RISC instruction bits */
|
|
|
|
#define RISC_BYTES_ENABLE (0xf << 12) /* byte enable bits */
|
|
|
|
#define RISC_RESYNC ( 1 << 15) /* disable FDSR errors */
|
|
|
|
#define RISC_SET_STATUS_SHIFT 16 /* set status bits */
|
|
|
|
#define RISC_RESET_STATUS_SHIFT 20 /* clear status bits */
|
|
|
|
#define RISC_IRQ ( 1 << 24) /* interrupt */
|
|
|
|
#define RISC_EOL ( 1 << 26) /* end of line */
|
|
|
|
#define RISC_SOL ( 1 << 27) /* start of line */
|
|
|
|
|
|
|
|
/* SYNC status bits values */
|
|
|
|
#define RISC_SYNC_FM1 0x6
|
|
|
|
#define RISC_SYNC_VRO 0xc
|
|
|
|
|
|
|
|
#define ANALOG_CLOCK 1792000
|
|
|
|
#ifdef CONFIG_SND_BT87X_OVERCLOCK
|
|
|
|
#define CLOCK_DIV_MIN 1
|
|
|
|
#else
|
|
|
|
#define CLOCK_DIV_MIN 4
|
|
|
|
#endif
|
|
|
|
#define CLOCK_DIV_MAX 15
|
|
|
|
|
|
|
|
#define ERROR_INTERRUPTS (INT_FBUS | INT_FTRGT | INT_PPERR | \
|
|
|
|
INT_RIPERR | INT_PABORT | INT_OCERR)
|
|
|
|
#define MY_INTERRUPTS (INT_RISCI | ERROR_INTERRUPTS)
|
|
|
|
|
|
|
|
/* SYNC, one WRITE per line, one extra WRITE per page boundary, SYNC, JUMP */
|
|
|
|
#define MAX_RISC_SIZE ((1 + 255 + (PAGE_ALIGN(255 * 4092) / PAGE_SIZE - 1) + 1 + 1) * 8)
|
|
|
|
|
2007-09-06 07:06:44 -06:00
|
|
|
/* Cards with configuration information */
|
|
|
|
enum snd_bt87x_boardid {
|
2007-09-17 01:33:37 -06:00
|
|
|
SND_BT87X_BOARD_UNKNOWN,
|
2007-09-06 07:06:44 -06:00
|
|
|
SND_BT87X_BOARD_GENERIC, /* both an & dig interfaces, 32kHz */
|
|
|
|
SND_BT87X_BOARD_ANALOG, /* board with no external A/D */
|
|
|
|
SND_BT87X_BOARD_OSPREY2x0,
|
|
|
|
SND_BT87X_BOARD_OSPREY440,
|
|
|
|
SND_BT87X_BOARD_AVPHONE98,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Card configuration */
|
|
|
|
struct snd_bt87x_board {
|
|
|
|
int dig_rate; /* Digital input sampling rate */
|
|
|
|
u32 digital_fmt; /* Register settings for digital input */
|
|
|
|
unsigned no_analog:1; /* No analog input */
|
|
|
|
unsigned no_digital:1; /* No digital input */
|
|
|
|
};
|
|
|
|
|
2012-12-06 10:35:19 -07:00
|
|
|
static struct snd_bt87x_board snd_bt87x_boards[] = {
|
2007-09-17 01:33:37 -06:00
|
|
|
[SND_BT87X_BOARD_UNKNOWN] = {
|
|
|
|
.dig_rate = 32000, /* just a guess */
|
|
|
|
},
|
2007-09-06 07:06:44 -06:00
|
|
|
[SND_BT87X_BOARD_GENERIC] = {
|
|
|
|
.dig_rate = 32000,
|
|
|
|
},
|
|
|
|
[SND_BT87X_BOARD_ANALOG] = {
|
|
|
|
.no_digital = 1,
|
|
|
|
},
|
|
|
|
[SND_BT87X_BOARD_OSPREY2x0] = {
|
|
|
|
.dig_rate = 44100,
|
|
|
|
.digital_fmt = CTL_DA_LRI | (1 << CTL_DA_LRD_SHIFT),
|
|
|
|
},
|
|
|
|
[SND_BT87X_BOARD_OSPREY440] = {
|
|
|
|
.dig_rate = 32000,
|
|
|
|
.digital_fmt = CTL_DA_LRI | (1 << CTL_DA_LRD_SHIFT),
|
|
|
|
.no_analog = 1,
|
|
|
|
},
|
|
|
|
[SND_BT87X_BOARD_AVPHONE98] = {
|
|
|
|
.dig_rate = 48000,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct snd_bt87x {
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_card *card;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct pci_dev *pci;
|
2007-09-06 07:06:44 -06:00
|
|
|
struct snd_bt87x_board board;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
void __iomem *mmio;
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
spinlock_t reg_lock;
|
2007-10-14 12:35:20 -06:00
|
|
|
unsigned long opened;
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_pcm_substream *substream;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct snd_dma_buffer dma_risc;
|
|
|
|
unsigned int line_bytes;
|
|
|
|
unsigned int lines;
|
|
|
|
|
|
|
|
u32 reg_control;
|
|
|
|
u32 interrupt_mask;
|
|
|
|
|
|
|
|
int current_line;
|
|
|
|
|
|
|
|
int pci_parity_errors;
|
|
|
|
};
|
|
|
|
|
|
|
|
enum { DEVICE_DIGITAL, DEVICE_ANALOG };
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static inline u32 snd_bt87x_readl(struct snd_bt87x *chip, u32 reg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
return readl(chip->mmio + reg);
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static inline void snd_bt87x_writel(struct snd_bt87x *chip, u32 reg, u32 value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
writel(value, chip->mmio + reg);
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_create_risc(struct snd_bt87x *chip, struct snd_pcm_substream *substream,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int periods, unsigned int period_bytes)
|
|
|
|
{
|
|
|
|
unsigned int i, offset;
|
|
|
|
u32 *risc;
|
|
|
|
|
|
|
|
if (chip->dma_risc.area == NULL) {
|
|
|
|
if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
|
|
|
|
PAGE_ALIGN(MAX_RISC_SIZE), &chip->dma_risc) < 0)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
risc = (u32 *)chip->dma_risc.area;
|
|
|
|
offset = 0;
|
|
|
|
*risc++ = cpu_to_le32(RISC_SYNC | RISC_SYNC_FM1);
|
|
|
|
*risc++ = cpu_to_le32(0);
|
|
|
|
for (i = 0; i < periods; ++i) {
|
|
|
|
u32 rest;
|
|
|
|
|
|
|
|
rest = period_bytes;
|
|
|
|
do {
|
|
|
|
u32 cmd, len;
|
2008-08-21 05:00:13 -06:00
|
|
|
unsigned int addr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
len = PAGE_SIZE - (offset % PAGE_SIZE);
|
|
|
|
if (len > rest)
|
|
|
|
len = rest;
|
|
|
|
cmd = RISC_WRITE | len;
|
|
|
|
if (rest == period_bytes) {
|
|
|
|
u32 block = i * 16 / periods;
|
|
|
|
cmd |= RISC_SOL;
|
|
|
|
cmd |= block << RISC_SET_STATUS_SHIFT;
|
|
|
|
cmd |= (~block & 0xf) << RISC_RESET_STATUS_SHIFT;
|
|
|
|
}
|
|
|
|
if (len == rest)
|
|
|
|
cmd |= RISC_EOL | RISC_IRQ;
|
|
|
|
*risc++ = cpu_to_le32(cmd);
|
2008-08-21 05:00:13 -06:00
|
|
|
addr = snd_pcm_sgbuf_get_addr(substream, offset);
|
|
|
|
*risc++ = cpu_to_le32(addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
offset += len;
|
|
|
|
rest -= len;
|
|
|
|
} while (rest > 0);
|
|
|
|
}
|
|
|
|
*risc++ = cpu_to_le32(RISC_SYNC | RISC_SYNC_VRO);
|
|
|
|
*risc++ = cpu_to_le32(0);
|
|
|
|
*risc++ = cpu_to_le32(RISC_JUMP);
|
|
|
|
*risc++ = cpu_to_le32(chip->dma_risc.addr);
|
|
|
|
chip->line_bytes = period_bytes;
|
|
|
|
chip->lines = periods;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static void snd_bt87x_free_risc(struct snd_bt87x *chip)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (chip->dma_risc.area) {
|
|
|
|
snd_dma_free_pages(&chip->dma_risc);
|
|
|
|
chip->dma_risc.area = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static void snd_bt87x_pci_error(struct snd_bt87x *chip, unsigned int status)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
u16 pci_status;
|
|
|
|
|
|
|
|
pci_read_config_word(chip->pci, PCI_STATUS, &pci_status);
|
|
|
|
pci_status &= PCI_STATUS_PARITY | PCI_STATUS_SIG_TARGET_ABORT |
|
|
|
|
PCI_STATUS_REC_TARGET_ABORT | PCI_STATUS_REC_MASTER_ABORT |
|
|
|
|
PCI_STATUS_SIG_SYSTEM_ERROR | PCI_STATUS_DETECTED_PARITY;
|
|
|
|
pci_write_config_word(chip->pci, PCI_STATUS, pci_status);
|
|
|
|
if (pci_status != PCI_STATUS_DETECTED_PARITY)
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_err(chip->card->dev,
|
|
|
|
"Aieee - PCI error! status %#08x, PCI status %#04x\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
status & ERROR_INTERRUPTS, pci_status);
|
|
|
|
else {
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_err(chip->card->dev,
|
|
|
|
"Aieee - PCI parity error detected!\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
/* error 'handling' similar to aic7xxx_pci.c: */
|
|
|
|
chip->pci_parity_errors++;
|
|
|
|
if (chip->pci_parity_errors > 20) {
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_err(chip->card->dev,
|
|
|
|
"Too many PCI parity errors observed.\n");
|
|
|
|
dev_err(chip->card->dev,
|
|
|
|
"Some device on this bus is generating bad parity.\n");
|
|
|
|
dev_err(chip->card->dev,
|
|
|
|
"This is an error *observed by*, not *generated by*, this card.\n");
|
|
|
|
dev_err(chip->card->dev,
|
|
|
|
"PCI parity error checking has been disabled.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
chip->interrupt_mask &= ~(INT_PPERR | INT_RIPERR);
|
|
|
|
snd_bt87x_writel(chip, REG_INT_MASK, chip->interrupt_mask);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 snd_bt87x_interrupt(int irq, void *dev_id)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = dev_id;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int status, irq_status;
|
|
|
|
|
|
|
|
status = snd_bt87x_readl(chip, REG_INT_STAT);
|
|
|
|
irq_status = status & chip->interrupt_mask;
|
|
|
|
if (!irq_status)
|
|
|
|
return IRQ_NONE;
|
|
|
|
snd_bt87x_writel(chip, REG_INT_STAT, irq_status);
|
|
|
|
|
|
|
|
if (irq_status & ERROR_INTERRUPTS) {
|
|
|
|
if (irq_status & (INT_FBUS | INT_FTRGT))
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_warn(chip->card->dev,
|
|
|
|
"FIFO overrun, status %#08x\n", status);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (irq_status & INT_OCERR)
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_err(chip->card->dev,
|
|
|
|
"internal RISC error, status %#08x\n", status);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (irq_status & (INT_PPERR | INT_RIPERR | INT_PABORT))
|
|
|
|
snd_bt87x_pci_error(chip, irq_status);
|
|
|
|
}
|
|
|
|
if ((irq_status & INT_RISCI) && (chip->reg_control & CTL_ACAP_EN)) {
|
|
|
|
int current_block, irq_block;
|
|
|
|
|
|
|
|
/* assume that exactly one line has been recorded */
|
|
|
|
chip->current_line = (chip->current_line + 1) % chip->lines;
|
|
|
|
/* but check if some interrupts have been skipped */
|
|
|
|
current_block = chip->current_line * 16 / chip->lines;
|
|
|
|
irq_block = status >> INT_RISCS_SHIFT;
|
|
|
|
if (current_block != irq_block)
|
|
|
|
chip->current_line = (irq_block * chip->lines + 15) / 16;
|
|
|
|
|
|
|
|
snd_pcm_period_elapsed(chip->substream);
|
|
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_pcm_hardware snd_bt87x_digital_hw = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.info = SNDRV_PCM_INFO_MMAP |
|
|
|
|
SNDRV_PCM_INFO_INTERLEAVED |
|
|
|
|
SNDRV_PCM_INFO_BLOCK_TRANSFER |
|
2009-04-28 04:25:59 -06:00
|
|
|
SNDRV_PCM_INFO_MMAP_VALID |
|
|
|
|
SNDRV_PCM_INFO_BATCH,
|
2005-04-16 16:20:36 -06:00
|
|
|
.formats = SNDRV_PCM_FMTBIT_S16_LE,
|
|
|
|
.rates = 0, /* set at runtime */
|
|
|
|
.channels_min = 2,
|
|
|
|
.channels_max = 2,
|
|
|
|
.buffer_bytes_max = 255 * 4092,
|
|
|
|
.period_bytes_min = 32,
|
|
|
|
.period_bytes_max = 4092,
|
|
|
|
.periods_min = 2,
|
|
|
|
.periods_max = 255,
|
|
|
|
};
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_pcm_hardware snd_bt87x_analog_hw = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.info = SNDRV_PCM_INFO_MMAP |
|
|
|
|
SNDRV_PCM_INFO_INTERLEAVED |
|
|
|
|
SNDRV_PCM_INFO_BLOCK_TRANSFER |
|
2009-04-28 04:25:59 -06:00
|
|
|
SNDRV_PCM_INFO_MMAP_VALID |
|
|
|
|
SNDRV_PCM_INFO_BATCH,
|
2005-04-16 16:20:36 -06:00
|
|
|
.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
|
|
|
|
.rates = SNDRV_PCM_RATE_KNOT,
|
|
|
|
.rate_min = ANALOG_CLOCK / CLOCK_DIV_MAX,
|
|
|
|
.rate_max = ANALOG_CLOCK / CLOCK_DIV_MIN,
|
|
|
|
.channels_min = 1,
|
|
|
|
.channels_max = 1,
|
|
|
|
.buffer_bytes_max = 255 * 4092,
|
|
|
|
.period_bytes_min = 32,
|
|
|
|
.period_bytes_max = 4092,
|
|
|
|
.periods_min = 2,
|
|
|
|
.periods_max = 255,
|
|
|
|
};
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_set_digital_hw(struct snd_bt87x *chip, struct snd_pcm_runtime *runtime)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-09-07 05:18:50 -06:00
|
|
|
chip->reg_control |= CTL_DA_IOM_DA | CTL_A_PWRDN;
|
2005-04-16 16:20:36 -06:00
|
|
|
runtime->hw = snd_bt87x_digital_hw;
|
2007-09-06 07:06:44 -06:00
|
|
|
runtime->hw.rates = snd_pcm_rate_to_rate_bit(chip->board.dig_rate);
|
|
|
|
runtime->hw.rate_min = chip->board.dig_rate;
|
|
|
|
runtime->hw.rate_max = chip->board.dig_rate;
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_set_analog_hw(struct snd_bt87x *chip, struct snd_pcm_runtime *runtime)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_ratnum analog_clock = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.num = ANALOG_CLOCK,
|
|
|
|
.den_min = CLOCK_DIV_MIN,
|
|
|
|
.den_max = CLOCK_DIV_MAX,
|
|
|
|
.den_step = 1
|
|
|
|
};
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_pcm_hw_constraint_ratnums constraint_rates = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.nrats = 1,
|
|
|
|
.rats = &analog_clock
|
|
|
|
};
|
|
|
|
|
2007-09-07 05:18:50 -06:00
|
|
|
chip->reg_control &= ~(CTL_DA_IOM_DA | CTL_A_PWRDN);
|
2005-04-16 16:20:36 -06:00
|
|
|
runtime->hw = snd_bt87x_analog_hw;
|
|
|
|
return snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
|
|
|
|
&constraint_rates);
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_pcm_open(struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_pcm_substream_chip(substream);
|
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (test_and_set_bit(0, &chip->opened))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
if (substream->pcm->device == DEVICE_DIGITAL)
|
|
|
|
err = snd_bt87x_set_digital_hw(chip, runtime);
|
|
|
|
else
|
|
|
|
err = snd_bt87x_set_analog_hw(chip, runtime);
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
|
|
|
|
err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
|
|
|
|
chip->substream = substream;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
_error:
|
|
|
|
clear_bit(0, &chip->opened);
|
2014-03-17 11:06:10 -06:00
|
|
|
smp_mb__after_atomic();
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_close(struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_pcm_substream_chip(substream);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-07 05:18:50 -06:00
|
|
|
spin_lock_irq(&chip->reg_lock);
|
|
|
|
chip->reg_control |= CTL_A_PWRDN;
|
|
|
|
snd_bt87x_writel(chip, REG_GPIO_DMA_CTL, chip->reg_control);
|
|
|
|
spin_unlock_irq(&chip->reg_lock);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
chip->substream = NULL;
|
|
|
|
clear_bit(0, &chip->opened);
|
2014-03-17 11:06:10 -06:00
|
|
|
smp_mb__after_atomic();
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_hw_params(struct snd_pcm_substream *substream,
|
|
|
|
struct snd_pcm_hw_params *hw_params)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_pcm_substream_chip(substream);
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = snd_pcm_lib_malloc_pages(substream,
|
|
|
|
params_buffer_bytes(hw_params));
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
return snd_bt87x_create_risc(chip, substream,
|
|
|
|
params_periods(hw_params),
|
|
|
|
params_period_bytes(hw_params));
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_hw_free(struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_pcm_substream_chip(substream);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
snd_bt87x_free_risc(chip);
|
|
|
|
snd_pcm_lib_free_pages(substream);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_prepare(struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_pcm_substream_chip(substream);
|
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
2005-04-16 16:20:36 -06:00
|
|
|
int decimation;
|
|
|
|
|
|
|
|
spin_lock_irq(&chip->reg_lock);
|
|
|
|
chip->reg_control &= ~(CTL_DA_SDR_MASK | CTL_DA_SBR);
|
|
|
|
decimation = (ANALOG_CLOCK + runtime->rate / 4) / runtime->rate;
|
|
|
|
chip->reg_control |= decimation << CTL_DA_SDR_SHIFT;
|
|
|
|
if (runtime->format == SNDRV_PCM_FORMAT_S8)
|
|
|
|
chip->reg_control |= CTL_DA_SBR;
|
|
|
|
snd_bt87x_writel(chip, REG_GPIO_DMA_CTL, chip->reg_control);
|
|
|
|
spin_unlock_irq(&chip->reg_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_start(struct snd_bt87x *chip)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
spin_lock(&chip->reg_lock);
|
|
|
|
chip->current_line = 0;
|
|
|
|
chip->reg_control |= CTL_FIFO_ENABLE | CTL_RISC_ENABLE | CTL_ACAP_EN;
|
|
|
|
snd_bt87x_writel(chip, REG_RISC_STRT_ADD, chip->dma_risc.addr);
|
|
|
|
snd_bt87x_writel(chip, REG_PACKET_LEN,
|
|
|
|
chip->line_bytes | (chip->lines << 16));
|
|
|
|
snd_bt87x_writel(chip, REG_INT_MASK, chip->interrupt_mask);
|
|
|
|
snd_bt87x_writel(chip, REG_GPIO_DMA_CTL, chip->reg_control);
|
|
|
|
spin_unlock(&chip->reg_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_stop(struct snd_bt87x *chip)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
spin_lock(&chip->reg_lock);
|
|
|
|
chip->reg_control &= ~(CTL_FIFO_ENABLE | CTL_RISC_ENABLE | CTL_ACAP_EN);
|
|
|
|
snd_bt87x_writel(chip, REG_GPIO_DMA_CTL, chip->reg_control);
|
|
|
|
snd_bt87x_writel(chip, REG_INT_MASK, 0);
|
|
|
|
snd_bt87x_writel(chip, REG_INT_STAT, MY_INTERRUPTS);
|
|
|
|
spin_unlock(&chip->reg_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_trigger(struct snd_pcm_substream *substream, int cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_pcm_substream_chip(substream);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case SNDRV_PCM_TRIGGER_START:
|
|
|
|
return snd_bt87x_start(chip);
|
|
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
|
|
return snd_bt87x_stop(chip);
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static snd_pcm_uframes_t snd_bt87x_pointer(struct snd_pcm_substream *substream)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_pcm_substream_chip(substream);
|
|
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return (snd_pcm_uframes_t)bytes_to_frames(runtime, chip->current_line * chip->line_bytes);
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_pcm_ops snd_bt87x_pcm_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.open = snd_bt87x_pcm_open,
|
|
|
|
.close = snd_bt87x_close,
|
|
|
|
.ioctl = snd_pcm_lib_ioctl,
|
|
|
|
.hw_params = snd_bt87x_hw_params,
|
|
|
|
.hw_free = snd_bt87x_hw_free,
|
|
|
|
.prepare = snd_bt87x_prepare,
|
|
|
|
.trigger = snd_bt87x_trigger,
|
|
|
|
.pointer = snd_bt87x_pointer,
|
|
|
|
.page = snd_pcm_sgbuf_ops_page,
|
|
|
|
};
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_capture_volume_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *info)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
|
|
info->count = 1;
|
|
|
|
info->value.integer.min = 0;
|
|
|
|
info->value.integer.max = 15;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_capture_volume_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
value->value.integer.value[0] = (chip->reg_control & CTL_A_GAIN_MASK) >> CTL_A_GAIN_SHIFT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_capture_volume_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 old_control;
|
|
|
|
int changed;
|
|
|
|
|
|
|
|
spin_lock_irq(&chip->reg_lock);
|
|
|
|
old_control = chip->reg_control;
|
|
|
|
chip->reg_control = (chip->reg_control & ~CTL_A_GAIN_MASK)
|
|
|
|
| (value->value.integer.value[0] << CTL_A_GAIN_SHIFT);
|
|
|
|
snd_bt87x_writel(chip, REG_GPIO_DMA_CTL, chip->reg_control);
|
|
|
|
changed = old_control != chip->reg_control;
|
|
|
|
spin_unlock_irq(&chip->reg_lock);
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_kcontrol_new snd_bt87x_capture_volume = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Capture Volume",
|
|
|
|
.info = snd_bt87x_capture_volume_info,
|
|
|
|
.get = snd_bt87x_capture_volume_get,
|
|
|
|
.put = snd_bt87x_capture_volume_put,
|
|
|
|
};
|
|
|
|
|
2007-07-23 07:42:26 -06:00
|
|
|
#define snd_bt87x_capture_boost_info snd_ctl_boolean_mono_info
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_capture_boost_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
value->value.integer.value[0] = !! (chip->reg_control & CTL_A_G2X);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_capture_boost_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 old_control;
|
|
|
|
int changed;
|
|
|
|
|
|
|
|
spin_lock_irq(&chip->reg_lock);
|
|
|
|
old_control = chip->reg_control;
|
|
|
|
chip->reg_control = (chip->reg_control & ~CTL_A_G2X)
|
|
|
|
| (value->value.integer.value[0] ? CTL_A_G2X : 0);
|
|
|
|
snd_bt87x_writel(chip, REG_GPIO_DMA_CTL, chip->reg_control);
|
|
|
|
changed = chip->reg_control != old_control;
|
|
|
|
spin_unlock_irq(&chip->reg_lock);
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_kcontrol_new snd_bt87x_capture_boost = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Capture Boost",
|
|
|
|
.info = snd_bt87x_capture_boost_info,
|
|
|
|
.get = snd_bt87x_capture_boost_get,
|
|
|
|
.put = snd_bt87x_capture_boost_put,
|
|
|
|
};
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_capture_source_info(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_info *info)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-01-10 08:27:26 -07:00
|
|
|
static const char *const texts[3] = {"TV Tuner", "FM", "Mic/Line"};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-01-10 08:27:26 -07:00
|
|
|
return snd_ctl_enum_info(info, 1, 3, texts);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_capture_source_get(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
value->value.enumerated.item[0] = (chip->reg_control & CTL_A_SEL_MASK) >> CTL_A_SEL_SHIFT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_capture_source_put(struct snd_kcontrol *kcontrol,
|
|
|
|
struct snd_ctl_elem_value *value)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = snd_kcontrol_chip(kcontrol);
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 old_control;
|
|
|
|
int changed;
|
|
|
|
|
|
|
|
spin_lock_irq(&chip->reg_lock);
|
|
|
|
old_control = chip->reg_control;
|
|
|
|
chip->reg_control = (chip->reg_control & ~CTL_A_SEL_MASK)
|
|
|
|
| (value->value.enumerated.item[0] << CTL_A_SEL_SHIFT);
|
|
|
|
snd_bt87x_writel(chip, REG_GPIO_DMA_CTL, chip->reg_control);
|
|
|
|
changed = chip->reg_control != old_control;
|
|
|
|
spin_unlock_irq(&chip->reg_lock);
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_kcontrol_new snd_bt87x_capture_source = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
|
|
.name = "Capture Source",
|
|
|
|
.info = snd_bt87x_capture_source_info,
|
|
|
|
.get = snd_bt87x_capture_source_get,
|
|
|
|
.put = snd_bt87x_capture_source_put,
|
|
|
|
};
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_free(struct snd_bt87x *chip)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-22 10:47:44 -07:00
|
|
|
if (chip->mmio)
|
2005-04-16 16:20:36 -06:00
|
|
|
snd_bt87x_stop(chip);
|
|
|
|
if (chip->irq >= 0)
|
|
|
|
free_irq(chip->irq, chip);
|
2008-02-22 10:47:44 -07:00
|
|
|
if (chip->mmio)
|
|
|
|
iounmap(chip->mmio);
|
2005-04-16 16:20:36 -06:00
|
|
|
pci_release_regions(chip->pci);
|
|
|
|
pci_disable_device(chip->pci);
|
|
|
|
kfree(chip);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-17 07:02:58 -07:00
|
|
|
static int snd_bt87x_dev_free(struct snd_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip = device->device_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
return snd_bt87x_free(chip);
|
|
|
|
}
|
|
|
|
|
2012-12-06 10:35:19 -07:00
|
|
|
static int snd_bt87x_pcm(struct snd_bt87x *chip, int device, char *name)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int err;
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_pcm *pcm;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
err = snd_pcm_new(chip->card, name, device, 0, 1, &pcm);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
pcm->private_data = chip;
|
|
|
|
strcpy(pcm->name, name);
|
|
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_bt87x_pcm_ops);
|
|
|
|
return snd_pcm_lib_preallocate_pages_for_all(pcm,
|
|
|
|
SNDRV_DMA_TYPE_DEV_SG,
|
|
|
|
snd_dma_pci_data(chip->pci),
|
|
|
|
128 * 1024,
|
2006-10-09 00:13:32 -06:00
|
|
|
ALIGN(255 * 4092, 1024));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-12-06 10:35:19 -07:00
|
|
|
static int snd_bt87x_create(struct snd_card *card,
|
|
|
|
struct pci_dev *pci,
|
|
|
|
struct snd_bt87x **rchip)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_bt87x *chip;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
2005-11-17 07:02:58 -07:00
|
|
|
static struct snd_device_ops ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.dev_free = snd_bt87x_dev_free
|
|
|
|
};
|
|
|
|
|
|
|
|
*rchip = NULL;
|
|
|
|
|
|
|
|
err = pci_enable_device(pci);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
[ALSA] Replace with kzalloc() - pci stuff
AD1889 driver,ATIIXP driver,ATIIXP-modem driver,AZT3328 driver
BT87x driver,CMIPCI driver,CS4281 driver,ENS1370/1+ driver
ES1938 driver,ES1968 driver,FM801 driver,Intel8x0 driver
Intel8x0-modem driver,Maestro3 driver,SonicVibes driver,VIA82xx driver
VIA82xx-modem driver,AC97 Codec,AK4531 codec,au88x0 driver
CA0106 driver,CS46xx driver,EMU10K1/EMU10K2 driver,HDA Codec driver
HDA generic driver,HDA Intel driver,ICE1712 driver,ICE1724 driver
KORG1212 driver,MIXART driver,NM256 driver,Trident driver,YMFPCI driver
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 06:21:46 -06:00
|
|
|
chip = kzalloc(sizeof(*chip), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!chip) {
|
|
|
|
pci_disable_device(pci);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
chip->card = card;
|
|
|
|
chip->pci = pci;
|
|
|
|
chip->irq = -1;
|
|
|
|
spin_lock_init(&chip->reg_lock);
|
|
|
|
|
|
|
|
if ((err = pci_request_regions(pci, "Bt87x audio")) < 0) {
|
|
|
|
kfree(chip);
|
|
|
|
pci_disable_device(pci);
|
|
|
|
return err;
|
|
|
|
}
|
2008-09-28 17:20:09 -06:00
|
|
|
chip->mmio = pci_ioremap_bar(pci, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!chip->mmio) {
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_err(card->dev, "cannot remap io memory\n");
|
2007-09-06 07:06:44 -06:00
|
|
|
err = -ENOMEM;
|
|
|
|
goto fail;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-09-07 05:18:50 -06:00
|
|
|
chip->reg_control = CTL_A_PWRDN | CTL_DA_ES2 |
|
|
|
|
CTL_PKTP_16 | (15 << CTL_DA_SDR_SHIFT);
|
2005-04-16 16:20:36 -06:00
|
|
|
chip->interrupt_mask = MY_INTERRUPTS;
|
|
|
|
snd_bt87x_writel(chip, REG_GPIO_DMA_CTL, chip->reg_control);
|
|
|
|
snd_bt87x_writel(chip, REG_INT_MASK, 0);
|
|
|
|
snd_bt87x_writel(chip, REG_INT_STAT, MY_INTERRUPTS);
|
|
|
|
|
2007-09-06 07:06:44 -06:00
|
|
|
err = request_irq(pci->irq, snd_bt87x_interrupt, IRQF_SHARED,
|
2011-06-10 08:36:37 -06:00
|
|
|
KBUILD_MODNAME, chip);
|
2007-09-06 07:06:44 -06:00
|
|
|
if (err < 0) {
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_err(card->dev, "cannot grab irq %d\n", pci->irq);
|
2007-09-06 07:06:44 -06:00
|
|
|
goto fail;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
chip->irq = pci->irq;
|
|
|
|
pci_set_master(pci);
|
|
|
|
synchronize_irq(chip->irq);
|
|
|
|
|
|
|
|
err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
|
2007-09-06 07:06:44 -06:00
|
|
|
if (err < 0)
|
|
|
|
goto fail;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
*rchip = chip;
|
|
|
|
return 0;
|
2007-09-06 07:06:44 -06:00
|
|
|
|
|
|
|
fail:
|
|
|
|
snd_bt87x_free(chip);
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-09-06 07:06:44 -06:00
|
|
|
#define BT_DEVICE(chip, subvend, subdev, id) \
|
2005-04-16 16:20:36 -06:00
|
|
|
{ .vendor = PCI_VENDOR_ID_BROOKTREE, \
|
2005-09-28 18:40:52 -06:00
|
|
|
.device = chip, \
|
2005-04-16 16:20:36 -06:00
|
|
|
.subvendor = subvend, .subdevice = subdev, \
|
2007-09-06 07:06:44 -06:00
|
|
|
.driver_data = SND_BT87X_BOARD_ ## id }
|
|
|
|
/* driver_data is the card id for that device */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-08-08 07:56:03 -06:00
|
|
|
static const struct pci_device_id snd_bt87x_ids[] = {
|
2005-09-28 18:40:52 -06:00
|
|
|
/* Hauppauge WinTV series */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x0070, 0x13eb, GENERIC),
|
2005-09-28 18:40:52 -06:00
|
|
|
/* Hauppauge WinTV series */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_879, 0x0070, 0x13eb, GENERIC),
|
2005-09-28 18:40:52 -06:00
|
|
|
/* Viewcast Osprey 200 */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x0070, 0xff01, OSPREY2x0),
|
2007-07-21 18:26:40 -06:00
|
|
|
/* Viewcast Osprey 440 (rate is configurable via gpio) */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x0070, 0xff07, OSPREY440),
|
2007-02-22 05:31:08 -07:00
|
|
|
/* ATI TV-Wonder */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x1002, 0x0001, GENERIC),
|
2006-02-08 01:10:36 -07:00
|
|
|
/* Leadtek Winfast tv 2000xp delux */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x107d, 0x6606, GENERIC),
|
2009-10-13 01:34:28 -06:00
|
|
|
/* Pinnacle PCTV */
|
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x11bd, 0x0012, GENERIC),
|
2006-06-01 00:33:48 -06:00
|
|
|
/* Voodoo TV 200 */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x121a, 0x3000, GENERIC),
|
2009-06-02 09:39:52 -06:00
|
|
|
/* Askey Computer Corp. MagicTView'99 */
|
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x144f, 0x3000, GENERIC),
|
2006-06-01 00:33:48 -06:00
|
|
|
/* AVerMedia Studio No. 103, 203, ...? */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x1461, 0x0003, AVPHONE98),
|
2007-08-22 06:19:45 -06:00
|
|
|
/* Prolink PixelView PV-M4900 */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0x1554, 0x4011, GENERIC),
|
2007-08-22 06:19:45 -06:00
|
|
|
/* Pinnacle Studio PCTV rave */
|
2007-09-06 07:06:44 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, 0xbd11, 0x1200, GENERIC),
|
2005-04-16 16:20:36 -06:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, snd_bt87x_ids);
|
|
|
|
|
|
|
|
/* cards known not to have audio
|
|
|
|
* (DVB cards use the audio function to transfer MPEG data) */
|
|
|
|
static struct {
|
|
|
|
unsigned short subvendor, subdevice;
|
2012-12-06 10:35:19 -07:00
|
|
|
} blacklist[] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
{0x0071, 0x0101}, /* Nebula Electronics DigiTV */
|
2006-03-13 02:36:44 -07:00
|
|
|
{0x11bd, 0x001c}, /* Pinnacle PCTV Sat */
|
2005-04-16 16:20:36 -06:00
|
|
|
{0x11bd, 0x0026}, /* Pinnacle PCTV SAT CI */
|
|
|
|
{0x1461, 0x0761}, /* AVermedia AverTV DVB-T */
|
|
|
|
{0x1461, 0x0771}, /* AVermedia DVB-T 771 */
|
|
|
|
{0x1822, 0x0001}, /* Twinhan VisionPlus DVB-T */
|
2006-03-13 02:36:44 -07:00
|
|
|
{0x18ac, 0xd500}, /* DVICO FusionHDTV 5 Lite */
|
2005-04-16 16:20:36 -06:00
|
|
|
{0x18ac, 0xdb10}, /* DVICO FusionHDTV DVB-T Lite */
|
2007-01-07 18:12:22 -07:00
|
|
|
{0x18ac, 0xdb11}, /* Ultraview DVB-T Lite */
|
2005-04-16 16:20:36 -06:00
|
|
|
{0x270f, 0xfc00}, /* Chaintech Digitop DST-1000 DVB-S */
|
2006-03-13 02:36:44 -07:00
|
|
|
{0x7063, 0x2000}, /* pcHDTV HD-2000 TV */
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2013-02-25 01:48:45 -07:00
|
|
|
static struct pci_driver driver;
|
|
|
|
|
2007-09-06 07:06:44 -06:00
|
|
|
/* return the id of the card, or a negative value if it's blacklisted */
|
2012-12-06 10:35:19 -07:00
|
|
|
static int snd_bt87x_detect_card(struct pci_dev *pci)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
const struct pci_device_id *supported;
|
|
|
|
|
2007-10-18 02:48:43 -06:00
|
|
|
supported = pci_match_id(snd_bt87x_ids, pci);
|
2006-01-11 23:56:40 -07:00
|
|
|
if (supported && supported->driver_data > 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return supported->driver_data;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(blacklist); ++i)
|
|
|
|
if (blacklist[i].subvendor == pci->subsystem_vendor &&
|
|
|
|
blacklist[i].subdevice == pci->subsystem_device) {
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_dbg(&pci->dev,
|
|
|
|
"card %#04x-%#04x:%#04x has no audio\n",
|
2006-02-08 01:10:36 -07:00
|
|
|
pci->device, pci->subsystem_vendor, pci->subsystem_device);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_info(&pci->dev, "unknown card %#04x-%#04x:%#04x\n",
|
2007-09-06 07:06:44 -06:00
|
|
|
pci->device, pci->subsystem_vendor, pci->subsystem_device);
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_info(&pci->dev, "please mail id, board name, and, "
|
2005-04-16 16:20:36 -06:00
|
|
|
"if it works, the correct digital_rate option to "
|
2007-03-21 05:05:06 -06:00
|
|
|
"<alsa-devel@alsa-project.org>\n");
|
2007-09-17 01:33:37 -06:00
|
|
|
return SND_BT87X_BOARD_UNKNOWN;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-12-06 10:35:19 -07:00
|
|
|
static int snd_bt87x_probe(struct pci_dev *pci,
|
|
|
|
const struct pci_device_id *pci_id)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
static int dev;
|
2005-11-17 07:02:58 -07:00
|
|
|
struct snd_card *card;
|
|
|
|
struct snd_bt87x *chip;
|
2007-09-06 07:06:44 -06:00
|
|
|
int err;
|
|
|
|
enum snd_bt87x_boardid boardid;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-06 07:06:44 -06:00
|
|
|
if (!pci_id->driver_data) {
|
|
|
|
err = snd_bt87x_detect_card(pci);
|
|
|
|
if (err < 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENODEV;
|
2007-09-06 07:06:44 -06:00
|
|
|
boardid = err;
|
|
|
|
} else
|
|
|
|
boardid = pci_id->driver_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (dev >= SNDRV_CARDS)
|
|
|
|
return -ENODEV;
|
|
|
|
if (!enable[dev]) {
|
|
|
|
++dev;
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2014-01-29 06:20:19 -07:00
|
|
|
err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
|
|
|
|
0, &card);
|
2008-12-28 08:44:30 -07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
err = snd_bt87x_create(card, pci, &chip);
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
|
2007-09-06 07:06:44 -06:00
|
|
|
memcpy(&chip->board, &snd_bt87x_boards[boardid], sizeof(chip->board));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-06 07:06:44 -06:00
|
|
|
if (!chip->board.no_digital) {
|
|
|
|
if (digital_rate[dev] > 0)
|
|
|
|
chip->board.dig_rate = digital_rate[dev];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-06 07:06:44 -06:00
|
|
|
chip->reg_control |= chip->board.digital_fmt;
|
|
|
|
|
|
|
|
err = snd_bt87x_pcm(chip, DEVICE_DIGITAL, "Bt87x Digital");
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
}
|
|
|
|
if (!chip->board.no_analog) {
|
|
|
|
err = snd_bt87x_pcm(chip, DEVICE_ANALOG, "Bt87x Analog");
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
err = snd_ctl_add(card, snd_ctl_new1(
|
|
|
|
&snd_bt87x_capture_volume, chip));
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
err = snd_ctl_add(card, snd_ctl_new1(
|
|
|
|
&snd_bt87x_capture_boost, chip));
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
err = snd_ctl_add(card, snd_ctl_new1(
|
|
|
|
&snd_bt87x_capture_source, chip));
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
}
|
2014-02-25 06:08:22 -07:00
|
|
|
dev_info(card->dev, "bt87x%d: Using board %d, %sanalog, %sdigital "
|
2007-09-06 07:06:44 -06:00
|
|
|
"(rate %d Hz)\n", dev, boardid,
|
|
|
|
chip->board.no_analog ? "no " : "",
|
|
|
|
chip->board.no_digital ? "no " : "", chip->board.dig_rate);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
strcpy(card->driver, "Bt87x");
|
|
|
|
sprintf(card->shortname, "Brooktree Bt%x", pci->device);
|
2006-06-12 15:50:27 -06:00
|
|
|
sprintf(card->longname, "%s at %#llx, irq %i",
|
|
|
|
card->shortname, (unsigned long long)pci_resource_start(pci, 0),
|
|
|
|
chip->irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
strcpy(card->mixername, "Bt87x");
|
|
|
|
|
|
|
|
err = snd_card_register(card);
|
|
|
|
if (err < 0)
|
|
|
|
goto _error;
|
|
|
|
|
|
|
|
pci_set_drvdata(pci, card);
|
|
|
|
++dev;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
_error:
|
|
|
|
snd_card_free(card);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-12-06 10:35:19 -07:00
|
|
|
static void snd_bt87x_remove(struct pci_dev *pci)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
snd_card_free(pci_get_drvdata(pci));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* default entries for all Bt87x cards - it's not exported */
|
|
|
|
/* driver_data is set to 0 to call detection */
|
2014-08-08 07:56:03 -06:00
|
|
|
static const struct pci_device_id snd_bt87x_default_ids[] = {
|
2007-09-17 01:33:37 -06:00
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878, PCI_ANY_ID, PCI_ANY_ID, UNKNOWN),
|
|
|
|
BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_879, PCI_ANY_ID, PCI_ANY_ID, UNKNOWN),
|
2005-04-16 16:20:36 -06:00
|
|
|
{ }
|
|
|
|
};
|
|
|
|
|
2013-02-25 01:48:45 -07:00
|
|
|
static struct pci_driver driver = {
|
2011-06-10 08:20:20 -06:00
|
|
|
.name = KBUILD_MODNAME,
|
2005-04-16 16:20:36 -06:00
|
|
|
.id_table = snd_bt87x_ids,
|
|
|
|
.probe = snd_bt87x_probe,
|
2012-12-06 10:35:19 -07:00
|
|
|
.remove = snd_bt87x_remove,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2013-02-25 01:48:45 -07:00
|
|
|
static int __init alsa_card_bt87x_init(void)
|
|
|
|
{
|
|
|
|
if (load_all)
|
|
|
|
driver.id_table = snd_bt87x_default_ids;
|
|
|
|
return pci_register_driver(&driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit alsa_card_bt87x_exit(void)
|
|
|
|
{
|
|
|
|
pci_unregister_driver(&driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(alsa_card_bt87x_init)
|
|
|
|
module_exit(alsa_card_bt87x_exit)
|