URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [isa/] [sb/] [sb8_main.c] - Blame information for rev 3

Details | Compare with Previous | View Log


/*
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 *                   Uros Bizjak <uros@kss-loka.si>
 *
 *  Routines for control of 8-bit SoundBlaster cards and clones
 *  Please note: I don't have access to old SB8 soundcards.
 *
 *
 *   This program 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 program 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
 *
 * --
 *
 * Thu Apr 29 20:36:17 BST 1999 George David Morrison <gdm@gedamo.demon.co.uk>
 *   DSP can't respond to commands whilst in "high speed" mode. Caused
 *   glitching during playback. Fixed.
 *
 * Wed Jul 12 22:02:55 CEST 2000 Uros Bizjak <uros@kss-loka.si>
 *   Cleaned up and rewrote lowlevel routines.
 */
 
#include <sound/driver.h>
#include <asm/io.h>
#include <asm/dma.h>
#include <linux/init.h>
#include <linux/time.h>
#include <sound/core.h>
#include <sound/sb.h>
 
MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Uros Bizjak <uros@kss-loka.si>");
MODULE_DESCRIPTION("Routines for control of 8-bit SoundBlaster cards and clones");
MODULE_LICENSE("GPL");
 
#define SB8_CLOCK       1000000
#define SB8_DEN(v)      ((SB8_CLOCK + (v) / 2) / (v))
#define SB8_RATE(v)     (SB8_CLOCK / SB8_DEN(v))
 
static struct snd_ratnum clock = {
        .num = SB8_CLOCK,
        .den_min = 1,
        .den_max = 256,
        .den_step = 1,
};
 
static struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = {
        .nrats = 1,
        .rats = &clock,
};
 
static struct snd_ratnum stereo_clocks[] = {
        {
                .num = SB8_CLOCK,
                .den_min = SB8_DEN(22050),
                .den_max = SB8_DEN(22050),
                .den_step = 1,
        },
        {
                .num = SB8_CLOCK,
                .den_min = SB8_DEN(11025),
                .den_max = SB8_DEN(11025),
                .den_step = 1,
        }
};
 
static int snd_sb8_hw_constraint_rate_channels(struct snd_pcm_hw_params *params,
                                               struct snd_pcm_hw_rule *rule)
{
        struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
        if (c->min > 1) {
                unsigned int num = 0, den = 0;
                int err = snd_interval_ratnum(hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE),
                                          2, stereo_clocks, &num, &den);
                if (err >= 0 && den) {
                        params->rate_num = num;
                        params->rate_den = den;
                }
                return err;
        }
        return 0;
}
 
static int snd_sb8_hw_constraint_channels_rate(struct snd_pcm_hw_params *params,
                                               struct snd_pcm_hw_rule *rule)
{
        struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
        if (r->min > SB8_RATE(22050) || r->max <= SB8_RATE(11025)) {
                struct snd_interval t = { .min = 1, .max = 1 };
                return snd_interval_refine(hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS), &t);
        }
        return 0;
}
 
static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)
{
        unsigned long flags;
        struct snd_sb *chip = snd_pcm_substream_chip(substream);
        struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned int mixreg, rate, size, count;
 
        rate = runtime->rate;
        switch (chip->hardware) {
        case SB_HW_PRO:
                if (runtime->channels > 1) {
                        snd_assert(rate == SB8_RATE(11025) || rate == SB8_RATE(22050), return -EINVAL);
                        chip->playback_format = SB_DSP_HI_OUTPUT_AUTO;
                        break;
                }
                /* fallthru */
        case SB_HW_201:
                if (rate > 23000) {
                        chip->playback_format = SB_DSP_HI_OUTPUT_AUTO;
                        break;
                }
                /* fallthru */
        case SB_HW_20:
                chip->playback_format = SB_DSP_LO_OUTPUT_AUTO;
                break;
        case SB_HW_10:
                chip->playback_format = SB_DSP_OUTPUT;
                break;
        default:
                return -EINVAL;
        }
        size = chip->p_dma_size = snd_pcm_lib_buffer_bytes(substream);
        count = chip->p_period_size = snd_pcm_lib_period_bytes(substream);
        spin_lock_irqsave(&chip->reg_lock, flags);
        snd_sbdsp_command(chip, SB_DSP_SPEAKER_ON);
        if (runtime->channels > 1) {
                /* set playback stereo mode */
                spin_lock(&chip->mixer_lock);
                mixreg = snd_sbmixer_read(chip, SB_DSP_STEREO_SW);
                snd_sbmixer_write(chip, SB_DSP_STEREO_SW, mixreg | 0x02);
                spin_unlock(&chip->mixer_lock);
 
                /* Soundblaster hardware programming reference guide, 3-23 */
                snd_sbdsp_command(chip, SB_DSP_DMA8_EXIT);
                runtime->dma_area[0] = 0x80;
                snd_dma_program(chip->dma8, runtime->dma_addr, 1, DMA_MODE_WRITE);
                /* force interrupt */
                chip->mode = SB_MODE_HALT;
                snd_sbdsp_command(chip, SB_DSP_OUTPUT);
                snd_sbdsp_command(chip, 0);
                snd_sbdsp_command(chip, 0);
        }
        snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);
        if (runtime->channels > 1) {
                snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);
                spin_lock(&chip->mixer_lock);
                /* save output filter status and turn it off */
                mixreg = snd_sbmixer_read(chip, SB_DSP_PLAYBACK_FILT);
                snd_sbmixer_write(chip, SB_DSP_PLAYBACK_FILT, mixreg | 0x20);
                spin_unlock(&chip->mixer_lock);
                /* just use force_mode16 for temporary storate... */
                chip->force_mode16 = mixreg;
        } else {
                snd_sbdsp_command(chip, 256 - runtime->rate_den);
        }
        if (chip->playback_format != SB_DSP_OUTPUT) {
                count--;
                snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);
                snd_sbdsp_command(chip, count & 0xff);
                snd_sbdsp_command(chip, count >> 8);
        }
        spin_unlock_irqrestore(&chip->reg_lock, flags);
        snd_dma_program(chip->dma8, runtime->dma_addr,
                        size, DMA_MODE_WRITE | DMA_AUTOINIT);
        return 0;
}
 
