[net-next-2.6.git] / sound / oss / pas2_card.c

/*
 * sound/oss/pas2_card.c
 *
 * Detection routine for the Pro Audio Spectrum cards.
 */

#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include "sound_config.h"

#include "pas2.h"
#include "sb.h"

static unsigned char dma_bits[] = {
	4, 1, 2, 3, 0, 5, 6, 7
};

static unsigned char irq_bits[] = {
	0, 0, 1, 2, 3, 4, 5, 6, 0, 1, 7, 8, 9, 0, 10, 11
};

static unsigned char sb_irq_bits[] = {
	0x00, 0x00, 0x08, 0x10, 0x00, 0x18, 0x00, 0x20, 
	0x00, 0x08, 0x28, 0x30, 0x38, 0, 0
};

static unsigned char sb_dma_bits[] = {
	0x00, 0x40, 0x80, 0xC0, 0, 0, 0, 0
};

/*
 * The Address Translation code is used to convert I/O register addresses to
 * be relative to the given base -register
 */

int      	pas_translate_code = 0;
static int      pas_intr_mask;
static int      pas_irq;
static int      pas_sb_base;
DEFINE_SPINLOCK(pas_lock);
#ifndef CONFIG_PAS_JOYSTICK
static int	joystick;
#else
static int 	joystick = 1;
#endif
#ifdef SYMPHONY_PAS
static int 	symphony = 1;
#else
static int 	symphony;
#endif
#ifdef BROKEN_BUS_CLOCK
static int	broken_bus_clock = 1;
#else
static int	broken_bus_clock;
#endif

static struct address_info cfg;
static struct address_info cfg2;

char            pas_model = 0;
static char    *pas_model_names[] = {
	"", 
	"Pro AudioSpectrum+", 
	"CDPC", 
	"Pro AudioSpectrum 16", 
	"Pro AudioSpectrum 16D"
};

/*
 * pas_read() and pas_write() are equivalents of inb and outb 
 * These routines perform the I/O address translation required
 * to support other than the default base address
 */

extern void     mix_write(unsigned char data, int ioaddr);

unsigned char pas_read(int ioaddr)
{
	return inb(ioaddr + pas_translate_code);
}

void pas_write(unsigned char data, int ioaddr)
{
	outb((data), ioaddr + pas_translate_code);
}

/******************* Begin of the Interrupt Handler ********************/

static irqreturn_t pasintr(int irq, void *dev_id)
{
	int             status;

	status = pas_read(0x0B89);
	pas_write(status, 0x0B89);	/* Clear interrupt */

	if (status & 0x08)
	{
		  pas_pcm_interrupt(status, 1);
		  status &= ~0x08;
	}
	if (status & 0x10)
	{
		  pas_midi_interrupt();
		  status &= ~0x10;
	}
	return IRQ_HANDLED;
}

int pas_set_intr(int mask)
{
	if (!mask)
		return 0;

	pas_intr_mask |= mask;

	pas_write(pas_intr_mask, 0x0B8B);
	return 0;
}

int pas_remove_intr(int mask)
{
	if (!mask)
		return 0;

	pas_intr_mask &= ~mask;
	pas_write(pas_intr_mask, 0x0B8B);

	return 0;
}

/******************* End of the Interrupt handler **********************/

/******************* Begin of the Initialization Code ******************/

