Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 *  Copyright (c) 1999 by Uros Bizjak <uros@kss-loka.si>

 *                        Takashi Iwai <tiwai@suse.de>

 *

 *  SB16ASP/AWE32 CSP control

 *

 *  CSP microcode loader:

 *   alsa-tools/sb16_csp/

 *

 *   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

 *

 */

#include <sound/driver.h>

#include <linux/delay.h>

#include <linux/init.h>

#include <linux/slab.h>

#include <sound/core.h>

#include <sound/control.h>

#include <sound/info.h>

#include <sound/sb16_csp.h>

#include <sound/initval.h>

MODULE_AUTHOR("Uros Bizjak <uros@kss-loka.si>");

MODULE_DESCRIPTION("ALSA driver for SB16 Creative Signal Processor");

MODULE_LICENSE("GPL");

#ifndef CONFIG_SND_SB16_CSP_FIRMWARE_IN_KERNEL

MODULE_FIRMWARE("sb16/mulaw_main.csp");

MODULE_FIRMWARE("sb16/alaw_main.csp");

MODULE_FIRMWARE("sb16/ima_adpcm_init.csp");

MODULE_FIRMWARE("sb16/ima_adpcm_playback.csp");

MODULE_FIRMWARE("sb16/ima_adpcm_capture.csp");

#endif

#ifdef SNDRV_LITTLE_ENDIAN

#define CSP_HDR_VALUE(a,b,c,d)  ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24))

#else

#define CSP_HDR_VALUE(a,b,c,d)  ((d) | ((c)<<8) | ((b)<<16) | ((a)<<24))

#endif

#define RIFF_HEADER     CSP_HDR_VALUE('R', 'I', 'F', 'F')

#define CSP__HEADER     CSP_HDR_VALUE('C', 'S', 'P', ' ')

#define LIST_HEADER     CSP_HDR_VALUE('L', 'I', 'S', 'T')

#define FUNC_HEADER     CSP_HDR_VALUE('f', 'u', 'n', 'c')

#define CODE_HEADER     CSP_HDR_VALUE('c', 'o', 'd', 'e')

#define INIT_HEADER     CSP_HDR_VALUE('i', 'n', 'i', 't')

#define MAIN_HEADER     CSP_HDR_VALUE('m', 'a', 'i', 'n')

/*

 * RIFF data format

 */

struct riff_header {

        __u32 name;

        __u32 len;

};

struct desc_header {

        struct riff_header info;

        __u16 func_nr;

        __u16 VOC_type;

        __u16 flags_play_rec;

        __u16 flags_16bit_8bit;

        __u16 flags_stereo_mono;

        __u16 flags_rates;

};

/*

 * prototypes

 */

static void snd_sb_csp_free(struct snd_hwdep *hw);

static int snd_sb_csp_open(struct snd_hwdep * hw, struct file *file);

static int snd_sb_csp_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg);

static int snd_sb_csp_release(struct snd_hwdep * hw, struct file *file);

static int csp_detect(struct snd_sb *chip, int *version);

static int set_codec_parameter(struct snd_sb *chip, unsigned char par, unsigned char val);

static int set_register(struct snd_sb *chip, unsigned char reg, unsigned char val);

static int read_register(struct snd_sb *chip, unsigned char reg);

static int set_mode_register(struct snd_sb *chip, unsigned char mode);

static int get_version(struct snd_sb *chip);

static int snd_sb_csp_riff_load(struct snd_sb_csp * p,

                                struct snd_sb_csp_microcode __user * code);

static int snd_sb_csp_unload(struct snd_sb_csp * p);

static int snd_sb_csp_load_user(struct snd_sb_csp * p, const unsigned char __user *buf, int size, int load_flags);

static int snd_sb_csp_autoload(struct snd_sb_csp * p, int pcm_sfmt, int play_rec_mode);

static int snd_sb_csp_check_version(struct snd_sb_csp * p);

static int snd_sb_csp_use(struct snd_sb_csp * p);

static int snd_sb_csp_unuse(struct snd_sb_csp * p);

static int snd_sb_csp_start(struct snd_sb_csp * p, int sample_width, int channels);

static int snd_sb_csp_stop(struct snd_sb_csp * p);

static int snd_sb_csp_pause(struct snd_sb_csp * p);

static int snd_sb_csp_restart(struct snd_sb_csp * p);

static int snd_sb_qsound_build(struct snd_sb_csp * p);

static void snd_sb_qsound_destroy(struct snd_sb_csp * p);

static int snd_sb_csp_qsound_transfer(struct snd_sb_csp * p);

static int init_proc_entry(struct snd_sb_csp * p, int device);

