Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5e24c1c1 authored by Takashi Iwai's avatar Takashi Iwai Committed by Jaroslav Kysela
Browse files

[ALSA] Port the rest of ALSA ISA drivers to isa_driver 



Port the rest of ALSA ISA drivers to use isa_driver framework
instead of platform_driver.

Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
Signed-off-by: default avatarJaroslav Kysela <perex@suse.cz>
parent 442f4f36

sound/isa/cmi8330.c

+41 −70
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ 
#include <sound/driver.h>

#include <linux/init.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/isa.h>

#include <linux/slab.h>

#include <linux/pnp.h>

#include <linux/moduleparam.h>
@@ -108,7 +108,6 @@ MODULE_PARM_DESC(wssirq, "IRQ # for CMI8330 WSS driver."); 
module_param_array(wssdma, int, NULL, 0444);

MODULE_PARM_DESC(wssdma, "DMA for CMI8330 WSS driver.");



static struct platform_device *platform_devices[SNDRV_CARDS];

#ifdef CONFIG_PNP

static int pnp_registered;

#endif
@@ -547,60 +546,70 @@ static int __devinit snd_cmi8330_probe(struct snd_card *card, int dev) 
	return snd_card_register(card);

}



static int __devinit snd_cmi8330_nonpnp_probe(struct platform_device *pdev)

static int __devinit snd_cmi8330_isa_match(struct device *pdev,

					   unsigned int dev)

{

	struct snd_card *card;

	int err;

	int dev = pdev->id;



	if (!enable[dev] || is_isapnp_selected(dev))

		return 0;

	if (wssport[dev] == SNDRV_AUTO_PORT) {

		snd_printk(KERN_ERR PFX "specify wssport\n");

		return -EINVAL;

		return 0;

	}

	if (sbport[dev] == SNDRV_AUTO_PORT) {

		snd_printk(KERN_ERR PFX "specify sbport\n");

		return -EINVAL;

		return 0;

	}

	return 1;

}



static int __devinit snd_cmi8330_isa_probe(struct device *pdev,

					   unsigned int dev)

{

	struct snd_card *card;

	int err;



	card = snd_cmi8330_card_new(dev);

	if (! card)

		return -ENOMEM;

	snd_card_set_dev(card, &pdev->dev);

	snd_card_set_dev(card, pdev);

	if ((err = snd_cmi8330_probe(card, dev)) < 0) {

		snd_card_free(card);

		return err;

	}

	platform_set_drvdata(pdev, card);

	dev_set_drvdata(pdev, card);

	return 0;

}



static int __devexit snd_cmi8330_nonpnp_remove(struct platform_device *devptr)

static int __devexit snd_cmi8330_isa_remove(struct device *devptr,

					    unsigned int dev)

{

	snd_card_free(platform_get_drvdata(devptr));

	platform_set_drvdata(devptr, NULL);

	snd_card_free(dev_get_drvdata(devptr));

	dev_set_drvdata(devptr, NULL);

	return 0;

}



#ifdef CONFIG_PM

static int snd_cmi8330_nonpnp_suspend(struct platform_device *dev, pm_message_t state)

static int snd_cmi8330_isa_suspend(struct device *dev, unsigned int n,

				   pm_message_t state)

{

	return snd_cmi8330_suspend(platform_get_drvdata(dev));

	return snd_cmi8330_suspend(dev_get_drvdata(dev));

}



static int snd_cmi8330_nonpnp_resume(struct platform_device *dev)

static int snd_cmi8330_isa_resume(struct device *dev, unsigned int n)

{

	return snd_cmi8330_resume(platform_get_drvdata(dev));

	return snd_cmi8330_resume(dev_get_drvdata(dev));

}

#endif



#define CMI8330_DRIVER	"snd_cmi8330"



static struct platform_driver snd_cmi8330_driver = {

	.probe		= snd_cmi8330_nonpnp_probe,

	.remove		= __devexit_p(snd_cmi8330_nonpnp_remove),

static struct isa_driver snd_cmi8330_driver = {

	.match		= snd_cmi8330_isa_match,

	.probe		= snd_cmi8330_isa_probe,

	.remove		= __devexit_p(snd_cmi8330_isa_remove),

#ifdef CONFIG_PM

	.suspend	= snd_cmi8330_nonpnp_suspend,

	.resume		= snd_cmi8330_nonpnp_resume,

