[net-next-2.6.git] / sound / isa / azt2320.c

/*
    card-azt2320.c - driver for Aztech Systems AZT2320 based soundcards.
    Copyright (C) 1999-2000 by Massimo Piccioni <dafastidio@libero.it>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
*/

/*
    This driver should provide support for most Aztech AZT2320 based cards.
    Several AZT2316 chips are also supported/tested, but autoprobe doesn't
    work: all module option have to be set.

    No docs available for us at Aztech headquarters !!!   Unbelievable ...
    No other help obtained.

    Thanks to Rainer Wiesner <rainer.wiesner@01019freenet.de> for the WSS
    activation method (full-duplex audio!).
*/

#include <asm/io.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/time.h>
#include <linux/wait.h>
#include <linux/pnp.h>
#include <linux/moduleparam.h>
#include <sound/core.h>
#include <sound/initval.h>
#include <sound/wss.h>
#include <sound/mpu401.h>
#include <sound/opl3.h>

#define PFX "azt2320: "

MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
MODULE_DESCRIPTION("Aztech Systems AZT2320");
MODULE_LICENSE("GPL");
MODULE_SUPPORTED_DEVICE("{{Aztech Systems,PRO16V},"
		"{Aztech Systems,AZT2320},"
		"{Aztech Systems,AZT3300},"
		"{Aztech Systems,AZT2320},"
		"{Aztech Systems,AZT3000}}");

static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;	/* Index 0-MAX */
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;	/* ID for this card */
static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;	/* PnP setup */
static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;	/* PnP setup */
static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;	/* PnP setup */
static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;	/* PnP setup */
static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;	/* Pnp setup */
static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;	/* Pnp setup */
static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;	/* PnP setup */
static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;	/* PnP setup */

module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "Index value for azt2320 based soundcard.");
module_param_array(id, charp, NULL, 0444);
MODULE_PARM_DESC(id, "ID string for azt2320 based soundcard.");
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "Enable azt2320 based soundcard.");

struct snd_card_azt2320 {
	int dev_no;
	struct pnp_dev *dev;
	struct pnp_dev *devmpu;
	struct snd_wss *chip;
};

static struct pnp_card_device_id snd_azt2320_pnpids[] = {
	/* PRO16V */
	{ .id = "AZT1008", .devs = { { "AZT1008" }, { "AZT2001" }, } },
	/* Aztech Sound Galaxy 16 */
	{ .id = "AZT2320", .devs = { { "AZT0001" }, { "AZT0002" }, } },
	/* Packard Bell Sound III 336 AM/SP */
	{ .id = "AZT3000", .devs = { { "AZT1003" }, { "AZT2001" }, } },
	/* AT3300 */
	{ .id = "AZT3002", .devs = { { "AZT1004" }, { "AZT2001" }, } },
	/* --- */
	{ .id = "AZT3005", .devs = { { "AZT1003" }, { "AZT2001" }, } },
	/* --- */
	{ .id = "AZT3011", .devs = { { "AZT1003" }, { "AZT2001" }, } },
	{ .id = "" }	/* end */
};

MODULE_DEVICE_TABLE(pnp_card, snd_azt2320_pnpids);

#define	DRIVER_NAME	"snd-card-azt2320"

static int __devinit snd_card_azt2320_pnp(int dev, struct snd_card_azt2320 *acard,
					  struct pnp_card_link *card,
					  const struct pnp_card_device_id *id)
{
	struct pnp_dev *pdev;
	int err;

	acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
	if (acard->dev == NULL)
		return -ENODEV;

	acard->devmpu = pnp_request_card_device(card, id->devs[1].id, NULL);

	pdev = acard->dev;

	err = pnp_activate_dev(pdev);
	if (err < 0) {
		snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
		return err;
	}
	port[dev] = pnp_port_start(pdev, 0);
	fm_port[dev] = pnp_port_start(pdev, 1);
	wss_port[dev] = pnp_port_start(pdev, 2);
	dma1[dev] = pnp_dma(pdev, 0);
	dma2[dev] = pnp_dma(pdev, 1);
	irq[dev] = pnp_irq(pdev, 0);

	pdev = acard->devmpu;
	if (pdev != NULL) {
		err = pnp_activate_dev(pdev);
		if (err < 0)
			goto __mpu_error;
		mpu_port[dev] = pnp_port_start(pdev, 0);
		mpu_irq[dev] = pnp_irq(pdev, 0);
	} else {
	     __mpu_error:
	     	if (pdev) {
		     	pnp_release_card_device(pdev);
	     		snd_printk(KERN_ERR PFX "MPU401 pnp configure failure, skipping\n");
	     	}
	     	acard->devmpu = NULL;
	     	mpu_port[dev] = -1;
	}

	return 0;
}

