3 * Support for audio capture
4 * PCI function #1 of the cx2388x.
6 * (c) 2007 Trent Piepho <xyzzy@speakeasy.org>
7 * (c) 2005,2006 Ricardo Cerqueira <v4l@cerqueira.org>
8 * (c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org>
9 * Based on a dummy cx88 module by Gerd Knorr <kraxel@bytesex.org>
10 * Based on dummy.c by Jaroslav Kysela <perex@perex.cz>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/device.h>
30 #include <linux/interrupt.h>
31 #include <linux/vmalloc.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/pci.h>
34 #include <linux/slab.h>
36 #include <asm/delay.h>
37 #include <sound/core.h>
38 #include <sound/pcm.h>
39 #include <sound/pcm_params.h>
40 #include <sound/control.h>
41 #include <sound/initval.h>
42 #include <sound/tlv.h>
43 #include <media/wm8775.h>
48 #define dprintk(level,fmt, arg...) if (debug >= level) \
49 printk(KERN_INFO "%s/1: " fmt, chip->core->name , ## arg)
51 #define dprintk_core(level,fmt, arg...) if (debug >= level) \
52 printk(KERN_DEBUG "%s/1: " fmt, chip->core->name , ## arg)
54 /****************************************************************************
55 Data type declarations - Can be moded to a header file later
56 ****************************************************************************/
58 struct cx88_audio_buffer
{
60 struct btcx_riscmem risc
;
61 struct videobuf_dmabuf dma
;
64 struct cx88_audio_dev
{
65 struct cx88_core
*core
;
66 struct cx88_dmaqueue q
;
74 struct snd_card
*card
;
79 unsigned int dma_size
;
80 unsigned int period_size
;
81 unsigned int num_periods
;
83 struct videobuf_dmabuf
*dma_risc
;
85 struct cx88_audio_buffer
*buf
;
87 struct snd_pcm_substream
*substream
;
89 typedef struct cx88_audio_dev snd_cx88_card_t
;
93 /****************************************************************************
94 Module global static vars
95 ****************************************************************************/
97 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
98 static const char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
99 static bool enable
[SNDRV_CARDS
] = {1, [1 ... (SNDRV_CARDS
- 1)] = 1};
101 module_param_array(enable
, bool, NULL
, 0444);
102 MODULE_PARM_DESC(enable
, "Enable cx88x soundcard. default enabled.");
104 module_param_array(index
, int, NULL
, 0444);
105 MODULE_PARM_DESC(index
, "Index value for cx88x capture interface(s).");
108 /****************************************************************************
110 ****************************************************************************/
112 MODULE_DESCRIPTION("ALSA driver module for cx2388x based TV cards");
113 MODULE_AUTHOR("Ricardo Cerqueira");
114 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
115 MODULE_LICENSE("GPL");
116 MODULE_VERSION(CX88_VERSION
);
118 MODULE_SUPPORTED_DEVICE("{{Conexant,23881},"
120 "{{Conexant,23883}");
121 static unsigned int debug
;
122 module_param(debug
,int,0644);
123 MODULE_PARM_DESC(debug
,"enable debug messages");
125 /****************************************************************************
126 Module specific funtions
127 ****************************************************************************/
130 * BOARD Specific: Sets audio DMA
133 static int _cx88_start_audio_dma(snd_cx88_card_t
*chip
)
135 struct cx88_audio_buffer
*buf
= chip
->buf
;
136 struct cx88_core
*core
=chip
->core
;
137 const struct sram_channel
*audio_ch
= &cx88_sram_channels
[SRAM_CH25
];
139 /* Make sure RISC/FIFO are off before changing FIFO/RISC settings */
140 cx_clear(MO_AUD_DMACNTRL
, 0x11);
142 /* setup fifo + format - out channel */
143 cx88_sram_channel_setup(chip
->core
, audio_ch
, buf
->bpl
, buf
->risc
.dma
);
146 cx_write(MO_AUDD_LNGTH
, buf
->bpl
);
149 cx_write(MO_AUDD_GPCNTRL
, GP_COUNT_CONTROL_RESET
);
150 atomic_set(&chip
->count
, 0);
152 dprintk(1, "Start audio DMA, %d B/line, %d lines/FIFO, %d periods, %d "
153 "byte buffer\n", buf
->bpl
, cx_read(audio_ch
->cmds_start
+ 8)>>1,
154 chip
->num_periods
, buf
->bpl
* chip
->num_periods
);
156 /* Enables corresponding bits at AUD_INT_STAT */
157 cx_write(MO_AUD_INTMSK
, AUD_INT_OPC_ERR
| AUD_INT_DN_SYNC
|
158 AUD_INT_DN_RISCI2
| AUD_INT_DN_RISCI1
);
160 /* Clean any pending interrupt bits already set */
161 cx_write(MO_AUD_INTSTAT
, ~0);
163 /* enable audio irqs */
164 cx_set(MO_PCI_INTMSK
, chip
->core
->pci_irqmask
| PCI_INT_AUDINT
);
167 cx_set(MO_DEV_CNTRL2
, (1<<5)); /* Enables Risc Processor */
168 cx_set(MO_AUD_DMACNTRL
, 0x11); /* audio downstream FIFO and RISC enable */
171 cx88_sram_channel_dump(chip
->core
, audio_ch
);
177 * BOARD Specific: Resets audio DMA
179 static int _cx88_stop_audio_dma(snd_cx88_card_t
*chip
)
181 struct cx88_core
*core
=chip
->core
;
182 dprintk(1, "Stopping audio DMA\n");
185 cx_clear(MO_AUD_DMACNTRL
, 0x11);
188 cx_clear(MO_PCI_INTMSK
, PCI_INT_AUDINT
);
189 cx_clear(MO_AUD_INTMSK
, AUD_INT_OPC_ERR
| AUD_INT_DN_SYNC
|
190 AUD_INT_DN_RISCI2
| AUD_INT_DN_RISCI1
);
193 cx88_sram_channel_dump(chip
->core
, &cx88_sram_channels
[SRAM_CH25
]);
198 #define MAX_IRQ_LOOP 50
201 * BOARD Specific: IRQ dma bits
203 static const char *cx88_aud_irqs
[32] = {
204 "dn_risci1", "up_risci1", "rds_dn_risc1", /* 0-2 */
206 "dn_risci2", "up_risci2", "rds_dn_risc2", /* 4-6 */
208 "dnf_of", "upf_uf", "rds_dnf_uf", /* 8-10 */
210 "dn_sync", "up_sync", "rds_dn_sync", /* 12-14 */
212 "opc_err", "par_err", "rip_err", /* 16-18 */
213 "pci_abort", "ber_irq", "mchg_irq" /* 19-21 */
217 * BOARD Specific: Threats IRQ audio specific calls
219 static void cx8801_aud_irq(snd_cx88_card_t
*chip
)
221 struct cx88_core
*core
= chip
->core
;
224 status
= cx_read(MO_AUD_INTSTAT
);
225 mask
= cx_read(MO_AUD_INTMSK
);
226 if (0 == (status
& mask
))
228 cx_write(MO_AUD_INTSTAT
, status
);
229 if (debug
> 1 || (status
& mask
& ~0xff))
230 cx88_print_irqbits(core
->name
, "irq aud",
231 cx88_aud_irqs
, ARRAY_SIZE(cx88_aud_irqs
),
233 /* risc op code error */
234 if (status
& AUD_INT_OPC_ERR
) {
235 printk(KERN_WARNING
"%s/1: Audio risc op code error\n",core
->name
);
236 cx_clear(MO_AUD_DMACNTRL
, 0x11);
237 cx88_sram_channel_dump(core
, &cx88_sram_channels
[SRAM_CH25
]);
239 if (status
& AUD_INT_DN_SYNC
) {
240 dprintk(1, "Downstream sync error\n");
241 cx_write(MO_AUDD_GPCNTRL
, GP_COUNT_CONTROL_RESET
);
244 /* risc1 downstream */
245 if (status
& AUD_INT_DN_RISCI1
) {
246 atomic_set(&chip
->count
, cx_read(MO_AUDD_GPCNT
));
247 snd_pcm_period_elapsed(chip
->substream
);
249 /* FIXME: Any other status should deserve a special handling? */
253 * BOARD Specific: Handles IRQ calls
255 static irqreturn_t
cx8801_irq(int irq
, void *dev_id
)
257 snd_cx88_card_t
*chip
= dev_id
;
258 struct cx88_core
*core
= chip
->core
;
260 int loop
, handled
= 0;
262 for (loop
= 0; loop
< MAX_IRQ_LOOP
; loop
++) {
263 status
= cx_read(MO_PCI_INTSTAT
) &
264 (core
->pci_irqmask
| PCI_INT_AUDINT
);
267 dprintk(3, "cx8801_irq loop %d/%d, status %x\n",
268 loop
, MAX_IRQ_LOOP
, status
);
270 cx_write(MO_PCI_INTSTAT
, status
);
272 if (status
& core
->pci_irqmask
)
273 cx88_core_irq(core
, status
);
274 if (status
& PCI_INT_AUDINT
)
275 cx8801_aud_irq(chip
);
278 if (MAX_IRQ_LOOP
== loop
) {
280 "%s/1: IRQ loop detected, disabling interrupts\n",
282 cx_clear(MO_PCI_INTMSK
, PCI_INT_AUDINT
);
286 return IRQ_RETVAL(handled
);
290 static int dsp_buffer_free(snd_cx88_card_t
*chip
)
292 BUG_ON(!chip
->dma_size
);
294 dprintk(2,"Freeing buffer\n");
295 videobuf_dma_unmap(&chip
->pci
->dev
, chip
->dma_risc
);
296 videobuf_dma_free(chip
->dma_risc
);
297 btcx_riscmem_free(chip
->pci
,&chip
->buf
->risc
);
300 chip
->dma_risc
= NULL
;
306 /****************************************************************************
308 ****************************************************************************/
311 * Digital hardware definition
313 #define DEFAULT_FIFO_SIZE 4096
314 static const struct snd_pcm_hardware snd_cx88_digital_hw
= {
315 .info
= SNDRV_PCM_INFO_MMAP
|
316 SNDRV_PCM_INFO_INTERLEAVED
|
317 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
318 SNDRV_PCM_INFO_MMAP_VALID
,
319 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
321 .rates
= SNDRV_PCM_RATE_48000
,
326 /* Analog audio output will be full of clicks and pops if there
327 are not exactly four lines in the SRAM FIFO buffer. */
328 .period_bytes_min
= DEFAULT_FIFO_SIZE
/4,
329 .period_bytes_max
= DEFAULT_FIFO_SIZE
/4,
332 .buffer_bytes_max
= (1024*1024),
336 * audio pcm capture open callback
338 static int snd_cx88_pcm_open(struct snd_pcm_substream
*substream
)
340 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
341 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
345 printk(KERN_ERR
"BUG: cx88 can't find device struct."
346 " Can't proceed with open\n");
350 err
= snd_pcm_hw_constraint_pow2(runtime
, 0, SNDRV_PCM_HW_PARAM_PERIODS
);
354 chip
->substream
= substream
;
356 runtime
->hw
= snd_cx88_digital_hw
;
358 if (cx88_sram_channels
[SRAM_CH25
].fifo_size
!= DEFAULT_FIFO_SIZE
) {
359 unsigned int bpl
= cx88_sram_channels
[SRAM_CH25
].fifo_size
/ 4;
360 bpl
&= ~7; /* must be multiple of 8 */
361 runtime
->hw
.period_bytes_min
= bpl
;
362 runtime
->hw
.period_bytes_max
= bpl
;
367 dprintk(1,"Error opening PCM!\n");
372 * audio close callback
374 static int snd_cx88_close(struct snd_pcm_substream
*substream
)
382 static int snd_cx88_hw_params(struct snd_pcm_substream
* substream
,
383 struct snd_pcm_hw_params
* hw_params
)
385 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
386 struct videobuf_dmabuf
*dma
;
388 struct cx88_audio_buffer
*buf
;
391 if (substream
->runtime
->dma_area
) {
392 dsp_buffer_free(chip
);
393 substream
->runtime
->dma_area
= NULL
;
396 chip
->period_size
= params_period_bytes(hw_params
);
397 chip
->num_periods
= params_periods(hw_params
);
398 chip
->dma_size
= chip
->period_size
* params_periods(hw_params
);
400 BUG_ON(!chip
->dma_size
);
401 BUG_ON(chip
->num_periods
& (chip
->num_periods
-1));
403 buf
= kzalloc(sizeof(*buf
), GFP_KERNEL
);
407 buf
->bpl
= chip
->period_size
;
410 videobuf_dma_init(dma
);
411 ret
= videobuf_dma_init_kernel(dma
, PCI_DMA_FROMDEVICE
,
412 (PAGE_ALIGN(chip
->dma_size
) >> PAGE_SHIFT
));
416 ret
= videobuf_dma_map(&chip
->pci
->dev
, dma
);
420 ret
= cx88_risc_databuffer(chip
->pci
, &buf
->risc
, dma
->sglist
,
421 chip
->period_size
, chip
->num_periods
, 1);
425 /* Loop back to start of program */
426 buf
->risc
.jmp
[0] = cpu_to_le32(RISC_JUMP
|RISC_IRQ1
|RISC_CNT_INC
);
427 buf
->risc
.jmp
[1] = cpu_to_le32(buf
->risc
.dma
);
430 chip
->dma_risc
= dma
;
432 substream
->runtime
->dma_area
= chip
->dma_risc
->vaddr
;
433 substream
->runtime
->dma_bytes
= chip
->dma_size
;
434 substream
->runtime
->dma_addr
= 0;
445 static int snd_cx88_hw_free(struct snd_pcm_substream
* substream
)
448 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
450 if (substream
->runtime
->dma_area
) {
451 dsp_buffer_free(chip
);
452 substream
->runtime
->dma_area
= NULL
;
461 static int snd_cx88_prepare(struct snd_pcm_substream
*substream
)
469 static int snd_cx88_card_trigger(struct snd_pcm_substream
*substream
, int cmd
)
471 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
474 /* Local interrupts are already disabled by ALSA */
475 spin_lock(&chip
->reg_lock
);
478 case SNDRV_PCM_TRIGGER_START
:
479 err
=_cx88_start_audio_dma(chip
);
481 case SNDRV_PCM_TRIGGER_STOP
:
482 err
=_cx88_stop_audio_dma(chip
);
489 spin_unlock(&chip
->reg_lock
);
497 static snd_pcm_uframes_t
snd_cx88_pointer(struct snd_pcm_substream
*substream
)
499 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
500 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
503 count
= atomic_read(&chip
->count
);
505 // dprintk(2, "%s - count %d (+%u), period %d, frame %lu\n", __func__,
506 // count, new, count & (runtime->periods-1),
507 // runtime->period_size * (count & (runtime->periods-1)));
508 return runtime
->period_size
* (count
& (runtime
->periods
-1));
512 * page callback (needed for mmap)
514 static struct page
*snd_cx88_page(struct snd_pcm_substream
*substream
,
515 unsigned long offset
)
517 void *pageptr
= substream
->runtime
->dma_area
+ offset
;
518 return vmalloc_to_page(pageptr
);
524 static struct snd_pcm_ops snd_cx88_pcm_ops
= {
525 .open
= snd_cx88_pcm_open
,
526 .close
= snd_cx88_close
,
527 .ioctl
= snd_pcm_lib_ioctl
,
528 .hw_params
= snd_cx88_hw_params
,
529 .hw_free
= snd_cx88_hw_free
,
530 .prepare
= snd_cx88_prepare
,
531 .trigger
= snd_cx88_card_trigger
,
532 .pointer
= snd_cx88_pointer
,
533 .page
= snd_cx88_page
,
537 * create a PCM device
539 static int __devinit
snd_cx88_pcm(snd_cx88_card_t
*chip
, int device
, const char *name
)
544 err
= snd_pcm_new(chip
->card
, name
, device
, 0, 1, &pcm
);
547 pcm
->private_data
= chip
;
548 strcpy(pcm
->name
, name
);
549 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_cx88_pcm_ops
);
554 /****************************************************************************
556 ****************************************************************************/
557 static int snd_cx88_volume_info(struct snd_kcontrol
*kcontrol
,
558 struct snd_ctl_elem_info
*info
)
560 info
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
562 info
->value
.integer
.min
= 0;
563 info
->value
.integer
.max
= 0x3f;
568 static int snd_cx88_volume_get(struct snd_kcontrol
*kcontrol
,
569 struct snd_ctl_elem_value
*value
)
571 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
572 struct cx88_core
*core
=chip
->core
;
573 int vol
= 0x3f - (cx_read(AUD_VOL_CTL
) & 0x3f),
574 bal
= cx_read(AUD_BAL_CTL
);
576 value
->value
.integer
.value
[(bal
& 0x40) ? 0 : 1] = vol
;
578 value
->value
.integer
.value
[(bal
& 0x40) ? 1 : 0] = vol
< 0 ? 0 : vol
;
583 static void snd_cx88_wm8775_volume_put(struct snd_kcontrol
*kcontrol
,
584 struct snd_ctl_elem_value
*value
)
586 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
587 struct cx88_core
*core
= chip
->core
;
588 struct v4l2_control client_ctl
;
589 int left
= value
->value
.integer
.value
[0];
590 int right
= value
->value
.integer
.value
[1];
593 memset(&client_ctl
, 0, sizeof(client_ctl
));
595 /* Pass volume & balance onto any WM8775 */
598 b
= left
? (0x8000 * right
) / left
: 0x8000;
601 b
= right
? 0xffff - (0x8000 * left
) / right
: 0x8000;
603 client_ctl
.value
= v
;
604 client_ctl
.id
= V4L2_CID_AUDIO_VOLUME
;
605 call_hw(core
, WM8775_GID
, core
, s_ctrl
, &client_ctl
);
607 client_ctl
.value
= b
;
608 client_ctl
.id
= V4L2_CID_AUDIO_BALANCE
;
609 call_hw(core
, WM8775_GID
, core
, s_ctrl
, &client_ctl
);
612 /* OK - TODO: test it */
613 static int snd_cx88_volume_put(struct snd_kcontrol
*kcontrol
,
614 struct snd_ctl_elem_value
*value
)
616 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
617 struct cx88_core
*core
=chip
->core
;
618 int left
, right
, v
, b
;
622 if (core
->board
.audio_chip
== V4L2_IDENT_WM8775
)
623 snd_cx88_wm8775_volume_put(kcontrol
, value
);
625 left
= value
->value
.integer
.value
[0] & 0x3f;
626 right
= value
->value
.integer
.value
[1] & 0x3f;
634 /* Do we really know this will always be called with IRQs on? */
635 spin_lock_irq(&chip
->reg_lock
);
636 old
= cx_read(AUD_VOL_CTL
);
637 if (v
!= (old
& 0x3f)) {
638 cx_swrite(SHADOW_AUD_VOL_CTL
, AUD_VOL_CTL
, (old
& ~0x3f) | v
);
641 if ((cx_read(AUD_BAL_CTL
) & 0x7f) != b
) {
642 cx_write(AUD_BAL_CTL
, b
);
645 spin_unlock_irq(&chip
->reg_lock
);
650 static const DECLARE_TLV_DB_SCALE(snd_cx88_db_scale
, -6300, 100, 0);
652 static const struct snd_kcontrol_new snd_cx88_volume
= {
653 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
654 .access
= SNDRV_CTL_ELEM_ACCESS_READWRITE
|
655 SNDRV_CTL_ELEM_ACCESS_TLV_READ
,
656 .name
= "Analog-TV Volume",
657 .info
= snd_cx88_volume_info
,
658 .get
= snd_cx88_volume_get
,
659 .put
= snd_cx88_volume_put
,
660 .tlv
.p
= snd_cx88_db_scale
,
663 static int snd_cx88_switch_get(struct snd_kcontrol
*kcontrol
,
664 struct snd_ctl_elem_value
*value
)
666 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
667 struct cx88_core
*core
= chip
->core
;
668 u32 bit
= kcontrol
->private_value
;
670 value
->value
.integer
.value
[0] = !(cx_read(AUD_VOL_CTL
) & bit
);
674 static int snd_cx88_switch_put(struct snd_kcontrol
*kcontrol
,
675 struct snd_ctl_elem_value
*value
)
677 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
678 struct cx88_core
*core
= chip
->core
;
679 u32 bit
= kcontrol
->private_value
;
683 spin_lock_irq(&chip
->reg_lock
);
684 vol
= cx_read(AUD_VOL_CTL
);
685 if (value
->value
.integer
.value
[0] != !(vol
& bit
)) {
687 cx_swrite(SHADOW_AUD_VOL_CTL
, AUD_VOL_CTL
, vol
);
688 /* Pass mute onto any WM8775 */
689 if ((core
->board
.audio_chip
== V4L2_IDENT_WM8775
) &&
691 struct v4l2_control client_ctl
;
693 memset(&client_ctl
, 0, sizeof(client_ctl
));
694 client_ctl
.value
= 0 != (vol
& bit
);
695 client_ctl
.id
= V4L2_CID_AUDIO_MUTE
;
696 call_hw(core
, WM8775_GID
, core
, s_ctrl
, &client_ctl
);
700 spin_unlock_irq(&chip
->reg_lock
);
704 static const struct snd_kcontrol_new snd_cx88_dac_switch
= {
705 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
706 .name
= "Audio-Out Switch",
707 .info
= snd_ctl_boolean_mono_info
,
708 .get
= snd_cx88_switch_get
,
709 .put
= snd_cx88_switch_put
,
710 .private_value
= (1<<8),
713 static const struct snd_kcontrol_new snd_cx88_source_switch
= {
714 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
715 .name
= "Analog-TV Switch",
716 .info
= snd_ctl_boolean_mono_info
,
717 .get
= snd_cx88_switch_get
,
718 .put
= snd_cx88_switch_put
,
719 .private_value
= (1<<6),
722 static int snd_cx88_alc_get(struct snd_kcontrol
*kcontrol
,
723 struct snd_ctl_elem_value
*value
)
725 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
726 struct cx88_core
*core
= chip
->core
;
727 struct v4l2_control client_ctl
;
729 memset(&client_ctl
, 0, sizeof(client_ctl
));
730 client_ctl
.id
= V4L2_CID_AUDIO_LOUDNESS
;
731 call_hw(core
, WM8775_GID
, core
, g_ctrl
, &client_ctl
);
732 value
->value
.integer
.value
[0] = client_ctl
.value
? 1 : 0;
737 static int snd_cx88_alc_put(struct snd_kcontrol
*kcontrol
,
738 struct snd_ctl_elem_value
*value
)
740 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
741 struct cx88_core
*core
= chip
->core
;
742 struct v4l2_control client_ctl
;
744 memset(&client_ctl
, 0, sizeof(client_ctl
));
745 client_ctl
.value
= 0 != value
->value
.integer
.value
[0];
746 client_ctl
.id
= V4L2_CID_AUDIO_LOUDNESS
;
747 call_hw(core
, WM8775_GID
, core
, s_ctrl
, &client_ctl
);
752 static struct snd_kcontrol_new snd_cx88_alc_switch
= {
753 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
754 .name
= "Line-In ALC Switch",
755 .info
= snd_ctl_boolean_mono_info
,
756 .get
= snd_cx88_alc_get
,
757 .put
= snd_cx88_alc_put
,
760 /****************************************************************************
761 Basic Flow for Sound Devices
762 ****************************************************************************/
765 * PCI ID Table - 14f1:8801 and 14f1:8811 means function 1: Audio
766 * Only boards with eeprom and byte 1 at eeprom=1 have it
769 static const struct pci_device_id
const cx88_audio_pci_tbl
[] __devinitdata
= {
770 {0x14f1,0x8801,PCI_ANY_ID
,PCI_ANY_ID
,0,0,0},
771 {0x14f1,0x8811,PCI_ANY_ID
,PCI_ANY_ID
,0,0,0},
774 MODULE_DEVICE_TABLE(pci
, cx88_audio_pci_tbl
);
777 * Chip-specific destructor
780 static int snd_cx88_free(snd_cx88_card_t
*chip
)
784 free_irq(chip
->irq
, chip
);
786 cx88_core_put(chip
->core
,chip
->pci
);
788 pci_disable_device(chip
->pci
);
793 * Component Destructor
795 static void snd_cx88_dev_free(struct snd_card
* card
)
797 snd_cx88_card_t
*chip
= card
->private_data
;
804 * Alsa Constructor - Component probe
808 static int __devinit
snd_cx88_create(struct snd_card
*card
,
810 snd_cx88_card_t
**rchip
,
811 struct cx88_core
**core_ptr
)
813 snd_cx88_card_t
*chip
;
814 struct cx88_core
*core
;
816 unsigned char pci_lat
;
820 err
= pci_enable_device(pci
);
826 chip
= card
->private_data
;
828 core
= cx88_core_get(pci
);
834 if (!pci_dma_supported(pci
,DMA_BIT_MASK(32))) {
835 dprintk(0, "%s/1: Oops: no 32bit PCI DMA ???\n",core
->name
);
837 cx88_core_put(core
, pci
);
846 spin_lock_init(&chip
->reg_lock
);
851 err
= request_irq(chip
->pci
->irq
, cx8801_irq
,
852 IRQF_SHARED
| IRQF_DISABLED
, chip
->core
->name
, chip
);
854 dprintk(0, "%s: can't get IRQ %d\n",
855 chip
->core
->name
, chip
->pci
->irq
);
860 pci_read_config_byte(pci
, PCI_LATENCY_TIMER
, &pci_lat
);
862 dprintk(1,"ALSA %s/%i: found at %s, rev: %d, irq: %d, "
863 "latency: %d, mmio: 0x%llx\n", core
->name
, devno
,
864 pci_name(pci
), pci
->revision
, pci
->irq
,
865 pci_lat
, (unsigned long long)pci_resource_start(pci
,0));
867 chip
->irq
= pci
->irq
;
868 synchronize_irq(chip
->irq
);
870 snd_card_set_dev(card
, &pci
->dev
);
878 static int __devinit
cx88_audio_initdev(struct pci_dev
*pci
,
879 const struct pci_device_id
*pci_id
)
881 struct snd_card
*card
;
882 snd_cx88_card_t
*chip
;
883 struct cx88_core
*core
= NULL
;
886 if (devno
>= SNDRV_CARDS
)
889 if (!enable
[devno
]) {
894 err
= snd_card_create(index
[devno
], id
[devno
], THIS_MODULE
,
895 sizeof(snd_cx88_card_t
), &card
);
899 card
->private_free
= snd_cx88_dev_free
;
901 err
= snd_cx88_create(card
, pci
, &chip
, &core
);
905 err
= snd_cx88_pcm(chip
, 0, "CX88 Digital");
909 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_cx88_volume
, chip
));
912 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_cx88_dac_switch
, chip
));
915 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_cx88_source_switch
, chip
));
919 /* If there's a wm8775 then add a Line-In ALC switch */
920 if (core
->board
.audio_chip
== V4L2_IDENT_WM8775
)
921 snd_ctl_add(card
, snd_ctl_new1(&snd_cx88_alc_switch
, chip
));
923 strcpy (card
->driver
, "CX88x");
924 sprintf(card
->shortname
, "Conexant CX%x", pci
->device
);
925 sprintf(card
->longname
, "%s at %#llx",
926 card
->shortname
,(unsigned long long)pci_resource_start(pci
, 0));
927 strcpy (card
->mixername
, "CX88");
929 dprintk (0, "%s/%i: ALSA support for cx2388x boards\n",
932 err
= snd_card_register(card
);
935 pci_set_drvdata(pci
,card
);
947 static void __devexit
cx88_audio_finidev(struct pci_dev
*pci
)
949 struct cx88_audio_dev
*card
= pci_get_drvdata(pci
);
951 snd_card_free((void *)card
);
953 pci_set_drvdata(pci
, NULL
);
959 * PCI driver definition
962 static struct pci_driver cx88_audio_pci_driver
= {
963 .name
= "cx88_audio",
964 .id_table
= cx88_audio_pci_tbl
,
965 .probe
= cx88_audio_initdev
,
966 .remove
= __devexit_p(cx88_audio_finidev
),
969 /****************************************************************************
971 ****************************************************************************/
976 static int __init
cx88_audio_init(void)
978 printk(KERN_INFO
"cx2388x alsa driver version %s loaded\n",
980 return pci_register_driver(&cx88_audio_pci_driver
);
986 static void __exit
cx88_audio_fini(void)
988 pci_unregister_driver(&cx88_audio_pci_driver
);
991 module_init(cx88_audio_init
);
992 module_exit(cx88_audio_fini
);