luck/tmp_suning_uos_patched
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

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

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@suse.cz>
This commit is contained in:
Takashi Iwai 2007-02-22 12:50:54 +01:00 committed by Jaroslav Kysela
parent 442f4f36be
commit 5e24c1c1c4
13 changed files with 483 additions and 837 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
sound/isa/cmi8330.c
View File

@ -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)

125
sound/isa/cs423x/cs4236.c
View File

@ -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)

106
sound/isa/es18xx.c
View File

@ -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)

67
sound/isa/gus/gusmax.c
View File

@ -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)

101
sound/isa/gus/interwave.c
View File

@ -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)

123
sound/isa/opl3sa2.c
View File

@ -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/interrupt.h>
#include <linux/pm.h>
#include <linux/slab.h>
@ -91,12 +91,10 @@ MODULE_PARM_DESC(dma2, "DMA2 # for OPL3-SA driver.");
module_param_array(opl3sa3_ymode, int, NULL, 0444);
MODULE_PARM_DESC(opl3sa3_ymode, "Speaker size selection for 3D Enhancement mode: Desktop/Large Notebook/Small Notebook/HiFi.");
static struct platform_device *platform_devices[SNDRV_CARDS];
#ifdef CONFIG_PNP
static int pnp_registered;
static int pnpc_registered;
#endif
static unsigned int snd_opl3sa2_devices;
/* control ports */
#define OPL3SA2_PM_CTRL 0x01
@ -783,7 +781,6 @@ static int __devinit snd_opl3sa2_pnp_detect(struct pnp_dev *pdev,
}
pnp_set_drvdata(pdev, card);
dev++;
snd_opl3sa2_devices++;
return 0;
}
@ -850,7 +847,6 @@ static int __devinit snd_opl3sa2_pnp_cdetect(struct pnp_card_link *pcard,
}
pnp_set_card_drvdata(pcard, card);
dev++;
snd_opl3sa2_devices++;
return 0;
}
@ -884,116 +880,95 @@ static struct pnp_card_driver opl3sa2_pnpc_driver = {
};
#endif /* CONFIG_PNP */
static int __devinit snd_opl3sa2_nonpnp_probe(struct platform_device *pdev)
static int __devinit snd_opl3sa2_isa_match(struct device *pdev,
unsigned int dev)
{
struct snd_card *card;
int err;
int dev = pdev->id;
if (!enable[dev])
return 0;
#ifdef CONFIG_PNP
if (isapnp[dev])
return 0;
#endif
if (port[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR PFX "specify port\n");
return -EINVAL;
return 0;
}
if (wss_port[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR PFX "specify wss_port\n");
return -EINVAL;
return 0;
}
if (fm_port[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR PFX "specify fm_port\n");
return -EINVAL;
return 0;
}
if (midi_port[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR PFX "specify midi_port\n");
return -EINVAL;
return 0;
}
return 1;
}
static int __devinit snd_opl3sa2_isa_probe(struct device *pdev,
unsigned int dev)
{
struct snd_card *card;
int err;
card = snd_opl3sa2_card_new(dev);
if (! card)
return -ENOMEM;
snd_card_set_dev(card, &pdev->dev);
snd_card_set_dev(card, pdev);
if ((err = snd_opl3sa2_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_opl3sa2_nonpnp_remove(struct platform_device *devptr)
static int __devexit snd_opl3sa2_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_opl3sa2_nonpnp_suspend(struct platform_device *dev, pm_message_t state)
static int snd_opl3sa2_isa_suspend(struct device *dev, unsigned int n,
pm_message_t state)
{
return snd_opl3sa2_suspend(platform_get_drvdata(dev), state);
return snd_opl3sa2_suspend(dev_get_drvdata(dev), state);
}
static int snd_opl3sa2_nonpnp_resume(struct platform_device *dev)
static int snd_opl3sa2_isa_resume(struct device *dev, unsigned int n)
{
return snd_opl3sa2_resume(platform_get_drvdata(dev));
return snd_opl3sa2_resume(dev_get_drvdata(dev));
}
#endif
#define OPL3SA2_DRIVER "snd_opl3sa2"
static struct platform_driver snd_opl3sa2_nonpnp_driver = {
.probe = snd_opl3sa2_nonpnp_probe,
.remove = __devexit( snd_opl3sa2_nonpnp_remove),
static struct isa_driver snd_opl3sa2_isa_driver = {
.match = snd_opl3sa2_isa_match,
.probe = snd_opl3sa2_isa_probe,
.remove = __devexit( snd_opl3sa2_isa_remove),
#ifdef CONFIG_PM
.suspend = snd_opl3sa2_nonpnp_suspend,
.resume = snd_opl3sa2_nonpnp_resume,
.suspend = snd_opl3sa2_isa_suspend,
.resume = snd_opl3sa2_isa_resume,
#endif
.driver = {
.name = OPL3SA2_DRIVER
},
};
static void __init_or_module snd_opl3sa2_unregister_all(void)
{
int i;
#ifdef CONFIG_PNP
if (pnpc_registered)
pnp_unregister_card_driver(&opl3sa2_pnpc_driver);
if (pnp_registered)
pnp_unregister_driver(&opl3sa2_pnp_driver);
#endif
for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)
platform_device_unregister(platform_devices[i]);
platform_driver_unregister(&snd_opl3sa2_nonpnp_driver);
}
static int __init alsa_card_opl3sa2_init(void)
{
int i, err;
int err;
if ((err = platform_driver_register(&snd_opl3sa2_nonpnp_driver)) < 0)
err = isa_register_driver(&snd_opl3sa2_isa_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(OPL3SA2_DRIVER,
i, NULL, 0);
if (IS_ERR(device))
continue;
if (!platform_get_drvdata(device)) {
platform_device_unregister(device);
continue;
}
platform_devices[i] = device;
snd_opl3sa2_devices++;
}
#ifdef CONFIG_PNP
err = pnp_register_driver(&opl3sa2_pnp_driver);
if (!err)
@ -1002,20 +977,18 @@ static int __init alsa_card_opl3sa2_init(void)
if (!err)
pnpc_registered = 1;
#endif
if (!snd_opl3sa2_devices) {
#ifdef MODULE
snd_printk(KERN_ERR "Yamaha OPL3-SA soundcard not found or device busy\n");
#endif
snd_opl3sa2_unregister_all();
return -ENODEV;
}
return 0;
}
static void __exit alsa_card_opl3sa2_exit(void)
{
snd_opl3sa2_unregister_all();
#ifdef CONFIG_PNP
if (pnpc_registered)
pnp_unregister_card_driver(&opl3sa2_pnpc_driver);
if (pnp_registered)
pnp_unregister_driver(&opl3sa2_pnp_driver);
#endif
isa_unregister_driver(&snd_opl3sa2_isa_driver);
}
module_init(alsa_card_opl3sa2_init)

74
sound/isa/opti9xx/miro.c
View File

@ -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/ioport.h>
@ -139,8 +139,6 @@ static void snd_miro_proc_init(struct snd_miro * miro);
#define DRIVER_NAME "snd-miro"
static struct platform_device *device;
static char * snd_opti9xx_names[] = {
"unkown",
"82C928", "82C929",
@ -558,7 +556,7 @@ static int snd_miro_put_double(struct snd_kcontrol *kcontrol,
return change;
}
static struct snd_kcontrol_new snd_miro_controls[] = {
static struct snd_kcontrol_new snd_miro_controls[] __devinitdata = {
MIRO_DOUBLE("Master Playback Volume", 0, ACI_GET_MASTER, ACI_SET_MASTER),
MIRO_DOUBLE("Mic Playback Volume", 1, ACI_GET_MIC, ACI_SET_MIC),
MIRO_DOUBLE("Line Playback Volume", 1, ACI_GET_LINE, ACI_SET_LINE),
@ -570,7 +568,7 @@ MIRO_DOUBLE("Aux Playback Volume", 2, ACI_GET_LINE2, ACI_SET_LINE2),
/* Equalizer with seven bands (only PCM20)
from -12dB up to +12dB on each band */
static struct snd_kcontrol_new snd_miro_eq_controls[] = {
static struct snd_kcontrol_new snd_miro_eq_controls[] __devinitdata = {
MIRO_DOUBLE("Tone Control - 28 Hz", 0, ACI_GET_EQ1, ACI_SET_EQ1),
MIRO_DOUBLE("Tone Control - 160 Hz", 0, ACI_GET_EQ2, ACI_SET_EQ2),
MIRO_DOUBLE("Tone Control - 400 Hz", 0, ACI_GET_EQ3, ACI_SET_EQ3),
@ -580,15 +578,15 @@ MIRO_DOUBLE("Tone Control - 6.3 kHz", 0, ACI_GET_EQ6, ACI_SET_EQ6),
MIRO_DOUBLE("Tone Control - 16 kHz", 0, ACI_GET_EQ7, ACI_SET_EQ7),
};
static struct snd_kcontrol_new snd_miro_radio_control[] = {
static struct snd_kcontrol_new snd_miro_radio_control[] __devinitdata = {
MIRO_DOUBLE("Radio Playback Volume", 0, ACI_GET_LINE1, ACI_SET_LINE1),
};
static struct snd_kcontrol_new snd_miro_line_control[] = {
static struct snd_kcontrol_new snd_miro_line_control[] __devinitdata = {
MIRO_DOUBLE("Line Playback Volume", 2, ACI_GET_LINE1, ACI_SET_LINE1),
};
static struct snd_kcontrol_new snd_miro_preamp_control[] = {
static struct snd_kcontrol_new snd_miro_preamp_control[] __devinitdata = {
{
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Mic Boost",
@ -598,7 +596,7 @@ static struct snd_kcontrol_new snd_miro_preamp_control[] = {
.put = snd_miro_put_preamp,
}};
static struct snd_kcontrol_new snd_miro_amp_control[] = {
static struct snd_kcontrol_new snd_miro_amp_control[] __devinitdata = {
{
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Line Boost",
@ -608,7 +606,7 @@ static struct snd_kcontrol_new snd_miro_amp_control[] = {
.put = snd_miro_put_amp,
}};
static struct snd_kcontrol_new snd_miro_capture_control[] = {
static struct snd_kcontrol_new snd_miro_capture_control[] __devinitdata = {
{
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PCM Capture Switch",
@ -618,7 +616,7 @@ static struct snd_kcontrol_new snd_miro_capture_control[] = {
.put = snd_miro_put_capture,
}};
static unsigned char aci_init_values[][2] __initdata = {
static unsigned char aci_init_values[][2] __devinitdata = {
{ ACI_SET_MUTE, 0x00 },
{ ACI_SET_POWERAMP, 0x00 },
{ ACI_SET_PREAMP, 0x00 },
@ -641,7 +639,7 @@ static unsigned char aci_init_values[][2] __initdata = {
{ ACI_SET_MASTER + 1, 0x20 },
};
static int __init snd_set_aci_init_values(struct snd_miro *miro)
static int __devinit snd_set_aci_init_values(struct snd_miro *miro)
{
int idx, error;
@ -751,7 +749,8 @@ static long snd_legacy_find_free_ioport(long *port_table, long size)
return -1;
}
static int __init snd_miro_init(struct snd_miro *chip, unsigned short hardware)
static int __devinit snd_miro_init(struct snd_miro *chip,
unsigned short hardware)
{
static int opti9xx_mc_size[] = {7, 7, 10, 10, 2, 2, 2};
@ -962,7 +961,7 @@ static void snd_miro_proc_read(struct snd_info_entry * entry,
snd_iprintf(buffer, " preamp : 0x%x\n", miro->aci_preamp);
}
static void __init snd_miro_proc_init(struct snd_miro * miro)
static void __devinit snd_miro_proc_init(struct snd_miro * miro)
{
struct snd_info_entry *entry;
@ -974,7 +973,7 @@ static void __init snd_miro_proc_init(struct snd_miro * miro)
* Init
*/
static int __init snd_miro_configure(struct snd_miro *chip)
static int __devinit snd_miro_configure(struct snd_miro *chip)
{
unsigned char wss_base_bits;
unsigned char irq_bits;
@ -1131,7 +1130,8 @@ static int __init snd_miro_configure(struct snd_miro *chip)
return 0;
}
static int __init snd_card_miro_detect(struct snd_card *card, struct snd_miro *chip)
static int __devinit snd_card_miro_detect(struct snd_card *card,
struct snd_miro *chip)
{
int i, err;
unsigned char value;
@ -1157,7 +1157,8 @@ static int __init snd_card_miro_detect(struct snd_card *card, struct snd_miro *c
return -ENODEV;
}
static int __init snd_card_miro_aci_detect(struct snd_card *card, struct snd_miro * miro)
static int __devinit snd_card_miro_aci_detect(struct snd_card *card,
struct snd_miro * miro)
{
unsigned char regval;
int i;
@ -1213,7 +1214,12 @@ static void snd_card_miro_free(struct snd_card *card)
release_and_free_resource(miro->res_mc_base);
}
static int __init snd_miro_probe(struct platform_device *devptr)
static int __devinit snd_miro_match(struct device *devptr, unsigned int n)
{
return 1;
}
static int __devinit snd_miro_probe(struct device *devptr, unsigned int n)
{
static long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1};
static long possible_mpu_ports[] = {0x330, 0x300, 0x310, 0x320, -1};
@ -1399,25 +1405,26 @@ static int __init snd_miro_probe(struct platform_device *devptr)
return error;
}
snd_card_set_dev(card, &devptr->dev);
snd_card_set_dev(card, devptr);
if ((error = snd_card_register(card))) {
snd_card_free(card);
return error;
}
platform_set_drvdata(devptr, card);
dev_set_drvdata(devptr, card);
return 0;
}
static int __devexit snd_miro_remove(struct platform_device *devptr)
static int __devexit snd_miro_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_miro_driver = {
static struct isa_driver snd_miro_driver = {
.match = snd_miro_match,
.probe = snd_miro_probe,
.remove = __devexit_p(snd_miro_remove),
/* FIXME: suspend/resume */
@ -1428,27 +1435,12 @@ static struct platform_driver snd_miro_driver = {
static int __init alsa_card_miro_init(void)
{
int error;
if ((error = platform_driver_register(&snd_miro_driver)) < 0)
return error;
device = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0);
if (! IS_ERR(device)) {
if (platform_get_drvdata(device))
return 0;
platform_device_unregister(device);
}
#ifdef MODULE
printk(KERN_ERR "no miro soundcard found\n");
#endif
platform_driver_unregister(&snd_miro_driver);
return PTR_ERR(device);
return isa_register_driver(&snd_miro_driver, 1);
}
static void __exit alsa_card_miro_exit(void)
{
platform_device_unregister(device);
platform_driver_unregister(&snd_miro_driver);
isa_unregister_driver(&snd_miro_driver);
}
module_init(alsa_card_miro_init)

94
sound/isa/opti9xx/opti92x-ad1848.c
View File

@ -26,7 +26,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>
@ -259,7 +259,6 @@ struct snd_opti9xx {
};
static int snd_opti9xx_pnp_is_probed;
static struct platform_device *snd_opti9xx_platform_device;
#ifdef CONFIG_PNP
@ -294,7 +293,7 @@ static char * snd_opti9xx_names[] = {
};
static long __init snd_legacy_find_free_ioport(long *port_table, long size)
static long __devinit snd_legacy_find_free_ioport(long *port_table, long size)
{
while (*port_table != -1) {
if (request_region(*port_table, size, "ALSA test")) {
@ -306,7 +305,8 @@ static long __init snd_legacy_find_free_ioport(long *port_table, long size)
return -1;
}
static int __init snd_opti9xx_init(struct snd_opti9xx *chip, unsigned short hardware)
static int __devinit snd_opti9xx_init(struct snd_opti9xx *chip,
unsigned short hardware)
{
static int opti9xx_mc_size[] = {7, 7, 10, 10, 2, 2, 2};
@ -451,7 +451,7 @@ static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg,
(snd_opti9xx_read(chip, reg) & ~(mask)) | ((value) & (mask)))
static int __init snd_opti9xx_configure(struct snd_opti9xx *chip)
static int __devinit snd_opti9xx_configure(struct snd_opti9xx *chip)
{
unsigned char wss_base_bits;
unsigned char irq_bits;
@ -1561,7 +1561,7 @@ static int snd_opti93x_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_
return change;
}
static struct snd_kcontrol_new snd_opti93x_controls[] = {
static struct snd_kcontrol_new snd_opti93x_controls[] __devinitdata = {
OPTi93X_DOUBLE("Master Playback Switch", 0, OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 7, 7, 1, 1),
OPTi93X_DOUBLE("Master Playback Volume", 0, OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 1, 1, 31, 1),
OPTi93X_DOUBLE("PCM Playback Switch", 0, OPTi93X_DAC_LEFT, OPTi93X_DAC_RIGHT, 7, 7, 1, 1),
@ -1622,7 +1622,8 @@ static int snd_opti93x_mixer(struct snd_opti93x *chip)
#endif /* OPTi93X */
static int __init snd_card_opti9xx_detect(struct snd_card *card, struct snd_opti9xx *chip)
static int __devinit snd_card_opti9xx_detect(struct snd_card *card,
struct snd_opti9xx *chip)
{
int i, err;
@ -1676,8 +1677,9 @@ static int __init snd_card_opti9xx_detect(struct snd_card *card, struct snd_opti
}
#ifdef CONFIG_PNP
static int __init snd_card_opti9xx_pnp(struct snd_opti9xx *chip, struct pnp_card_link *card,
const struct pnp_card_device_id *pid)
static int __devinit snd_card_opti9xx_pnp(struct snd_opti9xx *chip,
struct pnp_card_link *card,
const struct pnp_card_device_id *pid)
{
struct pnp_dev *pdev;
struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
@ -1778,7 +1780,7 @@ static void snd_card_opti9xx_free(struct snd_card *card)
release_and_free_resource(chip->res_mc_base);
}
static int __init snd_opti9xx_probe(struct snd_card *card)
static int __devinit snd_opti9xx_probe(struct snd_card *card)
{
static long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1};
int error;
@ -1924,7 +1926,18 @@ static struct snd_card *snd_opti9xx_card_new(void)
return card;
}
static int __init snd_opti9xx_nonpnp_probe(struct platform_device *devptr)
static int __devinit snd_opti9xx_isa_match(struct device *devptr,
unsigned int dev)
{
if (snd_opti9xx_pnp_is_probed)
return 0;
if (isapnp)
return 0;
return 1;
}
static int __devinit snd_opti9xx_isa_probe(struct device *devptr,
unsigned int dev)
{
struct snd_card *card;
int error;
@ -1940,9 +1953,6 @@ static int __init snd_opti9xx_nonpnp_probe(struct platform_device *devptr)
static int possible_dma2s[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}};
#endif /* CS4231 || OPTi93X */
if (snd_opti9xx_pnp_is_probed)
return -EBUSY;
if (mpu_port == SNDRV_AUTO_PORT) {
if ((mpu_port = snd_legacy_find_free_ioport(possible_mpu_ports, 2)) < 0) {
snd_printk(KERN_ERR "unable to find a free MPU401 port\n");
@ -1984,25 +1994,27 @@ static int __init snd_opti9xx_nonpnp_probe(struct platform_device *devptr)
snd_card_free(card);
return error;
}
snd_card_set_dev(card, &devptr->dev);
snd_card_set_dev(card, devptr);
if ((error = snd_opti9xx_probe(card)) < 0) {
snd_card_free(card);
return error;
}
platform_set_drvdata(devptr, card);
dev_set_drvdata(devptr, card);
return 0;
}
static int __devexit snd_opti9xx_nonpnp_remove(struct platform_device *devptr)
static int __devexit snd_opti9xx_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_opti9xx_driver = {
.probe = snd_opti9xx_nonpnp_probe,
.remove = __devexit_p(snd_opti9xx_nonpnp_remove),
static struct isa_driver snd_opti9xx_driver = {
.match = snd_opti9xx_isa_match,
.probe = snd_opti9xx_isa_probe,
.remove = __devexit_p(snd_opti9xx_isa_remove),
/* FIXME: suspend/resume */
.driver = {
.name = DRIVER_NAME
@ -2010,8 +2022,8 @@ static struct platform_driver snd_opti9xx_driver = {
};
#ifdef CONFIG_PNP
static int __init snd_opti9xx_pnp_probe(struct pnp_card_link *pcard,
const struct pnp_card_device_id *pid)
static int __devinit snd_opti9xx_pnp_probe(struct pnp_card_link *pcard,
const struct pnp_card_device_id *pid)
{
struct snd_card *card;
int error, hw;
@ -2074,11 +2086,6 @@ static struct pnp_card_driver opti9xx_pnpc_driver = {
};
#endif
#ifdef CONFIG_PNP
#define is_isapnp_selected() isapnp
#else
#define is_isapnp_selected() 0
#endif
#ifdef OPTi93X
#define CHIP_NAME "82C93x"
#else
@ -2087,42 +2094,19 @@ static struct pnp_card_driver opti9xx_pnpc_driver = {
static int __init alsa_card_opti9xx_init(void)
{
int error;
struct platform_device *device;
#ifdef CONFIG_PNP
pnp_register_card_driver(&opti9xx_pnpc_driver);
if (snd_opti9xx_pnp_is_probed)
return 0;
#endif
if (! is_isapnp_selected()) {
error = platform_driver_register(&snd_opti9xx_driver);
if (error < 0)
return error;
device = platform_device_register_simple(DRIVER_NAME, -1, NULL, 0);
if (!IS_ERR(device)) {
if (platform_get_drvdata(device)) {
snd_opti9xx_platform_device = device;
return 0;
}
platform_device_unregister(device);
}
platform_driver_unregister(&snd_opti9xx_driver);
}
#ifdef CONFIG_PNP
pnp_unregister_card_driver(&opti9xx_pnpc_driver);
#endif
#ifdef MODULE
printk(KERN_ERR "no OPTi " CHIP_NAME " soundcard found\n");
#endif
return -ENODEV;
return isa_register_driver(&snd_opti9xx_driver, 1);
}
static void __exit alsa_card_opti9xx_exit(void)
{
if (!snd_opti9xx_pnp_is_probed) {
platform_device_unregister(snd_opti9xx_platform_device);
platform_driver_unregister(&snd_opti9xx_driver);
isa_unregister_driver(&snd_opti9xx_driver);
return;
}
#ifdef CONFIG_PNP
pnp_unregister_card_driver(&opti9xx_pnpc_driver);

107
sound/isa/sb/sb16.c
View File

@ -25,7 +25,7 @@
#include <linux/slab.h>
#include <linux/pnp.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/isa.h>
#include <linux/moduleparam.h>
#include <sound/core.h>
#include <sound/sb.h>
@ -128,7 +128,6 @@ module_param_array(seq_ports, int, NULL, 0444);
MODULE_PARM_DESC(seq_ports, "Number of sequencer ports for WaveTable synth.");
#endif
static struct platform_device *platform_devices[SNDRV_CARDS];
#ifdef CONFIG_PNP
static int pnp_registered;
#endif
@ -519,7 +518,7 @@ static int snd_sb16_resume(struct snd_card *card)
}
#endif
static int __devinit snd_sb16_nonpnp_probe1(int dev, struct platform_device *devptr)
static int __devinit snd_sb16_isa_probe1(int dev, struct device *pdev)
{
struct snd_card_sb16 *acard;
struct snd_card *card;
@ -539,19 +538,23 @@ static int __devinit snd_sb16_nonpnp_probe1(int dev, struct platform_device *dev
awe_port[dev] = port[dev] + 0x400;
#endif
snd_card_set_dev(card, &devptr->dev);
snd_card_set_dev(card, pdev);
if ((err = snd_sb16_probe(card, dev)) < 0) {
snd_card_free(card);
return err;
}
platform_set_drvdata(devptr, card);
dev_set_drvdata(pdev, card);
return 0;
}
static int __devinit snd_sb16_nonpnp_probe(struct platform_device *pdev)
static int __devinit snd_sb16_isa_match(struct device *pdev, unsigned int dev)
{
return enable[dev] && !is_isapnp_selected(dev);
}
static int __devinit snd_sb16_isa_probe(struct device *pdev, unsigned int dev)
{
int dev = pdev->id;
int err;
static int possible_irqs[] = {5, 9, 10, 7, -1};
static int possible_dmas8[] = {1, 3, 0, -1};
@ -577,13 +580,13 @@ static int __devinit snd_sb16_nonpnp_probe(struct platform_device *pdev)
}
if (port[dev] != SNDRV_AUTO_PORT)
return snd_sb16_nonpnp_probe1(dev, pdev);
return snd_sb16_isa_probe1(dev, pdev);
else {
static int possible_ports[] = {0x220, 0x240, 0x260, 0x280};
int i;
for (i = 0; i < ARRAY_SIZE(possible_ports); i++) {
port[dev] = possible_ports[i];
err = snd_sb16_nonpnp_probe1(dev, pdev);
err = snd_sb16_isa_probe1(dev, pdev);
if (! err)
return 0;
}
@ -591,22 +594,23 @@ static int __devinit snd_sb16_nonpnp_probe(struct platform_device *pdev)
}
}
static int __devexit snd_sb16_nonpnp_remove(struct platform_device *devptr)
static int __devexit snd_sb16_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;
}
#ifdef CONFIG_PM
static int snd_sb16_nonpnp_suspend(struct platform_device *dev, pm_message_t state)
static int snd_sb16_isa_suspend(struct device *dev, unsigned int n,
pm_message_t state)
{
return snd_sb16_suspend(platform_get_drvdata(dev), state);
return snd_sb16_suspend(dev_get_drvdata(dev), state);
}
static int snd_sb16_nonpnp_resume(struct platform_device *dev)
static int snd_sb16_isa_resume(struct device *dev, unsigned int n)
{
return snd_sb16_resume(platform_get_drvdata(dev));
return snd_sb16_resume(dev_get_drvdata(dev));
}
#endif
@ -616,12 +620,13 @@ static int snd_sb16_nonpnp_resume(struct platform_device *dev)
#define SND_SB16_DRIVER "snd_sb16"
#endif
static struct platform_driver snd_sb16_nonpnp_driver = {
.probe = snd_sb16_nonpnp_probe,
.remove = __devexit_p(snd_sb16_nonpnp_remove),
static struct isa_driver snd_sb16_isa_driver = {
.match = snd_sb16_isa_match,
.probe = snd_sb16_isa_probe,
.remove = __devexit_p(snd_sb16_isa_remove),
#ifdef CONFIG_PM
.suspend = snd_sb16_nonpnp_suspend,
.resume = snd_sb16_nonpnp_resume,
.suspend = snd_sb16_isa_suspend,
.resume = snd_sb16_isa_resume,
#endif
.driver = {
.name = SND_SB16_DRIVER
@ -630,8 +635,6 @@ static struct platform_driver snd_sb16_nonpnp_driver = {
#ifdef CONFIG_PNP
static unsigned int __devinitdata sb16_pnp_devices;
static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *pcard,
const struct pnp_card_device_id *pid)
{
@ -653,7 +656,6 @@ static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *pcard,
}
pnp_set_card_drvdata(pcard, card);
dev++;
sb16_pnp_devices++;
return 0;
}
@ -695,68 +697,29 @@ static struct pnp_card_driver sb16_pnpc_driver = {
#endif /* CONFIG_PNP */
static void __init_or_module snd_sb16_unregister_all(void)
{
int i;
#ifdef CONFIG_PNP
if (pnp_registered)
pnp_unregister_card_driver(&sb16_pnpc_driver);
#endif
for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)
platform_device_unregister(platform_devices[i]);
platform_driver_unregister(&snd_sb16_nonpnp_driver);
}
static int __init alsa_card_sb16_init(void)
{
int i, err, cards = 0;
int err;
if ((err = platform_driver_register(&snd_sb16_nonpnp_driver)) < 0)
err = isa_register_driver(&snd_sb16_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(SND_SB16_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
/* PnP cards at last */
err = pnp_register_card_driver(&sb16_pnpc_driver);
if (!err) {
if (!err)
pnp_registered = 1;
cards += sb16_pnp_devices;
}
#endif
if (!cards) {
#ifdef MODULE
snd_printk(KERN_ERR "Sound Blaster 16 soundcard not found or device busy\n");
#ifdef SNDRV_SBAWE_EMU8000
snd_printk(KERN_ERR "In case, if you have non-AWE card, try snd-sb16 module\n");
#else
snd_printk(KERN_ERR "In case, if you have AWE card, try snd-sbawe module\n");
#endif
#endif
snd_sb16_unregister_all();
return -ENODEV;
}
return 0;
}
static void __exit alsa_card_sb16_exit(void)
{
snd_sb16_unregister_all();
#ifdef CONFIG_PNP
if (pnp_registered)
pnp_unregister_card_driver(&sb16_pnpc_driver);
#endif
isa_unregister_driver(&snd_sb16_isa_driver);
}
module_init(alsa_card_sb16_init)

86
sound/isa/sb/sb8.c
View File

@ -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/ioport.h>
#include <linux/moduleparam.h>
@ -56,8 +56,6 @@ MODULE_PARM_DESC(irq, "IRQ # for SB8 driver.");
module_param_array(dma8, int, NULL, 0444);
MODULE_PARM_DESC(dma8, "8-bit DMA # for SB8 driver.");
static struct platform_device *devices[SNDRV_CARDS];
struct snd_sb8 {
struct resource *fm_res; /* used to block FM i/o region for legacy cards */
struct snd_sb *chip;
@ -83,9 +81,23 @@ static void snd_sb8_free(struct snd_card *card)
release_and_free_resource(acard->fm_res);
}
static int __devinit snd_sb8_probe(struct platform_device *pdev)
static int __devinit snd_sb8_match(struct device *pdev, unsigned int dev)
{
if (!enable[dev])
return 0;
if (irq[dev] == SNDRV_AUTO_IRQ) {
snd_printk(KERN_ERR "%s: please specify irq\n", pdev->bus_id);
return 0;
}
if (dma8[dev] == SNDRV_AUTO_DMA) {
snd_printk(KERN_ERR "%s: please specify dma8\n", pdev->bus_id);
return 0;
}
return 1;
}
static int __devinit snd_sb8_probe(struct device *pdev, unsigned int dev)
{
int dev = pdev->id;
struct snd_sb *chip;
struct snd_card *card;
struct snd_sb8 *acard;
@ -180,12 +192,12 @@ static int __devinit snd_sb8_probe(struct platform_device *pdev)
chip->port,
irq[dev], dma8[dev]);
snd_card_set_dev(card, &pdev->dev);
snd_card_set_dev(card, pdev);
if ((err = snd_card_register(card)) < 0)
goto _err;
platform_set_drvdata(pdev, card);
dev_set_drvdata(pdev, card);
return 0;
_err:
@ -193,17 +205,18 @@ static int __devinit snd_sb8_probe(struct platform_device *pdev)
return err;
}
static int __devexit snd_sb8_remove(struct platform_device *pdev)
static int __devexit snd_sb8_remove(struct device *pdev, unsigned int dev)
{
snd_card_free(platform_get_drvdata(pdev));
platform_set_drvdata(pdev, NULL);
snd_card_free(dev_get_drvdata(pdev));
dev_set_drvdata(pdev, NULL);
return 0;
}
#ifdef CONFIG_PM
static int snd_sb8_suspend(struct platform_device *dev, pm_message_t state)
static int snd_sb8_suspend(struct device *dev, unsigned int n,
pm_message_t state)
{
struct snd_card *card = platform_get_drvdata(dev);
struct snd_card *card = dev_get_drvdata(dev);
struct snd_sb8 *acard = card->private_data;
struct snd_sb *chip = acard->chip;
@ -213,9 +226,9 @@ static int snd_sb8_suspend(struct platform_device *dev, pm_message_t state)
return 0;
}
static int snd_sb8_resume(struct platform_device *dev)
static int snd_sb8_resume(struct device *dev, unsigned int n)
{
struct snd_card *card = platform_get_drvdata(dev);
struct snd_card *card = dev_get_drvdata(dev);
struct snd_sb8 *acard = card->private_data;
struct snd_sb *chip = acard->chip;
@ -228,7 +241,8 @@ static int snd_sb8_resume(struct platform_device *dev)
#define SND_SB8_DRIVER "snd_sb8"
static struct platform_driver snd_sb8_driver = {
static struct isa_driver snd_sb8_driver = {
.match = snd_sb8_match,
.probe = snd_sb8_probe,
.remove = __devexit_p(snd_sb8_remove),
#ifdef CONFIG_PM
@ -240,52 +254,14 @@ static struct platform_driver snd_sb8_driver = {
},
};
static void __init_or_module snd_sb8_unregister_all(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(devices); ++i)
platform_device_unregister(devices[i]);
platform_driver_unregister(&snd_sb8_driver);
}
static int __init alsa_card_sb8_init(void)
{
int i, cards, err;
err = platform_driver_register(&snd_sb8_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(SND_SB8_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
snd_printk(KERN_ERR "Sound Blaster soundcard not found or device busy\n");
#endif
snd_sb8_unregister_all();
return -ENODEV;
}
return 0;
return isa_register_driver(&snd_sb8_driver, SNDRV_CARDS);
}
static void __exit alsa_card_sb8_exit(void)
{
snd_sb8_unregister_all();
isa_unregister_driver(&snd_sb8_driver);
}
module_init(alsa_card_sb8_init)

103
sound/isa/sgalaxy.c
View File

@ -24,7 +24,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/interrupt.h>
@ -64,8 +64,6 @@ MODULE_PARM_DESC(irq, "IRQ # for Sound Galaxy driver.");
module_param_array(dma1, int, NULL, 0444);
MODULE_PARM_DESC(dma1, "DMA1 # for Sound Galaxy driver.");
static struct platform_device *devices[SNDRV_CARDS];
#define SGALAXY_AUXC_LEFT 18
#define SGALAXY_AUXC_RIGHT 19
@ -96,7 +94,8 @@ static int snd_sgalaxy_sbdsp_reset(unsigned long port)
return 0;
}
static int __init snd_sgalaxy_sbdsp_command(unsigned long port, unsigned char val)
static int __devinit snd_sgalaxy_sbdsp_command(unsigned long port,
unsigned char val)
{
int i;
@ -114,7 +113,7 @@ static irqreturn_t snd_sgalaxy_dummy_interrupt(int irq, void *dev_id)
return IRQ_NONE;
}
static int __init snd_sgalaxy_setup_wss(unsigned long port, int irq, int dma)
static int __devinit snd_sgalaxy_setup_wss(unsigned long port, int irq, int dma)
{
static int interrupt_bits[] = {-1, -1, -1, -1, -1, -1, -1, 0x08, -1,
0x10, 0x18, 0x20, -1, -1, -1, -1};
@ -161,7 +160,7 @@ static int __init snd_sgalaxy_setup_wss(unsigned long port, int irq, int dma)
return 0;
}
static int __init snd_sgalaxy_detect(int dev, int irq, int dma)
static int __devinit snd_sgalaxy_detect(int dev, int irq, int dma)
{
#if 0
snd_printdd(PFX "switching to WSS mode\n");
@ -182,7 +181,7 @@ AD1848_DOUBLE("Aux Playback Switch", 0, SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 7
AD1848_DOUBLE("Aux Playback Volume", 0, SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 0, 0, 31, 0)
};
static int __init snd_sgalaxy_mixer(struct snd_ad1848 *chip)
static int __devinit snd_sgalaxy_mixer(struct snd_ad1848 *chip)
{
struct snd_card *card = chip->card;
struct snd_ctl_elem_id id1, id2;
@ -218,23 +217,29 @@ static int __init snd_sgalaxy_mixer(struct snd_ad1848 *chip)
return 0;
}
static int __init snd_sgalaxy_probe(struct platform_device *devptr)
static int __devinit snd_sgalaxy_match(struct device *devptr, unsigned int dev)
{
if (!enable[dev])
return 0;
if (sbport[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR PFX "specify SB port\n");
return 0;
}
if (wssport[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR PFX "specify WSS port\n");
return 0;
}
return 1;
}
static int __devinit snd_sgalaxy_probe(struct device *devptr, unsigned int dev)
{
int dev = devptr->id;
static int possible_irqs[] = {7, 9, 10, 11, -1};
static int possible_dmas[] = {1, 3, 0, -1};
int err, xirq, xdma1;
struct snd_card *card;
struct snd_ad1848 *chip;
if (sbport[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR PFX "specify SB port\n");
return -EINVAL;
}
if (wssport[dev] == SNDRV_AUTO_PORT) {
snd_printk(KERN_ERR PFX "specify WSS port\n");
return -EINVAL;
}
card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
if (card == NULL)
return -ENOMEM;
@ -283,12 +288,12 @@ static int __init snd_sgalaxy_probe(struct platform_device *devptr)
sprintf(card->longname, "Sound Galaxy at 0x%lx, irq %d, dma %d",
wssport[dev], xirq, xdma1);
snd_card_set_dev(card, &devptr->dev);
snd_card_set_dev(card, devptr);
if ((err = snd_card_register(card)) < 0)
goto _err;
platform_set_drvdata(devptr, card);
dev_set_drvdata(devptr, card);
return 0;
_err:
@ -296,17 +301,18 @@ static int __init snd_sgalaxy_probe(struct platform_device *devptr)
return err;
}
static int __devexit snd_sgalaxy_remove(struct platform_device *devptr)
static int __devexit snd_sgalaxy_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_sgalaxy_suspend(struct platform_device *pdev, pm_message_t state)
static int snd_sgalaxy_suspend(struct device *pdev, unsigned int n,
pm_message_t state)
{
struct snd_card *card = platform_get_drvdata(pdev);
struct snd_card *card = dev_get_drvdata(pdev);
struct snd_ad1848 *chip = card->private_data;
snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
@ -314,9 +320,9 @@ static int snd_sgalaxy_suspend(struct platform_device *pdev, pm_message_t state)
return 0;
}
static int snd_sgalaxy_resume(struct platform_device *pdev)
static int snd_sgalaxy_resume(struct device *pdev, unsigned int n)
{
struct snd_card *card = platform_get_drvdata(pdev);
struct snd_card *card = dev_get_drvdata(pdev);
struct snd_ad1848 *chip = card->private_data;
chip->resume(chip);
@ -330,7 +336,8 @@ static int snd_sgalaxy_resume(struct platform_device *pdev)
#define SND_SGALAXY_DRIVER "snd_sgalaxy"
static struct platform_driver snd_sgalaxy_driver = {
static struct isa_driver snd_sgalaxy_driver = {
.match = snd_sgalaxy_match,
.probe = snd_sgalaxy_probe,
.remove = __devexit_p(snd_sgalaxy_remove),
#ifdef CONFIG_PM
@ -342,52 +349,14 @@ static struct platform_driver snd_sgalaxy_driver = {
},
};
static void __init_or_module snd_sgalaxy_unregister_all(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(devices); ++i)
platform_device_unregister(devices[i]);
platform_driver_unregister(&snd_sgalaxy_driver);
}
static int __init alsa_card_sgalaxy_init(void)
{
int i, cards, err;
err = platform_driver_register(&snd_sgalaxy_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(SND_SGALAXY_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
snd_printk(KERN_ERR "Sound Galaxy soundcard not found or device busy\n");
#endif
snd_sgalaxy_unregister_all();
return -ENODEV;
}
return 0;
return isa_register_driver(&snd_sgalaxy_driver, SNDRV_CARDS);
}
static void __exit alsa_card_sgalaxy_exit(void)
{
snd_sgalaxy_unregister_all();
isa_unregister_driver(&snd_sgalaxy_driver);
}
module_init(alsa_card_sgalaxy_init)

116
sound/isa/sscape.c
View File

@ -24,7 +24,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/pnp.h>
#include <linux/spinlock.h>
@ -68,8 +68,6 @@ MODULE_PARM_DESC(mpu_irq, "MPU401 IRQ # for SoundScape driver.");
module_param_array(dma, int, NULL, 0444);
MODULE_PARM_DESC(dma, "DMA # for SoundScape driver.");
static struct platform_device *platform_devices[SNDRV_CARDS];
#ifdef CONFIG_PNP
static int pnp_registered;
static struct pnp_card_device_id sscape_pnpids[] = {
@ -1254,9 +1252,27 @@ static int __devinit create_sscape(int dev, struct snd_card **rcardp)
}
static int __devinit snd_sscape_probe(struct platform_device *pdev)
static int __devinit snd_sscape_match(struct device *pdev, unsigned int i)
{
/*
* Make sure we were given ALL of the other parameters.
*/
if (port[i] == SNDRV_AUTO_PORT)
return 0;
if (irq[i] == SNDRV_AUTO_IRQ ||
mpu_irq[i] == SNDRV_AUTO_IRQ ||
dma[i] == SNDRV_AUTO_DMA) {
printk(KERN_INFO
"sscape: insufficient parameters, need IO, IRQ, MPU-IRQ and DMA\n");
return 0;
}
return 1;
}
static int __devinit snd_sscape_probe(struct device *pdev, unsigned int dev)
{
int dev = pdev->id;
struct snd_card *card;
int ret;
@ -1264,25 +1280,26 @@ static int __devinit snd_sscape_probe(struct platform_device *pdev)
ret = create_sscape(dev, &card);
if (ret < 0)
return ret;
snd_card_set_dev(card, &pdev->dev);
snd_card_set_dev(card, pdev);
if ((ret = snd_card_register(card)) < 0) {
printk(KERN_ERR "sscape: Failed to register sound card\n");
return ret;
}
platform_set_drvdata(pdev, card);
dev_set_drvdata(pdev, card);
return 0;
}
static int __devexit snd_sscape_remove(struct platform_device *devptr)
static int __devexit snd_sscape_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 SSCAPE_DRIVER "snd_sscape"
static struct platform_driver snd_sscape_driver = {
static struct isa_driver snd_sscape_driver = {
.match = snd_sscape_match,
.probe = snd_sscape_probe,
.remove = __devexit_p(snd_sscape_remove),
/* FIXME: suspend/resume */
@ -1386,72 +1403,6 @@ static struct pnp_card_driver sscape_pnpc_driver = {
#endif /* CONFIG_PNP */
static void __init_or_module sscape_unregister_all(void)
{
int i;
#ifdef CONFIG_PNP
if (pnp_registered)
pnp_unregister_card_driver(&sscape_pnpc_driver);
#endif
for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)
platform_device_unregister(platform_devices[i]);
platform_driver_unregister(&snd_sscape_driver);
}
static int __init sscape_manual_probe(void)
{
struct platform_device *device;
int i, ret;
ret = platform_driver_register(&snd_sscape_driver);
if (ret < 0)
return ret;
for (i = 0; i < SNDRV_CARDS; ++i) {
/*
* We do NOT probe for ports.
* If we're not given a port number for this
* card then we completely ignore this line
* of parameters.
*/
if (port[i] == SNDRV_AUTO_PORT)
continue;
/*
* Make sure we were given ALL of the other parameters.
*/
if (irq[i] == SNDRV_AUTO_IRQ ||
mpu_irq[i] == SNDRV_AUTO_IRQ ||
dma[i] == SNDRV_AUTO_DMA) {
printk(KERN_INFO
"sscape: insufficient parameters, need IO, IRQ, MPU-IRQ and DMA\n");
sscape_unregister_all();
return -ENXIO;
}
/*
* This cards looks OK ...
*/
device = platform_device_register_simple(SSCAPE_DRIVER,
i, NULL, 0);
if (IS_ERR(device))
continue;
if (!platform_get_drvdata(device)) {
platform_device_unregister(device);
continue;
}
platform_devices[i] = device;
}
return 0;
}
static void sscape_exit(void)
{
sscape_unregister_all();
}
static int __init sscape_init(void)
{
int ret;
@ -1462,7 +1413,7 @@ static int __init sscape_init(void)
* of allocating cards, because the operator is
* S-P-E-L-L-I-N-G it out for us...
*/
ret = sscape_manual_probe();
ret = isa_register_driver(&snd_sscape_driver, SNDRV_CARDS);
if (ret < 0)
return ret;
#ifdef CONFIG_PNP
@ -1472,5 +1423,14 @@ static int __init sscape_init(void)
return 0;
}
static void __exit sscape_exit(void)
{
#ifdef CONFIG_PNP
if (pnp_registered)
pnp_unregister_card_driver(&sscape_pnpc_driver);
#endif
isa_unregister_driver(&snd_sscape_driver);
}
module_init(sscape_init);
module_exit(sscape_exit);

107
sound/isa/wavefront/wavefront.c
View File

@ -24,7 +24,7 @@
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/isa.h>
#include <linux/pnp.h>
#include <linux/moduleparam.h>
#include <sound/core.h>
@ -83,8 +83,6 @@ MODULE_PARM_DESC(fm_port, "FM port #.");
module_param_array(use_cs4232_midi, bool, NULL, 0444);
MODULE_PARM_DESC(use_cs4232_midi, "Use CS4232 MPU-401 interface (inaccessibly located inside your computer)");
static struct platform_device *platform_devices[SNDRV_CARDS];
#ifdef CONFIG_PNP
static int pnp_registered;
@ -588,46 +586,59 @@ snd_wavefront_probe (struct snd_card *card, int dev)
return snd_card_register(card);
}
static int __devinit snd_wavefront_nonpnp_probe(struct platform_device *pdev)
static int __devinit snd_wavefront_isa_match(struct device *pdev,
unsigned int dev)
{
int dev = pdev->id;
struct snd_card *card;
int err;
if (!enable[dev])
return 0;
#ifdef CONFIG_PNP
if (isapnp[dev])
return 0;
#endif
if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) {
snd_printk("specify CS4232 port\n");
return -EINVAL;
return 0;
}
if (ics2115_port[dev] == SNDRV_AUTO_PORT) {
snd_printk("specify ICS2115 port\n");
return -ENODEV;
return 0;
}
return 1;
}
static int __devinit snd_wavefront_isa_probe(struct device *pdev,
unsigned int dev)
{
struct snd_card *card;
int err;
card = snd_wavefront_card_new(dev);
if (! card)
return -ENOMEM;
snd_card_set_dev(card, &pdev->dev);
snd_card_set_dev(card, pdev);
if ((err = snd_wavefront_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_wavefront_nonpnp_remove(struct platform_device *devptr)
static int __devexit snd_wavefront_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;
}
#define WAVEFRONT_DRIVER "snd_wavefront"
static struct platform_driver snd_wavefront_driver = {
.probe = snd_wavefront_nonpnp_probe,
.remove = __devexit_p(snd_wavefront_nonpnp_remove),
static struct isa_driver snd_wavefront_driver = {
.match = snd_wavefront_isa_match,
.probe = snd_wavefront_isa_probe,
.remove = __devexit_p(snd_wavefront_isa_remove),
/* FIXME: suspend, resume */
.driver = {
.name = WAVEFRONT_DRIVER
@ -636,8 +647,6 @@ static struct platform_driver snd_wavefront_driver = {
#ifdef CONFIG_PNP
static unsigned int __devinitdata wavefront_pnp_devices;
static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard,
const struct pnp_card_device_id *pid)
{
@ -670,7 +679,6 @@ static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard,
pnp_set_card_drvdata(pcard, card);
dev++;
wavefront_pnp_devices++;
return 0;
}
@ -691,67 +699,28 @@ static struct pnp_card_driver wavefront_pnpc_driver = {
#endif /* CONFIG_PNP */
static void __init_or_module snd_wavefront_unregister_all(void)
{
int i;
#ifdef CONFIG_PNP
if (pnp_registered)
pnp_unregister_card_driver(&wavefront_pnpc_driver);
#endif
for (i = 0; i < ARRAY_SIZE(platform_devices); ++i)
platform_device_unregister(platform_devices[i]);
platform_driver_unregister(&snd_wavefront_driver);
}
static int __init alsa_card_wavefront_init(void)
{
int i, err, cards = 0;
int err;
if ((err = platform_driver_register(&snd_wavefront_driver)) < 0)
err = isa_register_driver(&snd_wavefront_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(WAVEFRONT_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(&wavefront_pnpc_driver);
if (!err) {
if (!err)
pnp_registered = 1;
cards += wavefront_pnp_devices;
}
#endif
if (!cards) {
#ifdef MODULE
printk (KERN_ERR "No WaveFront cards found or devices busy\n");
#endif
snd_wavefront_unregister_all();
return -ENODEV;
}
return 0;
}
static void __exit alsa_card_wavefront_exit(void)
{
snd_wavefront_unregister_all();
#ifdef CONFIG_PNP
if (pnp_registered)
pnp_unregister_card_driver(&wavefront_pnpc_driver);
#endif
isa_unregister_driver(&snd_wavefront_driver);
}
module_init(alsa_card_wavefront_init)