Remove all inclusions of <linux/config.h>
[linux-3.10.git] / 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