/* same of snd_sbdsp_command by Jaroslav Kysela */
static int __devinit snd_card_azt2320_command(unsigned long port, unsigned char val)
{
	int i;
	unsigned long limit;

	limit = jiffies + HZ / 10;
	for (i = 50000; i && time_after(limit, jiffies); i--)
		if (!(inb(port + 0x0c) & 0x80)) {
			outb(val, port + 0x0c);
			return 0;
		}
	return -EBUSY;
}

static int __devinit snd_card_azt2320_enable_wss(unsigned long port)
{
	int error;

	if ((error = snd_card_azt2320_command(port, 0x09)))
		return error;
	if ((error = snd_card_azt2320_command(port, 0x00)))
		return error;

	mdelay(5);
	return 0;
}

static int __devinit snd_card_azt2320_probe(int dev,
					    struct pnp_card_link *pcard,
					    const struct pnp_card_device_id *pid)
{
	int error;
	struct snd_card *card;
	struct snd_card_azt2320 *acard;
	struct snd_wss *chip;
	struct snd_opl3 *opl3;

	error = snd_card_create(index[dev], id[dev], THIS_MODULE,
				sizeof(struct snd_card_azt2320), &card);
	if (error < 0)
		return error;
	acard = card->private_data;

	if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) {
		snd_card_free(card);
		return error;
	}
	snd_card_set_dev(card, &pcard->card->dev);

	if ((error = snd_card_azt2320_enable_wss(port[dev]))) {
		snd_card_free(card);
		return error;
	}

	error = snd_wss_create(card, wss_port[dev], -1,
			       irq[dev],
			       dma1[dev], dma2[dev],
			       WSS_HW_DETECT, 0, &chip);
	if (error < 0) {
		snd_card_free(card);
		return error;
	}

	strcpy(card->driver, "AZT2320");
	strcpy(card->shortname, "Aztech AZT2320");
	sprintf(card->longname, "%s, WSS at 0x%lx, irq %i, dma %i&%i",
		card->shortname, chip->port, irq[dev], dma1[dev], dma2[dev]);

	error = snd_wss_pcm(chip, 0, NULL);
	if (error < 0) {
		snd_card_free(card);
		return error;
	}
	error = snd_wss_mixer(chip);
	if (error < 0) {
		snd_card_free(card);
		return error;
	}
	error = snd_wss_timer(chip, 0, NULL);
	if (error < 0) {
		snd_card_free(card);
		return error;
	}

	if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
		if (snd_mpu401_uart_new(card, 0, MPU401_HW_AZT2320,
				mpu_port[dev], 0,
				mpu_irq[dev], IRQF_DISABLED,
				NULL) < 0)
			snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
	}

	if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
		if (snd_opl3_create(card,
				    fm_port[dev], fm_port[dev] + 2,
				    OPL3_HW_AUTO, 0, &opl3) < 0) {
			snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
				   fm_port[dev], fm_port[dev] + 2);
		} else {
			if ((error = snd_opl3_timer_new(opl3, 1, 2)) < 0) {
				snd_card_free(card);
				return error;
			}
			if ((error = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
				snd_card_free(card);
				return error;
			}
		}
	}

	if ((error = snd_card_register(card)) < 0) {
		snd_card_free(card);
		return error;
	}
	pnp_set_card_drvdata(pcard, card);
	return 0;
}

static unsigned int __devinitdata azt2320_devices;