static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream,
                                    int cmd)
{
        unsigned long flags;
        struct snd_sb *chip = snd_pcm_substream_chip(substream);
        unsigned int count;
 
        spin_lock_irqsave(&chip->reg_lock, flags);
        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
                snd_sbdsp_command(chip, chip->playback_format);
                if (chip->playback_format == SB_DSP_OUTPUT) {
                        count = chip->p_period_size - 1;
                        snd_sbdsp_command(chip, count & 0xff);
                        snd_sbdsp_command(chip, count >> 8);
                }
                break;
        case SNDRV_PCM_TRIGGER_STOP:
                if (chip->playback_format == SB_DSP_HI_OUTPUT_AUTO) {
                        struct snd_pcm_runtime *runtime = substream->runtime;
                        snd_sbdsp_reset(chip);
                        if (runtime->channels > 1) {
                                spin_lock(&chip->mixer_lock);
                                /* restore output filter and set hardware to mono mode */
                                snd_sbmixer_write(chip, SB_DSP_STEREO_SW, chip->force_mode16 & ~0x02);
                                spin_unlock(&chip->mixer_lock);
                        }
                } else {
                        snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
                }
                snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
        }
        spin_unlock_irqrestore(&chip->reg_lock, flags);
        chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_PLAYBACK_8 : SB_MODE_HALT;
        return 0;
}
 
static int snd_sb8_hw_params(struct snd_pcm_substream *substream,
                             struct snd_pcm_hw_params *hw_params)
{
        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
}
 
static int snd_sb8_hw_free(struct snd_pcm_substream *substream)
{
        snd_pcm_lib_free_pages(substream);
        return 0;
}
 
static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream)
{
        unsigned long flags;
        struct snd_sb *chip = snd_pcm_substream_chip(substream);
        struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned int mixreg, rate, size, count;
 
        rate = runtime->rate;
        switch (chip->hardware) {
        case SB_HW_PRO:
                if (runtime->channels > 1) {
                        snd_assert(rate == SB8_RATE(11025) || rate == SB8_RATE(22050), return -EINVAL);
                        chip->capture_format = SB_DSP_HI_INPUT_AUTO;
                        break;
                }
                chip->capture_format = (rate > 23000) ? SB_DSP_HI_INPUT_AUTO : SB_DSP_LO_INPUT_AUTO;
                break;
        case SB_HW_201:
                if (rate > 13000) {
                        chip->capture_format = SB_DSP_HI_INPUT_AUTO;
                        break;
                }
                /* fallthru */
        case SB_HW_20:
                chip->capture_format = SB_DSP_LO_INPUT_AUTO;
                break;
        case SB_HW_10:
                chip->capture_format = SB_DSP_INPUT;
                break;
        default:
                return -EINVAL;
        }
        size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream);
        count = chip->c_period_size = snd_pcm_lib_period_bytes(substream);
        spin_lock_irqsave(&chip->reg_lock, flags);
        snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
        if (runtime->channels > 1)
                snd_sbdsp_command(chip, SB_DSP_STEREO_8BIT);
        snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);
        if (runtime->channels > 1) {
                snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);
                spin_lock(&chip->mixer_lock);
                /* save input filter status and turn it off */
                mixreg = snd_sbmixer_read(chip, SB_DSP_CAPTURE_FILT);
                snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, mixreg | 0x20);
                spin_unlock(&chip->mixer_lock);
                /* just use force_mode16 for temporary storate... */
                chip->force_mode16 = mixreg;
        } else {
                snd_sbdsp_command(chip, 256 - runtime->rate_den);
        }
        if (chip->capture_format != SB_DSP_OUTPUT) {
                count--;
                snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);
                snd_sbdsp_command(chip, count & 0xff);
                snd_sbdsp_command(chip, count >> 8);
        }
        spin_unlock_irqrestore(&chip->reg_lock, flags);
        snd_dma_program(chip->dma8, runtime->dma_addr,
                        size, DMA_MODE_READ | DMA_AUTOINIT);
        return 0;
}
 