static void info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer);

/*

 * Detect CSP chip and create a new instance

 */

int snd_sb_csp_new(struct snd_sb *chip, int device, struct snd_hwdep ** rhwdep)

{

        struct snd_sb_csp *p;

        int version, err;

        struct snd_hwdep *hw;

        if (rhwdep)

                *rhwdep = NULL;

        if (csp_detect(chip, &version))

                return -ENODEV;

        if ((err = snd_hwdep_new(chip->card, "SB16-CSP", device, &hw)) < 0)

                return err;

        if ((p = kzalloc(sizeof(*p), GFP_KERNEL)) == NULL) {

                snd_device_free(chip->card, hw);

                return -ENOMEM;

        }

        p->chip = chip;

        p->version = version;

        /* CSP operators */

        p->ops.csp_use = snd_sb_csp_use;

        p->ops.csp_unuse = snd_sb_csp_unuse;

        p->ops.csp_autoload = snd_sb_csp_autoload;

        p->ops.csp_start = snd_sb_csp_start;

        p->ops.csp_stop = snd_sb_csp_stop;

        p->ops.csp_qsound_transfer = snd_sb_csp_qsound_transfer;

        mutex_init(&p->access_mutex);

        sprintf(hw->name, "CSP v%d.%d", (version >> 4), (version & 0x0f));

        hw->iface = SNDRV_HWDEP_IFACE_SB16CSP;

        hw->private_data = p;

        hw->private_free = snd_sb_csp_free;

        /* operators - only write/ioctl */

        hw->ops.open = snd_sb_csp_open;

        hw->ops.ioctl = snd_sb_csp_ioctl;

        hw->ops.release = snd_sb_csp_release;

        /* create a proc entry */

        init_proc_entry(p, device);

        if (rhwdep)

                *rhwdep = hw;

        return 0;

}

/*

 * free_private for hwdep instance

 */

static void snd_sb_csp_free(struct snd_hwdep *hwdep)

{

#ifndef CONFIG_SND_SB16_CSP_FIRMWARE_IN_KERNEL

        int i;

#endif

        struct snd_sb_csp *p = hwdep->private_data;

        if (p) {

                if (p->running & SNDRV_SB_CSP_ST_RUNNING)

                        snd_sb_csp_stop(p);

#ifndef CONFIG_SND_SB16_CSP_FIRMWARE_IN_KERNEL

                for (i = 0; i < ARRAY_SIZE(p->csp_programs); ++i)

                        release_firmware(p->csp_programs[i]);

#endif

                kfree(p);

        }

}

/* ------------------------------ */

/*

 * open the device exclusively

 */

static int snd_sb_csp_open(struct snd_hwdep * hw, struct file *file)

{

        struct snd_sb_csp *p = hw->private_data;

        return (snd_sb_csp_use(p));

}

/*

 * ioctl for hwdep device:

 */

static int snd_sb_csp_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg)

{

        struct snd_sb_csp *p = hw->private_data;

        struct snd_sb_csp_info info;

        struct snd_sb_csp_start start_info;

        int err;

        snd_assert(p != NULL, return -EINVAL);

        if (snd_sb_csp_check_version(p))

                return -ENODEV;

        switch (cmd) {

                /* get information */

        case SNDRV_SB_CSP_IOCTL_INFO:

                *info.codec_name = *p->codec_name;

                info.func_nr = p->func_nr;

                info.acc_format = p->acc_format;

                info.acc_channels = p->acc_channels;

                info.acc_width = p->acc_width;

                info.acc_rates = p->acc_rates;

                info.csp_mode = p->mode;

                info.run_channels = p->run_channels;

                info.run_width = p->run_width;

                info.version = p->version;

                info.state = p->running;

                if (copy_to_user((void __user *)arg, &info, sizeof(info)))

                        err = -EFAULT;

                else

                        err = 0;

                break;

                /* load CSP microcode */

        case SNDRV_SB_CSP_IOCTL_LOAD_CODE:

                err = (p->running & SNDRV_SB_CSP_ST_RUNNING ?

                       -EBUSY : snd_sb_csp_riff_load(p, (struct snd_sb_csp_microcode __user *) arg));

                break;

        case SNDRV_SB_CSP_IOCTL_UNLOAD_CODE:

                err = (p->running & SNDRV_SB_CSP_ST_RUNNING ?

                       -EBUSY : snd_sb_csp_unload(p));

                break;

                /* change CSP running state */

        case SNDRV_SB_CSP_IOCTL_START:

                if (copy_from_user(&start_info, (void __user *) arg, sizeof(start_info)))

                        err = -EFAULT;

                else

                        err = snd_sb_csp_start(p, start_info.sample_width, start_info.channels);

                break;

        case SNDRV_SB_CSP_IOCTL_STOP:

                err = snd_sb_csp_stop(p);

                break;

        case SNDRV_SB_CSP_IOCTL_PAUSE:

                err = snd_sb_csp_pause(p);

                break;

        case SNDRV_SB_CSP_IOCTL_RESTART:

                err = snd_sb_csp_restart(p);

                break;

        default:

                err = -ENOTTY;

                break;

        }

        return err;

}