static int __devinit snd_azt2320_pnp_detect(struct pnp_card_link *card,
					    const struct pnp_card_device_id *id)
{
	static int dev;
	int res;

	for ( ; dev < SNDRV_CARDS; dev++) {
		if (!enable[dev])
			continue;
		res = snd_card_azt2320_probe(dev, card, id);
		if (res < 0)
			return res;
		dev++;
		azt2320_devices++;
		return 0;
	}
        return -ENODEV;
}

static void __devexit snd_azt2320_pnp_remove(struct pnp_card_link * pcard)
{
	snd_card_free(pnp_get_card_drvdata(pcard));
	pnp_set_card_drvdata(pcard, NULL);
}

#ifdef CONFIG_PM
static int snd_azt2320_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state)
{
	struct snd_card *card = pnp_get_card_drvdata(pcard);
	struct snd_card_azt2320 *acard = card->private_data;
	struct snd_wss *chip = acard->chip;

	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
	chip->suspend(chip);
	return 0;
}

static int snd_azt2320_pnp_resume(struct pnp_card_link *pcard)
{
	struct snd_card *card = pnp_get_card_drvdata(pcard);
	struct snd_card_azt2320 *acard = card->private_data;
	struct snd_wss *chip = acard->chip;

	chip->resume(chip);
	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
	return 0;
}
#endif

static struct pnp_card_driver azt2320_pnpc_driver = {
	.flags          = PNP_DRIVER_RES_DISABLE,
	.name           = "azt2320",
	.id_table       = snd_azt2320_pnpids,
	.probe          = snd_azt2320_pnp_detect,
	.remove         = __devexit_p(snd_azt2320_pnp_remove),
#ifdef CONFIG_PM
	.suspend	= snd_azt2320_pnp_suspend,
	.resume		= snd_azt2320_pnp_resume,
#endif
};

static int __init alsa_card_azt2320_init(void)
{
	int err;

	err = pnp_register_card_driver(&azt2320_pnpc_driver);
	if (err)
		return err;

	if (!azt2320_devices) {
		pnp_unregister_card_driver(&azt2320_pnpc_driver);
#ifdef MODULE
		snd_printk(KERN_ERR "no AZT2320 based soundcards found\n");
#endif
		return -ENODEV;
	}
	return 0;
}

static void __exit alsa_card_azt2320_exit(void)
{
	pnp_unregister_card_driver(&azt2320_pnpc_driver);
}

module_init(alsa_card_azt2320_init)
module_exit(alsa_card_azt2320_exit)
Commit	Line	Data
1da177e4 LT	1	/*
	2	card-azt2320.c - driver for Aztech Systems AZT2320 based soundcards.
	3	Copyright (C) 1999-2000 by Massimo Piccioni <dafastidio@libero.it>
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
	20	/*
	21	This driver should provide support for most Aztech AZT2320 based cards.
	22	Several AZT2316 chips are also supported/tested, but autoprobe doesn't
	23	work: all module option have to be set.
	24
	25	No docs available for us at Aztech headquarters !!! Unbelievable ...
	26	No other help obtained.
	27
	28	Thanks to Rainer Wiesner <rainer.wiesner@01019freenet.de> for the WSS
	29	activation method (full-duplex audio!).
	30	*/
	31
1da177e4 LT	32	#include <asm/io.h>
	33	#include <linux/delay.h>
	34	#include <linux/init.h>
	35	#include <linux/time.h>
	36	#include <linux/wait.h>
	37	#include <linux/pnp.h>
	38	#include <linux/moduleparam.h>
	39	#include <sound/core.h>
	40	#include <sound/initval.h>
