Subversion Repositories or1k

/*

 * sound/trix.c

 *

 * Low level driver for the MediaTrix AudioTrix Pro

 * (MT-0002-PC Control Chip)

 *

 *

 * Copyright (C) by Hannu Savolainen 1993-1997

 *

 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)

 * Version 2 (June 1991). See the "COPYING" file distributed with this software

 * for more info.

 *

 * Changes

 *      Alan Cox                Modularisation, cleanup.

 *      Christoph Hellwig       Adapted to module_init/module_exit

 *      Arnaldo C. de Melo      Got rid of attach_uart401

 */

#include <linux/init.h>

#include <linux/module.h>

#include "sound_config.h"

#include "sb.h"

#include "sound_firmware.h"

#include "ad1848.h"

#include "mpu401.h"

#include "trix_boot.h"

static int kilroy_was_here = 0;  /* Don't detect twice */

static int sb_initialized = 0;

static int mpu_initialized = 0;

static int *trix_osp = NULL;

static int mpu = 0;

static int joystick=0;

static unsigned char trix_read(int addr)

{

        outb(((unsigned char) addr), 0x390);    /* MT-0002-PC ASIC address */

        return inb(0x391);      /* MT-0002-PC ASIC data */

}

static void trix_write(int addr, int data)

{

        outb(((unsigned char) addr), 0x390);    /* MT-0002-PC ASIC address */

        outb(((unsigned char) data), 0x391);    /* MT-0002-PC ASIC data */

}

static void download_boot(int base)

{

        int i = 0, n = trix_boot_len;

        if (trix_boot_len == 0)

                return;

        trix_write(0xf8, 0x00); /* ??????? */

        outb((0x01), base + 6); /* Clear the internal data pointer */

        outb((0x00), base + 6); /* Restart */

        /*

           *  Write the boot code to the RAM upload/download register.

           *  Each write increments the internal data pointer.

         */

        outb((0x01), base + 6); /* Clear the internal data pointer */

        outb((0x1A), 0x390);    /* Select RAM download/upload port */

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

                outb((trix_boot[i]), 0x391);

        for (i = n; i < 10016; i++)     /* Clear up to first 16 bytes of data RAM */

                outb((0x00), 0x391);

        outb((0x00), base + 6); /* Reset */

        outb((0x50), 0x390);    /* ?????? */

}

static int trix_set_wss_port(struct address_info *hw_config)

{

        unsigned char   addr_bits;

        if (check_region(0x390, 2))

        {

                printk(KERN_ERR "AudioTrix: Config port I/O conflict\n");

                return 0;

        }

        if (kilroy_was_here)    /* Already initialized */

                return 0;

        if (trix_read(0x15) != 0x71)    /* No ASIC signature */

        {

                MDB(printk(KERN_ERR "No AudioTrix ASIC signature found\n"));

                return 0;

        }

        kilroy_was_here = 1;

        /*

         * Reset some registers.

         */

        trix_write(0x13, 0);

        trix_write(0x14, 0);

        /*

         * Configure the ASIC to place the codec to the proper I/O location

         */

        switch (hw_config->io_base)

        {

                case 0x530:

                        addr_bits = 0;

                        break;

                case 0x604:

                        addr_bits = 1;

                        break;

                case 0xE80:

                        addr_bits = 2;

                        break;

                case 0xF40:

                        addr_bits = 3;

                        break;

                default:

                        return 0;

        }

        trix_write(0x19, (trix_read(0x19) & 0x03) | addr_bits);

        return 1;

}

/*

 *    Probe and attach routines for the Windows Sound System mode of

 *      AudioTrix Pro

 */

static int __init probe_trix_wss(struct address_info *hw_config)

