2 * bt87x.c - Brooktree Bt878/Bt879 driver for ALSA
4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
6 * based on btaudio.c by Gerd Knorr <kraxel@bytesex.org>
9 * This driver is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This driver is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <sound/driver.h>
25 #include <linux/init.h>
26 #include <linux/interrupt.h>
27 #include <linux/pci.h>
28 #include <linux/slab.h>
29 #include <linux/moduleparam.h>
30 #include <linux/bitops.h>
32 #include <sound/core.h>
33 #include <sound/pcm.h>
34 #include <sound/pcm_params.h>
35 #include <sound/control.h>
36 #include <sound/initval.h>
38 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
39 MODULE_DESCRIPTION("Brooktree Bt87x audio driver");
40 MODULE_LICENSE("GPL");
41 MODULE_SUPPORTED_DEVICE("{{Brooktree,Bt878},"
42 "{Brooktree,Bt879}}");
44 static int index
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = -2}; /* Exclude the first card */
45 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
46 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
; /* Enable this card */
47 static int digital_rate
[SNDRV_CARDS
] = { [0 ... (SNDRV_CARDS
-1)] = 0 }; /* digital input rate */
48 static int load_all
; /* allow to load the non-whitelisted cards */
50 module_param_array(index
, int, NULL
, 0444);
51 MODULE_PARM_DESC(index
, "Index value for Bt87x soundcard");
52 module_param_array(id
, charp
, NULL
, 0444);
53 MODULE_PARM_DESC(id
, "ID string for Bt87x soundcard");
54 module_param_array(enable
, bool, NULL
, 0444);
55 MODULE_PARM_DESC(enable
, "Enable Bt87x soundcard");
56 module_param_array(digital_rate
, int, NULL
, 0444);
57 MODULE_PARM_DESC(digital_rate
, "Digital input rate for Bt87x soundcard");
58 module_param(load_all
, bool, 0444);
59 MODULE_PARM_DESC(load_all
, "Allow to load the non-whitelisted cards");
62 /* register offsets */
63 #define REG_INT_STAT 0x100 /* interrupt status */
64 #define REG_INT_MASK 0x104 /* interrupt mask */
65 #define REG_GPIO_DMA_CTL 0x10c /* audio control */
66 #define REG_PACKET_LEN 0x110 /* audio packet lengths */
67 #define REG_RISC_STRT_ADD 0x114 /* RISC program start address */
68 #define REG_RISC_COUNT 0x120 /* RISC program counter */
71 #define INT_OFLOW (1 << 3) /* audio A/D overflow */
72 #define INT_RISCI (1 << 11) /* RISC instruction IRQ bit set */
73 #define INT_FBUS (1 << 12) /* FIFO overrun due to bus access latency */
74 #define INT_FTRGT (1 << 13) /* FIFO overrun due to target latency */
75 #define INT_FDSR (1 << 14) /* FIFO data stream resynchronization */
76 #define INT_PPERR (1 << 15) /* PCI parity error */
77 #define INT_RIPERR (1 << 16) /* RISC instruction parity error */
78 #define INT_PABORT (1 << 17) /* PCI master or target abort */
79 #define INT_OCERR (1 << 18) /* invalid opcode */
80 #define INT_SCERR (1 << 19) /* sync counter overflow */
81 #define INT_RISC_EN (1 << 27) /* DMA controller running */
82 #define INT_RISCS_SHIFT 28 /* RISC status bits */
84 /* audio control bits */
85 #define CTL_FIFO_ENABLE (1 << 0) /* enable audio data FIFO */
86 #define CTL_RISC_ENABLE (1 << 1) /* enable audio DMA controller */
87 #define CTL_PKTP_4 (0 << 2) /* packet mode FIFO trigger point - 4 DWORDs */
88 #define CTL_PKTP_8 (1 << 2) /* 8 DWORDs */
89 #define CTL_PKTP_16 (2 << 2) /* 16 DWORDs */
90 #define CTL_ACAP_EN (1 << 4) /* enable audio capture */
91 #define CTL_DA_APP (1 << 5) /* GPIO input */
92 #define CTL_DA_IOM_AFE (0 << 6) /* audio A/D input */
93 #define CTL_DA_IOM_DA (1 << 6) /* digital audio input */
94 #define CTL_DA_SDR_SHIFT 8 /* DDF first stage decimation rate */
95 #define CTL_DA_SDR_MASK (0xf<< 8)
96 #define CTL_DA_LMT (1 << 12) /* limit audio data values */
97 #define CTL_DA_ES2 (1 << 13) /* enable DDF stage 2 */
98 #define CTL_DA_SBR (1 << 14) /* samples rounded to 8 bits */
99 #define CTL_DA_DPM (1 << 15) /* data packet mode */
100 #define CTL_DA_LRD_SHIFT 16 /* ALRCK delay */
101 #define CTL_DA_MLB (1 << 21) /* MSB/LSB format */
102 #define CTL_DA_LRI (1 << 22) /* left/right indication */
103 #define CTL_DA_SCE (1 << 23) /* sample clock edge */
104 #define CTL_A_SEL_STV (0 << 24) /* TV tuner audio input */
105 #define CTL_A_SEL_SFM (1 << 24) /* FM audio input */
106 #define CTL_A_SEL_SML (2 << 24) /* mic/line audio input */
107 #define CTL_A_SEL_SMXC (3 << 24) /* MUX bypass */
108 #define CTL_A_SEL_SHIFT 24
109 #define CTL_A_SEL_MASK (3 << 24)
110 #define CTL_A_PWRDN (1 << 26) /* analog audio power-down */
111 #define CTL_A_G2X (1 << 27) /* audio gain boost */
112 #define CTL_A_GAIN_SHIFT 28 /* audio input gain */
113 #define CTL_A_GAIN_MASK (0xf<<28)
115 /* RISC instruction opcodes */
116 #define RISC_WRITE (0x1 << 28) /* write FIFO data to memory at address */
117 #define RISC_WRITEC (0x5 << 28) /* write FIFO data to memory at current address */
118 #define RISC_SKIP (0x2 << 28) /* skip FIFO data */
119 #define RISC_JUMP (0x7 << 28) /* jump to address */
120 #define RISC_SYNC (0x8 << 28) /* synchronize with FIFO */
122 /* RISC instruction bits */
123 #define RISC_BYTES_ENABLE (0xf << 12) /* byte enable bits */
124 #define RISC_RESYNC ( 1 << 15) /* disable FDSR errors */
125 #define RISC_SET_STATUS_SHIFT 16 /* set status bits */
126 #define RISC_RESET_STATUS_SHIFT 20 /* clear status bits */
127 #define RISC_IRQ ( 1 << 24) /* interrupt */
128 #define RISC_EOL ( 1 << 26) /* end of line */
129 #define RISC_SOL ( 1 << 27) /* start of line */
131 /* SYNC status bits values */
132 #define RISC_SYNC_FM1 0x6
133 #define RISC_SYNC_VRO 0xc
135 #define ANALOG_CLOCK 1792000
136 #ifdef CONFIG_SND_BT87X_OVERCLOCK
137 #define CLOCK_DIV_MIN 1
139 #define CLOCK_DIV_MIN 4
141 #define CLOCK_DIV_MAX 15
143 #define ERROR_INTERRUPTS (INT_FBUS | INT_FTRGT | INT_PPERR | \
144 INT_RIPERR | INT_PABORT | INT_OCERR)
145 #define MY_INTERRUPTS (INT_RISCI | ERROR_INTERRUPTS)
147 /* SYNC, one WRITE per line, one extra WRITE per page boundary, SYNC, JUMP */
148 #define MAX_RISC_SIZE ((1 + 255 + (PAGE_ALIGN(255 * 4092) / PAGE_SIZE - 1) + 1 + 1) * 8)
150 typedef struct snd_bt87x bt87x_t
;
162 snd_pcm_substream_t
*substream
;
164 struct snd_dma_buffer dma_risc
;
165 unsigned int line_bytes
;
173 int pci_parity_errors
;
176 enum { DEVICE_DIGITAL
, DEVICE_ANALOG
};
178 static inline u32
snd_bt87x_readl(bt87x_t
*chip
, u32 reg
)
180 return readl(chip
->mmio
+ reg
);
183 static inline void snd_bt87x_writel(bt87x_t
*chip
, u32 reg
, u32 value
)
185 writel(value
, chip
->mmio
+ reg
);
188 static int snd_bt87x_create_risc(bt87x_t
*chip
, snd_pcm_substream_t
*substream
,
189 unsigned int periods
, unsigned int period_bytes
)
191 struct snd_sg_buf
*sgbuf
= snd_pcm_substream_sgbuf(substream
);
192 unsigned int i
, offset
;
195 if (chip
->dma_risc
.area
== NULL
) {
196 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(chip
->pci
),
197 PAGE_ALIGN(MAX_RISC_SIZE
), &chip
->dma_risc
) < 0)
200 risc
= (u32
*)chip
->dma_risc
.area
;
202 *risc
++ = cpu_to_le32(RISC_SYNC
| RISC_SYNC_FM1
);
203 *risc
++ = cpu_to_le32(0);
204 for (i
= 0; i
< periods
; ++i
) {
211 len
= PAGE_SIZE
- (offset
% PAGE_SIZE
);
214 cmd
= RISC_WRITE
| len
;
215 if (rest
== period_bytes
) {
216 u32 block
= i
* 16 / periods
;
218 cmd
|= block
<< RISC_SET_STATUS_SHIFT
;
219 cmd
|= (~block
& 0xf) << RISC_RESET_STATUS_SHIFT
;
222 cmd
|= RISC_EOL
| RISC_IRQ
;
223 *risc
++ = cpu_to_le32(cmd
);
224 *risc
++ = cpu_to_le32((u32
)snd_pcm_sgbuf_get_addr(sgbuf
, offset
));
229 *risc
++ = cpu_to_le32(RISC_SYNC
| RISC_SYNC_VRO
);
230 *risc
++ = cpu_to_le32(0);
231 *risc
++ = cpu_to_le32(RISC_JUMP
);
232 *risc
++ = cpu_to_le32(chip
->dma_risc
.addr
);
233 chip
->line_bytes
= period_bytes
;
234 chip
->lines
= periods
;
238 static void snd_bt87x_free_risc(bt87x_t
*chip
)
240 if (chip
->dma_risc
.area
) {
241 snd_dma_free_pages(&chip
->dma_risc
);
242 chip
->dma_risc
.area
= NULL
;
246 static void snd_bt87x_pci_error(bt87x_t
*chip
, unsigned int status
)
250 pci_read_config_word(chip
->pci
, PCI_STATUS
, &pci_status
);
251 pci_status
&= PCI_STATUS_PARITY
| PCI_STATUS_SIG_TARGET_ABORT
|
252 PCI_STATUS_REC_TARGET_ABORT
| PCI_STATUS_REC_MASTER_ABORT
|
253 PCI_STATUS_SIG_SYSTEM_ERROR
| PCI_STATUS_DETECTED_PARITY
;
254 pci_write_config_word(chip
->pci
, PCI_STATUS
, pci_status
);
255 if (pci_status
!= PCI_STATUS_DETECTED_PARITY
)
256 snd_printk(KERN_ERR
"Aieee - PCI error! status %#08x, PCI status %#04x\n",
257 status
& ERROR_INTERRUPTS
, pci_status
);
259 snd_printk(KERN_ERR
"Aieee - PCI parity error detected!\n");
260 /* error 'handling' similar to aic7xxx_pci.c: */
261 chip
->pci_parity_errors
++;
262 if (chip
->pci_parity_errors
> 20) {
263 snd_printk(KERN_ERR
"Too many PCI parity errors observed.\n");
264 snd_printk(KERN_ERR
"Some device on this bus is generating bad parity.\n");
265 snd_printk(KERN_ERR
"This is an error *observed by*, not *generated by*, this card.\n");
266 snd_printk(KERN_ERR
"PCI parity error checking has been disabled.\n");
267 chip
->interrupt_mask
&= ~(INT_PPERR
| INT_RIPERR
);
268 snd_bt87x_writel(chip
, REG_INT_MASK
, chip
->interrupt_mask
);
273 static irqreturn_t
snd_bt87x_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
275 bt87x_t
*chip
= dev_id
;
276 unsigned int status
, irq_status
;
278 status
= snd_bt87x_readl(chip
, REG_INT_STAT
);
279 irq_status
= status
& chip
->interrupt_mask
;
282 snd_bt87x_writel(chip
, REG_INT_STAT
, irq_status
);
284 if (irq_status
& ERROR_INTERRUPTS
) {
285 if (irq_status
& (INT_FBUS
| INT_FTRGT
))
286 snd_printk(KERN_WARNING
"FIFO overrun, status %#08x\n", status
);
287 if (irq_status
& INT_OCERR
)
288 snd_printk(KERN_ERR
"internal RISC error, status %#08x\n", status
);
289 if (irq_status
& (INT_PPERR
| INT_RIPERR
| INT_PABORT
))
290 snd_bt87x_pci_error(chip
, irq_status
);
292 if ((irq_status
& INT_RISCI
) && (chip
->reg_control
& CTL_ACAP_EN
)) {
293 int current_block
, irq_block
;
295 /* assume that exactly one line has been recorded */
296 chip
->current_line
= (chip
->current_line
+ 1) % chip
->lines
;
297 /* but check if some interrupts have been skipped */
298 current_block
= chip
->current_line
* 16 / chip
->lines
;
299 irq_block
= status
>> INT_RISCS_SHIFT
;
300 if (current_block
!= irq_block
)
301 chip
->current_line
= (irq_block
* chip
->lines
+ 15) / 16;
303 snd_pcm_period_elapsed(chip
->substream
);
308 static snd_pcm_hardware_t snd_bt87x_digital_hw
= {
309 .info
= SNDRV_PCM_INFO_MMAP
|
310 SNDRV_PCM_INFO_INTERLEAVED
|
311 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
312 SNDRV_PCM_INFO_MMAP_VALID
,
313 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
314 .rates
= 0, /* set at runtime */
317 .buffer_bytes_max
= 255 * 4092,
318 .period_bytes_min
= 32,
319 .period_bytes_max
= 4092,
324 static snd_pcm_hardware_t snd_bt87x_analog_hw
= {
325 .info
= SNDRV_PCM_INFO_MMAP
|
326 SNDRV_PCM_INFO_INTERLEAVED
|
327 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
328 SNDRV_PCM_INFO_MMAP_VALID
,
329 .formats
= SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_S8
,
330 .rates
= SNDRV_PCM_RATE_KNOT
,
331 .rate_min
= ANALOG_CLOCK
/ CLOCK_DIV_MAX
,
332 .rate_max
= ANALOG_CLOCK
/ CLOCK_DIV_MIN
,
335 .buffer_bytes_max
= 255 * 4092,
336 .period_bytes_min
= 32,
337 .period_bytes_max
= 4092,
342 static int snd_bt87x_set_digital_hw(bt87x_t
*chip
, snd_pcm_runtime_t
*runtime
)
348 {8000, SNDRV_PCM_RATE_8000
},
349 {11025, SNDRV_PCM_RATE_11025
},
350 {16000, SNDRV_PCM_RATE_16000
},
351 {22050, SNDRV_PCM_RATE_22050
},
352 {32000, SNDRV_PCM_RATE_32000
},
353 {44100, SNDRV_PCM_RATE_44100
},
354 {48000, SNDRV_PCM_RATE_48000
}
358 chip
->reg_control
|= CTL_DA_IOM_DA
;
359 runtime
->hw
= snd_bt87x_digital_hw
;
360 runtime
->hw
.rates
= SNDRV_PCM_RATE_KNOT
;
361 for (i
= 0; i
< ARRAY_SIZE(ratebits
); ++i
)
362 if (chip
->dig_rate
== ratebits
[i
].rate
) {
363 runtime
->hw
.rates
= ratebits
[i
].bit
;
366 runtime
->hw
.rate_min
= chip
->dig_rate
;
367 runtime
->hw
.rate_max
= chip
->dig_rate
;
371 static int snd_bt87x_set_analog_hw(bt87x_t
*chip
, snd_pcm_runtime_t
*runtime
)
373 static ratnum_t analog_clock
= {
375 .den_min
= CLOCK_DIV_MIN
,
376 .den_max
= CLOCK_DIV_MAX
,
379 static snd_pcm_hw_constraint_ratnums_t constraint_rates
= {
381 .rats
= &analog_clock
384 chip
->reg_control
&= ~CTL_DA_IOM_DA
;
385 runtime
->hw
= snd_bt87x_analog_hw
;
386 return snd_pcm_hw_constraint_ratnums(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
,
390 static int snd_bt87x_pcm_open(snd_pcm_substream_t
*substream
)
392 bt87x_t
*chip
= snd_pcm_substream_chip(substream
);
393 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
396 if (test_and_set_bit(0, &chip
->opened
))
399 if (substream
->pcm
->device
== DEVICE_DIGITAL
)
400 err
= snd_bt87x_set_digital_hw(chip
, runtime
);
402 err
= snd_bt87x_set_analog_hw(chip
, runtime
);
406 err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
410 chip
->substream
= substream
;
414 clear_bit(0, &chip
->opened
);
415 smp_mb__after_clear_bit();
419 static int snd_bt87x_close(snd_pcm_substream_t
*substream
)
421 bt87x_t
*chip
= snd_pcm_substream_chip(substream
);
423 chip
->substream
= NULL
;
424 clear_bit(0, &chip
->opened
);
425 smp_mb__after_clear_bit();
429 static int snd_bt87x_hw_params(snd_pcm_substream_t
*substream
,
430 snd_pcm_hw_params_t
*hw_params
)
432 bt87x_t
*chip
= snd_pcm_substream_chip(substream
);
435 err
= snd_pcm_lib_malloc_pages(substream
,
436 params_buffer_bytes(hw_params
));
439 return snd_bt87x_create_risc(chip
, substream
,
440 params_periods(hw_params
),
441 params_period_bytes(hw_params
));
444 static int snd_bt87x_hw_free(snd_pcm_substream_t
*substream
)
446 bt87x_t
*chip
= snd_pcm_substream_chip(substream
);
448 snd_bt87x_free_risc(chip
);
449 snd_pcm_lib_free_pages(substream
);
453 static int snd_bt87x_prepare(snd_pcm_substream_t
*substream
)
455 bt87x_t
*chip
= snd_pcm_substream_chip(substream
);
456 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
459 spin_lock_irq(&chip
->reg_lock
);
460 chip
->reg_control
&= ~(CTL_DA_SDR_MASK
| CTL_DA_SBR
);
461 decimation
= (ANALOG_CLOCK
+ runtime
->rate
/ 4) / runtime
->rate
;
462 chip
->reg_control
|= decimation
<< CTL_DA_SDR_SHIFT
;
463 if (runtime
->format
== SNDRV_PCM_FORMAT_S8
)
464 chip
->reg_control
|= CTL_DA_SBR
;
465 snd_bt87x_writel(chip
, REG_GPIO_DMA_CTL
, chip
->reg_control
);
466 spin_unlock_irq(&chip
->reg_lock
);
470 static int snd_bt87x_start(bt87x_t
*chip
)
472 spin_lock(&chip
->reg_lock
);
473 chip
->current_line
= 0;
474 chip
->reg_control
|= CTL_FIFO_ENABLE
| CTL_RISC_ENABLE
| CTL_ACAP_EN
;
475 snd_bt87x_writel(chip
, REG_RISC_STRT_ADD
, chip
->dma_risc
.addr
);
476 snd_bt87x_writel(chip
, REG_PACKET_LEN
,
477 chip
->line_bytes
| (chip
->lines
<< 16));
478 snd_bt87x_writel(chip
, REG_INT_MASK
, chip
->interrupt_mask
);
479 snd_bt87x_writel(chip
, REG_GPIO_DMA_CTL
, chip
->reg_control
);
480 spin_unlock(&chip
->reg_lock
);
484 static int snd_bt87x_stop(bt87x_t
*chip
)
486 spin_lock(&chip
->reg_lock
);
487 chip
->reg_control
&= ~(CTL_FIFO_ENABLE
| CTL_RISC_ENABLE
| CTL_ACAP_EN
);
488 snd_bt87x_writel(chip
, REG_GPIO_DMA_CTL
, chip
->reg_control
);
489 snd_bt87x_writel(chip
, REG_INT_MASK
, 0);
490 snd_bt87x_writel(chip
, REG_INT_STAT
, MY_INTERRUPTS
);
491 spin_unlock(&chip
->reg_lock
);
495 static int snd_bt87x_trigger(snd_pcm_substream_t
*substream
, int cmd
)
497 bt87x_t
*chip
= snd_pcm_substream_chip(substream
);
500 case SNDRV_PCM_TRIGGER_START
:
501 return snd_bt87x_start(chip
);
502 case SNDRV_PCM_TRIGGER_STOP
:
503 return snd_bt87x_stop(chip
);
509 static snd_pcm_uframes_t
snd_bt87x_pointer(snd_pcm_substream_t
*substream
)
511 bt87x_t
*chip
= snd_pcm_substream_chip(substream
);
512 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
514 return (snd_pcm_uframes_t
)bytes_to_frames(runtime
, chip
->current_line
* chip
->line_bytes
);
517 static snd_pcm_ops_t snd_bt87x_pcm_ops
= {
518 .open
= snd_bt87x_pcm_open
,
519 .close
= snd_bt87x_close
,
520 .ioctl
= snd_pcm_lib_ioctl
,
521 .hw_params
= snd_bt87x_hw_params
,
522 .hw_free
= snd_bt87x_hw_free
,
523 .prepare
= snd_bt87x_prepare
,
524 .trigger
= snd_bt87x_trigger
,
525 .pointer
= snd_bt87x_pointer
,
526 .page
= snd_pcm_sgbuf_ops_page
,
529 static int snd_bt87x_capture_volume_info(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_info_t
*info
)
531 info
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
533 info
->value
.integer
.min
= 0;
534 info
->value
.integer
.max
= 15;
538 static int snd_bt87x_capture_volume_get(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_value_t
*value
)
540 bt87x_t
*chip
= snd_kcontrol_chip(kcontrol
);
542 value
->value
.integer
.value
[0] = (chip
->reg_control
& CTL_A_GAIN_MASK
) >> CTL_A_GAIN_SHIFT
;
546 static int snd_bt87x_capture_volume_put(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_value_t
*value
)
548 bt87x_t
*chip
= snd_kcontrol_chip(kcontrol
);
552 spin_lock_irq(&chip
->reg_lock
);
553 old_control
= chip
->reg_control
;
554 chip
->reg_control
= (chip
->reg_control
& ~CTL_A_GAIN_MASK
)
555 | (value
->value
.integer
.value
[0] << CTL_A_GAIN_SHIFT
);
556 snd_bt87x_writel(chip
, REG_GPIO_DMA_CTL
, chip
->reg_control
);
557 changed
= old_control
!= chip
->reg_control
;
558 spin_unlock_irq(&chip
->reg_lock
);
562 static snd_kcontrol_new_t snd_bt87x_capture_volume
= {
563 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
564 .name
= "Capture Volume",
565 .info
= snd_bt87x_capture_volume_info
,
566 .get
= snd_bt87x_capture_volume_get
,
567 .put
= snd_bt87x_capture_volume_put
,
570 static int snd_bt87x_capture_boost_info(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_info_t
*info
)
572 info
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
574 info
->value
.integer
.min
= 0;
575 info
->value
.integer
.max
= 1;
579 static int snd_bt87x_capture_boost_get(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_value_t
*value
)
581 bt87x_t
*chip
= snd_kcontrol_chip(kcontrol
);
583 value
->value
.integer
.value
[0] = !! (chip
->reg_control
& CTL_A_G2X
);
587 static int snd_bt87x_capture_boost_put(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_value_t
*value
)
589 bt87x_t
*chip
= snd_kcontrol_chip(kcontrol
);
593 spin_lock_irq(&chip
->reg_lock
);
594 old_control
= chip
->reg_control
;
595 chip
->reg_control
= (chip
->reg_control
& ~CTL_A_G2X
)
596 | (value
->value
.integer
.value
[0] ? CTL_A_G2X
: 0);
597 snd_bt87x_writel(chip
, REG_GPIO_DMA_CTL
, chip
->reg_control
);
598 changed
= chip
->reg_control
!= old_control
;
599 spin_unlock_irq(&chip
->reg_lock
);
603 static snd_kcontrol_new_t snd_bt87x_capture_boost
= {
604 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
605 .name
= "Capture Boost",
606 .info
= snd_bt87x_capture_boost_info
,
607 .get
= snd_bt87x_capture_boost_get
,
608 .put
= snd_bt87x_capture_boost_put
,
611 static int snd_bt87x_capture_source_info(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_info_t
*info
)
613 static char *texts
[3] = {"TV Tuner", "FM", "Mic/Line"};
615 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
617 info
->value
.enumerated
.items
= 3;
618 if (info
->value
.enumerated
.item
> 2)
619 info
->value
.enumerated
.item
= 2;
620 strcpy(info
->value
.enumerated
.name
, texts
[info
->value
.enumerated
.item
]);
624 static int snd_bt87x_capture_source_get(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_value_t
*value
)
626 bt87x_t
*chip
= snd_kcontrol_chip(kcontrol
);
628 value
->value
.enumerated
.item
[0] = (chip
->reg_control
& CTL_A_SEL_MASK
) >> CTL_A_SEL_SHIFT
;
632 static int snd_bt87x_capture_source_put(snd_kcontrol_t
*kcontrol
, snd_ctl_elem_value_t
*value
)
634 bt87x_t
*chip
= snd_kcontrol_chip(kcontrol
);
638 spin_lock_irq(&chip
->reg_lock
);
639 old_control
= chip
->reg_control
;
640 chip
->reg_control
= (chip
->reg_control
& ~CTL_A_SEL_MASK
)
641 | (value
->value
.enumerated
.item
[0] << CTL_A_SEL_SHIFT
);
642 snd_bt87x_writel(chip
, REG_GPIO_DMA_CTL
, chip
->reg_control
);
643 changed
= chip
->reg_control
!= old_control
;
644 spin_unlock_irq(&chip
->reg_lock
);
648 static snd_kcontrol_new_t snd_bt87x_capture_source
= {
649 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
650 .name
= "Capture Source",
651 .info
= snd_bt87x_capture_source_info
,
652 .get
= snd_bt87x_capture_source_get
,
653 .put
= snd_bt87x_capture_source_put
,
656 static int snd_bt87x_free(bt87x_t
*chip
)
659 snd_bt87x_stop(chip
);
661 synchronize_irq(chip
->irq
);
666 free_irq(chip
->irq
, chip
);
667 pci_release_regions(chip
->pci
);
668 pci_disable_device(chip
->pci
);
673 static int snd_bt87x_dev_free(snd_device_t
*device
)
675 bt87x_t
*chip
= device
->device_data
;
676 return snd_bt87x_free(chip
);
679 static int __devinit
snd_bt87x_pcm(bt87x_t
*chip
, int device
, char *name
)
684 err
= snd_pcm_new(chip
->card
, name
, device
, 0, 1, &pcm
);
687 pcm
->private_data
= chip
;
688 strcpy(pcm
->name
, name
);
689 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_bt87x_pcm_ops
);
690 return snd_pcm_lib_preallocate_pages_for_all(pcm
,
691 SNDRV_DMA_TYPE_DEV_SG
,
692 snd_dma_pci_data(chip
->pci
),
694 (255 * 4092 + 1023) & ~1023);
697 static int __devinit
snd_bt87x_create(snd_card_t
*card
,
703 static snd_device_ops_t ops
= {
704 .dev_free
= snd_bt87x_dev_free
709 err
= pci_enable_device(pci
);
713 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
715 pci_disable_device(pci
);
721 spin_lock_init(&chip
->reg_lock
);
723 if ((err
= pci_request_regions(pci
, "Bt87x audio")) < 0) {
725 pci_disable_device(pci
);
728 chip
->mmio
= ioremap_nocache(pci_resource_start(pci
, 0),
729 pci_resource_len(pci
, 0));
731 snd_bt87x_free(chip
);
732 snd_printk(KERN_ERR
"cannot remap io memory\n");
736 chip
->reg_control
= CTL_DA_ES2
| CTL_PKTP_16
| (15 << CTL_DA_SDR_SHIFT
);
737 chip
->interrupt_mask
= MY_INTERRUPTS
;
738 snd_bt87x_writel(chip
, REG_GPIO_DMA_CTL
, chip
->reg_control
);
739 snd_bt87x_writel(chip
, REG_INT_MASK
, 0);
740 snd_bt87x_writel(chip
, REG_INT_STAT
, MY_INTERRUPTS
);
742 if (request_irq(pci
->irq
, snd_bt87x_interrupt
, SA_INTERRUPT
| SA_SHIRQ
,
743 "Bt87x audio", chip
)) {
744 snd_bt87x_free(chip
);
745 snd_printk(KERN_ERR
"cannot grab irq\n");
748 chip
->irq
= pci
->irq
;
750 synchronize_irq(chip
->irq
);
752 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
);
754 snd_bt87x_free(chip
);
757 snd_card_set_dev(card
, &pci
->dev
);
762 #define BT_DEVICE(chip, subvend, subdev, rate) \
763 { .vendor = PCI_VENDOR_ID_BROOKTREE, \
765 .subvendor = subvend, .subdevice = subdev, \
766 .driver_data = rate }
768 /* driver_data is the default digital_rate value for that device */
769 static struct pci_device_id snd_bt87x_ids
[] = {
770 /* Hauppauge WinTV series */
771 BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878
, 0x0070, 0x13eb, 32000),
772 /* Hauppauge WinTV series */
773 BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_879
, 0x0070, 0x13eb, 32000),
774 /* Viewcast Osprey 200 */
775 BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878
, 0x0070, 0xff01, 44100),
778 MODULE_DEVICE_TABLE(pci
, snd_bt87x_ids
);
780 /* cards known not to have audio
781 * (DVB cards use the audio function to transfer MPEG data) */
783 unsigned short subvendor
, subdevice
;
784 } blacklist
[] __devinitdata
= {
785 {0x0071, 0x0101}, /* Nebula Electronics DigiTV */
786 {0x11bd, 0x0026}, /* Pinnacle PCTV SAT CI */
787 {0x1461, 0x0761}, /* AVermedia AverTV DVB-T */
788 {0x1461, 0x0771}, /* AVermedia DVB-T 771 */
789 {0x1822, 0x0001}, /* Twinhan VisionPlus DVB-T */
790 {0x18ac, 0xdb10}, /* DVICO FusionHDTV DVB-T Lite */
791 {0x270f, 0xfc00}, /* Chaintech Digitop DST-1000 DVB-S */
794 static struct pci_driver driver
;
796 /* return the rate of the card, or a negative value if it's blacklisted */
797 static int __devinit
snd_bt87x_detect_card(struct pci_dev
*pci
)
800 const struct pci_device_id
*supported
;
802 supported
= pci_match_device(&driver
, pci
);
804 return supported
->driver_data
;
806 for (i
= 0; i
< ARRAY_SIZE(blacklist
); ++i
)
807 if (blacklist
[i
].subvendor
== pci
->subsystem_vendor
&&
808 blacklist
[i
].subdevice
== pci
->subsystem_device
) {
809 snd_printdd(KERN_INFO
"card %#04x:%#04x has no audio\n",
810 pci
->subsystem_vendor
, pci
->subsystem_device
);
814 snd_printk(KERN_INFO
"unknown card %#04x:%#04x, using default rate 32000\n",
815 pci
->subsystem_vendor
, pci
->subsystem_device
);
816 snd_printk(KERN_DEBUG
"please mail id, board name, and, "
817 "if it works, the correct digital_rate option to "
818 "<alsa-devel@lists.sf.net>\n");
819 return 32000; /* default rate */
822 static int __devinit
snd_bt87x_probe(struct pci_dev
*pci
,
823 const struct pci_device_id
*pci_id
)
830 rate
= pci_id
->driver_data
;
832 if ((rate
= snd_bt87x_detect_card(pci
)) <= 0)
835 if (dev
>= SNDRV_CARDS
)
842 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
, 0);
846 err
= snd_bt87x_create(card
, pci
, &chip
);
850 if (digital_rate
[dev
] > 0)
851 chip
->dig_rate
= digital_rate
[dev
];
853 chip
->dig_rate
= rate
;
855 err
= snd_bt87x_pcm(chip
, DEVICE_DIGITAL
, "Bt87x Digital");
858 err
= snd_bt87x_pcm(chip
, DEVICE_ANALOG
, "Bt87x Analog");
862 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_bt87x_capture_volume
, chip
));
865 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_bt87x_capture_boost
, chip
));
868 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_bt87x_capture_source
, chip
));
872 strcpy(card
->driver
, "Bt87x");
873 sprintf(card
->shortname
, "Brooktree Bt%x", pci
->device
);
874 sprintf(card
->longname
, "%s at %#lx, irq %i",
875 card
->shortname
, pci_resource_start(pci
, 0), chip
->irq
);
876 strcpy(card
->mixername
, "Bt87x");
878 err
= snd_card_register(card
);
882 pci_set_drvdata(pci
, card
);
891 static void __devexit
snd_bt87x_remove(struct pci_dev
*pci
)
893 snd_card_free(pci_get_drvdata(pci
));
894 pci_set_drvdata(pci
, NULL
);
897 /* default entries for all Bt87x cards - it's not exported */
898 /* driver_data is set to 0 to call detection */
899 static struct pci_device_id snd_bt87x_default_ids
[] = {
900 BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_878
, PCI_ANY_ID
, PCI_ANY_ID
, 0),
901 BT_DEVICE(PCI_DEVICE_ID_BROOKTREE_879
, PCI_ANY_ID
, PCI_ANY_ID
, 0),
905 static struct pci_driver driver
= {
907 .id_table
= snd_bt87x_ids
,
908 .probe
= snd_bt87x_probe
,
909 .remove
= __devexit_p(snd_bt87x_remove
),
912 static int __init
alsa_card_bt87x_init(void)
915 driver
.id_table
= snd_bt87x_default_ids
;
916 return pci_register_driver(&driver
);
919 static void __exit
alsa_card_bt87x_exit(void)
921 pci_unregister_driver(&driver
);
924 module_init(alsa_card_bt87x_init
)
925 module_exit(alsa_card_bt87x_exit
)