static int __init config_pas_hw(struct address_info *hw_config)
{
	char            ok = 1;
	unsigned        int_ptrs;	/* scsi/sound interrupt pointers */

	pas_irq = hw_config->irq;

	pas_write(0x00, 0x0B8B);
	pas_write(0x36, 0x138B);
	pas_write(0x36, 0x1388);
	pas_write(0, 0x1388);
	pas_write(0x74, 0x138B);
	pas_write(0x74, 0x1389);
	pas_write(0, 0x1389);

	pas_write(0x80 | 0x40 | 0x20 | 1, 0x0B8A);
	pas_write(0x80 | 0x20 | 0x10 | 0x08 | 0x01, 0xF8A);
	pas_write(0x01 | 0x02 | 0x04 | 0x10	/*
						 * |
						 * 0x80
						 */ , 0xB88);

	pas_write(0x80 | (joystick ? 0x40 : 0), 0xF388);

	if (pas_irq < 0 || pas_irq > 15)
	{
		printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq);
		hw_config->irq=-1;
		ok = 0;
	}
	else
	{
		int_ptrs = pas_read(0xF38A);
		int_ptrs = (int_ptrs & 0xf0) | irq_bits[pas_irq];
		pas_write(int_ptrs, 0xF38A);
		if (!irq_bits[pas_irq])
		{
			printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq);
			hw_config->irq=-1;
			ok = 0;
		}
		else
		{
			if (request_irq(pas_irq, pasintr, 0, "PAS16",hw_config) < 0) {
				printk(KERN_ERR "PAS16: Cannot allocate IRQ %d\n",pas_irq);
				hw_config->irq=-1;
				ok = 0;
			}
		}
	}

	if (hw_config->dma < 0 || hw_config->dma > 7)
	{
		printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma);
		hw_config->dma=-1;
		ok = 0;
	}
	else
	{
		pas_write(dma_bits[hw_config->dma], 0xF389);
		if (!dma_bits[hw_config->dma])
		{
			printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma);
			hw_config->dma=-1;
			ok = 0;
		}
		else
		{
			if (sound_alloc_dma(hw_config->dma, "PAS16"))
			{
				printk(KERN_ERR "pas2_card.c: Can't allocate DMA channel\n");
				hw_config->dma=-1;
				ok = 0;
			}
		}
	}

	/*
	 * This fixes the timing problems of the PAS due to the Symphony chipset
	 * as per Media Vision.  Only define this if your PAS doesn't work correctly.
	 */

	if(symphony)
	{
		outb((0x05), 0xa8);
		outb((0x60), 0xa9);
	}

	if(broken_bus_clock)
		pas_write(0x01 | 0x10 | 0x20 | 0x04, 0x8388);
	else
		/*
		 * pas_write(0x01, 0x8388);
		 */
		pas_write(0x01 | 0x10 | 0x20, 0x8388);

	pas_write(0x18, 0x838A);	/* ??? */
	pas_write(0x20 | 0x01, 0x0B8A);		/* Mute off, filter = 17.897 kHz */
	pas_write(8, 0xBF8A);

	mix_write(0x80 | 5, 0x078B);
	mix_write(5, 0x078B);

	{
		struct address_info *sb_config;

		sb_config = &cfg2;
		if (sb_config->io_base)
		{
			unsigned char   irq_dma;

			/*
			 * Turn on Sound Blaster compatibility
			 * bit 1 = SB emulation
			 * bit 0 = MPU401 emulation (CDPC only :-( )
			 */
			
			pas_write(0x02, 0xF788);

			/*
			 * "Emulation address"
			 */
			
			pas_write((sb_config->io_base >> 4) & 0x0f, 0xF789);
			pas_sb_base = sb_config->io_base;

			if (!sb_dma_bits[sb_config->dma])
				printk(KERN_ERR "PAS16 Warning: Invalid SB DMA %d\n\n", sb_config->dma);

			if (!sb_irq_bits[sb_config->irq])
				printk(KERN_ERR "PAS16 Warning: Invalid SB IRQ %d\n\n", sb_config->irq);

			irq_dma = sb_dma_bits[sb_config->dma] |
				sb_irq_bits[sb_config->irq];

			pas_write(irq_dma, 0xFB8A);
		}
		else
			pas_write(0x00, 0xF788);
	}

	if (!ok)
		printk(KERN_WARNING "PAS16: Driver not enabled\n");

	return ok;
}

