sound/oss/gus_card.c

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