LXR linux-old/drivers/sound/gus

   1/*
   2 * sound/gus_card.c
   3 *
   4 * Detection routine for the Gravis Ultrasound.
   5 *
   6 * Copyright (C) by Hannu Savolainen 1993-1997
   7 *
   8 *
   9 * Frank van de Pol : Fixed GUS MAX interrupt handling, enabled simultanious
  10 *                    usage of CS4231A codec, GUS wave and MIDI for GUS MAX.
  11 * Christoph Hellwig: Adapted to module_init/module_exit, simple cleanups.
  12 *
  13 * Status:
  14 *              Tested... 
  15 */
  16      
  17 
  18#include <linux/config.h>
  19#include <linux/init.h>
  20#include <linux/module.h>
  21
  22#include "sound_config.h"
  23
  24#include "gus.h"
  25#include "gus_hw.h"
  26
  27void            gusintr(int irq, void *dev_id, struct pt_regs *dummy);
  28
  29int             gus_base = 0, gus_irq = 0, gus_dma = 0;
  30int             gus_no_wave_dma = 0; 
  31extern int      gus_wave_volume;
  32extern int      gus_pcm_volume;
  33extern int      have_gus_max;
  34int             gus_pnp_flag = 0;
  35#ifdef CONFIG_SOUND_GUS16
  36static int      db16 = 0;       /* Has a Gus16 AD1848 on it */
  37#endif
  38
  39static void __init attach_gus(struct address_info *hw_config)
  40{
  41        gus_wave_init(hw_config);
  42
  43        request_region(hw_config->io_base, 16, "GUS");
  44        request_region(hw_config->io_base + 0x100, 12, "GUS");  /* 0x10c-> is MAX */
  45
  46        if (sound_alloc_dma(hw_config->dma, "GUS"))
  47                printk(KERN_ERR "gus_card.c: Can't allocate DMA channel %d\n", hw_config->dma);
  48        if (hw_config->dma2 != -1 && hw_config->dma2 != hw_config->dma)
  49                if (sound_alloc_dma(hw_config->dma2, "GUS(2)"))
  50                        printk(KERN_ERR "gus_card.c: Can't allocate DMA channel %d\n", hw_config->dma2);
  51        gus_midi_init(hw_config);
  52        if(request_irq(hw_config->irq, gusintr, 0,  "Gravis Ultrasound", hw_config)<0)
  53                printk(KERN_ERR "gus_card.c: Unable to allocate IRQ %d\n", hw_config->irq);
  54
  55        return;
  56}
  57
  58static int __init probe_gus(struct address_info *hw_config)
  59{
  60        int             irq;
  61        int             io_addr;
  62
  63        if (hw_config->card_subtype == 1)
  64                gus_pnp_flag = 1;
  65
  66        irq = hw_config->irq;
  67
  68        if (hw_config->card_subtype == 0)       /* GUS/MAX/ACE */
  69                if (irq != 3 && irq != 5 && irq != 7 && irq != 9 &&
  70                    irq != 11 && irq != 12 && irq != 15)
  71                  {
  72                          printk(KERN_ERR "GUS: Unsupported IRQ %d\n", irq);
  73                          return 0;
  74                  }
  75        if (check_region(hw_config->io_base, 16))
  76                printk(KERN_ERR "GUS: I/O range conflict (1)\n");
  77        else if (check_region(hw_config->io_base + 0x100, 16))
  78                printk(KERN_ERR "GUS: I/O range conflict (2)\n");
  79        else if (gus_wave_detect(hw_config->io_base))
  80                return 1;
  81
  82#ifndef EXCLUDE_GUS_IODETECT
  83
  84        /*
  85         * Look at the possible base addresses (0x2X0, X=1, 2, 3, 4, 5, 6)
  86         */
  87
  88        for (io_addr = 0x210; io_addr <= 0x260; io_addr += 0x10)
  89                if (io_addr != hw_config->io_base)      /*
  90                                                         * Already tested
  91                                                         */
  92                        if (!check_region(io_addr, 16))
  93                                if (!check_region(io_addr + 0x100, 16))
  94                                        if (gus_wave_detect(io_addr))
  95                                          {
  96                                                  hw_config->io_base = io_addr;
  97                                                  return 1;
  98                                          }
  99#endif
 100
 101        printk("NO GUS card found !\n");
 102        return 0;
 103}
 104
 105static void __exit unload_gus(struct address_info *hw_config)
 106{
 107        DDB(printk("unload_gus(%x)\n", hw_config->io_base));
 108
 109        gus_wave_unload(hw_config);
 110
 111        release_region(hw_config->io_base, 16);
 112        release_region(hw_config->io_base + 0x100, 12);         /* 0x10c-> is MAX */
 113        free_irq(hw_config->irq, hw_config);
 114
 115        sound_free_dma(hw_config->dma);
 116
 117        if (hw_config->dma2 != -1 && hw_config->dma2 != hw_config->dma)
 118                sound_free_dma(hw_config->dma2);
 119}
 120
 121void gusintr(int irq, void *dev_id, struct pt_regs *dummy)
 122{
 123        unsigned char src;
 124        extern int gus_timer_enabled;
 125
 126        sti();
 127
 128#ifdef CONFIG_SOUND_GUSMAX
 129        if (have_gus_max) {
 130                struct address_info *hw_config = dev_id;
 131                adintr(irq, (void *)hw_config->slots[1], NULL);
 132        }
 133#endif
 134#ifdef CONFIG_SOUND_GUS16
 135        if (db16) {
 136                struct address_info *hw_config = dev_id;
 137                adintr(irq, (void *)hw_config->slots[3], NULL);
 138        }
 139#endif
 140
 141        while (1)
 142        {
 143                if (!(src = inb(u_IrqStatus)))
 144                        return;
 145
 146                if (src & DMA_TC_IRQ)
 147                {
 148                        guswave_dma_irq();
 149                }
 150                if (src & (MIDI_TX_IRQ | MIDI_RX_IRQ))
 151                {
 152                        gus_midi_interrupt(0);
 153                }
 154                if (src & (GF1_TIMER1_IRQ | GF1_TIMER2_IRQ))
 155                {
 156                        if (gus_timer_enabled)
 157                                sound_timer_interrupt();
 158                        gus_write8(0x45, 0);    /* Ack IRQ */
 159                        gus_timer_command(4, 0x80);             /* Reset IRQ flags */
 160                }
 161                if (src & (WAVETABLE_IRQ | ENVELOPE_IRQ))
 162                        gus_voice_irq();
 163        }
 164}
 165
 166/*
 167 *      Some extra code for the 16 bit sampling option
 168 */
 169
 170#ifdef CONFIG_SOUND_GUS16
 171
 172static int __init probe_gus_db16(struct address_info *hw_config)
 173{
 174        return ad1848_detect(hw_config->io_base, NULL, hw_config->osp);
 175}
 176
 177static void __init attach_gus_db16(struct address_info *hw_config)
 178{
 179        gus_pcm_volume = 100;
 180        gus_wave_volume = 90;
 181
 182        hw_config->slots[3] = ad1848_init("GUS 16 bit sampling", hw_config->io_base,
 183                                          hw_config->irq,
 184                                          hw_config->dma,
 185                                          hw_config->dma, 0,
 186                                          hw_config->osp,
 187                                          THIS_MODULE);
 188}
 189
 190static void __exit unload_gus_db16(struct address_info *hw_config)
 191{
 192
 193        ad1848_unload(hw_config->io_base,
 194                      hw_config->irq,
 195                      hw_config->dma,
 196                      hw_config->dma, 0);
 197        sound_unload_audiodev(hw_config->slots[3]);
 198}
 199#endif
 200
 201#ifdef CONFIG_SOUND_GUS16
 202static int gus16 = 0;
 203#endif
 204#ifdef CONFIG_SOUND_GUSMAX
 205static int no_wave_dma = 0;/* Set if no dma is to be used for the
 206                                   wave table (GF1 chip) */
 207#endif
 208
 209
 210/*
 211 *    Note DMA2 of -1 has the right meaning in the GUS driver as well
 212 *      as here. 
 213 */
 214
 215static struct address_info cfg;
 216
 217static int __initdata io = -1;
 218static int __initdata irq = -1;
 219static int __initdata dma = -1;
 220static int __initdata dma16 = -1;       /* Set this for modules that need it */
 221static int __initdata type = 0;         /* 1 for PnP */
 222
 223MODULE_PARM(io, "i");
 224MODULE_PARM(irq, "i");
 225MODULE_PARM(dma, "i");
 226MODULE_PARM(dma16, "i");
 227MODULE_PARM(type, "i");
 228#ifdef CONFIG_SOUND_GUSMAX
 229MODULE_PARM(no_wave_dma, "i");
 230#endif
 231#ifdef CONFIG_SOUND_GUS16
 232MODULE_PARM(db16, "i");
 233MODULE_PARM(gus16, "i");
 234#endif
 235MODULE_LICENSE("GPL");
 236
 237static int __init init_gus(void)
 238{
 239        printk(KERN_INFO "Gravis Ultrasound audio driver Copyright (C) by Hannu Savolainen 1993-1996\n");
 240
 241        cfg.io_base = io;
 242        cfg.irq = irq;
 243        cfg.dma = dma;
 244        cfg.dma2 = dma16;
 245        cfg.card_subtype = type;
 246#ifdef CONFIG_SOUND_GUSMAX
 247        gus_no_wave_dma = no_wave_dma;
 248#endif
 249
 250        if (cfg.io_base == -1 || cfg.dma == -1 || cfg.irq == -1) {
 251                printk(KERN_ERR "I/O, IRQ, and DMA are mandatory\n");
 252                return -EINVAL;
 253        }
 254
 255#ifdef CONFIG_SOUND_GUS16
 256        if (probe_gus_db16(&cfg) && gus16) {
 257                /* FIXME: This can't work, can it ? -- Christoph */
 258                attach_gus_db16(&cfg);
 259                db16 = 1;
 260        }       
 261#endif
 262        if (!probe_gus(&cfg))
 263                return -ENODEV;
 264        attach_gus(&cfg);
 265
 266        return 0;
 267}
 268
 269static void __exit cleanup_gus(void)
 270{
 271#ifdef CONFIG_SOUND_GUS16
 272        if (db16)
 273                unload_gus_db16(&cfg);
 274#endif
 275        unload_gus(&cfg);
 276}
 277
 278module_init(init_gus);
 279module_exit(cleanup_gus);
 280
 281#ifndef MODULE
 282static int __init setup_gus(char *str)
 283{
 284        /* io, irq, dma, dma2 */
 285        int ints[5];
 286        
 287        str = get_options(str, ARRAY_SIZE(ints), ints);
 288        
 289        io      = ints[1];
 290        irq     = ints[2];
 291        dma     = ints[3];
 292        dma16   = ints[4];
 293
 294        return 1;
 295}
 296
 297__setup("gus=", setup_gus);
 298#endif
 299