/*

 * close the device

 */

static int snd_sb_csp_release(struct snd_hwdep * hw, struct file *file)

{

        struct snd_sb_csp *p = hw->private_data;

        return (snd_sb_csp_unuse(p));

}

/* ------------------------------ */

/*

 * acquire device

 */

static int snd_sb_csp_use(struct snd_sb_csp * p)

{

        mutex_lock(&p->access_mutex);

        if (p->used) {

                mutex_unlock(&p->access_mutex);

                return -EAGAIN;

        }

        p->used++;

        mutex_unlock(&p->access_mutex);

        return 0;

}

/*

 * release device

 */

static int snd_sb_csp_unuse(struct snd_sb_csp * p)

{

        mutex_lock(&p->access_mutex);

        p->used--;

        mutex_unlock(&p->access_mutex);

        return 0;

}

/*

 * load microcode via ioctl:

 * code is user-space pointer

 */

static int snd_sb_csp_riff_load(struct snd_sb_csp * p,

                                struct snd_sb_csp_microcode __user * mcode)

{

        struct snd_sb_csp_mc_header info;

        unsigned char __user *data_ptr;

        unsigned char __user *data_end;

        unsigned short func_nr = 0;

        struct riff_header file_h, item_h, code_h;

        __u32 item_type;

        struct desc_header funcdesc_h;

        unsigned long flags;

        int err;

        if (copy_from_user(&info, mcode, sizeof(info)))

                return -EFAULT;

        data_ptr = mcode->data;

        if (copy_from_user(&file_h, data_ptr, sizeof(file_h)))

                return -EFAULT;

        if ((file_h.name != RIFF_HEADER) ||

            (le32_to_cpu(file_h.len) >= SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE - sizeof(file_h))) {

                snd_printd("%s: Invalid RIFF header\n", __FUNCTION__);

                return -EINVAL;

        }

        data_ptr += sizeof(file_h);

        data_end = data_ptr + le32_to_cpu(file_h.len);

        if (copy_from_user(&item_type, data_ptr, sizeof(item_type)))

                return -EFAULT;

        if (item_type != CSP__HEADER) {

                snd_printd("%s: Invalid RIFF file type\n", __FUNCTION__);

                return -EINVAL;

        }

        data_ptr += sizeof (item_type);