static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream,
                                   int cmd)
{
        unsigned long flags;
        struct snd_sb *chip = snd_pcm_substream_chip(substream);
        unsigned int count;
 
        spin_lock_irqsave(&chip->reg_lock, flags);
        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
                snd_sbdsp_command(chip, chip->capture_format);
                if (chip->capture_format == SB_DSP_INPUT) {
                        count = chip->c_period_size - 1;
                        snd_sbdsp_command(chip, count & 0xff);
                        snd_sbdsp_command(chip, count >> 8);
                }
                break;
        case SNDRV_PCM_TRIGGER_STOP:
                if (chip->capture_format == SB_DSP_HI_INPUT_AUTO) {
                        struct snd_pcm_runtime *runtime = substream->runtime;
                        snd_sbdsp_reset(chip);
                        if (runtime->channels > 1) {
                                /* restore input filter status */
                                spin_lock(&chip->mixer_lock);
                                snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, chip->force_mode16);
                                spin_unlock(&chip->mixer_lock);
                                /* set hardware to mono mode */
                                snd_sbdsp_command(chip, SB_DSP_MONO_8BIT);
                        }
                } else {
                        snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
                }
                snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
        }
        spin_unlock_irqrestore(&chip->reg_lock, flags);
        chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_CAPTURE_8 : SB_MODE_HALT;
        return 0;
}
 
irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip)
{
        struct snd_pcm_substream *substream;
        struct snd_pcm_runtime *runtime;
 
        snd_sb_ack_8bit(chip);
        switch (chip->mode) {
        case SB_MODE_PLAYBACK_8:        /* ok.. playback is active */
                substream = chip->playback_substream;
                runtime = substream->runtime;
                if (chip->playback_format == SB_DSP_OUTPUT)
                        snd_sb8_playback_trigger(substream, SNDRV_PCM_TRIGGER_START);
                snd_pcm_period_elapsed(substream);
                break;
        case SB_MODE_CAPTURE_8:
                substream = chip->capture_substream;
                runtime = substream->runtime;
                if (chip->capture_format == SB_DSP_INPUT)
                        snd_sb8_capture_trigger(substream, SNDRV_PCM_TRIGGER_START);
                snd_pcm_period_elapsed(substream);
                break;
        }
        return IRQ_HANDLED;
}
 
static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *substream)
{
        struct snd_sb *chip = snd_pcm_substream_chip(substream);
        size_t ptr;
 
        if (chip->mode != SB_MODE_PLAYBACK_8)
                return 0;
        ptr = snd_dma_pointer(chip->dma8, chip->p_dma_size);
        return bytes_to_frames(substream->runtime, ptr);
}
 
static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *substream)
{
        struct snd_sb *chip = snd_pcm_substream_chip(substream);
        size_t ptr;
 
        if (chip->mode != SB_MODE_CAPTURE_8)
                return 0;
        ptr = snd_dma_pointer(chip->dma8, chip->c_dma_size);
        return bytes_to_frames(substream->runtime, ptr);
}
 
/*
 
 */
 
static struct snd_pcm_hardware snd_sb8_playback =
{
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_MMAP_VALID),
        .formats =               SNDRV_PCM_FMTBIT_U8,
        .rates =                (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 |
                                 SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_22050),
        .rate_min =             4000,
        .rate_max =             23000,
        .channels_min =         1,
        .channels_max =         1,
        .buffer_bytes_max =     65536,
        .period_bytes_min =     64,
        .period_bytes_max =     65536,
        .periods_min =          1,
        .periods_max =          1024,
        .fifo_size =            0,
};
 
static struct snd_pcm_hardware snd_sb8_capture =
{
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_MMAP_VALID),
        .formats =              SNDRV_PCM_FMTBIT_U8,
        .rates =                (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 |
                                 SNDRV_PCM_RATE_11025),
        .rate_min =             4000,
        .rate_max =             13000,
        .channels_min =         1,
        .channels_max =         1,
        .buffer_bytes_max =     65536,
        .period_bytes_min =     64,
        .period_bytes_max =     65536,
        .periods_min =          1,
        .periods_max =          1024,
        .fifo_size =            0,
};
 
/*
 *
 */
 
static int snd_sb8_open(struct snd_pcm_substream *substream)
{
        struct snd_sb *chip = snd_pcm_substream_chip(substream);
        struct snd_pcm_runtime *runtime = substream->runtime;
        unsigned long flags;
 
        spin_lock_irqsave(&chip->open_lock, flags);
        if (chip->open) {
                spin_unlock_irqrestore(&chip->open_lock, flags);
                return -EAGAIN;
        }
        chip->open |= SB_OPEN_PCM;
        spin_unlock_irqrestore(&chip->open_lock, flags);
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                chip->playback_substream = substream;
                runtime->hw = snd_sb8_playback;
        } else {
                chip->capture_substream = substream;
                runtime->hw = snd_sb8_capture;
        }
        switch (chip->hardware) {
        case SB_HW_PRO:
                runtime->hw.rate_max = 44100;
                runtime->hw.channels_max = 2;
                snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
                                    snd_sb8_hw_constraint_rate_channels, NULL,
                                    SNDRV_PCM_HW_PARAM_CHANNELS,
                                    SNDRV_PCM_HW_PARAM_RATE, -1);
                snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
                                     snd_sb8_hw_constraint_channels_rate, NULL,
                                     SNDRV_PCM_HW_PARAM_RATE, -1);
                break;
        case SB_HW_201:
                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                        runtime->hw.rate_max = 44100;
                } else {
                        runtime->hw.rate_max = 15000;
                }
        default:
                break;
        }
        snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
                                      &hw_constraints_clock);
        return 0;
}
 