61ef19d7	41	#include <sound/wss.h>
1da177e4 LT	42	#include <sound/mpu401.h>
	43	#include <sound/opl3.h>
	44
	45	#define PFX "azt2320: "
	46
	47	MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
	48	MODULE_DESCRIPTION("Aztech Systems AZT2320");
	49	MODULE_LICENSE("GPL");
	50	MODULE_SUPPORTED_DEVICE("{{Aztech Systems,PRO16V},"
	51	"{Aztech Systems,AZT2320},"
	52	"{Aztech Systems,AZT3300},"
	53	"{Aztech Systems,AZT2320},"
	54	"{Aztech Systems,AZT3000}}");
	55
	56	static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
	57	static char id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; / ID for this card */
	58	static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
	59	static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
	60	static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
	61	static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
	62	static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
	63	static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* Pnp setup */
	64	static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* Pnp setup */
	65	static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* PnP setup */
	66	static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* PnP setup */
	67
	68	module_param_array(index, int, NULL, 0444);
	69	MODULE_PARM_DESC(index, "Index value for azt2320 based soundcard.");
	70	module_param_array(id, charp, NULL, 0444);
	71	MODULE_PARM_DESC(id, "ID string for azt2320 based soundcard.");
	72	module_param_array(enable, bool, NULL, 0444);
	73	MODULE_PARM_DESC(enable, "Enable azt2320 based soundcard.");
1da177e4 LT	74
	75	struct snd_card_azt2320 {
	76	int dev_no;
	77	struct pnp_dev *dev;
	78	struct pnp_dev *devmpu;
7779f75f	79	struct snd_wss *chip;
1da177e4 LT	80	};
	81
	82	static struct pnp_card_device_id snd_azt2320_pnpids[] = {
	83	/* PRO16V */
	84	{ .id = "AZT1008", .devs = { { "AZT1008" }, { "AZT2001" }, } },
	85	/* Aztech Sound Galaxy 16 */
	86	{ .id = "AZT2320", .devs = { { "AZT0001" }, { "AZT0002" }, } },
	87	/* Packard Bell Sound III 336 AM/SP */
	88	{ .id = "AZT3000", .devs = { { "AZT1003" }, { "AZT2001" }, } },
	89	/* AT3300 */
	90	{ .id = "AZT3002", .devs = { { "AZT1004" }, { "AZT2001" }, } },
	91	/* --- */
	92	{ .id = "AZT3005", .devs = { { "AZT1003" }, { "AZT2001" }, } },
	93	/* --- */
	94	{ .id = "AZT3011", .devs = { { "AZT1003" }, { "AZT2001" }, } },
	95	{ .id = "" } /* end */
	96	};
	97
	98	MODULE_DEVICE_TABLE(pnp_card, snd_azt2320_pnpids);
	99
	100	#define DRIVER_NAME "snd-card-azt2320"
	101
	102	static int __devinit snd_card_azt2320_pnp(int dev, struct snd_card_azt2320 *acard,
	103	struct pnp_card_link *card,
	104	const struct pnp_card_device_id *id)
	105	{
	106	struct pnp_dev *pdev;
1da177e4 LT	107	int err;
1da177e4 LT	108
1da177e4	109	acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL);
109c53f8	110	if (acard->dev == NULL)
1da177e4	111	return -ENODEV;
1da177e4 LT	112
	113	acard->devmpu = pnp_request_card_device(card, id->devs[1].id, NULL);
	114
	115	pdev = acard->dev;
1da177e4 LT	116
	117	err = pnp_activate_dev(pdev);
	118	if (err < 0) {
	119	snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n");
1da177e4 LT	120	return err;
	121	}
	122	port[dev] = pnp_port_start(pdev, 0);
	123	fm_port[dev] = pnp_port_start(pdev, 1);
	124	wss_port[dev] = pnp_port_start(pdev, 2);
	125	dma1[dev] = pnp_dma(pdev, 0);
	126	dma2[dev] = pnp_dma(pdev, 1);
	127	irq[dev] = pnp_irq(pdev, 0);
	128
	129	pdev = acard->devmpu;
	130	if (pdev != NULL) {
1da177e4 LT	131	err = pnp_activate_dev(pdev);
	132	if (err < 0)
	133	goto __mpu_error;
	134	mpu_port[dev] = pnp_port_start(pdev, 0);
	135	mpu_irq[dev] = pnp_irq(pdev, 0);
	136	} else {
	137	__mpu_error:
	138	if (pdev) {
	139	pnp_release_card_device(pdev);
	140	snd_printk(KERN_ERR PFX "MPU401 pnp configure failure, skipping\n");
	141	}
	142	acard->devmpu = NULL;
	143	mpu_port[dev] = -1;
	144	}
	145