{

        int ret;

        /*

         * Check if the IO port returns valid signature. The original MS Sound

         * system returns 0x04 while some cards (AudioTrix Pro for example)

         * return 0x00.

         */

        if (check_region(hw_config->io_base, 8))

        {

                printk(KERN_ERR "AudioTrix: MSS I/O port conflict (%x)\n", hw_config->io_base);

                return 0;

        }

        trix_osp = hw_config->osp;

        if (!trix_set_wss_port(hw_config))

                return 0;

        if ((inb(hw_config->io_base + 3) & 0x3f) != 0x00)

        {

                MDB(printk(KERN_ERR "No MSS signature detected on port 0x%x\n", hw_config->io_base));

                return 0;

        }

        if (hw_config->irq > 11)

        {

                printk(KERN_ERR "AudioTrix: Bad WSS IRQ %d\n", hw_config->irq);

                return 0;

        }

        if (hw_config->dma != 0 && hw_config->dma != 1 && hw_config->dma != 3)

        {

                printk(KERN_ERR "AudioTrix: Bad WSS DMA %d\n", hw_config->dma);

                return 0;

        }

        if (hw_config->dma2 != -1 && hw_config->dma2 != hw_config->dma)

                if (hw_config->dma2 != 0 && hw_config->dma2 != 1 && hw_config->dma2 != 3)

                {

                          printk(KERN_ERR "AudioTrix: Bad capture DMA %d\n", hw_config->dma2);

                          return 0;

                }

        /*

         * Check that DMA0 is not in use with a 8 bit board.

         */

        if (hw_config->dma == 0 && inb(hw_config->io_base + 3) & 0x80)

        {

                printk(KERN_ERR "AudioTrix: Can't use DMA0 with a 8 bit card slot\n");

                return 0;

        }

        if (hw_config->irq > 7 && hw_config->irq != 9 && inb(hw_config->io_base + 3) & 0x80)

        {

                printk(KERN_ERR "AudioTrix: Can't use IRQ%d with a 8 bit card slot\n", hw_config->irq);

                return 0;

        }

        ret = ad1848_detect(hw_config->io_base + 4, NULL, hw_config->osp);

        if (ret)

        {

                if(joystick==1)

                        trix_write(0x15, 0x80);

                request_region(0x390, 2, "AudioTrix");

        }

        return ret;

}

static void __init attach_trix_wss(struct address_info *hw_config)

{

        static unsigned char interrupt_bits[12] = {

                0, 0, 0, 0, 0, 0, 0, 0x08, 0, 0x10, 0x18, 0x20

        };

        char bits;

        static unsigned char dma_bits[4] = {

                1, 2, 0, 3

        };

        int config_port = hw_config->io_base + 0;

        int dma1 = hw_config->dma, dma2 = hw_config->dma2;

        int old_num_mixers = num_mixers;

        trix_osp = hw_config->osp;

        if (!kilroy_was_here)

        {

                DDB(printk("AudioTrix: Attach called but not probed yet???\n"));

                return;

        }

        /*

         * Set the IRQ and DMA addresses.

         */

        bits = interrupt_bits[hw_config->irq];

        if (bits == 0)

        {

                printk("AudioTrix: Bad IRQ (%d)\n", hw_config->irq);

                return;

        }

        outb((bits | 0x40), config_port);

        if (hw_config->dma2 == -1 || hw_config->dma2 == hw_config->dma)

        {

                  bits |= dma_bits[dma1];

                  dma2 = dma1;

        }

        else

        {

                unsigned char tmp;

                tmp = trix_read(0x13) & ~30;

                trix_write(0x13, tmp | 0x80 | (dma1 << 4));

                tmp = trix_read(0x14) & ~30;

                trix_write(0x14, tmp | 0x80 | (dma2 << 4));

        }

        outb((bits), config_port);      /* Write IRQ+DMA setup */

        hw_config->slots[0] = ad1848_init("AudioTrix Pro", hw_config->io_base + 4,

                                          hw_config->irq,

                                          dma1,

                                          dma2,

                                          0,

                                          hw_config->osp,

                                          THIS_MODULE);

        request_region(hw_config->io_base, 4, "MSS config");

        if (num_mixers > old_num_mixers)        /* Mixer got installed */

        {

                AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_LINE);    /* Line in */

                AD1848_REROUTE(SOUND_MIXER_LINE2, SOUND_MIXER_CD);

                AD1848_REROUTE(SOUND_MIXER_LINE3, SOUND_MIXER_SYNTH);           /* OPL4 */

                AD1848_REROUTE(SOUND_MIXER_SPEAKER, SOUND_MIXER_ALTPCM);        /* SB */

        }

}