static int snd_sb8_close(struct snd_pcm_substream *substream)
{
        unsigned long flags;
        struct snd_sb *chip = snd_pcm_substream_chip(substream);
 
        chip->playback_substream = NULL;
        chip->capture_substream = NULL;
        spin_lock_irqsave(&chip->open_lock, flags);
        chip->open &= ~SB_OPEN_PCM;
        spin_unlock_irqrestore(&chip->open_lock, flags);
        return 0;
}
 
/*
 *  Initialization part
 */
 
static struct snd_pcm_ops snd_sb8_playback_ops = {
        .open =                 snd_sb8_open,
        .close =                snd_sb8_close,
        .ioctl =                snd_pcm_lib_ioctl,
        .hw_params =            snd_sb8_hw_params,
        .hw_free =              snd_sb8_hw_free,
        .prepare =              snd_sb8_playback_prepare,
        .trigger =              snd_sb8_playback_trigger,
        .pointer =              snd_sb8_playback_pointer,
};
 
static struct snd_pcm_ops snd_sb8_capture_ops = {
        .open =                 snd_sb8_open,
        .close =                snd_sb8_close,
        .ioctl =                snd_pcm_lib_ioctl,
        .hw_params =            snd_sb8_hw_params,
        .hw_free =              snd_sb8_hw_free,
        .prepare =              snd_sb8_capture_prepare,
        .trigger =              snd_sb8_capture_trigger,
        .pointer =              snd_sb8_capture_pointer,
};
 
int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm)
{
        struct snd_card *card = chip->card;
        struct snd_pcm *pcm;
        int err;
 
        if (rpcm)
                *rpcm = NULL;
        if ((err = snd_pcm_new(card, "SB8 DSP", device, 1, 1, &pcm)) < 0)
                return err;
        sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff);
        pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
        pcm->private_data = chip;
 
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb8_playback_ops);
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops);
 
        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                              snd_dma_isa_data(),
                                              64*1024, 64*1024);
 
        if (rpcm)
                *rpcm = pcm;
        return 0;
}
 
EXPORT_SYMBOL(snd_sb8dsp_pcm);
EXPORT_SYMBOL(snd_sb8dsp_interrupt);
  /* sb8_midi.c */
EXPORT_SYMBOL(snd_sb8dsp_midi_interrupt);
EXPORT_SYMBOL(snd_sb8dsp_midi);
 
/*
 *  INIT part
 */
 
static int __init alsa_sb8_init(void)
{
        return 0;
}
 
static void __exit alsa_sb8_exit(void)
{
}
 
