drivers/sound/gus_card.c

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