Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 *  linux/drivers/sound/vidc.c

 *

 *  Copyright (C) 1997-2000 by Russell King <rmk@arm.linux.org.uk>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 *

 *  VIDC20 audio driver.

 *

 * The VIDC20 sound hardware consists of the VIDC20 itself, a DAC and a DMA

 * engine.  The DMA transfers fixed-format (16-bit little-endian linear)

 * samples to the VIDC20, which then transfers this data serially to the

 * DACs.  The samplerate is controlled by the VIDC.

 *

 * We currently support a mixer device, but it is currently non-functional.

 */

#include <linux/init.h>

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/interrupt.h>

#include <asm/hardware.h>

#include <asm/dma.h>

#include <asm/io.h>

#include <asm/hardware/iomd.h>

#include <asm/irq.h>

#include <asm/system.h>

#include "sound_config.h"

#include "vidc.h"

#ifndef _SIOC_TYPE

#define _SIOC_TYPE(x)   _IOC_TYPE(x)

#endif

#ifndef _SIOC_NR

#define _SIOC_NR(x)     _IOC_NR(x)

#endif

#define VIDC_SOUND_CLOCK        (250000)

#define VIDC_SOUND_CLOCK_EXT    (176400)

/*

 * When using SERIAL SOUND mode (external DAC), the number of physical

 * channels is fixed at 2.

 */

static int              vidc_busy;

static int              vidc_adev;

static int              vidc_audio_rate;

static char             vidc_audio_format;

static char             vidc_audio_channels;

static unsigned char    vidc_level_l[SOUND_MIXER_NRDEVICES] = {

        85,             /* master       */

        50,             /* bass         */

        50,             /* treble       */

        0,               /* synth        */

        75,             /* pcm          */

        0,               /* speaker      */

        100,            /* ext line     */

        0,               /* mic          */

        100,            /* CD           */

        0,

};

static unsigned char    vidc_level_r[SOUND_MIXER_NRDEVICES] = {

        85,             /* master       */

        50,             /* bass         */

        50,             /* treble       */

        0,               /* synth        */

        75,             /* pcm          */

        0,               /* speaker      */

        100,            /* ext line     */

        0,               /* mic          */

        100,            /* CD           */

        0,

};

static unsigned int     vidc_audio_volume_l;    /* left PCM vol, 0 - 65536 */

static unsigned int     vidc_audio_volume_r;    /* right PCM vol, 0 - 65536 */

extern void     vidc_update_filler(int bits, int channels);

extern int      softoss_dev;

static void

vidc_mixer_set(int mdev, unsigned int level)

{

        unsigned int lev_l = level & 0x007f;

        unsigned int lev_r = (level & 0x7f00) >> 8;

        unsigned int mlev_l, mlev_r;

        if (lev_l > 100)

                lev_l = 100;

        if (lev_r > 100)

                lev_r = 100;

#define SCALE(lev,master)       ((lev) * (master) * 65536 / 10000)

        mlev_l = vidc_level_l[SOUND_MIXER_VOLUME];

        mlev_r = vidc_level_r[SOUND_MIXER_VOLUME];

        switch (mdev) {

        case SOUND_MIXER_VOLUME:

        case SOUND_MIXER_PCM:

                vidc_level_l[mdev] = lev_l;

                vidc_level_r[mdev] = lev_r;

                vidc_audio_volume_l = SCALE(lev_l, mlev_l);

                vidc_audio_volume_r = SCALE(lev_r, mlev_r);

/*printk("VIDC: PCM vol %05X %05X\n", vidc_audio_volume_l, vidc_audio_volume_r);*/

                break;

        }

#undef SCALE

}

static int vidc_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)

