3 * Support for audio capture
4 * PCI function #1 of the cx2388x.
6 * (c) 2005,2006 Ricardo Cerqueira <v4l@cerqueira.org>
7 * (c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org>
8 * Based on a dummy cx88 module by Gerd Knorr <kraxel@bytesex.org>
9 * Based on dummy.c by Jaroslav Kysela <perex@suse.cz>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/device.h>
29 #include <linux/interrupt.h>
30 #include <linux/dma-mapping.h>
32 #include <asm/delay.h>
33 #include <sound/driver.h>
34 #include <sound/core.h>
35 #include <sound/pcm.h>
36 #include <sound/pcm_params.h>
37 #include <sound/control.h>
38 #include <sound/initval.h>
43 #define dprintk(level,fmt, arg...) if (debug >= level) \
44 printk(KERN_INFO "%s/1: " fmt, chip->core->name , ## arg)
46 #define dprintk_core(level,fmt, arg...) if (debug >= level) \
47 printk(KERN_DEBUG "%s/1: " fmt, chip->core->name , ## arg)
50 /****************************************************************************
51 Data type declarations - Can be moded to a header file later
52 ****************************************************************************/
54 /* These can be replaced after done */
55 #define MIXER_ADDR_LAST MAX_CX88_INPUT
57 struct cx88_audio_dev
{
58 struct cx88_core
*core
;
59 struct cx88_dmaqueue q
;
63 unsigned char pci_rev
,pci_lat
;
68 struct snd_card
*card
;
72 unsigned int dma_size
;
73 unsigned int period_size
;
74 unsigned int num_periods
;
76 struct videobuf_dmabuf dma_risc
;
78 int mixer_volume
[MIXER_ADDR_LAST
+1][2];
79 int capture_source
[MIXER_ADDR_LAST
+1][2];
84 struct cx88_buffer
*buf
;
87 struct snd_pcm_substream
*substream
;
90 typedef struct cx88_audio_dev snd_cx88_card_t
;
94 /****************************************************************************
95 Module global static vars
96 ****************************************************************************/
98 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
99 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
100 static int enable
[SNDRV_CARDS
] = {1, [1 ... (SNDRV_CARDS
- 1)] = 1};
101 static struct snd_card
*snd_cx88_cards
[SNDRV_CARDS
];
103 module_param_array(enable
, bool, NULL
, 0444);
104 MODULE_PARM_DESC(enable
, "Enable cx88x soundcard. default enabled.");
106 module_param_array(index
, int, NULL
, 0444);
107 MODULE_PARM_DESC(index
, "Index value for cx88x capture interface(s).");
110 /****************************************************************************
112 ****************************************************************************/
114 MODULE_DESCRIPTION("ALSA driver module for cx2388x based TV cards");
115 MODULE_AUTHOR("Ricardo Cerqueira");
116 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
117 MODULE_LICENSE("GPL");
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_buffer
*buf
= chip
->buf
;
136 struct cx88_core
*core
=chip
->core
;
137 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
);
151 dprintk(1, "Start audio DMA, %d B/line, %d lines/FIFO, %d lines/irq, "
152 "%d B/irq\n", buf
->bpl
, cx_read(audio_ch
->cmds_start
+ 8)>>1,
153 chip
->num_periods
, buf
->bpl
* chip
->num_periods
);
155 dprintk(1, "Enabling IRQ, setting mask from 0x%x to 0x%x\n",
156 chip
->core
->pci_irqmask
,
157 chip
->core
->pci_irqmask
| PCI_INT_AUDINT
);
159 /* Enables corresponding bits at AUD_INT_STAT */
160 cx_write(MO_AUD_INTMSK
, AUD_INT_OPC_ERR
| AUD_INT_DN_SYNC
|
161 AUD_INT_DN_RISCI2
| AUD_INT_DN_RISCI1
);
163 /* Clean any pending interrupt bits already set */
164 cx_write(MO_AUD_INTSTAT
, ~0);
166 /* enable audio irqs */
167 cx_set(MO_PCI_INTMSK
, chip
->core
->pci_irqmask
| PCI_INT_AUDINT
);
170 cx_set(MO_DEV_CNTRL2
, (1<<5)); /* Enables Risc Processor */
171 cx_set(MO_AUD_DMACNTRL
, 0x11); /* audio downstream FIFO and RISC enable */
174 cx88_sram_channel_dump(chip
->core
, audio_ch
);
180 * BOARD Specific: Resets audio DMA
182 static int _cx88_stop_audio_dma(snd_cx88_card_t
*chip
)
184 struct cx88_core
*core
=chip
->core
;
185 dprintk(1, "Stopping audio DMA\n");
188 cx_clear(MO_AUD_DMACNTRL
, 0x11);
191 cx_clear(MO_PCI_INTMSK
, PCI_INT_AUDINT
);
192 cx_clear(MO_AUD_INTMSK
, AUD_INT_OPC_ERR
| AUD_INT_DN_SYNC
|
193 AUD_INT_DN_RISCI2
| AUD_INT_DN_RISCI1
);
196 cx88_sram_channel_dump(chip
->core
, &cx88_sram_channels
[SRAM_CH25
]);
201 #define MAX_IRQ_LOOP 10
204 * BOARD Specific: IRQ dma bits
206 static char *cx88_aud_irqs
[32] = {
207 "dn_risci1", "up_risci1", "rds_dn_risc1", /* 0-2 */
209 "dn_risci2", "up_risci2", "rds_dn_risc2", /* 4-6 */
211 "dnf_of", "upf_uf", "rds_dnf_uf", /* 8-10 */
213 "dn_sync", "up_sync", "rds_dn_sync", /* 12-14 */
215 "opc_err", "par_err", "rip_err", /* 16-18 */
216 "pci_abort", "ber_irq", "mchg_irq" /* 19-21 */
220 * BOARD Specific: Threats IRQ audio specific calls
222 static void cx8801_aud_irq(snd_cx88_card_t
*chip
)
224 struct cx88_core
*core
= chip
->core
;
228 status
= cx_read(MO_AUD_INTSTAT
);
229 mask
= cx_read(MO_AUD_INTMSK
);
230 if (0 == (status
& mask
)) {
231 spin_unlock(&chip
->reg_lock
);
234 cx_write(MO_AUD_INTSTAT
, status
);
235 if (debug
> 1 || (status
& mask
& ~0xff))
236 cx88_print_irqbits(core
->name
, "irq aud",
237 cx88_aud_irqs
, ARRAY_SIZE(cx88_aud_irqs
),
239 /* risc op code error */
240 if (status
& AUD_INT_OPC_ERR
) {
241 printk(KERN_WARNING
"%s/0: audio risc op code error\n",core
->name
);
242 cx_clear(MO_AUD_DMACNTRL
, 0x11);
243 cx88_sram_channel_dump(core
, &cx88_sram_channels
[SRAM_CH25
]);
246 /* risc1 downstream */
247 if (status
& AUD_INT_DN_RISCI1
) {
248 spin_lock(&chip
->reg_lock
);
249 count
= cx_read(MO_AUDD_GPCNT
);
250 spin_unlock(&chip
->reg_lock
);
251 if (chip
->read_count
== 0)
252 chip
->read_count
+= chip
->dma_size
;
255 if (chip
->read_count
>= chip
->period_size
) {
256 dprintk(2, "Elapsing period\n");
257 snd_pcm_period_elapsed(chip
->substream
);
260 dprintk(3,"Leaving audio IRQ handler...\n");
262 /* FIXME: Any other status should deserve a special handling? */
266 * BOARD Specific: Handles IRQ calls
268 static irqreturn_t
cx8801_irq(int irq
, void *dev_id
)
270 snd_cx88_card_t
*chip
= dev_id
;
271 struct cx88_core
*core
= chip
->core
;
273 int loop
, handled
= 0;
275 for (loop
= 0; loop
< MAX_IRQ_LOOP
; loop
++) {
276 status
= cx_read(MO_PCI_INTSTAT
) &
277 (core
->pci_irqmask
| PCI_INT_AUDINT
);
280 dprintk( 3, "cx8801_irq\n" );
281 dprintk( 3, " loop: %d/%d\n", loop
, MAX_IRQ_LOOP
);
282 dprintk( 3, " status: %d\n", status
);
284 cx_write(MO_PCI_INTSTAT
, status
);
286 if (status
& core
->pci_irqmask
)
287 cx88_core_irq(core
, status
);
288 if (status
& PCI_INT_AUDINT
) {
289 dprintk( 2, " ALSA IRQ handling\n" );
290 cx8801_aud_irq(chip
);
294 if (MAX_IRQ_LOOP
== loop
) {
295 dprintk( 0, "clearing mask\n" );
296 dprintk(1,"%s/0: irq loop -- clearing mask\n",
298 cx_clear(MO_PCI_INTMSK
, PCI_INT_AUDINT
);
302 return IRQ_RETVAL(handled
);
306 static int dsp_buffer_free(snd_cx88_card_t
*chip
)
308 BUG_ON(!chip
->dma_size
);
310 dprintk(2,"Freeing buffer\n");
311 videobuf_pci_dma_unmap(chip
->pci
, &chip
->dma_risc
);
312 videobuf_dma_free(&chip
->dma_risc
);
313 btcx_riscmem_free(chip
->pci
,&chip
->buf
->risc
);
321 /****************************************************************************
323 ****************************************************************************/
326 * Digital hardware definition
328 static struct snd_pcm_hardware snd_cx88_digital_hw
= {
329 .info
= SNDRV_PCM_INFO_MMAP
|
330 SNDRV_PCM_INFO_INTERLEAVED
|
331 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
332 SNDRV_PCM_INFO_MMAP_VALID
,
333 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
335 .rates
= SNDRV_PCM_RATE_48000
,
340 .buffer_bytes_max
= (2*2048),
341 .period_bytes_min
= 2048,
342 .period_bytes_max
= 2048,
348 * audio pcm capture runtime free
350 static void snd_card_cx88_runtime_free(struct snd_pcm_runtime
*runtime
)
354 * audio pcm capture open callback
356 static int snd_cx88_pcm_open(struct snd_pcm_substream
*substream
)
358 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
359 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
362 if (test_and_set_bit(0, &chip
->opened
))
365 err
= snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
369 chip
->substream
= substream
;
371 chip
->read_count
= 0;
372 chip
->read_offset
= 0;
374 runtime
->private_free
= snd_card_cx88_runtime_free
;
375 runtime
->hw
= snd_cx88_digital_hw
;
379 dprintk(1,"Error opening PCM!\n");
380 clear_bit(0, &chip
->opened
);
381 smp_mb__after_clear_bit();
386 * audio close callback
388 static int snd_cx88_close(struct snd_pcm_substream
*substream
)
390 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
392 clear_bit(0, &chip
->opened
);
393 smp_mb__after_clear_bit();
401 static int snd_cx88_hw_params(struct snd_pcm_substream
* substream
,
402 struct snd_pcm_hw_params
* hw_params
)
404 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
405 struct cx88_buffer
*buf
;
407 if (substream
->runtime
->dma_area
) {
408 dsp_buffer_free(chip
);
409 substream
->runtime
->dma_area
= NULL
;
413 chip
->period_size
= params_period_bytes(hw_params
);
414 chip
->num_periods
= params_periods(hw_params
);
415 chip
->dma_size
= chip
->period_size
* params_periods(hw_params
);
417 BUG_ON(!chip
->dma_size
);
419 dprintk(1,"Setting buffer\n");
421 buf
= kzalloc(sizeof(*buf
),GFP_KERNEL
);
425 buf
->vb
.memory
= V4L2_MEMORY_MMAP
;
426 buf
->vb
.width
= chip
->period_size
;
427 buf
->vb
.height
= chip
->num_periods
;
428 buf
->vb
.size
= chip
->dma_size
;
429 buf
->vb
.field
= V4L2_FIELD_NONE
;
431 videobuf_dma_init(&buf
->vb
.dma
);
432 videobuf_dma_init_kernel(&buf
->vb
.dma
,PCI_DMA_FROMDEVICE
,
433 (PAGE_ALIGN(buf
->vb
.size
) >> PAGE_SHIFT
));
435 videobuf_pci_dma_map(chip
->pci
,&buf
->vb
.dma
);
438 cx88_risc_databuffer(chip
->pci
, &buf
->risc
,
440 buf
->vb
.width
, buf
->vb
.height
);
442 buf
->risc
.jmp
[0] = cpu_to_le32(RISC_JUMP
| RISC_IRQ1
| RISC_CNT_INC
);
443 buf
->risc
.jmp
[1] = cpu_to_le32(buf
->risc
.dma
);
445 buf
->vb
.state
= STATE_PREPARED
;
447 buf
->bpl
= chip
->period_size
;
449 chip
->dma_risc
= buf
->vb
.dma
;
451 dprintk(1,"Buffer ready at %u\n",chip
->dma_risc
.nr_pages
);
452 substream
->runtime
->dma_area
= chip
->dma_risc
.vmalloc
;
459 static int snd_cx88_hw_free(struct snd_pcm_substream
* substream
)
462 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
464 if (substream
->runtime
->dma_area
) {
465 dsp_buffer_free(chip
);
466 substream
->runtime
->dma_area
= NULL
;
475 static int snd_cx88_prepare(struct snd_pcm_substream
*substream
)
484 static int snd_cx88_card_trigger(struct snd_pcm_substream
*substream
, int cmd
)
486 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
489 spin_lock(&chip
->reg_lock
);
492 case SNDRV_PCM_TRIGGER_START
:
493 err
=_cx88_start_audio_dma(chip
);
495 case SNDRV_PCM_TRIGGER_STOP
:
496 err
=_cx88_stop_audio_dma(chip
);
503 spin_unlock(&chip
->reg_lock
);
511 static snd_pcm_uframes_t
snd_cx88_pointer(struct snd_pcm_substream
*substream
)
513 snd_cx88_card_t
*chip
= snd_pcm_substream_chip(substream
);
514 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
516 if (chip
->read_count
) {
517 chip
->read_count
-= snd_pcm_lib_period_bytes(substream
);
518 chip
->read_offset
+= snd_pcm_lib_period_bytes(substream
);
519 if (chip
->read_offset
== chip
->dma_size
)
520 chip
->read_offset
= 0;
523 dprintk(2, "Pointer time, will return %li, read %li\n",chip
->read_offset
,chip
->read_count
);
524 return bytes_to_frames(runtime
, chip
->read_offset
);
531 static struct snd_pcm_ops snd_cx88_pcm_ops
= {
532 .open
= snd_cx88_pcm_open
,
533 .close
= snd_cx88_close
,
534 .ioctl
= snd_pcm_lib_ioctl
,
535 .hw_params
= snd_cx88_hw_params
,
536 .hw_free
= snd_cx88_hw_free
,
537 .prepare
= snd_cx88_prepare
,
538 .trigger
= snd_cx88_card_trigger
,
539 .pointer
= snd_cx88_pointer
,
543 * create a PCM device
545 static int __devinit
snd_cx88_pcm(snd_cx88_card_t
*chip
, int device
, char *name
)
550 err
= snd_pcm_new(chip
->card
, name
, device
, 0, 1, &pcm
);
553 pcm
->private_data
= chip
;
554 strcpy(pcm
->name
, name
);
555 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_cx88_pcm_ops
);
560 /****************************************************************************
562 ****************************************************************************/
563 static int snd_cx88_capture_volume_info(struct snd_kcontrol
*kcontrol
,
564 struct snd_ctl_elem_info
*info
)
566 info
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
568 info
->value
.integer
.min
= 0;
569 info
->value
.integer
.max
= 0x3f;
574 /* OK - TODO: test it */
575 static int snd_cx88_capture_volume_get(struct snd_kcontrol
*kcontrol
,
576 struct snd_ctl_elem_value
*value
)
578 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
579 struct cx88_core
*core
=chip
->core
;
581 value
->value
.integer
.value
[0] = 0x3f - (cx_read(AUD_VOL_CTL
) & 0x3f);
586 /* OK - TODO: test it */
587 static int snd_cx88_capture_volume_put(struct snd_kcontrol
*kcontrol
,
588 struct snd_ctl_elem_value
*value
)
590 snd_cx88_card_t
*chip
= snd_kcontrol_chip(kcontrol
);
591 struct cx88_core
*core
=chip
->core
;
595 spin_lock_irq(&chip
->reg_lock
);
596 old_control
= 0x3f - (cx_read(AUD_VOL_CTL
) & 0x3f);
597 v
= 0x3f - (value
->value
.integer
.value
[0] & 0x3f);
598 cx_andor(AUD_VOL_CTL
, 0x3f, v
);
599 spin_unlock_irq(&chip
->reg_lock
);
601 return v
!= old_control
;
604 static struct snd_kcontrol_new snd_cx88_capture_volume
= {
605 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
606 .name
= "Capture Volume",
607 .info
= snd_cx88_capture_volume_info
,
608 .get
= snd_cx88_capture_volume_get
,
609 .put
= snd_cx88_capture_volume_put
,
613 /****************************************************************************
614 Basic Flow for Sound Devices
615 ****************************************************************************/
618 * PCI ID Table - 14f1:8801 and 14f1:8811 means function 1: Audio
619 * Only boards with eeprom and byte 1 at eeprom=1 have it
622 static struct pci_device_id cx88_audio_pci_tbl
[] __devinitdata
= {
623 {0x14f1,0x8801,PCI_ANY_ID
,PCI_ANY_ID
,0,0,0},
624 {0x14f1,0x8811,PCI_ANY_ID
,PCI_ANY_ID
,0,0,0},
627 MODULE_DEVICE_TABLE(pci
, cx88_audio_pci_tbl
);
630 * Chip-specific destructor
633 static int snd_cx88_free(snd_cx88_card_t
*chip
)
637 synchronize_irq(chip
->irq
);
638 free_irq(chip
->irq
, chip
);
641 cx88_core_put(chip
->core
,chip
->pci
);
643 pci_disable_device(chip
->pci
);
648 * Component Destructor
650 static void snd_cx88_dev_free(struct snd_card
* card
)
652 snd_cx88_card_t
*chip
= card
->private_data
;
659 * Alsa Constructor - Component probe
663 static int __devinit
snd_cx88_create(struct snd_card
*card
,
665 snd_cx88_card_t
**rchip
)
667 snd_cx88_card_t
*chip
;
668 struct cx88_core
*core
;
673 err
= pci_enable_device(pci
);
679 chip
= (snd_cx88_card_t
*) card
->private_data
;
681 core
= cx88_core_get(pci
);
688 if (!pci_dma_supported(pci
,DMA_32BIT_MASK
)) {
689 dprintk(0, "%s/1: Oops: no 32bit PCI DMA ???\n",core
->name
);
691 cx88_core_put(core
,pci
);
700 spin_lock_init(&chip
->reg_lock
);
705 err
= request_irq(chip
->pci
->irq
, cx8801_irq
,
706 IRQF_SHARED
| IRQF_DISABLED
, chip
->core
->name
, chip
);
708 dprintk(0, "%s: can't get IRQ %d\n",
709 chip
->core
->name
, chip
->pci
->irq
);
714 pci_read_config_byte(pci
, PCI_CLASS_REVISION
, &chip
->pci_rev
);
715 pci_read_config_byte(pci
, PCI_LATENCY_TIMER
, &chip
->pci_lat
);
717 dprintk(1,"ALSA %s/%i: found at %s, rev: %d, irq: %d, "
718 "latency: %d, mmio: 0x%llx\n", core
->name
, devno
,
719 pci_name(pci
), chip
->pci_rev
, pci
->irq
,
720 chip
->pci_lat
,(unsigned long long)pci_resource_start(pci
,0));
722 chip
->irq
= pci
->irq
;
723 synchronize_irq(chip
->irq
);
725 snd_card_set_dev(card
, &pci
->dev
);
732 static int __devinit
cx88_audio_initdev(struct pci_dev
*pci
,
733 const struct pci_device_id
*pci_id
)
735 struct snd_card
*card
;
736 snd_cx88_card_t
*chip
;
739 if (devno
>= SNDRV_CARDS
)
742 if (!enable
[devno
]) {
747 card
= snd_card_new(index
[devno
], id
[devno
], THIS_MODULE
, sizeof(snd_cx88_card_t
));
751 card
->private_free
= snd_cx88_dev_free
;
753 err
= snd_cx88_create(card
, pci
, &chip
);
757 err
= snd_cx88_pcm(chip
, 0, "CX88 Digital");
764 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_cx88_capture_volume
, chip
));
770 strcpy (card
->driver
, "CX88x");
771 sprintf(card
->shortname
, "Conexant CX%x", pci
->device
);
772 sprintf(card
->longname
, "%s at %#llx",
773 card
->shortname
,(unsigned long long)pci_resource_start(pci
, 0));
774 strcpy (card
->mixername
, "CX88");
776 dprintk (0, "%s/%i: ALSA support for cx2388x boards\n",
779 err
= snd_card_register(card
);
784 snd_cx88_cards
[devno
] = card
;
786 pci_set_drvdata(pci
,card
);
794 static void __devexit
cx88_audio_finidev(struct pci_dev
*pci
)
796 struct cx88_audio_dev
*card
= pci_get_drvdata(pci
);
798 snd_card_free((void *)card
);
800 pci_set_drvdata(pci
, NULL
);
806 * PCI driver definition
809 static struct pci_driver cx88_audio_pci_driver
= {
810 .name
= "cx88_audio",
811 .id_table
= cx88_audio_pci_tbl
,
812 .probe
= cx88_audio_initdev
,
813 .remove
= cx88_audio_finidev
,
816 /****************************************************************************
818 ****************************************************************************/
823 static int cx88_audio_init(void)
825 printk(KERN_INFO
"cx2388x alsa driver version %d.%d.%d loaded\n",
826 (CX88_VERSION_CODE
>> 16) & 0xff,
827 (CX88_VERSION_CODE
>> 8) & 0xff,
828 CX88_VERSION_CODE
& 0xff);
830 printk(KERN_INFO
"cx2388x: snapshot date %04d-%02d-%02d\n",
831 SNAPSHOT
/10000, (SNAPSHOT
/100)%100, SNAPSHOT
%100);
833 return pci_register_driver(&cx88_audio_pci_driver
);
839 static void cx88_audio_fini(void)
842 pci_unregister_driver(&cx88_audio_pci_driver
);
845 module_init(cx88_audio_init
);
846 module_exit(cx88_audio_fini
);
848 /* ----------------------------------------------------------- */