static int __init detect_pas_hw(struct address_info *hw_config)
{
	unsigned char   board_id, foo;

	/*
	 * WARNING: Setting an option like W:1 or so that disables warm boot reset
	 * of the card will screw up this detect code something fierce. Adding code
	 * to handle this means possibly interfering with other cards on the bus if
	 * you have something on base port 0x388. SO be forewarned.
	 */

	outb((0xBC), 0x9A01);	/* Activate first board */
	outb((hw_config->io_base >> 2), 0x9A01);	/* Set base address */
	pas_translate_code = hw_config->io_base - 0x388;
	pas_write(1, 0xBF88);	/* Select one wait states */

	board_id = pas_read(0x0B8B);

	if (board_id == 0xff)
		return 0;

	/*
	 * We probably have a PAS-series board, now check for a PAS16-series board
	 * by trying to change the board revision bits. PAS16-series hardware won't
	 * let you do this - the bits are read-only.
	 */

	foo = board_id ^ 0xe0;

	pas_write(foo, 0x0B8B);
	foo = pas_read(0x0B8B);
	pas_write(board_id, 0x0B8B);

	if (board_id != foo)
		return 0;

	pas_model = pas_read(0xFF88);

	return pas_model;
}

static void __init attach_pas_card(struct address_info *hw_config)
{
	pas_irq = hw_config->irq;

	if (detect_pas_hw(hw_config))
	{

		if ((pas_model = pas_read(0xFF88)))
		{
			char            temp[100];

			sprintf(temp,
			    "%s rev %d", pas_model_names[(int) pas_model],
				    pas_read(0x2789));
			conf_printf(temp, hw_config);
		}
		if (config_pas_hw(hw_config))
		{
			pas_pcm_init(hw_config);
			pas_midi_init();
			pas_init_mixer();
		}
	}
}

static inline int __init probe_pas(struct address_info *hw_config)
{
	return detect_pas_hw(hw_config);
}

static void __exit unload_pas(struct address_info *hw_config)
{
	extern int pas_audiodev;
	extern int pas2_mididev;

	if (hw_config->dma>0)
		sound_free_dma(hw_config->dma);
	if (hw_config->irq>0)
		free_irq(hw_config->irq, hw_config);

	if(pas_audiodev!=-1)
		sound_unload_mixerdev(audio_devs[pas_audiodev]->mixer_dev);
	if(pas2_mididev!=-1)
	        sound_unload_mididev(pas2_mididev);
	if(pas_audiodev!=-1)
		sound_unload_audiodev(pas_audiodev);
}

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 sb_io	= 0;
static int __initdata sb_irq	= -1;
static int __initdata sb_dma	= -1;
static int __initdata sb_dma16	= -1;

module_param(io, int, 0);
module_param(irq, int, 0);
module_param(dma, int, 0);
module_param(dma16, int, 0);

module_param(sb_io, int, 0);
module_param(sb_irq, int, 0);
module_param(sb_dma, int, 0);
module_param(sb_dma16, int, 0);

module_param(joystick, bool, 0);
module_param(symphony, bool, 0);
module_param(broken_bus_clock, bool, 0);

MODULE_LICENSE("GPL");

static int __init init_pas2(void)
{
	printk(KERN_INFO "Pro Audio Spectrum driver Copyright (C) by Hannu Savolainen 1993-1996\n");

	cfg.io_base = io;
	cfg.irq = irq;
	cfg.dma = dma;
	cfg.dma2 = dma16;

	cfg2.io_base = sb_io;
	cfg2.irq = sb_irq;
	cfg2.dma = sb_dma;
	cfg2.dma2 = sb_dma16;

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

	if (!probe_pas(&cfg))
		return -ENODEV;
	attach_pas_card(&cfg);

	return 0;
}

static void __exit cleanup_pas2(void)
{
	unload_pas(&cfg);
}

module_init(init_pas2);
module_exit(cleanup_pas2);