{

        unsigned int val;

        unsigned int mdev;

        if (_SIOC_TYPE(cmd) != 'M')

                return -EINVAL;

        mdev = _SIOC_NR(cmd);

        if (_SIOC_DIR(cmd) & _SIOC_WRITE) {

                if (get_user(val, (unsigned int __user *)arg))

                        return -EFAULT;

                if (mdev < SOUND_MIXER_NRDEVICES)

                        vidc_mixer_set(mdev, val);

                else

                        return -EINVAL;

        }

        /*

         * Return parameters

         */

        switch (mdev) {

        case SOUND_MIXER_RECSRC:

                val = 0;

                break;

        case SOUND_MIXER_DEVMASK:

                val = SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_SYNTH;

                break;

        case SOUND_MIXER_STEREODEVS:

                val = SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_SYNTH;

                break;

        case SOUND_MIXER_RECMASK:

                val = 0;

                break;

        case SOUND_MIXER_CAPS:

                val = 0;

                break;

        default:

                if (mdev < SOUND_MIXER_NRDEVICES)

                        val = vidc_level_l[mdev] | vidc_level_r[mdev] << 8;

                else

                        return -EINVAL;

        }

        return put_user(val, (unsigned int __user *)arg) ? -EFAULT : 0;

}

static unsigned int vidc_audio_set_format(int dev, unsigned int fmt)

{

        switch (fmt) {

        default:

                fmt = AFMT_S16_LE;

        case AFMT_U8:

        case AFMT_S8:

        case AFMT_S16_LE:

                vidc_audio_format = fmt;

                vidc_update_filler(vidc_audio_format, vidc_audio_channels);

        case AFMT_QUERY:

                break;

        }

        return vidc_audio_format;

}

#define my_abs(i) ((i)<0 ? -(i) : (i))

static int vidc_audio_set_speed(int dev, int rate)

{

        if (rate) {

                unsigned int hwctrl, hwrate, hwrate_ext, rate_int, rate_ext;

                unsigned int diff_int, diff_ext;

                unsigned int newsize, new2size;

                hwctrl = 0x00000003;

                /* Using internal clock */

                hwrate = (((VIDC_SOUND_CLOCK * 2) / rate) + 1) >> 1;

                if (hwrate < 3)

                        hwrate = 3;

                if (hwrate > 255)

                        hwrate = 255;

                /* Using exernal clock */

                hwrate_ext = (((VIDC_SOUND_CLOCK_EXT * 2) / rate) + 1) >> 1;

                if (hwrate_ext < 3)

                        hwrate_ext = 3;

                if (hwrate_ext > 255)

                        hwrate_ext = 255;

                rate_int = VIDC_SOUND_CLOCK / hwrate;

                rate_ext = VIDC_SOUND_CLOCK_EXT / hwrate_ext;

                /* Chose between external and internal clock */

                diff_int = my_abs(rate_ext-rate);

                diff_ext = my_abs(rate_int-rate);

                if (diff_ext < diff_int) {

                        /*printk("VIDC: external %d %d %d\n", rate, rate_ext, hwrate_ext);*/

                        hwrate=hwrate_ext;

                        hwctrl=0x00000002;

                        /* Allow roughly 0.4% tolerance */

                        if (diff_ext > (rate/256))

                                rate=rate_ext;

                } else {

                        /*printk("VIDC: internal %d %d %d\n", rate, rate_int, hwrate);*/

                        hwctrl=0x00000003;

                        /* Allow rougly 0.4% tolerance */

                        if (diff_int > (rate/256))

                                rate=rate_int;

                }

                vidc_writel(0xb0000000 | (hwrate - 2));

                vidc_writel(0xb1000000 | hwctrl);

                newsize = (10000 / hwrate) & ~3;

                if (newsize < 208)

                        newsize = 208;

                if (newsize > 4096)

                        newsize = 4096;

                for (new2size = 128; new2size < newsize; new2size <<= 1);

                if (new2size - newsize > newsize - (new2size >> 1))

                        new2size >>= 1;

                if (new2size > 4096) {

                        printk(KERN_ERR "VIDC: error: dma buffer (%d) %d > 4K\n",

                                newsize, new2size);

                        new2size = 4096;

                }

                /*printk("VIDC: dma size %d\n", new2size);*/

                dma_bufsize = new2size;

                vidc_audio_rate = rate;

        }

        return vidc_audio_rate;

}

static short vidc_audio_set_channels(int dev, short channels)

{

        switch (channels) {

        default:

                channels = 2;

        case 1:

        case 2:

                vidc_audio_channels = channels;

                vidc_update_filler(vidc_audio_format, vidc_audio_channels);

        case 0:

                break;

        }

        return vidc_audio_channels;

}

