[deliverable/linux.git] / sound / oss / gus_card.c

/*
 * sound/gus_card.c
 *
 * Detection routine for the Gravis Ultrasound.
 *
 * Copyright (C) by Hannu Savolainen 1993-1997
 *
 *
 * Frank van de Pol : Fixed GUS MAX interrupt handling, enabled simultanious
 *                    usage of CS4231A codec, GUS wave and MIDI for GUS MAX.
 * Christoph Hellwig: Adapted to module_init/module_exit, simple cleanups.
 *
 * Status:
 *              Tested... 
 */
      
 
#include <linux/config.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>

#include "sound_config.h"

#include "gus.h"
#include "gus_hw.h"

irqreturn_t gusintr(int irq, void *dev_id, struct pt_regs *dummy);

int             gus_base = 0, gus_irq = 0, gus_dma = 0;
int             gus_no_wave_dma = 0; 
extern int      gus_wave_volume;
extern int      gus_pcm_volume;
extern int      have_gus_max;
int             gus_pnp_flag = 0;
#ifdef CONFIG_SOUND_GUS16
static int      db16;	/* Has a Gus16 AD1848 on it */
#endif

static void __init attach_gus(struct address_info *hw_config)
{
	gus_wave_init(hw_config);

	if (sound_alloc_dma(hw_config->dma, "GUS"))
		printk(KERN_ERR "gus_card.c: Can't allocate DMA channel %d\n", hw_config->dma);
	if (hw_config->dma2 != -1 && hw_config->dma2 != hw_config->dma)
		if (sound_alloc_dma(hw_config->dma2, "GUS(2)"))
			printk(KERN_ERR "gus_card.c: Can't allocate DMA channel %d\n", hw_config->dma2);
	gus_midi_init(hw_config);
	if(request_irq(hw_config->irq, gusintr, 0,  "Gravis Ultrasound", hw_config)<0)
		printk(KERN_ERR "gus_card.c: Unable to allocate IRQ %d\n", hw_config->irq);

	return;
}

static int __init probe_gus(struct address_info *hw_config)
{
	int             irq;
	int             io_addr;

	if (hw_config->card_subtype == 1)
		gus_pnp_flag = 1;

	irq = hw_config->irq;

	if (hw_config->card_subtype == 0)	/* GUS/MAX/ACE */
		if (irq != 3 && irq != 5 && irq != 7 && irq != 9 &&
		    irq != 11 && irq != 12 && irq != 15)
		  {
			  printk(KERN_ERR "GUS: Unsupported IRQ %d\n", irq);
			  return 0;
		  }
	if (gus_wave_detect(hw_config->io_base))
		return 1;

#ifndef EXCLUDE_GUS_IODETECT

	/*
	 * Look at the possible base addresses (0x2X0, X=1, 2, 3, 4, 5, 6)
	 */

	for (io_addr = 0x210; io_addr <= 0x260; io_addr += 0x10) {
		if (io_addr == hw_config->io_base)	/* Already tested */
			continue;
		if (gus_wave_detect(io_addr)) {
			hw_config->io_base = io_addr;
			return 1;
		}
	}
#endif

	printk("NO GUS card found !\n");
	return 0;
}

static void __exit unload_gus(struct address_info *hw_config)
{
	DDB(printk("unload_gus(%x)\n", hw_config->io_base));

	gus_wave_unload(hw_config);

	release_region(hw_config->io_base, 16);
	release_region(hw_config->io_base + 0x100, 12);		/* 0x10c-> is MAX */
	free_irq(hw_config->irq, hw_config);

	sound_free_dma(hw_config->dma);

	if (hw_config->dma2 != -1 && hw_config->dma2 != hw_config->dma)
		sound_free_dma(hw_config->dma2);
}