	.suspend	= snd_cmi8330_isa_suspend,

	.resume		= snd_cmi8330_isa_resume,

#endif

	.driver		= {

		.name	= CMI8330_DRIVER
@@ -609,8 +618,6 @@ static struct platform_driver snd_cmi8330_driver = { 




#ifdef CONFIG_PNP

static unsigned int __devinitdata cmi8330_pnp_devices;



static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *pcard,

					    const struct pnp_card_device_id *pid)

{
@@ -640,7 +647,6 @@ static int __devinit snd_cmi8330_pnp_detect(struct pnp_card_link *pcard, 
	}

	pnp_set_card_drvdata(pcard, card);

	dev++;

	cmi8330_pnp_devices++;

	return 0;

}
@@ -675,63 +681,28 @@ static struct pnp_card_driver cmi8330_pnpc_driver = { 
};

#endif /* CONFIG_PNP */



static void __init_or_module snd_cmi8330_unregister_all(void)

{

	int i;



#ifdef CONFIG_PNP

	if (pnp_registered)

		pnp_unregister_card_driver(&cmi8330_pnpc_driver);

#endif

	for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)

		platform_device_unregister(platform_devices[i]);

	platform_driver_unregister(&snd_cmi8330_driver);

}



static int __init alsa_card_cmi8330_init(void)

{

	int i, err, cards = 0;

	int err;



	if ((err = platform_driver_register(&snd_cmi8330_driver)) < 0)

	err = isa_register_driver(&snd_cmi8330_driver, SNDRV_CARDS);

	if (err < 0)

		return err;



	for (i = 0; i < SNDRV_CARDS; i++) {

		struct platform_device *device;

		if (! enable[i] || is_isapnp_selected(i))

			continue;

		device = platform_device_register_simple(CMI8330_DRIVER,

							 i, NULL, 0);

		if (IS_ERR(device))

			continue;

		if (!platform_get_drvdata(device)) {

			platform_device_unregister(device);

			continue;

		}

		platform_devices[i] = device;

		cards++;

	}



#ifdef CONFIG_PNP

	err = pnp_register_card_driver(&cmi8330_pnpc_driver);

	if (!err) {

	if (!err)

		pnp_registered = 1;

		cards += cmi8330_pnp_devices;

	}

#endif



	if (!cards) {

#ifdef MODULE

		snd_printk(KERN_ERR "CMI8330 not found or device busy\n");

#endif

		snd_cmi8330_unregister_all();

		return -ENODEV;

	}

	return 0;

}



static void __exit alsa_card_cmi8330_exit(void)

{

	snd_cmi8330_unregister_all();

#ifdef CONFIG_PNP

	if (pnp_registered)

		pnp_unregister_card_driver(&cmi8330_pnpc_driver);

#endif

	isa_unregister_driver(&snd_cmi8330_driver);

}



module_init(alsa_card_cmi8330_init)

sound/isa/cs423x/cs4236.c

+54 −71
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ 
#include <sound/driver.h>

#include <linux/init.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/isa.h>

#include <linux/slab.h>

#include <linux/pnp.h>

#include <linux/moduleparam.h>
@@ -126,14 +126,12 @@ MODULE_PARM_DESC(dma1, "DMA1 # for " IDENT " driver."); 
module_param_array(dma2, int, NULL, 0444);

MODULE_PARM_DESC(dma2, "DMA2 # for " IDENT " driver.");



static struct platform_device *platform_devices[SNDRV_CARDS];

#ifdef CONFIG_PNP

static int pnpc_registered;

#ifdef CS4232

static int pnp_registered;

#endif

#endif /* CONFIG_PNP */

static unsigned int snd_cs423x_devices;



struct snd_card_cs4236 {