        for (; data_ptr < data_end; data_ptr += le32_to_cpu(item_h.len)) {

                if (copy_from_user(&item_h, data_ptr, sizeof(item_h)))

                        return -EFAULT;

                data_ptr += sizeof(item_h);

                if (item_h.name != LIST_HEADER)

                        continue;

                if (copy_from_user(&item_type, data_ptr, sizeof(item_type)))

                         return -EFAULT;

                switch (item_type) {

                case FUNC_HEADER:

                        if (copy_from_user(&funcdesc_h, data_ptr + sizeof(item_type), sizeof(funcdesc_h)))

                                return -EFAULT;

                        func_nr = le16_to_cpu(funcdesc_h.func_nr);

                        break;

                case CODE_HEADER:

                        if (func_nr != info.func_req)

                                break;  /* not required function, try next */

                        data_ptr += sizeof(item_type);

                        /* destroy QSound mixer element */

                        if (p->mode == SNDRV_SB_CSP_MODE_QSOUND) {

                                snd_sb_qsound_destroy(p);

                        }

                        /* Clear all flags */

                        p->running = 0;

                        p->mode = 0;

                        /* load microcode blocks */

                        for (;;) {

                                if (data_ptr >= data_end)

                                        return -EINVAL;

                                if (copy_from_user(&code_h, data_ptr, sizeof(code_h)))

                                        return -EFAULT;

                                /* init microcode blocks */

                                if (code_h.name != INIT_HEADER)

                                        break;

                                data_ptr += sizeof(code_h);

                                err = snd_sb_csp_load_user(p, data_ptr, le32_to_cpu(code_h.len),

                                                      SNDRV_SB_CSP_LOAD_INITBLOCK);

                                if (err)

                                        return err;

                                data_ptr += le32_to_cpu(code_h.len);

                        }

                        /* main microcode block */

                        if (copy_from_user(&code_h, data_ptr, sizeof(code_h)))

                                return -EFAULT;

                        if (code_h.name != MAIN_HEADER) {

                                snd_printd("%s: Missing 'main' microcode\n", __FUNCTION__);

                                return -EINVAL;

                        }

                        data_ptr += sizeof(code_h);

                        err = snd_sb_csp_load_user(p, data_ptr,

                                                   le32_to_cpu(code_h.len), 0);

                        if (err)

                                return err;

                        /* fill in codec header */

                        strlcpy(p->codec_name, info.codec_name, sizeof(p->codec_name));

                        p->func_nr = func_nr;

                        p->mode = le16_to_cpu(funcdesc_h.flags_play_rec);

                        switch (le16_to_cpu(funcdesc_h.VOC_type)) {

                        case 0x0001:    /* QSound decoder */

                                if (le16_to_cpu(funcdesc_h.flags_play_rec) == SNDRV_SB_CSP_MODE_DSP_WRITE) {

                                        if (snd_sb_qsound_build(p) == 0)

                                                /* set QSound flag and clear all other mode flags */

                                                p->mode = SNDRV_SB_CSP_MODE_QSOUND;

                                }

                                p->acc_format = 0;

                                break;

                        case 0x0006:    /* A Law codec */

                                p->acc_format = SNDRV_PCM_FMTBIT_A_LAW;

                                break;

                        case 0x0007:    /* Mu Law codec */

                                p->acc_format = SNDRV_PCM_FMTBIT_MU_LAW;

                                break;

                        case 0x0011:    /* what Creative thinks is IMA ADPCM codec */

                        case 0x0200:    /* Creative ADPCM codec */

                                p->acc_format = SNDRV_PCM_FMTBIT_IMA_ADPCM;

                                break;

                        case    201:    /* Text 2 Speech decoder */

                                /* TODO: Text2Speech handling routines */

                                p->acc_format = 0;

                                break;

                        case 0x0202:    /* Fast Speech 8 codec */

                        case 0x0203:    /* Fast Speech 10 codec */

                                p->acc_format = SNDRV_PCM_FMTBIT_SPECIAL;

                                break;

                        default:        /* other codecs are unsupported */

                                p->acc_format = p->acc_width = p->acc_rates = 0;

                                p->mode = 0;

                                snd_printd("%s: Unsupported CSP codec type: 0x%04x\n",

                                           __FUNCTION__,

                                           le16_to_cpu(funcdesc_h.VOC_type));

                                return -EINVAL;

                        }

                        p->acc_channels = le16_to_cpu(funcdesc_h.flags_stereo_mono);

                        p->acc_width = le16_to_cpu(funcdesc_h.flags_16bit_8bit);

                        p->acc_rates = le16_to_cpu(funcdesc_h.flags_rates);

                        /* Decouple CSP from IRQ and DMAREQ lines */

                        spin_lock_irqsave(&p->chip->reg_lock, flags);

                        set_mode_register(p->chip, 0xfc);

                        set_mode_register(p->chip, 0x00);

                        spin_unlock_irqrestore(&p->chip->reg_lock, flags);

                        /* finished loading successfully */

                        p->running = SNDRV_SB_CSP_ST_LOADED;    /* set LOADED flag */

                        return 0;

                }

        }

        snd_printd("%s: Function #%d not found\n", __FUNCTION__, info.func_req);

        return -EINVAL;

}

/*

 * unload CSP microcode

 */

static int snd_sb_csp_unload(struct snd_sb_csp * p)

{

        if (p->running & SNDRV_SB_CSP_ST_RUNNING)

                return -EBUSY;

        if (!(p->running & SNDRV_SB_CSP_ST_LOADED))

                return -ENXIO;

        /* clear supported formats */

        p->acc_format = 0;

        p->acc_channels = p->acc_width = p->acc_rates = 0;

        /* destroy QSound mixer element */

        if (p->mode == SNDRV_SB_CSP_MODE_QSOUND) {

                snd_sb_qsound_destroy(p);

        }

        /* clear all flags */

        p->running = 0;

        p->mode = 0;

        return 0;

}

/*

 * send command sequence to DSP

 */

static inline int command_seq(struct snd_sb *chip, const unsigned char *seq, int size)

{

        int i;

        for (i = 0; i < size; i++) {

                if (!snd_sbdsp_command(chip, seq[i]))

                        return -EIO;

        }

        return 0;

}

/*

 * set CSP codec parameter

 */

static int set_codec_parameter(struct snd_sb *chip, unsigned char par, unsigned char val)