irqreturn_t gusintr(int irq, void *dev_id, struct pt_regs *dummy)
{
	unsigned char src;
	extern int gus_timer_enabled;
	int handled = 0;

#ifdef CONFIG_SOUND_GUSMAX
	if (have_gus_max) {
		struct address_info *hw_config = dev_id;
		adintr(irq, (void *)hw_config->slots[1], NULL);
	}
#endif
#ifdef CONFIG_SOUND_GUS16
	if (db16) {
		struct address_info *hw_config = dev_id;
		adintr(irq, (void *)hw_config->slots[3], NULL);
	}
#endif

	while (1)
	{
		if (!(src = inb(u_IrqStatus)))
			break;
		handled = 1;
		if (src & DMA_TC_IRQ)
		{
			guswave_dma_irq();
		}
		if (src & (MIDI_TX_IRQ | MIDI_RX_IRQ))
		{
			gus_midi_interrupt(0);
		}
		if (src & (GF1_TIMER1_IRQ | GF1_TIMER2_IRQ))
		{
			if (gus_timer_enabled)
				sound_timer_interrupt();
			gus_write8(0x45, 0);	/* Ack IRQ */
			gus_timer_command(4, 0x80);		/* Reset IRQ flags */
		}
		if (src & (WAVETABLE_IRQ | ENVELOPE_IRQ))
			gus_voice_irq();
	}
	return IRQ_RETVAL(handled);
}

/*
 *	Some extra code for the 16 bit sampling option
 */

#ifdef CONFIG_SOUND_GUS16

static int __init init_gus_db16(struct address_info *hw_config)
{
	struct resource *ports;

	ports = request_region(hw_config->io_base, 4, "ad1848");
	if (!ports)
		return 0;

	if (!ad1848_detect(ports, NULL, hw_config->osp)) {
		release_region(hw_config->io_base, 4);
		return 0;
	}

	gus_pcm_volume = 100;
	gus_wave_volume = 90;

	hw_config->slots[3] = ad1848_init("GUS 16 bit sampling", ports,
					  hw_config->irq,
					  hw_config->dma,
					  hw_config->dma, 0,
					  hw_config->osp,
					  THIS_MODULE);
	return 1;
}

static void __exit unload_gus_db16(struct address_info *hw_config)
{

	ad1848_unload(hw_config->io_base,
		      hw_config->irq,
		      hw_config->dma,
		      hw_config->dma, 0);
	sound_unload_audiodev(hw_config->slots[3]);
}
#endif

#ifdef CONFIG_SOUND_GUS16
static int gus16;
#endif
#ifdef CONFIG_SOUND_GUSMAX
static int no_wave_dma;   /* Set if no dma is to be used for the
                                   wave table (GF1 chip) */
#endif


/*
 *    Note DMA2 of -1 has the right meaning in the GUS driver as well
 *      as here. 
 */

static struct address_info cfg;

static int __initdata io = -1;
static int __initdata irq = -1;
static int __initdata dma = -1;
static int __initdata dma16 = -1;	/* Set this for modules that need it */
static int __initdata type = 0;		/* 1 for PnP */

module_param(io, int, 0);
module_param(irq, int, 0);
module_param(dma, int, 0);
module_param(dma16, int, 0);
module_param(type, int, 0);
#ifdef CONFIG_SOUND_GUSMAX
module_param(no_wave_dma, int, 0);
#endif
#ifdef CONFIG_SOUND_GUS16
module_param(db16, int, 0);
module_param(gus16, int, 0);
#endif
MODULE_LICENSE("GPL");

static int __init init_gus(void)
{
	printk(KERN_INFO "Gravis Ultrasound audio driver Copyright (C) by Hannu Savolainen 1993-1996\n");

	cfg.io_base = io;
	cfg.irq = irq;
	cfg.dma = dma;
	cfg.dma2 = dma16;
	cfg.card_subtype = type;
#ifdef CONFIG_SOUND_GUSMAX
	gus_no_wave_dma = no_wave_dma;
#endif

	if (cfg.io_base == -1 || cfg.dma == -1 || cfg.irq == -1) {
		printk(KERN_ERR "I/O, IRQ, and DMA are mandatory\n");
		return -EINVAL;
	}

#ifdef CONFIG_SOUND_GUS16
	if (gus16 && init_gus_db16(&cfg))
		db16 = 1;
#endif
	if (!probe_gus(&cfg))
		return -ENODEV;
	attach_gus(&cfg);

	return 0;
}