	struct snd_cs4231 *chip;
@@ -542,38 +540,55 @@ static int __devinit snd_cs423x_probe(struct snd_card *card, int dev) 
	return snd_card_register(card);

}



static int __init snd_cs423x_nonpnp_probe(struct platform_device *pdev)

static int __devinit snd_cs423x_isa_match(struct device *pdev,

					  unsigned int dev)

{

	int dev = pdev->id;

	struct snd_card *card;

	int err;

	if (!enable[dev] || is_isapnp_selected(dev))

		return 0;



	if (port[dev] == SNDRV_AUTO_PORT) {

		snd_printk(KERN_ERR "specify port\n");

		return -EINVAL;

		snd_printk(KERN_ERR "%s: please specify port\n", pdev->bus_id);

		return 0;

	}

	if (cport[dev] == SNDRV_AUTO_PORT) {

		snd_printk(KERN_ERR "specify cport\n");

		return -EINVAL;

		snd_printk(KERN_ERR "%s: please specify cport\n", pdev->bus_id);

		return 0;

	}

	if (irq[dev] == SNDRV_AUTO_IRQ) {

		snd_printk(KERN_ERR "%s: please specify irq\n", pdev->bus_id);

		return 0;

	}

	if (dma1[dev] == SNDRV_AUTO_DMA) {

		snd_printk(KERN_ERR "%s: please specify dma1\n", pdev->bus_id);

		return 0;

	}

	return 1;

}



static int __devinit snd_cs423x_isa_probe(struct device *pdev,

					  unsigned int dev)

{

	struct snd_card *card;

	int err;



	card = snd_cs423x_card_new(dev);

	if (! card)

		return -ENOMEM;

	snd_card_set_dev(card, &pdev->dev);

	snd_card_set_dev(card, pdev);

	if ((err = snd_cs423x_probe(card, dev)) < 0) {

		snd_card_free(card);

		return err;

	}



	platform_set_drvdata(pdev, card);

	dev_set_drvdata(pdev, card);

	return 0;

}



static int __devexit snd_cs423x_nonpnp_remove(struct platform_device *devptr)

static int __devexit snd_cs423x_isa_remove(struct device *pdev,

					   unsigned int dev)

{

	snd_card_free(platform_get_drvdata(devptr));

	platform_set_drvdata(devptr, NULL);

	snd_card_free(dev_get_drvdata(pdev));

	dev_set_drvdata(pdev, NULL);

	return 0;

}
@@ -594,23 +609,25 @@ static int snd_cs423x_resume(struct snd_card *card) 
	return 0;

}



static int snd_cs423x_nonpnp_suspend(struct platform_device *dev, pm_message_t state)

static int snd_cs423x_isa_suspend(struct device *dev, unsigned int n,

				  pm_message_t state)

{

	return snd_cs423x_suspend(platform_get_drvdata(dev));

	return snd_cs423x_suspend(dev_get_drvdata(dev));

}



static int snd_cs423x_nonpnp_resume(struct platform_device *dev)

static int snd_cs423x_isa_resume(struct device *dev, unsigned int n)

{

	return snd_cs423x_resume(platform_get_drvdata(dev));

	return snd_cs423x_resume(dev_get_drvdata(dev));

}

#endif



static struct platform_driver cs423x_nonpnp_driver = {

	.probe		= snd_cs423x_nonpnp_probe,

	.remove		= __devexit_p(snd_cs423x_nonpnp_remove),

static struct isa_driver cs423x_isa_driver = {

	.match		= snd_cs423x_isa_match,

	.probe		= snd_cs423x_isa_probe,

	.remove		= __devexit_p(snd_cs423x_isa_remove),

#ifdef CONFIG_PM

	.suspend	= snd_cs423x_nonpnp_suspend,

	.resume		= snd_cs423x_nonpnp_resume,

	.suspend	= snd_cs423x_isa_suspend,

	.resume		= snd_cs423x_isa_resume,

#endif

	.driver		= {

		.name	= CS423X_DRIVER
@@ -651,7 +668,6 @@ static int __devinit snd_cs4232_pnpbios_detect(struct pnp_dev *pdev, 
	}

	pnp_set_drvdata(pdev, card);

	dev++;

	snd_cs423x_devices++;

	return 0;

}
@@ -715,7 +731,6 @@ static int __devinit snd_cs423x_pnpc_detect(struct pnp_card_link *pcard, 
	}

	pnp_set_card_drvdata(pcard, card);

	dev++;

	snd_cs423x_devices++;

	return 0;

}
@@ -750,45 +765,13 @@ static struct pnp_card_driver cs423x_pnpc_driver = { 
};

#endif /* CONFIG_PNP */



static void __init_or_module snd_cs423x_unregister_all(void)

{

	int i;



#ifdef CONFIG_PNP

	if (pnpc_registered)

		pnp_unregister_card_driver(&cs423x_pnpc_driver);

#ifdef CS4232

	if (pnp_registered)

		pnp_unregister_driver(&cs4232_pnp_driver);

#endif

#endif /* CONFIG_PNP */

	for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)