{

        unsigned char dsp_cmd[3];

        dsp_cmd[0] = 0x05;       /* CSP set codec parameter */

        dsp_cmd[1] = val;       /* Parameter value */

        dsp_cmd[2] = par;       /* Parameter */

        command_seq(chip, dsp_cmd, 3);

        snd_sbdsp_command(chip, 0x03);  /* DSP read? */

        if (snd_sbdsp_get_byte(chip) != par)

                return -EIO;

        return 0;

}

/*

 * set CSP register

 */

static int set_register(struct snd_sb *chip, unsigned char reg, unsigned char val)

{

        unsigned char dsp_cmd[3];

        dsp_cmd[0] = 0x0e;       /* CSP set register */

        dsp_cmd[1] = reg;       /* CSP Register */

        dsp_cmd[2] = val;       /* value */

        return command_seq(chip, dsp_cmd, 3);

}

/*

 * read CSP register

 * return < 0 -> error

 */

static int read_register(struct snd_sb *chip, unsigned char reg)

{

        unsigned char dsp_cmd[2];

        dsp_cmd[0] = 0x0f;       /* CSP read register */

        dsp_cmd[1] = reg;       /* CSP Register */

        command_seq(chip, dsp_cmd, 2);

        return snd_sbdsp_get_byte(chip);        /* Read DSP value */

}

/*

 * set CSP mode register

 */

static int set_mode_register(struct snd_sb *chip, unsigned char mode)

{

        unsigned char dsp_cmd[2];

        dsp_cmd[0] = 0x04;       /* CSP set mode register */

        dsp_cmd[1] = mode;      /* mode */

        return command_seq(chip, dsp_cmd, 2);

}

/*

 * Detect CSP

 * return 0 if CSP exists.

 */

static int csp_detect(struct snd_sb *chip, int *version)

{

        unsigned char csp_test1, csp_test2;

        unsigned long flags;

        int result = -ENODEV;

        spin_lock_irqsave(&chip->reg_lock, flags);

        set_codec_parameter(chip, 0x00, 0x00);

        set_mode_register(chip, 0xfc);          /* 0xfc = ?? */

        csp_test1 = read_register(chip, 0x83);

        set_register(chip, 0x83, ~csp_test1);

        csp_test2 = read_register(chip, 0x83);

        if (csp_test2 != (csp_test1 ^ 0xff))

                goto __fail;

        set_register(chip, 0x83, csp_test1);

        csp_test2 = read_register(chip, 0x83);

        if (csp_test2 != csp_test1)

                goto __fail;

        set_mode_register(chip, 0x00);          /* 0x00 = ? */

        *version = get_version(chip);

        snd_sbdsp_reset(chip);  /* reset DSP after getversion! */

        if (*version >= 0x10 && *version <= 0x1f)

                result = 0;              /* valid version id */

      __fail:

        spin_unlock_irqrestore(&chip->reg_lock, flags);

        return result;

}

/*

 * get CSP version number

 */

static int get_version(struct snd_sb *chip)

{

        unsigned char dsp_cmd[2];

        dsp_cmd[0] = 0x08;       /* SB_DSP_!something! */

        dsp_cmd[1] = 0x03;      /* get chip version id? */

        command_seq(chip, dsp_cmd, 2);

        return (snd_sbdsp_get_byte(chip));

}

/*

 * check if the CSP version is valid

 */

static int snd_sb_csp_check_version(struct snd_sb_csp * p)

{

        if (p->version < 0x10 || p->version > 0x1f) {

                snd_printd("%s: Invalid CSP version: 0x%x\n", __FUNCTION__, p->version);

                return 1;

        }

        return 0;

}

/*

 * download microcode to CSP (microcode should have one "main" block).

 */

static int snd_sb_csp_load(struct snd_sb_csp * p, const unsigned char *buf, int size, int load_flags)

{

        int status, i;

        int err;

        int result = -EIO;

        unsigned long flags;

        spin_lock_irqsave(&p->chip->reg_lock, flags);

        snd_sbdsp_command(p->chip, 0x01);       /* CSP download command */

        if (snd_sbdsp_get_byte(p->chip)) {

                snd_printd("%s: Download command failed\n", __FUNCTION__);

                goto __fail;

        }

        /* Send CSP low byte (size - 1) */

        snd_sbdsp_command(p->chip, (unsigned char)(size - 1));

        /* Send high byte */

        snd_sbdsp_command(p->chip, (unsigned char)((size - 1) >> 8));

        /* send microcode sequence */

        /* load from kernel space */

        while (size--) {

                if (!snd_sbdsp_command(p->chip, *buf++))