static void __exit cleanup_gus(void)
{
#ifdef CONFIG_SOUND_GUS16
	if (db16)
		unload_gus_db16(&cfg);
#endif
	unload_gus(&cfg);
}

module_init(init_gus);
module_exit(cleanup_gus);

#ifndef MODULE
static int __init setup_gus(char *str)
{
	/* io, irq, dma, dma2 */
	int ints[5];
	
	str = get_options(str, ARRAY_SIZE(ints), ints);
	
	io	= ints[1];
	irq	= ints[2];
	dma	= ints[3];
	dma16	= ints[4];

	return 1;
}

__setup("gus=", setup_gus);
#endif
Commit	Line	Data
1da177e4 LT	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 init_gus_db16(struct address_info *hw_config)
164	{
165	struct resource *ports;
166
167	ports = request_region(hw_config->io_base, 4, "ad1848");
168	if (!ports)
169	return 0;
170
171	if (!ad1848_detect(ports, NULL, hw_config->osp)) {
172	release_region(hw_config->io_base, 4);
173	return 0;
174	}
175
176	gus_pcm_volume = 100;
177	gus_wave_volume = 90;
178
179	hw_config->slots[3] = ad1848_init("GUS 16 bit sampling", ports,
180	hw_config->irq,
181	hw_config->dma,
182	hw_config->dma, 0,
183	hw_config->osp,
184	THIS_MODULE);
185	return 1;
186	}
187
188	static void __exit unload_gus_db16(struct address_info *hw_config)
189	{
190
191	ad1848_unload(hw_config->io_base,
192	hw_config->irq,
193	hw_config->dma,
194	hw_config->dma, 0);
195	sound_unload_audiodev(hw_config->slots[3]);
196	}
197	#endif
198
199	#ifdef CONFIG_SOUND_GUS16
200	static int gus16;
201	#endif
202	#ifdef CONFIG_SOUND_GUSMAX
203	static int no_wave_dma; /* 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_param(io, int, 0);
222	module_param(irq, int, 0);
223	module_param(dma, int, 0);
224	module_param(dma16, int, 0);
225	module_param(type, int, 0);
226	#ifdef CONFIG_SOUND_GUSMAX
227	module_param(no_wave_dma, int, 0);
228	#endif
229	#ifdef CONFIG_SOUND_GUS16
230	module_param(db16, int, 0);
231	module_param(gus16, int, 0);
232	#endif
233	MODULE_LICENSE("GPL");
234
235	static int __init init_gus(void)
236	{
237	printk(KERN_INFO "Gravis Ultrasound audio driver Copyright (C) by Hannu Savolainen 1993-1996\n");
238
239	cfg.io_base = io;
240	cfg.irq = irq;
241	cfg.dma = dma;
242	cfg.dma2 = dma16;
243	cfg.card_subtype = type;
244	#ifdef CONFIG_SOUND_GUSMAX
245	gus_no_wave_dma = no_wave_dma;
246	#endif
247
248	if (cfg.io_base == -1 \|\| cfg.dma == -1 \|\| cfg.irq == -1) {
249	printk(KERN_ERR "I/O, IRQ, and DMA are mandatory\n");
250	return -EINVAL;
251	}
252
253	#ifdef CONFIG_SOUND_GUS16
254	if (gus16 && init_gus_db16(&cfg))
255	db16 = 1;
256	#endif
257	if (!probe_gus(&cfg))
258	return -ENODEV;
259	attach_gus(&cfg);
260
261	return 0;
262	}
263
264	static void __exit cleanup_gus(void)
265	{
266	#ifdef CONFIG_SOUND_GUS16
267	if (db16)
268	unload_gus_db16(&cfg);
269	#endif
270	unload_gus(&cfg);
271	}
272
273	module_init(init_gus);
274	module_exit(cleanup_gus);
275
276	#ifndef MODULE
277	static int __init setup_gus(char *str)
278	{
279	/* io, irq, dma, dma2 */
280	int ints[5];
281
282	str = get_options(str, ARRAY_SIZE(ints), ints);
283
284	io = ints[1];
285	irq = ints[2];
286	dma = ints[3];
287	dma16 = ints[4];
288
289	return 1;
290	}
291
292	__setup("gus=", setup_gus);
293	#endif