		platform_device_unregister(platform_devices[i]);

	platform_driver_unregister(&cs423x_nonpnp_driver);

}



static int __init alsa_card_cs423x_init(void)

{

	int i, err;

	int err;



	if ((err = platform_driver_register(&cs423x_nonpnp_driver)) < 0)

	err = isa_register_driver(&cs423x_isa_driver, SNDRV_CARDS);

	if (err < 0)

		return err;



	for (i = 0; i < SNDRV_CARDS; i++) {

		struct platform_device *device;

		if (! enable[i] || is_isapnp_selected(i))

			continue;

		device = platform_device_register_simple(CS423X_DRIVER,

							 i, NULL, 0);

		if (IS_ERR(device))

			continue;

		if (!platform_get_drvdata(device)) {

			platform_device_unregister(device);

			continue;

		}

		platform_devices[i] = device;

		snd_cs423x_devices++;

	}

#ifdef CONFIG_PNP

#ifdef CS4232

	err = pnp_register_driver(&cs4232_pnp_driver);
@@ -799,20 +782,20 @@ static int __init alsa_card_cs423x_init(void) 
	if (!err)

		pnpc_registered = 1;

#endif /* CONFIG_PNP */



	if (!snd_cs423x_devices) {

#ifdef MODULE

		printk(KERN_ERR IDENT " soundcard not found or device busy\n");

#endif

		snd_cs423x_unregister_all();

		return -ENODEV;

	}

	return 0;

}



static void __exit alsa_card_cs423x_exit(void)

{

	snd_cs423x_unregister_all();

#ifdef CONFIG_PNP

	if (pnpc_registered)

		pnp_unregister_card_driver(&cs423x_pnpc_driver);

#ifdef CS4232

	if (pnp_registered)

		pnp_unregister_driver(&cs4232_pnp_driver);

#endif

#endif /* CONFIG_PNP */

	isa_unregister_driver(&cs423x_isa_driver);

}



module_init(alsa_card_cs423x_init)

sound/isa/es18xx.c

+37 −69
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ 
#include <sound/driver.h>

#include <linux/init.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/isa.h>

#include <linux/slab.h>

#include <linux/pnp.h>

#include <linux/isapnp.h>
@@ -2035,8 +2035,6 @@ MODULE_PARM_DESC(dma1, "DMA 1 # for ES18xx driver."); 
module_param_array(dma2, int, NULL, 0444);

MODULE_PARM_DESC(dma2, "DMA 2 # for ES18xx driver.");



static struct platform_device *platform_devices[SNDRV_CARDS];



#ifdef CONFIG_PNP

static int pnp_registered, pnpc_registered;
@@ -2237,7 +2235,12 @@ static int __devinit snd_audiodrive_probe(struct snd_card *card, int dev) 
	return snd_card_register(card);

}



static int __devinit snd_es18xx_nonpnp_probe1(int dev, struct platform_device *devptr)

static int __devinit snd_es18xx_isa_match(struct device *pdev, unsigned int dev)

{

	return enable[dev] && !is_isapnp_selected(dev);

}



static int __devinit snd_es18xx_isa_probe1(int dev, struct device *devptr)

{

	struct snd_card *card;

	int err;
@@ -2245,18 +2248,17 @@ static int __devinit snd_es18xx_nonpnp_probe1(int dev, struct platform_device *d 
	card = snd_es18xx_card_new(dev);

	if (! card)

		return -ENOMEM;

	snd_card_set_dev(card, &devptr->dev);

	snd_card_set_dev(card, devptr);

	if ((err = snd_audiodrive_probe(card, dev)) < 0) {

		snd_card_free(card);

		return err;

	}

	platform_set_drvdata(devptr, card);

	dev_set_drvdata(devptr, card);

	return 0;

}



static int __devinit snd_es18xx_nonpnp_probe(struct platform_device *pdev)

static int __devinit snd_es18xx_isa_probe(struct device *pdev, unsigned int dev)

{

	int dev = pdev->id;

	int err;

	static int possible_irqs[] = {5, 9, 10, 7, 11, 12, -1};

	static int possible_dmas[] = {1, 0, 3, 5, -1};
@@ -2281,13 +2283,13 @@ static int __devinit snd_es18xx_nonpnp_probe(struct platform_device *pdev) 
	}



	if (port[dev] != SNDRV_AUTO_PORT) {

		return snd_es18xx_nonpnp_probe1(dev, pdev);

		return snd_es18xx_isa_probe1(dev, pdev);

	} else {

		static unsigned long possible_ports[] = {0x220, 0x240, 0x260, 0x280};

		int i;

		for (i = 0; i < ARRAY_SIZE(possible_ports); i++) {

			port[dev] = possible_ports[i];

			err = snd_es18xx_nonpnp_probe1(dev, pdev);

			err = snd_es18xx_isa_probe1(dev, pdev);

			if (! err)

				return 0;

		}
@@ -2295,33 +2297,36 @@ static int __devinit snd_es18xx_nonpnp_probe(struct platform_device *pdev) 
	}

}