static int __init probe_trix_sb(struct address_info *hw_config)

{

        int tmp;

        unsigned char conf;

        static signed char irq_translate[] = {

                -1, -1, -1, 0, 1, 2, -1, 3

        };

        if (trix_boot_len == 0)

                return 0;        /* No boot code -> no fun */

        if (!kilroy_was_here)

                return 0;        /* AudioTrix Pro has not been detected earlier */

        if (sb_initialized)

                return 0;

        if (check_region(hw_config->io_base, 16))

        {

                printk(KERN_ERR "AudioTrix: SB I/O port conflict (%x)\n", hw_config->io_base);

                return 0;

        }

        if ((hw_config->io_base & 0xffffff8f) != 0x200)

                return 0;

        tmp = hw_config->irq;

        if (tmp > 7)

                return 0;

        if (irq_translate[tmp] == -1)

                return 0;

        tmp = hw_config->dma;

        if (tmp != 1 && tmp != 3)

                return 0;

        conf = 0x84;            /* DMA and IRQ enable */

        conf |= hw_config->io_base & 0x70;      /* I/O address bits */

        conf |= irq_translate[hw_config->irq];

        if (hw_config->dma == 3)

                conf |= 0x08;

        trix_write(0x1b, conf);

        download_boot(hw_config->io_base);

        sb_initialized = 1;

        hw_config->name = "AudioTrix SB";

        return sb_dsp_detect(hw_config, 0, 0, NULL);

}

static void __init attach_trix_sb(struct address_info *hw_config)

{

        extern int sb_be_quiet;

        int old_quiet;

        hw_config->driver_use_1 = SB_NO_MIDI | SB_NO_MIXER | SB_NO_RECORDING;

        /* Prevent false alarms */

        old_quiet = sb_be_quiet;

        sb_be_quiet = 1;

        sb_dsp_init(hw_config, THIS_MODULE);

        sb_be_quiet = old_quiet;

}

static int __init probe_trix_mpu(struct address_info *hw_config)

{

        unsigned char conf;

        static int irq_bits[] = {

                -1, -1, -1, 1, 2, 3, -1, 4, -1, 5

        };

        if (!kilroy_was_here)

        {

                DDB(printk("Trix: WSS and SB modes must be initialized before MPU\n"));

                return 0;        /* AudioTrix Pro has not been detected earlier */

        }

        if (!sb_initialized)

        {

                DDB(printk("Trix: SB mode must be initialized before MPU\n"));

                return 0;

        }

        if (mpu_initialized)

        {

                DDB(printk("Trix: MPU mode already initialized\n"));

                return 0;

        }

        if (hw_config->irq > 9)

        {

                printk(KERN_ERR "AudioTrix: Bad MPU IRQ %d\n", hw_config->irq);

                return 0;

        }

        if (irq_bits[hw_config->irq] == -1)

        {

                printk(KERN_ERR "AudioTrix: Bad MPU IRQ %d\n", hw_config->irq);

                return 0;

        }

        switch (hw_config->io_base)

        {

                case 0x330:

                        conf = 0x00;

                        break;

                case 0x370:

                        conf = 0x04;

                        break;

                case 0x3b0:

                        conf = 0x08;

                        break;

                case 0x3f0:

                        conf = 0x0c;

                        break;

                default:

                        return 0;        /* Invalid port */

        }

        conf |= irq_bits[hw_config->irq] << 4;

        trix_write(0x19, (trix_read(0x19) & 0x83) | conf);

        mpu_initialized = 1;

        hw_config->name = "AudioTrix Pro";

        return probe_uart401(hw_config, THIS_MODULE);

}

static void __exit unload_trix_wss(struct address_info *hw_config)

{

        int dma2 = hw_config->dma2;

        if (dma2 == -1)

                dma2 = hw_config->dma;

        release_region(0x390, 2);

        release_region(hw_config->io_base, 4);

        ad1848_unload(hw_config->io_base + 4,

                      hw_config->irq,

                      hw_config->dma,

                      dma2,

                      0);

        sound_unload_audiodev(hw_config->slots[0]);

}