#ifndef MODULE
static int __init setup_pas2(char *str)
{
	/* io, irq, dma, dma2, sb_io, sb_irq, sb_dma, sb_dma2 */
	int ints[9];
	
	str = get_options(str, ARRAY_SIZE(ints), ints);

	io	= ints[1];
	irq	= ints[2];
	dma	= ints[3];
	dma16	= ints[4];

	sb_io	= ints[5];
	sb_irq	= ints[6];
	sb_dma	= ints[7];
	sb_dma16 = ints[8];

	return 1;
}

__setup("pas2=", setup_pas2);
#endif
Commit	Line	Data
1da177e4	1	/*
f30c2269	2	* sound/oss/pas2_card.c
1da177e4 LT	3	*
	4	* Detection routine for the Pro Audio Spectrum cards.
	5	*/
	6
1da177e4 LT	7	#include <linux/init.h>
	8	#include <linux/interrupt.h>
	9	#include <linux/module.h>
	10	#include <linux/spinlock.h>
	11	#include "sound_config.h"
	12
	13	#include "pas2.h"
	14	#include "sb.h"
	15
	16	static unsigned char dma_bits[] = {
	17	4, 1, 2, 3, 0, 5, 6, 7
	18	};
	19
	20	static unsigned char irq_bits[] = {
	21	0, 0, 1, 2, 3, 4, 5, 6, 0, 1, 7, 8, 9, 0, 10, 11
	22	};
	23
	24	static unsigned char sb_irq_bits[] = {
	25	0x00, 0x00, 0x08, 0x10, 0x00, 0x18, 0x00, 0x20,
	26	0x00, 0x08, 0x28, 0x30, 0x38, 0, 0
	27	};
	28
	29	static unsigned char sb_dma_bits[] = {
	30	0x00, 0x40, 0x80, 0xC0, 0, 0, 0, 0
	31	};
	32
	33	/*
	34	* The Address Translation code is used to convert I/O register addresses to
	35	* be relative to the given base -register
	36	*/
	37
	38	int pas_translate_code = 0;
	39	static int pas_intr_mask;
	40	static int pas_irq;
	41	static int pas_sb_base;
	42	DEFINE_SPINLOCK(pas_lock);
	43	#ifndef CONFIG_PAS_JOYSTICK
	44	static int joystick;
	45	#else
	46	static int joystick = 1;
	47	#endif
	48	#ifdef SYMPHONY_PAS
	49	static int symphony = 1;
	50	#else
	51	static int symphony;
	52	#endif
	53	#ifdef BROKEN_BUS_CLOCK
	54	static int broken_bus_clock = 1;
	55	#else
	56	static int broken_bus_clock;
	57	#endif
	58
	59	static struct address_info cfg;
	60	static struct address_info cfg2;
	61
	62	char pas_model = 0;
	63	static char *pas_model_names[] = {
	64	"",
	65	"Pro AudioSpectrum+",
	66	"CDPC",
	67	"Pro AudioSpectrum 16",
	68	"Pro AudioSpectrum 16D"
	69	};
	70