1da177e4 LT	146	return 0;
	147	}
	148
	149	/* same of snd_sbdsp_command by Jaroslav Kysela */
	150	static int __devinit snd_card_azt2320_command(unsigned long port, unsigned char val)
	151	{
	152	int i;
	153	unsigned long limit;
	154
	155	limit = jiffies + HZ / 10;
	156	for (i = 50000; i && time_after(limit, jiffies); i--)
	157	if (!(inb(port + 0x0c) & 0x80)) {
	158	outb(val, port + 0x0c);
	159	return 0;
	160	}
	161	return -EBUSY;
	162	}
	163
	164	static int __devinit snd_card_azt2320_enable_wss(unsigned long port)
	165	{
	166	int error;
	167
	168	if ((error = snd_card_azt2320_command(port, 0x09)))
	169	return error;
	170	if ((error = snd_card_azt2320_command(port, 0x00)))
	171	return error;
	172
	173	mdelay(5);
	174	return 0;
	175	}
	176
	177	static int __devinit snd_card_azt2320_probe(int dev,
	178	struct pnp_card_link *pcard,
	179	const struct pnp_card_device_id *pid)
	180	{
	181	int error;
11ff5c62	182	struct snd_card *card;
1da177e4	183	struct snd_card_azt2320 *acard;
7779f75f	184	struct snd_wss *chip;
11ff5c62	185	struct snd_opl3 *opl3;
1da177e4	186
c95eadd2 TI	187	error = snd_card_create(index[dev], id[dev], THIS_MODULE,
	188	sizeof(struct snd_card_azt2320), &card);
	189	if (error < 0)
	190	return error;
9fe856e4	191	acard = card->private_data;
1da177e4 LT	192
	193	if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) {
	194	snd_card_free(card);
	195	return error;
	196	}
	197	snd_card_set_dev(card, &pcard->card->dev);
	198
	199	if ((error = snd_card_azt2320_enable_wss(port[dev]))) {
	200	snd_card_free(card);
	201	return error;
	202	}
	203
7779f75f KH	204	error = snd_wss_create(card, wss_port[dev], -1,
	205	irq[dev],
	206	dma1[dev], dma2[dev],
	207	WSS_HW_DETECT, 0, &chip);
	208	if (error < 0) {
1da177e4 LT	209	snd_card_free(card);
	210	return error;
	211	}
	212
	213	strcpy(card->driver, "AZT2320");
	214	strcpy(card->shortname, "Aztech AZT2320");
	215	sprintf(card->longname, "%s, WSS at 0x%lx, irq %i, dma %i&%i",
	216	card->shortname, chip->port, irq[dev], dma1[dev], dma2[dev]);
	217
7779f75f KH	218	error = snd_wss_pcm(chip, 0, NULL);
7779f75f KH	219	if (error < 0) {
1da177e4 LT	220	snd_card_free(card);
	221	return error;
	222	}
7779f75f KH	223	error = snd_wss_mixer(chip);
7779f75f KH	224	if (error < 0) {
1da177e4 LT	225	snd_card_free(card);
	226	return error;
	227	}
7779f75f KH	228	error = snd_wss_timer(chip, 0, NULL);
7779f75f KH	229	if (error < 0) {
1da177e4 LT	230	snd_card_free(card);
	231	return error;
	232	}
	233
	234	if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
	235	if (snd_mpu401_uart_new(card, 0, MPU401_HW_AZT2320,
	236	mpu_port[dev], 0,
65ca68b3	237	mpu_irq[dev], IRQF_DISABLED,
1da177e4 LT	238	NULL) < 0)
	239	snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
	240	}
	241
	242	if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
	243	if (snd_opl3_create(card,
	244	fm_port[dev], fm_port[dev] + 2,
	245	OPL3_HW_AUTO, 0, &opl3) < 0) {
	246	snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
	247	fm_port[dev], fm_port[dev] + 2);
	248	} else {
	249	if ((error = snd_opl3_timer_new(opl3, 1, 2)) < 0) {
	250	snd_card_free(card);
	251	return error;
	252	}
	253	if ((error = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
	254	snd_card_free(card);
	255	return error;
	256	}
	257	}
	258	}
	259
	260	if ((error = snd_card_register(card)) < 0) {
	261	snd_card_free(card);
	262	return error;
	263	}
	264	pnp_set_card_drvdata(pcard, card);
	265	return 0;
	266	}
	267
