sound/oss/gus_card.c

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