static inline void __exit unload_trix_mpu(struct address_info *hw_config)

{

        unload_uart401(hw_config);

}

static inline void __exit unload_trix_sb(struct address_info *hw_config)

{

        sb_dsp_unload(hw_config, mpu);

}

static struct address_info cfg;

static struct address_info cfg2;

static struct address_info cfg_mpu;

static int sb = 0;

static int fw_load;

static int __initdata io        = -1;

static int __initdata irq       = -1;

static int __initdata dma       = -1;

static int __initdata dma2      = -1;   /* Set this for modules that need it */

static int __initdata sb_io     = -1;

static int __initdata sb_dma    = -1;

static int __initdata sb_irq    = -1;

static int __initdata mpu_io    = -1;

static int __initdata mpu_irq   = -1;

MODULE_PARM(io,"i");

MODULE_PARM(irq,"i");

MODULE_PARM(dma,"i");

MODULE_PARM(dma2,"i");

MODULE_PARM(sb_io,"i");

MODULE_PARM(sb_dma,"i");

MODULE_PARM(sb_irq,"i");

MODULE_PARM(mpu_io,"i");

MODULE_PARM(mpu_irq,"i");

MODULE_PARM(joystick, "i");

static int __init init_trix(void)

{

        printk(KERN_INFO "MediaTrix audio driver Copyright (C) by Hannu Savolainen 1993-1996\n");

        cfg.io_base = io;

        cfg.irq = irq;

        cfg.dma = dma;

        cfg.dma2 = dma2;

        cfg2.io_base = sb_io;

        cfg2.irq = sb_irq;

        cfg2.dma = sb_dma;

        cfg_mpu.io_base = mpu_io;

        cfg_mpu.irq = mpu_irq;

        if (cfg.io_base == -1 || cfg.dma == -1 || cfg.irq == -1) {

                printk(KERN_INFO "I/O, IRQ, DMA and type are mandatory\n");

                return -EINVAL;

        }

        if (cfg2.io_base != -1 && (cfg2.irq == -1 || cfg2.dma == -1)) {

                printk(KERN_INFO "CONFIG_SB_IRQ and CONFIG_SB_DMA must be specified if SB_IO is set.\n");

                return -EINVAL;

        }

        if (cfg_mpu.io_base != -1 && cfg_mpu.irq == -1) {

                printk(KERN_INFO "CONFIG_MPU_IRQ must be specified if MPU_IO is set.\n");

                return -EINVAL;

        }

        if (!trix_boot)

        {

                fw_load = 1;

                trix_boot_len = mod_firmware_load("/etc/sound/trxpro.bin",

                                                    (char **) &trix_boot);

        }

        if (!probe_trix_wss(&cfg))

                return -ENODEV;

        attach_trix_wss(&cfg);

        /*

         *    We must attach in the right order to get the firmware

         *      loaded up in time.

         */

        if (cfg2.io_base != -1) {

                sb = probe_trix_sb(&cfg2);

                if (sb)

                        attach_trix_sb(&cfg2);

        }

        if (cfg_mpu.io_base != -1)

                mpu = probe_trix_mpu(&cfg_mpu);

        return 0;

}

static void __exit cleanup_trix(void)

{

        if (fw_load && trix_boot)

                vfree(trix_boot);

        if (sb)

                unload_trix_sb(&cfg2);

        if (mpu)

                unload_trix_mpu(&cfg_mpu);

        unload_trix_wss(&cfg);

}

module_init(init_trix);

module_exit(cleanup_trix);

#ifndef MODULE

static int __init setup_trix (char *str)

{

        /* io, irq, dma, dma2, sb_io, sb_irq, sb_dma, mpu_io, mpu_irq */

        int ints[9];

        str = get_options(str, ARRAY_SIZE(ints), ints);

        io      = ints[1];

        irq     = ints[2];

        dma     = ints[3];

        dma2    = ints[4];

        sb_io   = ints[5];

        sb_irq  = ints[6];

        sb_dma  = ints[6];

        mpu_io  = ints[7];

        mpu_irq = ints[8];

        return 1;

}

__setup("trix=", setup_trix);

#endif

MODULE_LICENSE("GPL");