static int __devexit snd_es18xx_nonpnp_remove(struct platform_device *devptr)

static int __devexit snd_es18xx_isa_remove(struct device *devptr,

					   unsigned int dev)

{

	snd_card_free(platform_get_drvdata(devptr));

	platform_set_drvdata(devptr, NULL);

	snd_card_free(dev_get_drvdata(devptr));

	dev_set_drvdata(devptr, NULL);

	return 0;

}



#ifdef CONFIG_PM

static int snd_es18xx_nonpnp_suspend(struct platform_device *dev, pm_message_t state)

static int snd_es18xx_isa_suspend(struct device *dev, unsigned int n,

				  pm_message_t state)

{

	return snd_es18xx_suspend(platform_get_drvdata(dev), state);

	return snd_es18xx_suspend(dev_get_drvdata(dev), state);

}



static int snd_es18xx_nonpnp_resume(struct platform_device *dev)

static int snd_es18xx_isa_resume(struct device *dev, unsigned int n)

{

	return snd_es18xx_resume(platform_get_drvdata(dev));

	return snd_es18xx_resume(dev_get_drvdata(dev));

}

#endif



#define ES18XX_DRIVER	"snd_es18xx"



static struct platform_driver snd_es18xx_nonpnp_driver = {

	.probe		= snd_es18xx_nonpnp_probe,

	.remove		= __devexit_p(snd_es18xx_nonpnp_remove),

static struct isa_driver snd_es18xx_isa_driver = {

	.match		= snd_es18xx_isa_match,

	.probe		= snd_es18xx_isa_probe,

	.remove		= __devexit_p(snd_es18xx_isa_remove),

#ifdef CONFIG_PM

	.suspend	= snd_es18xx_nonpnp_suspend,

	.resume		= snd_es18xx_nonpnp_resume,

	.suspend	= snd_es18xx_isa_suspend,

	.resume		= snd_es18xx_isa_resume,

#endif