/*

 * Open the device

 */

static int vidc_audio_open(int dev, int mode)

{

        /* This audio device does not have recording capability */

        if (mode == OPEN_READ)

                return -EPERM;

        if (vidc_busy)

                return -EBUSY;

        vidc_busy = 1;

        return 0;

}

/*

 * Close the device

 */

static void vidc_audio_close(int dev)

{

        vidc_busy = 0;

}

/*

 * Output a block via DMA to sound device.

 *

 * We just set the DMA start and count; the DMA interrupt routine

 * will take care of formatting the samples (via the appropriate

 * vidc_filler routine), and flag via vidc_audio_dma_interrupt when

 * more data is required.

 */

static void

vidc_audio_output_block(int dev, unsigned long buf, int total_count, int one)

{

        struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;

        unsigned long flags;

        local_irq_save(flags);

        dma_start = buf - (unsigned long)dmap->raw_buf_phys + (unsigned long)dmap->raw_buf;

        dma_count = total_count;

        local_irq_restore(flags);

}

static void

vidc_audio_start_input(int dev, unsigned long buf, int count, int intrflag)

{

}

static int vidc_audio_prepare_for_input(int dev, int bsize, int bcount)

{

        return -EINVAL;

}

static irqreturn_t vidc_audio_dma_interrupt(void)

{

        DMAbuf_outputintr(vidc_adev, 1);

        return IRQ_HANDLED;

}

/*

 * Prepare for outputting samples.

 *

 * Each buffer that will be passed will be `bsize' bytes long,

 * with a total of `bcount' buffers.

 */

static int vidc_audio_prepare_for_output(int dev, int bsize, int bcount)

{

        struct audio_operations *adev = audio_devs[dev];

        dma_interrupt = NULL;

        adev->dmap_out->flags |= DMA_NODMA;

        return 0;

}

/*

 * Stop our current operation.

 */

static void vidc_audio_reset(int dev)

{

        dma_interrupt = NULL;

}

static int vidc_audio_local_qlen(int dev)

{

        return /*dma_count !=*/ 0;

}

static void vidc_audio_trigger(int dev, int enable_bits)

{

        struct audio_operations *adev = audio_devs[dev];

        if (enable_bits & PCM_ENABLE_OUTPUT) {

                if (!(adev->flags & DMA_ACTIVE)) {

                        unsigned long flags;

                        local_irq_save(flags);

                        /* prevent recusion */

                        adev->flags |= DMA_ACTIVE;

                        dma_interrupt = vidc_audio_dma_interrupt;

                        vidc_sound_dma_irq(0, NULL);

                        iomd_writeb(DMA_CR_E | 0x10, IOMD_SD0CR);

                        local_irq_restore(flags);

                }

        }

}

static struct audio_driver vidc_audio_driver =

{

        .owner                  = THIS_MODULE,

        .open                   = vidc_audio_open,

        .close                  = vidc_audio_close,

        .output_block           = vidc_audio_output_block,

        .start_input            = vidc_audio_start_input,

        .prepare_for_input      = vidc_audio_prepare_for_input,

        .prepare_for_output     = vidc_audio_prepare_for_output,

        .halt_io                = vidc_audio_reset,

        .local_qlen             = vidc_audio_local_qlen,

        .trigger                = vidc_audio_trigger,

        .set_speed              = vidc_audio_set_speed,

        .set_bits               = vidc_audio_set_format,

        .set_channels           = vidc_audio_set_channels

};

static struct mixer_operations vidc_mixer_operations = {

        .owner          = THIS_MODULE,

        .id             = "VIDC",

        .name           = "VIDCsound",

        .ioctl          = vidc_mixer_ioctl

};

void vidc_update_filler(int format, int channels)

{

#define TYPE(fmt,ch) (((fmt)<<2) | ((ch)&3))

        switch (TYPE(format, channels)) {

        default:

        case TYPE(AFMT_U8, 1):

                vidc_filler = vidc_fill_1x8_u;

                break;

        case TYPE(AFMT_U8, 2):

                vidc_filler = vidc_fill_2x8_u;

                break;

        case TYPE(AFMT_S8, 1):

                vidc_filler = vidc_fill_1x8_s;

                break;

        case TYPE(AFMT_S8, 2):

                vidc_filler = vidc_fill_2x8_s;

                break;

        case TYPE(AFMT_S16_LE, 1):

                vidc_filler = vidc_fill_1x16_s;

                break;

        case TYPE(AFMT_S16_LE, 2):

                vidc_filler = vidc_fill_2x16_s;

                break;

        }

}