71	/*
72	* pas_read() and pas_write() are equivalents of inb and outb
73	* These routines perform the I/O address translation required
74	* to support other than the default base address
75	*/
76
77	extern void mix_write(unsigned char data, int ioaddr);
78
79	unsigned char pas_read(int ioaddr)
80	{
81	return inb(ioaddr + pas_translate_code);
82	}
83
84	void pas_write(unsigned char data, int ioaddr)
85	{
86	outb((data), ioaddr + pas_translate_code);
87	}
88
89	/***************** Begin of the Interrupt Handler ******************/
90
7d12e780	91	static irqreturn_t pasintr(int irq, void *dev_id)
1da177e4 LT	92	{
	93	int status;
	94
	95	status = pas_read(0x0B89);
	96	pas_write(status, 0x0B89); /* Clear interrupt */
	97
	98	if (status & 0x08)
	99	{
	100	pas_pcm_interrupt(status, 1);
	101	status &= ~0x08;
	102	}
	103	if (status & 0x10)
	104	{
	105	pas_midi_interrupt();
	106	status &= ~0x10;
	107	}
	108	return IRQ_HANDLED;
	109	}
	110
	111	int pas_set_intr(int mask)
	112	{
	113	if (!mask)
	114	return 0;
	115
	116	pas_intr_mask \|= mask;
	117
	118	pas_write(pas_intr_mask, 0x0B8B);
	119	return 0;
	120	}
	121
	122	int pas_remove_intr(int mask)
	123	{
	124	if (!mask)
	125	return 0;
	126
	127	pas_intr_mask &= ~mask;
	128	pas_write(pas_intr_mask, 0x0B8B);
	129
	130	return 0;
	131	}
	132
	133	/***************** End of the Interrupt handler ********************/
	134
	135	/***************** Begin of the Initialization Code ****************/
	136
	137	static int __init config_pas_hw(struct address_info *hw_config)
	138	{
	139	char ok = 1;
	140	unsigned int_ptrs; /* scsi/sound interrupt pointers */
	141
	142	pas_irq = hw_config->irq;
	143
	144	pas_write(0x00, 0x0B8B);
	145	pas_write(0x36, 0x138B);
	146	pas_write(0x36, 0x1388);
	147	pas_write(0, 0x1388);
	148	pas_write(0x74, 0x138B);
	149	pas_write(0x74, 0x1389);
	150	pas_write(0, 0x1389);
	151
	152	pas_write(0x80 \| 0x40 \| 0x20 \| 1, 0x0B8A);
	153	pas_write(0x80 \| 0x20 \| 0x10 \| 0x08 \| 0x01, 0xF8A);
	154	pas_write(0x01 \| 0x02 \| 0x04 \| 0x10 /*
	155	* \|
156	* 0x80
157	*/ , 0xB88);
158
c1615912	159	pas_write(0x80 \| (joystick ? 0x40 : 0), 0xF388);
1da177e4 LT	160
	161	if (pas_irq < 0 \|\| pas_irq > 15)
	162	{
	163	printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq);
	164	hw_config->irq=-1;
	165	ok = 0;
	166	}
	167	else
	168	{
	169	int_ptrs = pas_read(0xF38A);
	170	int_ptrs = (int_ptrs & 0xf0) \| irq_bits[pas_irq];
	171	pas_write(int_ptrs, 0xF38A);
	172	if (!irq_bits[pas_irq])
	173	{
	174	printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq);
	175	hw_config->irq=-1;
	176	ok = 0;
	177	}
	178	else
	179	{
	180	if (request_irq(pas_irq, pasintr, 0, "PAS16",hw_config) < 0) {
	181	printk(KERN_ERR "PAS16: Cannot allocate IRQ %d\n",pas_irq);
	182	hw_config->irq=-1;
	183	ok = 0;
	184	}
	185	}
	186	}
	187
	188	if (hw_config->dma < 0 \|\| hw_config->dma > 7)
	189	{
	190	printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma);
	191	hw_config->dma=-1;
	192	ok = 0;
	193	}
	194	else
	195	{
	196	pas_write(dma_bits[hw_config->dma], 0xF389);
	197	if (!dma_bits[hw_config->dma])
	198	{
	199	printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma);
	200	hw_config->dma=-1;
	201	ok = 0;
	202	}
	203	else
	204	{
	205	if (sound_alloc_dma(hw_config->dma, "PAS16"))
	206	{
	207	printk(KERN_ERR "pas2_card.c: Can't allocate DMA channel\n");
	208	hw_config->dma=-1;
	209	ok = 0;
	210	}
	211	}
	212	}
	213
	214	/*
	215	* This fixes the timing problems of the PAS due to the Symphony chipset
	216	* as per Media Vision. Only define this if your PAS doesn't work correctly.
	217	*/
	218
	219	if(symphony)
	220	{
	221	outb((0x05), 0xa8);
	222	outb((0x60), 0xa9);
	223	}