	.driver		= {

		.name	= ES18XX_DRIVER
@@ -2330,8 +2335,6 @@ static struct platform_driver snd_es18xx_nonpnp_driver = { 




#ifdef CONFIG_PNP

static unsigned int __devinitdata es18xx_pnp_devices;



static int __devinit snd_audiodrive_pnp_detect(struct pnp_dev *pdev,

					    const struct pnp_device_id *id)

{
@@ -2362,7 +2365,6 @@ static int __devinit snd_audiodrive_pnp_detect(struct pnp_dev *pdev, 
	}

	pnp_set_drvdata(pdev, card);

	dev++;

	es18xx_pnp_devices++;

	return 0;

}
@@ -2424,7 +2426,6 @@ static int __devinit snd_audiodrive_pnpc_detect(struct pnp_card_link *pcard, 


	pnp_set_card_drvdata(pcard, card);

	dev++;

	es18xx_pnp_devices++;

	return 0;

}
@@ -2460,44 +2461,14 @@ static struct pnp_card_driver es18xx_pnpc_driver = { 
};

#endif /* CONFIG_PNP */



static void __init_or_module snd_es18xx_unregister_all(void)

{

	int i;



#ifdef CONFIG_PNP

	if (pnpc_registered)

		pnp_unregister_card_driver(&es18xx_pnpc_driver);

	if (pnp_registered)

		pnp_unregister_driver(&es18xx_pnp_driver);

#endif

	for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)

		platform_device_unregister(platform_devices[i]);

	platform_driver_unregister(&snd_es18xx_nonpnp_driver);

}



static int __init alsa_card_es18xx_init(void)

{

	int i, err, cards = 0;

	int err;



	if ((err = platform_driver_register(&snd_es18xx_nonpnp_driver)) < 0)

	err = isa_register_driver(&snd_es18xx_isa_driver, SNDRV_CARDS);

	if (err < 0)

		return err;



	for (i = 0; i < SNDRV_CARDS; i++) {

		struct platform_device *device;

		if (! enable[i] || is_isapnp_selected(i))

			continue;

		device = platform_device_register_simple(ES18XX_DRIVER,

							 i, NULL, 0);

		if (IS_ERR(device))

	       		continue;

		if (!platform_get_drvdata(device)) {

			platform_device_unregister(device);

			continue;

		}

		platform_devices[i] = device;

		cards++;

	}



#ifdef CONFIG_PNP

	err = pnp_register_driver(&es18xx_pnp_driver);

	if (!err)
@@ -2505,22 +2476,19 @@ static int __init alsa_card_es18xx_init(void) 
	err = pnp_register_card_driver(&es18xx_pnpc_driver);

	if (!err)

		pnpc_registered = 1;

	cards += es18xx_pnp_devices;

#endif



	if(!cards) {

#ifdef MODULE

		snd_printk(KERN_ERR "ESS AudioDrive ES18xx soundcard not found or device busy\n");

#endif

		snd_es18xx_unregister_all();

		return -ENODEV;

	}

	return 0;

}



static void __exit alsa_card_es18xx_exit(void)

{

	snd_es18xx_unregister_all();

#ifdef CONFIG_PNP

	if (pnpc_registered)

		pnp_unregister_card_driver(&es18xx_pnpc_driver);

	if (pnp_registered)

		pnp_unregister_driver(&es18xx_pnp_driver);

#endif

	isa_unregister_driver(&snd_es18xx_isa_driver);

}



module_init(alsa_card_es18xx_init)

sound/isa/gus/gusmax.c

+16 −51
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ 
#include <sound/driver.h>

#include <linux/init.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/isa.h>

#include <linux/delay.h>

#include <linux/time.h>

#include <linux/moduleparam.h>
@@ -72,8 +72,6 @@ MODULE_PARM_DESC(channels, "Used GF1 channels for GUS MAX driver."); 
module_param_array(pcm_channels, int, NULL, 0444);

MODULE_PARM_DESC(pcm_channels, "Reserved PCM channels for GUS MAX driver.");



static struct platform_device *devices[SNDRV_CARDS];



struct snd_gusmax {

	int irq;

	struct snd_card *card;
@@ -205,9 +203,13 @@ static void snd_gusmax_free(struct snd_card *card) 
		free_irq(maxcard->irq, (void *)maxcard);

}



static int __devinit snd_gusmax_probe(struct platform_device *pdev)

static int __devinit snd_gusmax_match(struct device *pdev, unsigned int dev)

{

	return enable[dev];

}



static int __devinit snd_gusmax_probe(struct device *pdev, unsigned int dev)

{

	int dev = pdev->id;

	static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1};

	static int possible_dmas[] = {5, 6, 7, 1, 3, -1};

	int xirq, xdma1, xdma2, err;
@@ -333,7 +335,7 @@ static int __devinit snd_gusmax_probe(struct platform_device *pdev) 
	if (xdma2 >= 0)

		sprintf(card->longname + strlen(card->longname), "&%i", xdma2);



	snd_card_set_dev(card, &pdev->dev);

	snd_card_set_dev(card, pdev);



	if ((err = snd_card_register(card)) < 0)

		goto _err;
@@ -341,7 +343,7 @@ static int __devinit snd_gusmax_probe(struct platform_device *pdev) 
	maxcard->gus = gus;

	maxcard->cs4231 = cs4231;



	platform_set_drvdata(pdev, card);

	dev_set_drvdata(pdev, card);

	return 0;



 _err:
@@ -349,16 +351,17 @@ static int __devinit snd_gusmax_probe(struct platform_device *pdev) 
	return err;

}



static int __devexit snd_gusmax_remove(struct platform_device *devptr)

static int __devexit snd_gusmax_remove(struct device *devptr, unsigned int dev)

{

	snd_card_free(platform_get_drvdata(devptr));

	platform_set_drvdata(devptr, NULL);

	snd_card_free(dev_get_drvdata(devptr));

	dev_set_drvdata(devptr, NULL);

	return 0;

}



#define GUSMAX_DRIVER	"snd_gusmax"



static struct platform_driver snd_gusmax_driver = {

static struct isa_driver snd_gusmax_driver = {