module_init(alsa_sb8_init)
module_exit(alsa_sb8_exit)

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [isa/] [sb/] [sb8_main.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* Copyright (c) by Jaroslav Kysela <perex@perex.cz>`
3			`* Uros Bizjak <uros@kss-loka.si>`
4			`*`
5			`* Routines for control of 8-bit SoundBlaster cards and clones`
6			`* Please note: I don't have access to old SB8 soundcards.`
7			`*`
8			`*`
9			`* This program 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.`
13			`*`
14			`* This program 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.`
18			`*`
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`
22			`*`
23			`* --`
24			`*`
25			`* Thu Apr 29 20:36:17 BST 1999 George David Morrison <gdm@gedamo.demon.co.uk>`
26			`* DSP can't respond to commands whilst in "high speed" mode. Caused`
27			`* glitching during playback. Fixed.`
28			`*`
29			`* Wed Jul 12 22:02:55 CEST 2000 Uros Bizjak <uros@kss-loka.si>`
30			`* Cleaned up and rewrote lowlevel routines.`
31			`*/`
32
33			`#include <sound/driver.h>`
34			`#include <asm/io.h>`
35			`#include <asm/dma.h>`
36			`#include <linux/init.h>`
37			`#include <linux/time.h>`
38			`#include <sound/core.h>`
39			`#include <sound/sb.h>`
40
41			`MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Uros Bizjak <uros@kss-loka.si>");`
42			`MODULE_DESCRIPTION("Routines for control of 8-bit SoundBlaster cards and clones");`
43			`MODULE_LICENSE("GPL");`
44
45			`#define SB8_CLOCK 1000000`
46			`#define SB8_DEN(v) ((SB8_CLOCK + (v) / 2) / (v))`
47			`#define SB8_RATE(v) (SB8_CLOCK / SB8_DEN(v))`
48
49			`static struct snd_ratnum clock = {`
50			`.num = SB8_CLOCK,`
51			`.den_min = 1,`
52			`.den_max = 256,`
53			`.den_step = 1,`
54			`};`
55
56			`static struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = {`
57			`.nrats = 1,`
58			`.rats = &clock,`
59			`};`
60
61			`static struct snd_ratnum stereo_clocks[] = {`
62			`{`
63			`.num = SB8_CLOCK,`
64			`.den_min = SB8_DEN(22050),`
65			`.den_max = SB8_DEN(22050),`
66			`.den_step = 1,`
67			`},`
68			`{`
69			`.num = SB8_CLOCK,`
70			`.den_min = SB8_DEN(11025),`
71			`.den_max = SB8_DEN(11025),`
72			`.den_step = 1,`
73			`}`
74			`};`
75
76			`static int snd_sb8_hw_constraint_rate_channels(struct snd_pcm_hw_params *params,`
77			`struct snd_pcm_hw_rule *rule)`
78			`{`
79			`struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);`
80			`if (c->min > 1) {`
81			`unsigned int num = 0, den = 0;`
82			`int err = snd_interval_ratnum(hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE),`
83			`2, stereo_clocks, &num, &den);`
84			`if (err >= 0 && den) {`
85			`params->rate_num = num;`
86			`params->rate_den = den;`
87			`}`
88			`return err;`
89			`}`
90			`return 0;`
91			`}`
92
93			`static int snd_sb8_hw_constraint_channels_rate(struct snd_pcm_hw_params *params,`
94			`struct snd_pcm_hw_rule *rule)`
95			`{`
96			`struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);`
97			`if (r->min > SB8_RATE(22050) \|\| r->max <= SB8_RATE(11025)) {`
98			`struct snd_interval t = { .min = 1, .max = 1 };`
99			`return snd_interval_refine(hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS), &t);`
100			`}`
101			`return 0;`
102			`}`
103
104			`static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)`
105			`{`
106			`unsigned long flags;`
107			`struct snd_sb *chip = snd_pcm_substream_chip(substream);`
108			`struct snd_pcm_runtime *runtime = substream->runtime;`
109			`unsigned int mixreg, rate, size, count;`
110
111			`rate = runtime->rate;`
112			`switch (chip->hardware) {`
113			`case SB_HW_PRO:`
114			`if (runtime->channels > 1) {`
115			`snd_assert(rate == SB8_RATE(11025) \|\| rate == SB8_RATE(22050), return -EINVAL);`
116			`chip->playback_format = SB_DSP_HI_OUTPUT_AUTO;`
117			`break;`
118			`}`
119			`/* fallthru */`
120			`case SB_HW_201:`
121			`if (rate > 23000) {`
122			`chip->playback_format = SB_DSP_HI_OUTPUT_AUTO;`
123			`break;`
124			`}`
125			`/* fallthru */`
126			`case SB_HW_20:`
127			`chip->playback_format = SB_DSP_LO_OUTPUT_AUTO;`
128			`break;`
129			`case SB_HW_10:`
130			`chip->playback_format = SB_DSP_OUTPUT;`
131			`break;`
132			`default:`
133			`return -EINVAL;`
134			`}`
135			`size = chip->p_dma_size = snd_pcm_lib_buffer_bytes(substream);`
136			`count = chip->p_period_size = snd_pcm_lib_period_bytes(substream);`
137			`spin_lock_irqsave(&chip->reg_lock, flags);`
138			`snd_sbdsp_command(chip, SB_DSP_SPEAKER_ON);`
139			`if (runtime->channels > 1) {`
140			`/* set playback stereo mode */`
141			`spin_lock(&chip->mixer_lock);`
142			`mixreg = snd_sbmixer_read(chip, SB_DSP_STEREO_SW);`
143			`snd_sbmixer_write(chip, SB_DSP_STEREO_SW, mixreg \| 0x02);`
144			`spin_unlock(&chip->mixer_lock);`
145
146			`/* Soundblaster hardware programming reference guide, 3-23 */`
147			`snd_sbdsp_command(chip, SB_DSP_DMA8_EXIT);`
148			`runtime->dma_area[0] = 0x80;`
149			`snd_dma_program(chip->dma8, runtime->dma_addr, 1, DMA_MODE_WRITE);`
150			`/* force interrupt */`
151			`chip->mode = SB_MODE_HALT;`
152			`snd_sbdsp_command(chip, SB_DSP_OUTPUT);`
153			`snd_sbdsp_command(chip, 0);`
154			`snd_sbdsp_command(chip, 0);`
155			`}`
156			`snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);`
157			`if (runtime->channels > 1) {`
158			`snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);`
159			`spin_lock(&chip->mixer_lock);`
160			`/* save output filter status and turn it off */`
161			`mixreg = snd_sbmixer_read(chip, SB_DSP_PLAYBACK_FILT);`
162			`snd_sbmixer_write(chip, SB_DSP_PLAYBACK_FILT, mixreg \| 0x20);`
163			`spin_unlock(&chip->mixer_lock);`
164			`/* just use force_mode16 for temporary storate... */`
165			`chip->force_mode16 = mixreg;`
166			`} else {`
167			`snd_sbdsp_command(chip, 256 - runtime->rate_den);`
168			`}`
169			`if (chip->playback_format != SB_DSP_OUTPUT) {`
170			`count--;`
171			`snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);`
172			`snd_sbdsp_command(chip, count & 0xff);`
173			`snd_sbdsp_command(chip, count >> 8);`
174			`}`
175			`spin_unlock_irqrestore(&chip->reg_lock, flags);`
176			`snd_dma_program(chip->dma8, runtime->dma_addr,`
177			`size, DMA_MODE_WRITE \| DMA_AUTOINIT);`
178			`return 0;`
179			`}`
180
181			`static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream,`
182			`int cmd)`
183			`{`
184			`unsigned long flags;`
185			`struct snd_sb *chip = snd_pcm_substream_chip(substream);`
186			`unsigned int count;`
187
188			`spin_lock_irqsave(&chip->reg_lock, flags);`
189			`switch (cmd) {`
190			`case SNDRV_PCM_TRIGGER_START:`
191			`snd_sbdsp_command(chip, chip->playback_format);`
192			`if (chip->playback_format == SB_DSP_OUTPUT) {`
193			`count = chip->p_period_size - 1;`
194			`snd_sbdsp_command(chip, count & 0xff);`
195			`snd_sbdsp_command(chip, count >> 8);`
196			`}`
197			`break;`
198			`case SNDRV_PCM_TRIGGER_STOP:`
199			`if (chip->playback_format == SB_DSP_HI_OUTPUT_AUTO) {`
200			`struct snd_pcm_runtime *runtime = substream->runtime;`
201			`snd_sbdsp_reset(chip);`
202			`if (runtime->channels > 1) {`
203			`spin_lock(&chip->mixer_lock);`
204			`/* restore output filter and set hardware to mono mode */`
205			`snd_sbmixer_write(chip, SB_DSP_STEREO_SW, chip->force_mode16 & ~0x02);`
206			`spin_unlock(&chip->mixer_lock);`
207			`}`
208			`} else {`
209			`snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);`
210			`}`
211			`snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);`
212			`}`
213			`spin_unlock_irqrestore(&chip->reg_lock, flags);`
214			`chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_PLAYBACK_8 : SB_MODE_HALT;`
215			`return 0;`
216			`}`
217
218			`static int snd_sb8_hw_params(struct snd_pcm_substream *substream,`
219			`struct snd_pcm_hw_params *hw_params)`
220			`{`
221			`return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));`
222			`}`
223
224			`static int snd_sb8_hw_free(struct snd_pcm_substream *substream)`
225			`{`
226			`snd_pcm_lib_free_pages(substream);`
227			`return 0;`
228			`}`
229
230			`static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream)`
231			`{`
232			`unsigned long flags;`
233			`struct snd_sb *chip = snd_pcm_substream_chip(substream);`
234			`struct snd_pcm_runtime *runtime = substream->runtime;`
235			`unsigned int mixreg, rate, size, count;`
236
237			`rate = runtime->rate;`
238			`switch (chip->hardware) {`
239			`case SB_HW_PRO:`
240			`if (runtime->channels > 1) {`
241			`snd_assert(rate == SB8_RATE(11025) \|\| rate == SB8_RATE(22050), return -EINVAL);`
242			`chip->capture_format = SB_DSP_HI_INPUT_AUTO;`
243			`break;`
244			`}`
245			`chip->capture_format = (rate > 23000) ? SB_DSP_HI_INPUT_AUTO : SB_DSP_LO_INPUT_AUTO;`
246			`break;`
247			`case SB_HW_201:`
248			`if (rate > 13000) {`
249			`chip->capture_format = SB_DSP_HI_INPUT_AUTO;`
250			`break;`
251			`}`
252			`/* fallthru */`
253			`case SB_HW_20:`
254			`chip->capture_format = SB_DSP_LO_INPUT_AUTO;`
255			`break;`
256			`case SB_HW_10:`
257			`chip->capture_format = SB_DSP_INPUT;`
258			`break;`
259			`default:`
260			`return -EINVAL;`
261			`}`
262			`size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream);`
263			`count = chip->c_period_size = snd_pcm_lib_period_bytes(substream);`
264			`spin_lock_irqsave(&chip->reg_lock, flags);`
265			`snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);`
266			`if (runtime->channels > 1)`
267			`snd_sbdsp_command(chip, SB_DSP_STEREO_8BIT);`
268			`snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);`
269			`if (runtime->channels > 1) {`
270			`snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);`
271			`spin_lock(&chip->mixer_lock);`
272			`/* save input filter status and turn it off */`
273			`mixreg = snd_sbmixer_read(chip, SB_DSP_CAPTURE_FILT);`
274			`snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, mixreg \| 0x20);`
275			`spin_unlock(&chip->mixer_lock);`
276			`/* just use force_mode16 for temporary storate... */`
277			`chip->force_mode16 = mixreg;`
278			`} else {`
279			`snd_sbdsp_command(chip, 256 - runtime->rate_den);`
280			`}`
281			`if (chip->capture_format != SB_DSP_OUTPUT) {`
282			`count--;`
283			`snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);`
284			`snd_sbdsp_command(chip, count & 0xff);`
285			`snd_sbdsp_command(chip, count >> 8);`
286			`}`
287			`spin_unlock_irqrestore(&chip->reg_lock, flags);`
288			`snd_dma_program(chip->dma8, runtime->dma_addr,`
289			`size, DMA_MODE_READ \| DMA_AUTOINIT);`
290			`return 0;`
291			`}`
292
293			`static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream,`
294			`int cmd)`
295			`{`
296			`unsigned long flags;`
297			`struct snd_sb *chip = snd_pcm_substream_chip(substream);`
298			`unsigned int count;`
299
300			`spin_lock_irqsave(&chip->reg_lock, flags);`
301			`switch (cmd) {`
302			`case SNDRV_PCM_TRIGGER_START:`
303			`snd_sbdsp_command(chip, chip->capture_format);`
304			`if (chip->capture_format == SB_DSP_INPUT) {`
305			`count = chip->c_period_size - 1;`
306			`snd_sbdsp_command(chip, count & 0xff);`
307			`snd_sbdsp_command(chip, count >> 8);`
308			`}`
309			`break;`
310			`case SNDRV_PCM_TRIGGER_STOP:`
311			`if (chip->capture_format == SB_DSP_HI_INPUT_AUTO) {`
312			`struct snd_pcm_runtime *runtime = substream->runtime;`
313			`snd_sbdsp_reset(chip);`
314			`if (runtime->channels > 1) {`
315			`/* restore input filter status */`
316			`spin_lock(&chip->mixer_lock);`
317			`snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, chip->force_mode16);`
318			`spin_unlock(&chip->mixer_lock);`
319			`/* set hardware to mono mode */`
320			`snd_sbdsp_command(chip, SB_DSP_MONO_8BIT);`
321			`}`
322			`} else {`
323			`snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);`
324			`}`
325			`snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);`
326			`}`
327			`spin_unlock_irqrestore(&chip->reg_lock, flags);`
328			`chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_CAPTURE_8 : SB_MODE_HALT;`
329			`return 0;`
330			`}`
331
332			`irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip)`
333			`{`
334			`struct snd_pcm_substream *substream;`
335			`struct snd_pcm_runtime *runtime;`
336
337			`snd_sb_ack_8bit(chip);`
338			`switch (chip->mode) {`
339			`case SB_MODE_PLAYBACK_8: /* ok.. playback is active */`
340			`substream = chip->playback_substream;`
341			`runtime = substream->runtime;`
342			`if (chip->playback_format == SB_DSP_OUTPUT)`
343			`snd_sb8_playback_trigger(substream, SNDRV_PCM_TRIGGER_START);`
344			`snd_pcm_period_elapsed(substream);`
345			`break;`
346			`case SB_MODE_CAPTURE_8:`
347			`substream = chip->capture_substream;`
348			`runtime = substream->runtime;`
349			`if (chip->capture_format == SB_DSP_INPUT)`
350			`snd_sb8_capture_trigger(substream, SNDRV_PCM_TRIGGER_START);`
351			`snd_pcm_period_elapsed(substream);`
352			`break;`
353			`}`
354			`return IRQ_HANDLED;`
355			`}`
356
357			`static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *substream)`
358			`{`
359			`struct snd_sb *chip = snd_pcm_substream_chip(substream);`
360			`size_t ptr;`
361
362			`if (chip->mode != SB_MODE_PLAYBACK_8)`
363			`return 0;`
364			`ptr = snd_dma_pointer(chip->dma8, chip->p_dma_size);`
365			`return bytes_to_frames(substream->runtime, ptr);`
366			`}`
367
368			`static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *substream)`
369			`{`
370			`struct snd_sb *chip = snd_pcm_substream_chip(substream);`
371			`size_t ptr;`
372
373			`if (chip->mode != SB_MODE_CAPTURE_8)`
374			`return 0;`
375			`ptr = snd_dma_pointer(chip->dma8, chip->c_dma_size);`
376			`return bytes_to_frames(substream->runtime, ptr);`
377			`}`
378
379			`/*`
380
381			`*/`
382
383			`static struct snd_pcm_hardware snd_sb8_playback =`
384			`{`
385			`.info = (SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_INTERLEAVED \|`
386			`SNDRV_PCM_INFO_MMAP_VALID),`
387			`.formats = SNDRV_PCM_FMTBIT_U8,`
388			`.rates = (SNDRV_PCM_RATE_CONTINUOUS \| SNDRV_PCM_RATE_8000 \|`
389			`SNDRV_PCM_RATE_11025 \| SNDRV_PCM_RATE_22050),`
390			`.rate_min = 4000,`
391			`.rate_max = 23000,`
392			`.channels_min = 1,`
393			`.channels_max = 1,`
394			`.buffer_bytes_max = 65536,`
395			`.period_bytes_min = 64,`
396			`.period_bytes_max = 65536,`
397			`.periods_min = 1,`
398			`.periods_max = 1024,`
399			`.fifo_size = 0,`
400			`};`
401
402			`static struct snd_pcm_hardware snd_sb8_capture =`
403			`{`
404			`.info = (SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_INTERLEAVED \|`
405			`SNDRV_PCM_INFO_MMAP_VALID),`
406			`.formats = SNDRV_PCM_FMTBIT_U8,`
407			`.rates = (SNDRV_PCM_RATE_CONTINUOUS \| SNDRV_PCM_RATE_8000 \|`
408			`SNDRV_PCM_RATE_11025),`
409			`.rate_min = 4000,`
410			`.rate_max = 13000,`
411			`.channels_min = 1,`
412			`.channels_max = 1,`
413			`.buffer_bytes_max = 65536,`
414			`.period_bytes_min = 64,`
415			`.period_bytes_max = 65536,`
416			`.periods_min = 1,`
417			`.periods_max = 1024,`
418			`.fifo_size = 0,`
419			`};`
420
421			`/*`
422			`*`
423			`*/`
424
425			`static int snd_sb8_open(struct snd_pcm_substream *substream)`
426			`{`
427			`struct snd_sb *chip = snd_pcm_substream_chip(substream);`
428			`struct snd_pcm_runtime *runtime = substream->runtime;`
429			`unsigned long flags;`
430
431			`spin_lock_irqsave(&chip->open_lock, flags);`
432			`if (chip->open) {`
433			`spin_unlock_irqrestore(&chip->open_lock, flags);`
434			`return -EAGAIN;`
435			`}`
436			`chip->open \|= SB_OPEN_PCM;`
437			`spin_unlock_irqrestore(&chip->open_lock, flags);`
438			`if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {`
439			`chip->playback_substream = substream;`
440			`runtime->hw = snd_sb8_playback;`
441			`} else {`
442			`chip->capture_substream = substream;`
443			`runtime->hw = snd_sb8_capture;`
444			`}`
445			`switch (chip->hardware) {`
446			`case SB_HW_PRO:`
447			`runtime->hw.rate_max = 44100;`
448			`runtime->hw.channels_max = 2;`
449			`snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,`
450			`snd_sb8_hw_constraint_rate_channels, NULL,`
451			`SNDRV_PCM_HW_PARAM_CHANNELS,`
452			`SNDRV_PCM_HW_PARAM_RATE, -1);`
453			`snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,`
454			`snd_sb8_hw_constraint_channels_rate, NULL,`
455			`SNDRV_PCM_HW_PARAM_RATE, -1);`
456			`break;`
457			`case SB_HW_201:`
458			`if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {`
459			`runtime->hw.rate_max = 44100;`
460			`} else {`
461			`runtime->hw.rate_max = 15000;`
462			`}`
463			`default:`
464			`break;`
465			`}`
466			`snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,`
467			`&hw_constraints_clock);`
468			`return 0;`
469			`}`
470
471			`static int snd_sb8_close(struct snd_pcm_substream *substream)`
472			`{`
473			`unsigned long flags;`
474			`struct snd_sb *chip = snd_pcm_substream_chip(substream);`
475
476			`chip->playback_substream = NULL;`
477			`chip->capture_substream = NULL;`
478			`spin_lock_irqsave(&chip->open_lock, flags);`
479			`chip->open &= ~SB_OPEN_PCM;`
480			`spin_unlock_irqrestore(&chip->open_lock, flags);`
481			`return 0;`
482			`}`
483
484			`/*`
485			`* Initialization part`
486			`*/`
487
488			`static struct snd_pcm_ops snd_sb8_playback_ops = {`
489			`.open = snd_sb8_open,`
490			`.close = snd_sb8_close,`
491			`.ioctl = snd_pcm_lib_ioctl,`
492			`.hw_params = snd_sb8_hw_params,`
493			`.hw_free = snd_sb8_hw_free,`
494			`.prepare = snd_sb8_playback_prepare,`
495			`.trigger = snd_sb8_playback_trigger,`
496			`.pointer = snd_sb8_playback_pointer,`
497			`};`
498
499			`static struct snd_pcm_ops snd_sb8_capture_ops = {`
500			`.open = snd_sb8_open,`
501			`.close = snd_sb8_close,`
502			`.ioctl = snd_pcm_lib_ioctl,`
503			`.hw_params = snd_sb8_hw_params,`
504			`.hw_free = snd_sb8_hw_free,`
505			`.prepare = snd_sb8_capture_prepare,`
506			`.trigger = snd_sb8_capture_trigger,`
507			`.pointer = snd_sb8_capture_pointer,`
508			`};`
509
510			`int snd_sb8dsp_pcm(struct snd_sb chip, int device, struct snd_pcm * rpcm)`
511			`{`
512			`struct snd_card *card = chip->card;`
513			`struct snd_pcm *pcm;`
514			`int err;`
515
516			`if (rpcm)`
517			`*rpcm = NULL;`
518			`if ((err = snd_pcm_new(card, "SB8 DSP", device, 1, 1, &pcm)) < 0)`
519			`return err;`
520			`sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff);`
521			`pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;`
522			`pcm->private_data = chip;`
523
524			`snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb8_playback_ops);`
525			`snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops);`
526
527			`snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,`
528			`snd_dma_isa_data(),`
529			`641024, 641024);`
530
531			`if (rpcm)`
532			`*rpcm = pcm;`
533			`return 0;`
534			`}`
535
536			`EXPORT_SYMBOL(snd_sb8dsp_pcm);`
537			`EXPORT_SYMBOL(snd_sb8dsp_interrupt);`
538			`/* sb8_midi.c */`
539			`EXPORT_SYMBOL(snd_sb8dsp_midi_interrupt);`
540			`EXPORT_SYMBOL(snd_sb8dsp_midi);`
541
542			`/*`
543			`* INIT part`
544			`*/`
545
546			`static int __init alsa_sb8_init(void)`
547			`{`
548			`return 0;`
549			`}`
550
551			`static void __exit alsa_sb8_exit(void)`
552			`{`
553			`}`
554
555			`module_init(alsa_sb8_init)`
556			`module_exit(alsa_sb8_exit)`