2 * BRIEF MODULE DESCRIPTION
3 * Driver for AMD Au1000 MIPS Processor, AC'97 Sound Port
5 * Copyright 2004 Cooper Street Innovations Inc.
6 * Author: Charles Eidsness <charles@cooper-street.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
13 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
14 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
15 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
16 * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
19 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 * You should have received a copy of the GNU General Public License along
25 * with this program; if not, write to the Free Software Foundation, Inc.,
26 * 675 Mass Ave, Cambridge, MA 02139, USA.
30 * 2004-09-09 Charles Eidsness -- Original verion -- based on
31 * sa11xx-uda1341.c ALSA driver and the
32 * au1000.c OSS driver.
33 * 2004-09-09 Matt Porter -- Added support for ALSA 1.0.6
37 #include <linux/ioport.h>
38 #include <linux/interrupt.h>
39 #include <sound/driver.h>
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/version.h>
43 #include <sound/core.h>
44 #include <sound/initval.h>
45 #include <sound/pcm.h>
46 #include <sound/ac97_codec.h>
47 #include <asm/mach-au1x00/au1000.h>
48 #include <asm/mach-au1x00/au1000_dma.h>
50 MODULE_AUTHOR("Charles Eidsness <charles@cooper-street.com>");
51 MODULE_DESCRIPTION("Au1000 AC'97 ALSA Driver");
52 MODULE_LICENSE("GPL");
53 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
54 MODULE_SUPPORTED_DEVICE("{{AMD,Au1000 AC'97}}");
56 MODULE_CLASSES("{sound}");
57 MODULE_DEVICES("{{AMD,Au1000 AC'97}}");
62 #define AC97_SLOT_3 0x01
63 #define AC97_SLOT_4 0x02
64 #define AC97_SLOT_6 0x08
65 #define AC97_CMD_IRQ 31
71 DECLARE_WAIT_QUEUE_HEAD(ac97_command_wq
);
73 typedef struct au1000_period au1000_period_t
;
77 u32 relative_end
; /*realtive to start of buffer*/
78 au1000_period_t
* next
;
81 /*Au1000 AC97 Port Control Reisters*/
82 typedef struct au1000_ac97_reg au1000_ac97_reg_t
;
83 struct au1000_ac97_reg
{
91 typedef struct audio_stream audio_stream_t
;
93 snd_pcm_substream_t
* substream
;
96 au1000_period_t
* buffer
;
97 unsigned long period_size
;
100 typedef struct snd_card_au1000
{
102 au1000_ac97_reg_t
volatile *ac97_ioport
;
104 struct resource
*ac97_res_port
;
105 spinlock_t ac97_lock
;
109 audio_stream_t
*stream
[2]; /* playback & capture */
112 static au1000_t
*au1000
= NULL
;
114 /*--------------------------- Local Functions --------------------------------*/
116 au1000_set_ac97_xmit_slots(long xmit_slots
)
118 u32
volatile ac97_config
;
120 spin_lock(&au1000
->ac97_lock
);
121 ac97_config
= au1000
->ac97_ioport
->config
;
122 ac97_config
= ac97_config
& ~AC97C_XMIT_SLOTS_MASK
;
123 ac97_config
|= (xmit_slots
<< AC97C_XMIT_SLOTS_BIT
);
124 au1000
->ac97_ioport
->config
= ac97_config
;
125 spin_unlock(&au1000
->ac97_lock
);
129 au1000_set_ac97_recv_slots(long recv_slots
)
131 u32
volatile ac97_config
;
133 spin_lock(&au1000
->ac97_lock
);
134 ac97_config
= au1000
->ac97_ioport
->config
;
135 ac97_config
= ac97_config
& ~AC97C_RECV_SLOTS_MASK
;
136 ac97_config
|= (recv_slots
<< AC97C_RECV_SLOTS_BIT
);
137 au1000
->ac97_ioport
->config
= ac97_config
;
138 spin_unlock(&au1000
->ac97_lock
);
143 au1000_dma_stop(audio_stream_t
*stream
)
146 au1000_period_t
* pointer
;
147 au1000_period_t
* pointer_next
;
149 if (stream
->buffer
!= NULL
) {
150 spin_lock_irqsave(&stream
->dma_lock
, flags
);
151 disable_dma(stream
->dma
);
152 spin_unlock_irqrestore(&stream
->dma_lock
, flags
);
154 pointer
= stream
->buffer
;
155 pointer_next
= stream
->buffer
->next
;
159 pointer
= pointer_next
;
160 pointer_next
= pointer
->next
;
161 } while (pointer
!= stream
->buffer
);
163 stream
->buffer
= NULL
;
168 au1000_dma_start(audio_stream_t
*stream
)
170 snd_pcm_substream_t
*substream
= stream
->substream
;
171 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
173 unsigned long flags
, dma_start
;
175 au1000_period_t
* pointer
;
177 if (stream
->buffer
== NULL
) {
178 dma_start
= virt_to_phys(runtime
->dma_area
);
180 stream
->period_size
= frames_to_bytes(runtime
,
181 runtime
->period_size
);
182 stream
->buffer
= kmalloc(sizeof(au1000_period_t
), GFP_KERNEL
);
183 pointer
= stream
->buffer
;
184 for (i
= 0 ; i
< runtime
->periods
; i
++) {
185 pointer
->start
= (u32
)(dma_start
+
186 (i
* stream
->period_size
));
187 pointer
->relative_end
= (u32
)
188 (((i
+1) * stream
->period_size
) - 0x1);
189 if ( i
< runtime
->periods
- 1) {
190 pointer
->next
= kmalloc(sizeof(au1000_period_t
)
192 pointer
= pointer
->next
;
195 pointer
->next
= stream
->buffer
;
197 spin_lock_irqsave(&stream
->dma_lock
, flags
);
198 init_dma(stream
->dma
);
199 if (get_dma_active_buffer(stream
->dma
) == 0) {
200 clear_dma_done0(stream
->dma
);
201 set_dma_addr0(stream
->dma
, stream
->buffer
->start
);
202 set_dma_count0(stream
->dma
, stream
->period_size
>> 1);
203 set_dma_addr1(stream
->dma
, stream
->buffer
->next
->start
);
204 set_dma_count1(stream
->dma
, stream
->period_size
>> 1);
206 clear_dma_done1(stream
->dma
);
207 set_dma_addr1(stream
->dma
, stream
->buffer
->start
);
208 set_dma_count1(stream
->dma
, stream
->period_size
>> 1);
209 set_dma_addr0(stream
->dma
, stream
->buffer
->next
->start
);
210 set_dma_count0(stream
->dma
, stream
->period_size
>> 1);
212 enable_dma_buffers(stream
->dma
);
213 start_dma(stream
->dma
);
214 spin_unlock_irqrestore(&stream
->dma_lock
, flags
);
219 au1000_dma_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
221 audio_stream_t
*stream
= (audio_stream_t
*) dev_id
;
222 snd_pcm_substream_t
*substream
= stream
->substream
;
224 spin_lock(&stream
->dma_lock
);
225 switch (get_dma_buffer_done(stream
->dma
)) {
227 stream
->buffer
= stream
->buffer
->next
;
228 clear_dma_done0(stream
->dma
);
229 set_dma_addr0(stream
->dma
, stream
->buffer
->next
->start
);
230 set_dma_count0(stream
->dma
, stream
->period_size
>> 1);
231 enable_dma_buffer0(stream
->dma
);
234 stream
->buffer
= stream
->buffer
->next
;
235 clear_dma_done1(stream
->dma
);
236 set_dma_addr1(stream
->dma
, stream
->buffer
->next
->start
);
237 set_dma_count1(stream
->dma
, stream
->period_size
>> 1);
238 enable_dma_buffer1(stream
->dma
);
240 case (DMA_D0
| DMA_D1
):
241 spin_unlock(&stream
->dma_lock
);
242 printk(KERN_ERR
"DMA %d missed interrupt.\n",stream
->dma
);
243 au1000_dma_stop(stream
);
244 au1000_dma_start(stream
);
245 spin_lock(&stream
->dma_lock
);
247 case (~DMA_D0
& ~DMA_D1
):
248 printk(KERN_ERR
"DMA %d empty irq.\n",stream
->dma
);
250 spin_unlock(&stream
->dma_lock
);
251 snd_pcm_period_elapsed(substream
);
255 /*-------------------------- PCM Audio Streams -------------------------------*/
257 static unsigned int rates
[] = {8000, 11025, 16000, 22050};
258 static snd_pcm_hw_constraint_list_t hw_constraints_rates
= {
259 .count
= sizeof(rates
) / sizeof(rates
[0]),
264 static snd_pcm_hardware_t snd_au1000
=
266 .info
= (SNDRV_PCM_INFO_INTERLEAVED
| \
267 SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_MMAP_VALID
),
268 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
269 .rates
= (SNDRV_PCM_RATE_8000
| SNDRV_PCM_RATE_11025
|
270 SNDRV_PCM_RATE_16000
| SNDRV_PCM_RATE_22050
),
275 .buffer_bytes_max
= 128*1024,
276 .period_bytes_min
= 32,
277 .period_bytes_max
= 16*1024,
284 snd_au1000_playback_open(snd_pcm_substream_t
* substream
)
286 au1000
->stream
[PLAYBACK
]->substream
= substream
;
287 au1000
->stream
[PLAYBACK
]->buffer
= NULL
;
288 substream
->private_data
= au1000
->stream
[PLAYBACK
];
289 substream
->runtime
->hw
= snd_au1000
;
290 return (snd_pcm_hw_constraint_list(substream
->runtime
, 0,
291 SNDRV_PCM_HW_PARAM_RATE
, &hw_constraints_rates
) < 0);
295 snd_au1000_capture_open(snd_pcm_substream_t
* substream
)
297 au1000
->stream
[CAPTURE
]->substream
= substream
;
298 au1000
->stream
[CAPTURE
]->buffer
= NULL
;
299 substream
->private_data
= au1000
->stream
[CAPTURE
];
300 substream
->runtime
->hw
= snd_au1000
;
301 return (snd_pcm_hw_constraint_list(substream
->runtime
, 0,
302 SNDRV_PCM_HW_PARAM_RATE
, &hw_constraints_rates
) < 0);
307 snd_au1000_playback_close(snd_pcm_substream_t
* substream
)
309 au1000
->stream
[PLAYBACK
]->substream
= NULL
;
314 snd_au1000_capture_close(snd_pcm_substream_t
* substream
)
316 au1000
->stream
[CAPTURE
]->substream
= NULL
;
321 snd_au1000_hw_params(snd_pcm_substream_t
* substream
,
322 snd_pcm_hw_params_t
* hw_params
)
324 return snd_pcm_lib_malloc_pages(substream
,
325 params_buffer_bytes(hw_params
));
329 snd_au1000_hw_free(snd_pcm_substream_t
* substream
)
331 return snd_pcm_lib_free_pages(substream
);
335 snd_au1000_playback_prepare(snd_pcm_substream_t
* substream
)
337 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
339 if (runtime
->channels
== 1 )
340 au1000_set_ac97_xmit_slots(AC97_SLOT_4
);
342 au1000_set_ac97_xmit_slots(AC97_SLOT_3
| AC97_SLOT_4
);
343 snd_ac97_set_rate(au1000
->ac97
, AC97_PCM_FRONT_DAC_RATE
, runtime
->rate
);
348 snd_au1000_capture_prepare(snd_pcm_substream_t
* substream
)
350 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
352 if (runtime
->channels
== 1 )
353 au1000_set_ac97_recv_slots(AC97_SLOT_4
);
355 au1000_set_ac97_recv_slots(AC97_SLOT_3
| AC97_SLOT_4
);
356 snd_ac97_set_rate(au1000
->ac97
, AC97_PCM_LR_ADC_RATE
, runtime
->rate
);
361 snd_au1000_trigger(snd_pcm_substream_t
* substream
, int cmd
)
363 audio_stream_t
*stream
= substream
->private_data
;
367 case SNDRV_PCM_TRIGGER_START
:
368 au1000_dma_start(stream
);
370 case SNDRV_PCM_TRIGGER_STOP
:
371 au1000_dma_stop(stream
);
380 static snd_pcm_uframes_t
381 snd_au1000_pointer(snd_pcm_substream_t
* substream
)
383 audio_stream_t
*stream
= substream
->private_data
;
384 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
388 spin_lock_irqsave(&stream
->dma_lock
, flags
);
389 location
= get_dma_residue(stream
->dma
);
390 spin_unlock_irqrestore(&stream
->dma_lock
, flags
);
391 location
= stream
->buffer
->relative_end
- location
;
394 return bytes_to_frames(runtime
,location
);
397 static snd_pcm_ops_t snd_card_au1000_playback_ops
= {
398 .open
= snd_au1000_playback_open
,
399 .close
= snd_au1000_playback_close
,
400 .ioctl
= snd_pcm_lib_ioctl
,
401 .hw_params
= snd_au1000_hw_params
,
402 .hw_free
= snd_au1000_hw_free
,
403 .prepare
= snd_au1000_playback_prepare
,
404 .trigger
= snd_au1000_trigger
,
405 .pointer
= snd_au1000_pointer
,
408 static snd_pcm_ops_t snd_card_au1000_capture_ops
= {
409 .open
= snd_au1000_capture_open
,
410 .close
= snd_au1000_capture_close
,
411 .ioctl
= snd_pcm_lib_ioctl
,
412 .hw_params
= snd_au1000_hw_params
,
413 .hw_free
= snd_au1000_hw_free
,
414 .prepare
= snd_au1000_capture_prepare
,
415 .trigger
= snd_au1000_trigger
,
416 .pointer
= snd_au1000_pointer
,
420 snd_au1000_pcm_new(void)
426 if ((err
= snd_pcm_new(au1000
->card
, "AU1000 AC97 PCM", 0, 1, 1, &pcm
)) < 0)
429 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_CONTINUOUS
,
430 snd_dma_continuous_data(GFP_KERNEL
), 128*1024, 128*1024);
432 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
433 &snd_card_au1000_playback_ops
);
434 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
,
435 &snd_card_au1000_capture_ops
);
437 pcm
->private_data
= au1000
;
439 strcpy(pcm
->name
, "Au1000 AC97 PCM");
441 flags
= claim_dma_lock();
442 if ((au1000
->stream
[PLAYBACK
]->dma
= request_au1000_dma(DMA_ID_AC97C_TX
,
443 "AC97 TX", au1000_dma_interrupt
, SA_INTERRUPT
,
444 au1000
->stream
[PLAYBACK
])) < 0) {
445 release_dma_lock(flags
);
448 if ((au1000
->stream
[CAPTURE
]->dma
= request_au1000_dma(DMA_ID_AC97C_RX
,
449 "AC97 RX", au1000_dma_interrupt
, SA_INTERRUPT
,
450 au1000
->stream
[CAPTURE
])) < 0){
451 release_dma_lock(flags
);
454 /* enable DMA coherency in read/write DMA channels */
455 set_dma_mode(au1000
->stream
[PLAYBACK
]->dma
,
456 get_dma_mode(au1000
->stream
[PLAYBACK
]->dma
) & ~DMA_NC
);
457 set_dma_mode(au1000
->stream
[CAPTURE
]->dma
,
458 get_dma_mode(au1000
->stream
[CAPTURE
]->dma
) & ~DMA_NC
);
459 release_dma_lock(flags
);
460 spin_lock_init(&au1000
->stream
[PLAYBACK
]->dma_lock
);
461 spin_lock_init(&au1000
->stream
[CAPTURE
]->dma_lock
);
467 /*-------------------------- AC97 CODEC Control ------------------------------*/
469 static unsigned short
470 snd_au1000_ac97_read(ac97_t
*ac97
, unsigned short reg
)
475 spin_lock(&au1000
->ac97_lock
);
476 /* would rather use the interupt than this polling but it works and I can't
477 get the interupt driven case to work efficiently */
478 for (i
= 0; i
< 0x5000; i
++)
479 if (!(au1000
->ac97_ioport
->status
& AC97C_CP
))
482 printk(KERN_ERR
"au1000 AC97: AC97 command read timeout\n");
484 cmd
= (u32
) reg
& AC97C_INDEX_MASK
;
486 au1000
->ac97_ioport
->cmd
= cmd
;
488 /* now wait for the data */
489 for (i
= 0; i
< 0x5000; i
++)
490 if (!(au1000
->ac97_ioport
->status
& AC97C_CP
))
493 printk(KERN_ERR
"au1000 AC97: AC97 command read timeout\n");
497 data
= au1000
->ac97_ioport
->cmd
& 0xffff;
498 spin_unlock(&au1000
->ac97_lock
);
506 snd_au1000_ac97_write(ac97_t
*ac97
, unsigned short reg
, unsigned short val
)
510 spin_lock(&au1000
->ac97_lock
);
511 /* would rather use the interupt than this polling but it works and I can't
512 get the interupt driven case to work efficiently */
513 for (i
= 0; i
< 0x5000; i
++)
514 if (!(au1000
->ac97_ioport
->status
& AC97C_CP
))
517 printk(KERN_ERR
"au1000 AC97: AC97 command write timeout\n");
519 cmd
= (u32
) reg
& AC97C_INDEX_MASK
;
521 cmd
|= ((u32
) val
<< AC97C_WD_BIT
);
522 au1000
->ac97_ioport
->cmd
= cmd
;
523 spin_unlock(&au1000
->ac97_lock
);
526 snd_au1000_ac97_free(ac97_t
*ac97
)
532 snd_au1000_ac97_new(void)
536 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
538 ac97_template_t ac97
;
539 static ac97_bus_ops_t ops
= {
540 .write
= snd_au1000_ac97_write
,
541 .read
= snd_au1000_ac97_read
,
544 ac97_bus_t bus
, *pbus
;
548 if ((au1000
->ac97_res_port
= request_region(AC97C_CONFIG
,
549 sizeof(au1000_ac97_reg_t
), "Au1x00 AC97")) == NULL
) {
550 snd_printk(KERN_ERR
"ALSA AC97: can't grap AC97 port\n");
553 au1000
->ac97_ioport
= (au1000_ac97_reg_t
*) au1000
->ac97_res_port
->start
;
555 spin_lock_init(&au1000
->ac97_lock
);
557 spin_lock(&au1000
->ac97_lock
);
559 /* configure pins for AC'97
560 TODO: move to board_setup.c */
561 au_writel(au_readl(SYS_PINFUNC
) & ~0x02, SYS_PINFUNC
);
563 /* Initialise Au1000's AC'97 Control Block */
564 au1000
->ac97_ioport
->cntrl
= AC97C_RS
| AC97C_CE
;
566 au1000
->ac97_ioport
->cntrl
= AC97C_CE
;
569 /* Initialise External CODEC -- cold reset */
570 au1000
->ac97_ioport
->config
= AC97C_RESET
;
572 au1000
->ac97_ioport
->config
= 0x0;
575 spin_unlock(&au1000
->ac97_lock
);
577 /* Initialise AC97 middle-layer */
578 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,8)
579 if ((err
= snd_ac97_bus(au1000
->card
, 0, &ops
, au1000
, &pbus
)) < 0)
582 memset(&bus
, 0, sizeof(bus
));
583 bus
.write
= snd_au1000_ac97_write
;
584 bus
.read
= snd_au1000_ac97_read
;
585 if ((err
= snd_ac97_bus(au1000
->card
, &bus
, &pbus
)) < 0)
588 memset(&ac97
, 0, sizeof(ac97
));
589 ac97
.private_data
= au1000
;
590 ac97
.private_free
= snd_au1000_ac97_free
;
591 if ((err
= snd_ac97_mixer(pbus
, &ac97
, &au1000
->ac97
)) < 0)
597 /*------------------------------ Setup / Destroy ----------------------------*/
600 snd_au1000_free(snd_card_t
*card
)
603 if (au1000
->ac97_res_port
) {
604 /* put internal AC97 block into reset */
605 au1000
->ac97_ioport
->cntrl
= AC97C_RS
;
606 au1000
->ac97_ioport
= NULL
;
607 release_and_free_resource(au1000
->ac97_res_port
);
610 if (au1000
->stream
[PLAYBACK
]->dma
>= 0)
611 free_au1000_dma(au1000
->stream
[PLAYBACK
]->dma
);
613 if (au1000
->stream
[CAPTURE
]->dma
>= 0)
614 free_au1000_dma(au1000
->stream
[CAPTURE
]->dma
);
616 kfree(au1000
->stream
[PLAYBACK
]);
617 au1000
->stream
[PLAYBACK
] = NULL
;
618 kfree(au1000
->stream
[CAPTURE
]);
619 au1000
->stream
[CAPTURE
] = NULL
;
630 au1000
= kmalloc(sizeof(au1000_t
), GFP_KERNEL
);
633 au1000
->stream
[PLAYBACK
] = kmalloc(sizeof(audio_stream_t
), GFP_KERNEL
);
634 if (au1000
->stream
[PLAYBACK
] == NULL
)
636 au1000
->stream
[CAPTURE
] = kmalloc(sizeof(audio_stream_t
), GFP_KERNEL
);
637 if (au1000
->stream
[CAPTURE
] == NULL
)
639 /* so that snd_au1000_free will work as intended */
640 au1000
->stream
[PLAYBACK
]->dma
= -1;
641 au1000
->stream
[CAPTURE
]->dma
= -1;
642 au1000
->ac97_res_port
= NULL
;
644 au1000
->card
= snd_card_new(-1, "AC97", THIS_MODULE
, sizeof(au1000_t
));
645 if (au1000
->card
== NULL
) {
646 snd_au1000_free(au1000
->card
);
650 au1000
->card
->private_data
= (au1000_t
*)au1000
;
651 au1000
->card
->private_free
= snd_au1000_free
;
653 if ((err
= snd_au1000_ac97_new()) < 0 ) {
654 snd_card_free(au1000
->card
);
658 if ((err
= snd_au1000_pcm_new()) < 0) {
659 snd_card_free(au1000
->card
);
663 strcpy(au1000
->card
->driver
, "AMD-Au1000-AC97");
664 strcpy(au1000
->card
->shortname
, "Au1000-AC97");
665 sprintf(au1000
->card
->longname
, "AMD Au1000--AC97 ALSA Driver");
667 if ((err
= snd_card_set_generic_dev(au1000
->card
)) < 0) {
668 snd_card_free(au1000
->card
);
672 if ((err
= snd_card_register(au1000
->card
)) < 0) {
673 snd_card_free(au1000
->card
);
677 printk( KERN_INFO
"ALSA AC97: Driver Initialized\n" );
681 static void __exit
au1000_exit(void)
683 snd_card_free(au1000
->card
);
686 module_init(au1000_init
);
687 module_exit(au1000_exit
);