	.match		= snd_gusmax_match,

	.probe		= snd_gusmax_probe,

	.remove		= __devexit_p(snd_gusmax_remove),

	/* FIXME: suspend/resume */
@@ -367,52 +370,14 @@ static struct platform_driver snd_gusmax_driver = { 
	},

};



static void __init_or_module snd_gusmax_unregister_all(void)

{

	int i;



	for (i = 0; i < ARRAY_SIZE(devices); ++i)

		platform_device_unregister(devices[i]);

	platform_driver_unregister(&snd_gusmax_driver);

}



static int __init alsa_card_gusmax_init(void)

{

	int i, cards, err;



	err = platform_driver_register(&snd_gusmax_driver);

	if (err < 0)

		return err;



	cards = 0;

	for (i = 0; i < SNDRV_CARDS; i++) {

		struct platform_device *device;

		if (! enable[i])

			continue;

		device = platform_device_register_simple(GUSMAX_DRIVER,

							 i, NULL, 0);

		if (IS_ERR(device))

			continue;

		if (!platform_get_drvdata(device)) {

			platform_device_unregister(device);

			continue;

		}

		devices[i] = device;

		cards++;

	}

	if (!cards) {

#ifdef MODULE

		printk(KERN_ERR "GUS MAX soundcard not found or device busy\n");

#endif

		snd_gusmax_unregister_all();

		return -ENODEV;

	}

	return 0;

	return isa_register_driver(&snd_gusmax_driver, SNDRV_CARDS);

}



static void __exit alsa_card_gusmax_exit(void)

{

	snd_gusmax_unregister_all();

	isa_unregister_driver(&snd_gusmax_driver);

}



module_init(alsa_card_gusmax_init)

sound/isa/gus/interwave.c

+37 −64
Original line number Diff line number Diff line
@@ -25,7 +25,7 @@ 
#include <sound/driver.h>

#include <linux/init.h>

#include <linux/err.h>

#include <linux/platform_device.h>

#include <linux/isa.h>

#include <linux/delay.h>

#include <linux/slab.h>

#include <linux/pnp.h>
@@ -115,9 +115,6 @@ MODULE_PARM_DESC(pcm_channels, "Reserved PCM channels for InterWave driver."); 
module_param_array(effect, int, NULL, 0444);

MODULE_PARM_DESC(effect, "Effects enable for InterWave driver.");



static struct platform_device *platform_devices[SNDRV_CARDS];

static int pnp_registered;



struct snd_interwave {

	int irq;

	struct snd_card *card;
@@ -138,6 +135,7 @@ struct snd_interwave { 




#ifdef CONFIG_PNP

static int pnp_registered;



static struct pnp_card_device_id snd_interwave_pnpids[] = {

#ifndef SNDRV_STB
@@ -793,7 +791,7 @@ static int __devinit snd_interwave_probe(struct snd_card *card, int dev) 
	return 0;

}



static int __devinit snd_interwave_nonpnp_probe1(int dev, struct platform_device *devptr)

static int __devinit snd_interwave_isa_probe1(int dev, struct device *devptr)

{

	struct snd_card *card;

	int err;
@@ -802,18 +800,30 @@ static int __devinit snd_interwave_nonpnp_probe1(int dev, struct platform_device 
	if (! card)

		return -ENOMEM;



	snd_card_set_dev(card, &devptr->dev);

	snd_card_set_dev(card, devptr);

	if ((err = snd_interwave_probe(card, dev)) < 0) {

		snd_card_free(card);

		return err;

	}

	platform_set_drvdata(devptr, card);

	dev_set_drvdata(devptr, card);

	return 0;

}



static int __devinit snd_interwave_nonpnp_probe(struct platform_device *pdev)

static int __devinit snd_interwave_isa_match(struct device *pdev,

					     unsigned int dev)

{

	if (!enable[dev])

		return 0;

#ifdef CONFIG_PNP

	if (isapnp[dev])

		return 0;

#endif

	return 1;

}



static int __devinit snd_interwave_isa_probe(struct device *pdev,

					     unsigned int dev)

{

	int dev = pdev->id;

	int err;

	static int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1};

	static int possible_dmas[] = {0, 1, 3, 5, 6, 7, -1};
@@ -838,13 +848,13 @@ static int __devinit snd_interwave_nonpnp_probe(struct platform_device *pdev) 
	}



	if (port[dev] != SNDRV_AUTO_PORT)

		return snd_interwave_nonpnp_probe1(dev, pdev);

		return snd_interwave_isa_probe1(dev, pdev);

	else {

		static long possible_ports[] = {0x210, 0x220, 0x230, 0x240, 0x250, 0x260};

		int i;

		for (i = 0; i < ARRAY_SIZE(possible_ports); i++) {

			port[dev] = possible_ports[i];

			err = snd_interwave_nonpnp_probe1(dev, pdev);

			err = snd_interwave_isa_probe1(dev, pdev);

			if (! err)

				return 0;

		}
@@ -852,16 +862,17 @@ static int __devinit snd_interwave_nonpnp_probe(struct platform_device *pdev) 
	}

}



static int __devexit snd_interwave_nonpnp_remove(struct platform_device *devptr)

static int __devexit snd_interwave_isa_remove(struct device *devptr, unsigned int dev)

{

	snd_card_free(platform_get_drvdata(devptr));

	platform_set_drvdata(devptr, NULL);

	snd_card_free(dev_get_drvdata(devptr));

	dev_set_drvdata(devptr, NULL);

	return 0;

}



static struct platform_driver snd_interwave_driver = {