static void __init attach_vidc(struct address_info *hw_config)

{

        char name[32];

        int i, adev;

        sprintf(name, "VIDC %d-bit sound", hw_config->card_subtype);

        conf_printf(name, hw_config);

        memset(dma_buf, 0, sizeof(dma_buf));

        adev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, name,

                        &vidc_audio_driver, sizeof(vidc_audio_driver),

                        DMA_AUTOMODE, AFMT_U8 | AFMT_S8 | AFMT_S16_LE,

                        NULL, hw_config->dma, hw_config->dma2);

        if (adev < 0)

                goto audio_failed;

        /*

         * 1024 bytes => 64 buffers

         */

        audio_devs[adev]->min_fragment = 10;

        audio_devs[adev]->mixer_dev = num_mixers;

        audio_devs[adev]->mixer_dev =

                sound_install_mixer(MIXER_DRIVER_VERSION,

                                name, &vidc_mixer_operations,

                                sizeof(vidc_mixer_operations), NULL);

        if (audio_devs[adev]->mixer_dev < 0)

                goto mixer_failed;

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

                dma_buf[i] = get_zeroed_page(GFP_KERNEL);

                if (!dma_buf[i]) {

                        printk(KERN_ERR "%s: can't allocate required buffers\n",

                                name);

                        goto mem_failed;

                }

                dma_pbuf[i] = virt_to_phys((void *)dma_buf[i]);

        }

        if (sound_alloc_dma(hw_config->dma, hw_config->name)) {

                printk(KERN_ERR "%s: DMA %d is in  use\n", name, hw_config->dma);

                goto dma_failed;

        }

        if (request_irq(hw_config->irq, vidc_sound_dma_irq, 0,

                        hw_config->name, &dma_start)) {

                printk(KERN_ERR "%s: IRQ %d is in use\n", name, hw_config->irq);

                goto irq_failed;

        }

        vidc_adev = adev;

        vidc_mixer_set(SOUND_MIXER_VOLUME, (85 | 85 << 8));

#if defined(CONFIG_SOUND_SOFTOSS) || defined(CONFIG_SOUND_SOFTOSS_MODULE)

        softoss_dev = adev;

#endif

        return;

irq_failed:

        sound_free_dma(hw_config->dma);

dma_failed:

mem_failed:

        for (i = 0; i < 2; i++)

                free_page(dma_buf[i]);

        sound_unload_mixerdev(audio_devs[adev]->mixer_dev);

mixer_failed:

        sound_unload_audiodev(adev);

audio_failed:

        return;

}

static int __init probe_vidc(struct address_info *hw_config)

{

        hw_config->irq          = IRQ_DMAS0;

        hw_config->dma          = DMA_VIRTUAL_SOUND;

        hw_config->dma2         = -1;

        hw_config->card_subtype = 16;

        hw_config->name         = "VIDC20";

        return 1;

}

static void __exit unload_vidc(struct address_info *hw_config)

{

        int i, adev = vidc_adev;

        vidc_adev = -1;

        free_irq(hw_config->irq, &dma_start);

        sound_free_dma(hw_config->dma);

        if (adev >= 0) {

                sound_unload_mixerdev(audio_devs[adev]->mixer_dev);

                sound_unload_audiodev(adev);

                for (i = 0; i < 2; i++)

                        free_page(dma_buf[i]);

        }

}

static struct address_info cfg;

static int __init init_vidc(void)

{

        if (probe_vidc(&cfg) == 0)

                return -ENODEV;

        attach_vidc(&cfg);

        return 0;

}

static void __exit cleanup_vidc(void)

{

        unload_vidc(&cfg);

}

module_init(init_vidc);

module_exit(cleanup_vidc);

MODULE_AUTHOR("Russell King");

MODULE_DESCRIPTION("VIDC20 audio driver");

MODULE_LICENSE("GPL");