224
225	if(broken_bus_clock)
226	pas_write(0x01 \| 0x10 \| 0x20 \| 0x04, 0x8388);
227	else
228	/*
229	* pas_write(0x01, 0x8388);
230	*/
231	pas_write(0x01 \| 0x10 \| 0x20, 0x8388);
232
233	pas_write(0x18, 0x838A); /* ??? */
234	pas_write(0x20 \| 0x01, 0x0B8A); /* Mute off, filter = 17.897 kHz */
235	pas_write(8, 0xBF8A);
236
237	mix_write(0x80 \| 5, 0x078B);
238	mix_write(5, 0x078B);
239
240	{
241	struct address_info *sb_config;
242
243	sb_config = &cfg2;
244	if (sb_config->io_base)
245	{
246	unsigned char irq_dma;
247
248	/*
249	* Turn on Sound Blaster compatibility
250	* bit 1 = SB emulation
251	* bit 0 = MPU401 emulation (CDPC only :-( )
252	*/
253
254	pas_write(0x02, 0xF788);
255
256	/*
257	* "Emulation address"
258	*/
259
260	pas_write((sb_config->io_base >> 4) & 0x0f, 0xF789);
261	pas_sb_base = sb_config->io_base;
262
263	if (!sb_dma_bits[sb_config->dma])
264	printk(KERN_ERR "PAS16 Warning: Invalid SB DMA %d\n\n", sb_config->dma);
265
266	if (!sb_irq_bits[sb_config->irq])
267	printk(KERN_ERR "PAS16 Warning: Invalid SB IRQ %d\n\n", sb_config->irq);
268
269	irq_dma = sb_dma_bits[sb_config->dma] \|
270	sb_irq_bits[sb_config->irq];
271
272	pas_write(irq_dma, 0xFB8A);
273	}
274	else
275	pas_write(0x00, 0xF788);
276	}
277
278	if (!ok)
279	printk(KERN_WARNING "PAS16: Driver not enabled\n");
280
281	return ok;
282	}
283
284	static int __init detect_pas_hw(struct address_info *hw_config)
285	{
286	unsigned char board_id, foo;
287
288	/*
289	* WARNING: Setting an option like W:1 or so that disables warm boot reset
290	* of the card will screw up this detect code something fierce. Adding code
291	* to handle this means possibly interfering with other cards on the bus if
292	* you have something on base port 0x388. SO be forewarned.
293	*/
294
295	outb((0xBC), 0x9A01); /* Activate first board */
296	outb((hw_config->io_base >> 2), 0x9A01); /* Set base address */
297	pas_translate_code = hw_config->io_base - 0x388;
298	pas_write(1, 0xBF88); /* Select one wait states */
299
300	board_id = pas_read(0x0B8B);
301
302	if (board_id == 0xff)
303	return 0;
304
305	/*
306	* We probably have a PAS-series board, now check for a PAS16-series board
307	* by trying to change the board revision bits. PAS16-series hardware won't
308	* let you do this - the bits are read-only.
309	*/
310
311	foo = board_id ^ 0xe0;
312
313	pas_write(foo, 0x0B8B);
314	foo = pas_read(0x0B8B);
315	pas_write(board_id, 0x0B8B);
316
317	if (board_id != foo)
318	return 0;
319
320	pas_model = pas_read(0xFF88);
321
322	return pas_model;
323	}
324
325	static void __init attach_pas_card(struct address_info *hw_config)
326	{
327	pas_irq = hw_config->irq;
328
329	if (detect_pas_hw(hw_config))
330	{
331
332	if ((pas_model = pas_read(0xFF88)))
333	{
334	char temp[100];
335
336	sprintf(temp,
337	"%s rev %d", pas_model_names[(int) pas_model],
338	pas_read(0x2789));
339	conf_printf(temp, hw_config);
340	}
341	if (config_pas_hw(hw_config))
342	{
343	pas_pcm_init(hw_config);
344	pas_midi_init();
345	pas_init_mixer();
346	}
347	}
348	}
349
350	static inline int __init probe_pas(struct address_info *hw_config)
351	{
352	return detect_pas_hw(hw_config);
353	}
354
355	static void __exit unload_pas(struct address_info *hw_config)
356	{
357	extern int pas_audiodev;
358	extern int pas2_mididev;
359
360	if (hw_config->dma>0)
361	sound_free_dma(hw_config->dma);
362	if (hw_config->irq>0)
363	free_irq(hw_config->irq, hw_config);
364
365	if(pas_audiodev!=-1)
366	sound_unload_mixerdev(audio_devs[pas_audiodev]->mixer_dev);
367	if(pas2_mididev!=-1)
368	sound_unload_mididev(pas2_mididev);
369	if(pas_audiodev!=-1)
370	sound_unload_audiodev(pas_audiodev);
371	}
372
373	static int __initdata io = -1;
374	static int __initdata irq = -1;
375	static int __initdata dma = -1;
376	static int __initdata dma16 = -1; /* Set this for modules that need it */
377
378	static int __initdata sb_io = 0;
379	static int __initdata sb_irq = -1;
380	static int __initdata sb_dma = -1;
381	static int __initdata sb_dma16 = -1;
382
383	module_param(io, int, 0);
384	module_param(irq, int, 0);
385	module_param(dma, int, 0);
386	module_param(dma16, int, 0);
387
388	module_param(sb_io, int, 0);
389	module_param(sb_irq, int, 0);
390	module_param(sb_dma, int, 0);
391	module_param(sb_dma16, int, 0);
392
393	module_param(joystick, bool, 0);
394	module_param(symphony, bool, 0);
395	module_param(broken_bus_clock, bool, 0);
396
397	MODULE_LICENSE("GPL");
398
399	static int __init init_pas2(void)
400	{
401	printk(KERN_INFO "Pro Audio Spectrum driver Copyright (C) by Hannu Savolainen 1993-1996\n");
402
403	cfg.io_base = io;
404	cfg.irq = irq;
405	cfg.dma = dma;
406	cfg.dma2 = dma16;
407
408	cfg2.io_base = sb_io;
409	cfg2.irq = sb_irq;
410	cfg2.dma = sb_dma;
411	cfg2.dma2 = sb_dma16;
412
413	if (cfg.io_base == -1 \|\| cfg.dma == -1 \|\| cfg.irq == -1) {
414	printk(KERN_INFO "I/O, IRQ, DMA and type are mandatory\n");
415	return -EINVAL;
416	}
417
418	if (!probe_pas(&cfg))
419	return -ENODEV;
420	attach_pas_card(&cfg);
421
422	return 0;
423	}
424
425	static void __exit cleanup_pas2(void)
426	{
427	unload_pas(&cfg);
428	}
429
430	module_init(init_pas2);
431	module_exit(cleanup_pas2);
432
433	#ifndef MODULE
434	static int __init setup_pas2(char *str)
435	{
436	/* io, irq, dma, dma2, sb_io, sb_irq, sb_dma, sb_dma2 */
437	int ints[9];
438
439	str = get_options(str, ARRAY_SIZE(ints), ints);
440
441	io = ints[1];
442	irq = ints[2];
443	dma = ints[3];
444	dma16 = ints[4];
445
446	sb_io = ints[5];
447	sb_irq = ints[6];
448	sb_dma = ints[7];
449	sb_dma16 = ints[8];
450
451	return 1;
452	}
453
454	__setup("pas2=", setup_pas2);
455	#endif