	.probe		= snd_interwave_nonpnp_probe,

	.remove		= __devexit_p(snd_interwave_nonpnp_remove),

static struct isa_driver snd_interwave_driver = {

	.match		= snd_interwave_isa_match,

	.probe		= snd_interwave_isa_probe,

	.remove		= __devexit_p(snd_interwave_isa_remove),

	/* FIXME: suspend,resume */

	.driver		= {

		.name	= INTERWAVE_DRIVER
@@ -869,8 +880,6 @@ static struct platform_driver snd_interwave_driver = { 
};



#ifdef CONFIG_PNP

static unsigned int __devinitdata interwave_pnp_devices;



static int __devinit snd_interwave_pnp_detect(struct pnp_card_link *pcard,

					      const struct pnp_card_device_id *pid)

{
@@ -900,7 +909,6 @@ static int __devinit snd_interwave_pnp_detect(struct pnp_card_link *pcard, 
	}

	pnp_set_card_drvdata(pcard, card);

	dev++;

	interwave_pnp_devices++;

	return 0;

}
@@ -921,64 +929,29 @@ static struct pnp_card_driver interwave_pnpc_driver = { 


#endif /* CONFIG_PNP */



static void __init_or_module snd_interwave_unregister_all(void)

{

	int i;



	if (pnp_registered)

		pnp_unregister_card_driver(&interwave_pnpc_driver);

	for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)

		platform_device_unregister(platform_devices[i]);

	platform_driver_unregister(&snd_interwave_driver);

}



static int __init alsa_card_interwave_init(void)

{

	int i, err, cards = 0;

	int err;



	if ((err = platform_driver_register(&snd_interwave_driver)) < 0)

	err = isa_register_driver(&snd_interwave_driver, SNDRV_CARDS);

	if (err < 0)

		return err;



	for (i = 0; i < SNDRV_CARDS; i++) {

		struct platform_device *device;

		if (! enable[i])

			continue;

#ifdef CONFIG_PNP

		if (isapnp[i])

			continue;

#endif

		device = platform_device_register_simple(INTERWAVE_DRIVER,

							 i, NULL, 0);

		if (IS_ERR(device))

			continue;

		if (!platform_get_drvdata(device)) {

			platform_device_unregister(device);

			continue;

		}

		platform_devices[i] = device;

		cards++;

	}



	/* ISA PnP cards */

	err = pnp_register_card_driver(&interwave_pnpc_driver);

	if (!err) {

	if (!err)

		pnp_registered = 1;

		cards += interwave_pnp_devices;;

	}



	if (!cards) {

#ifdef MODULE

		printk(KERN_ERR "InterWave soundcard not found or device busy\n");

#endif

		snd_interwave_unregister_all();

		return -ENODEV;

	}

	return 0;

}



static void __exit alsa_card_interwave_exit(void)

{

	snd_interwave_unregister_all();

#ifdef CONFIG_PNP

	if (pnp_registered)

		pnp_unregister_card_driver(&interwave_pnpc_driver);

#endif

	isa_unregister_driver(&snd_interwave_driver);

}



module_init(alsa_card_interwave_init)