db2735eb BH	268	static unsigned int __devinitdata azt2320_devices;
db2735eb BH	269
1da177e4 LT	270	static int __devinit snd_azt2320_pnp_detect(struct pnp_card_link *card,
	271	const struct pnp_card_device_id *id)
	272	{
	273	static int dev;
	274	int res;
	275
	276	for ( ; dev < SNDRV_CARDS; dev++) {
	277	if (!enable[dev])
	278	continue;
	279	res = snd_card_azt2320_probe(dev, card, id);
	280	if (res < 0)
	281	return res;
	282	dev++;
db2735eb	283	azt2320_devices++;
1da177e4 LT	284	return 0;
	285	}
	286	return -ENODEV;
	287	}
	288
	289	static void __devexit snd_azt2320_pnp_remove(struct pnp_card_link * pcard)
	290	{
b6cc25ca TI	291	snd_card_free(pnp_get_card_drvdata(pcard));
	292	pnp_set_card_drvdata(pcard, NULL);
	293	}
	294
	295	#ifdef CONFIG_PM
	296	static int snd_azt2320_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state)
	297	{
	298	struct snd_card *card = pnp_get_card_drvdata(pcard);
	299	struct snd_card_azt2320 *acard = card->private_data;
7779f75f	300	struct snd_wss *chip = acard->chip;
b6cc25ca TI	301
	302	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
	303	chip->suspend(chip);
	304	return 0;
	305	}
	306
	307	static int snd_azt2320_pnp_resume(struct pnp_card_link *pcard)
	308	{
	309	struct snd_card *card = pnp_get_card_drvdata(pcard);
	310	struct snd_card_azt2320 *acard = card->private_data;
7779f75f	311	struct snd_wss *chip = acard->chip;
1da177e4	312
b6cc25ca TI	313	chip->resume(chip);
	314	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
	315	return 0;
1da177e4	316	}
b6cc25ca	317	#endif
1da177e4 LT	318
	319	static struct pnp_card_driver azt2320_pnpc_driver = {
	320	.flags = PNP_DRIVER_RES_DISABLE,
	321	.name = "azt2320",
	322	.id_table = snd_azt2320_pnpids,
	323	.probe = snd_azt2320_pnp_detect,
	324	.remove = __devexit_p(snd_azt2320_pnp_remove),
b6cc25ca TI	325	#ifdef CONFIG_PM
	326	.suspend = snd_azt2320_pnp_suspend,
	327	.resume = snd_azt2320_pnp_resume,
	328	#endif
1da177e4 LT	329	};
	330
	331	static int __init alsa_card_azt2320_init(void)
	332	{
db2735eb BH	333	int err;
	334
	335	err = pnp_register_card_driver(&azt2320_pnpc_driver);
	336	if (err)
	337	return err;
1da177e4	338
db2735eb	339	if (!azt2320_devices) {
1da177e4	340	pnp_unregister_card_driver(&azt2320_pnpc_driver);
b6cc25ca	341	#ifdef MODULE
1da177e4	342	snd_printk(KERN_ERR "no AZT2320 based soundcards found\n");
1da177e4	343	#endif
b6cc25ca TI	344	return -ENODEV;
	345	}
	346	return 0;
1da177e4 LT	347	}
	348
	349	static void __exit alsa_card_azt2320_exit(void)
	350	{
	351	pnp_unregister_card_driver(&azt2320_pnpc_driver);
	352	}
	353
	354	module_init(alsa_card_azt2320_init)
	355	module_exit(alsa_card_azt2320_exit)