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