[mirror_ubuntu-bionic-kernel.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 <linux/io.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/time.h>
#include <linux/wait.h>
#include <linux/pnp.h>
#include <linux/module.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 bool 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 const 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 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 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 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 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_new(&pcard->card->dev,
			     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;
	}

	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);
	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);
	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], 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 azt2320_devices;

static int 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 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         = 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
6cbbfe1c	32	#include <linux/io.h>
1da177e4 LT	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>
65a77217	38	#include <linux/module.h>
1da177e4 LT	39	#include <sound/core.h>
1da177e4 LT	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 */
a67ff6a5	58	static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */
1da177e4 LT	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	};
1da177e4 LT	81
1d906e85	82	static const struct pnp_card_device_id snd_azt2320_pnpids[] = {
1da177e4 LT	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
1bff292e BP	102	static int 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)
1da177e4 LT	105	{
1da177e4 LT	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 */
1bff292e	150	static int snd_card_azt2320_command(unsigned long port, unsigned char val)
1da177e4 LT	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
1bff292e	164	static int snd_card_azt2320_enable_wss(unsigned long port)
1da177e4 LT	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
1bff292e BP	177	static int snd_card_azt2320_probe(int dev,
	178	struct pnp_card_link *pcard,
	179	const struct pnp_card_device_id *pid)
1da177e4 LT	180	{
1da177e4 LT	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
4323cc4d TI	187	error = snd_card_new(&pcard->card->dev,
	188	index[dev], id[dev], THIS_MODULE,
	189	sizeof(struct snd_card_azt2320), &card);
c95eadd2 TI	190	if (error < 0)
c95eadd2 TI	191	return error;
9fe856e4	192	acard = card->private_data;
1da177e4 LT	193
	194	if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) {
	195	snd_card_free(card);
	196	return error;
	197	}
1da177e4 LT	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
fa60c065	218	error = snd_wss_pcm(chip, 0);
7779f75f	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	}
fa60c065	228	error = snd_wss_timer(chip, 0);
7779f75f	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,
dba8b469	237	mpu_irq[dev], NULL) < 0)
1da177e4 LT	238	snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]);
	239	}
	240
	241	if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
	242	if (snd_opl3_create(card,
	243	fm_port[dev], fm_port[dev] + 2,
	244	OPL3_HW_AUTO, 0, &opl3) < 0) {
	245	snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n",
	246	fm_port[dev], fm_port[dev] + 2);
	247	} else {
	248	if ((error = snd_opl3_timer_new(opl3, 1, 2)) < 0) {
	249	snd_card_free(card);
	250	return error;
	251	}
	252	if ((error = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
	253	snd_card_free(card);
	254	return error;
	255	}
	256	}
	257	}
	258
	259	if ((error = snd_card_register(card)) < 0) {
	260	snd_card_free(card);
	261	return error;
	262	}
	263	pnp_set_card_drvdata(pcard, card);
	264	return 0;
	265	}
	266
1bff292e	267	static unsigned int azt2320_devices;
db2735eb	268
1bff292e BP	269	static int snd_azt2320_pnp_detect(struct pnp_card_link *card,
1bff292e BP	270	const struct pnp_card_device_id *id)
1da177e4 LT	271	{
	272	static int dev;
	273	int res;
	274
	275	for ( ; dev < SNDRV_CARDS; dev++) {
	276	if (!enable[dev])
	277	continue;
	278	res = snd_card_azt2320_probe(dev, card, id);
	279	if (res < 0)
	280	return res;
	281	dev++;
db2735eb	282	azt2320_devices++;
1da177e4 LT	283	return 0;
	284	}
	285	return -ENODEV;
	286	}
	287
1bff292e	288	static void snd_azt2320_pnp_remove(struct pnp_card_link *pcard)
1da177e4	289	{
b6cc25ca TI	290	snd_card_free(pnp_get_card_drvdata(pcard));
	291	pnp_set_card_drvdata(pcard, NULL);
	292	}
	293
	294	#ifdef CONFIG_PM
	295	static int snd_azt2320_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state)
	296	{
	297	struct snd_card *card = pnp_get_card_drvdata(pcard);
	298	struct snd_card_azt2320 *acard = card->private_data;
7779f75f	299	struct snd_wss *chip = acard->chip;
b6cc25ca TI	300
	301	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
	302	chip->suspend(chip);
	303	return 0;
	304	}
	305
	306	static int snd_azt2320_pnp_resume(struct pnp_card_link *pcard)
	307	{
	308	struct snd_card *card = pnp_get_card_drvdata(pcard);
	309	struct snd_card_azt2320 *acard = card->private_data;
7779f75f	310	struct snd_wss *chip = acard->chip;
1da177e4	311
b6cc25ca TI	312	chip->resume(chip);
	313	snd_power_change_state(card, SNDRV_CTL_POWER_D0);
	314	return 0;
1da177e4	315	}
b6cc25ca	316	#endif
1da177e4 LT	317
	318	static struct pnp_card_driver azt2320_pnpc_driver = {
	319	.flags = PNP_DRIVER_RES_DISABLE,
	320	.name = "azt2320",
	321	.id_table = snd_azt2320_pnpids,
	322	.probe = snd_azt2320_pnp_detect,
1bff292e	323	.remove = snd_azt2320_pnp_remove,
b6cc25ca TI	324	#ifdef CONFIG_PM
	325	.suspend = snd_azt2320_pnp_suspend,
	326	.resume = snd_azt2320_pnp_resume,
	327	#endif
1da177e4 LT	328	};
	329
	330	static int __init alsa_card_azt2320_init(void)
	331	{
db2735eb BH	332	int err;
	333
	334	err = pnp_register_card_driver(&azt2320_pnpc_driver);
	335	if (err)
	336	return err;
1da177e4	337
db2735eb	338	if (!azt2320_devices) {
1da177e4	339	pnp_unregister_card_driver(&azt2320_pnpc_driver);
b6cc25ca	340	#ifdef MODULE
1da177e4	341	snd_printk(KERN_ERR "no AZT2320 based soundcards found\n");
1da177e4	342	#endif
b6cc25ca TI	343	return -ENODEV;
	344	}
	345	return 0;
1da177e4 LT	346	}
	347
	348	static void __exit alsa_card_azt2320_exit(void)
	349	{
	350	pnp_unregister_card_driver(&azt2320_pnpc_driver);
	351	}
	352
	353	module_init(alsa_card_azt2320_init)
	354	module_exit(alsa_card_azt2320_exit)