URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [isa/] [sb/] [sb8.c] - Blame information for rev 3

Details | Compare with Previous | View Log


/*
 *  Driver for SoundBlaster 1.0/2.0/Pro soundcards and compatible
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */
 
#include <sound/driver.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/isa.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/moduleparam.h>
#include <sound/core.h>
#include <sound/sb.h>
#include <sound/opl3.h>
#include <sound/initval.h>
 
MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
MODULE_DESCRIPTION("Sound Blaster 1.0/2.0/Pro");
MODULE_LICENSE("GPL");
MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB 1.0/SB 2.0/SB Pro}}");
 
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;  /* Enable this card */
static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;     /* 0x220,0x240,0x260 */
static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;        /* 5,7,9,10 */
static int dma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;       /* 1,3 */
 
module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "Index value for Sound Blaster soundcard.");
module_param_array(id, charp, NULL, 0444);
MODULE_PARM_DESC(id, "ID string for Sound Blaster soundcard.");
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "Enable Sound Blaster soundcard.");
module_param_array(port, long, NULL, 0444);
MODULE_PARM_DESC(port, "Port # for SB8 driver.");
module_param_array(irq, int, NULL, 0444);
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.");
 
struct snd_sb8 {
        struct resource *fm_res;        /* used to block FM i/o region for legacy cards */
        struct snd_sb *chip;
};
 
static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id)
{
        struct snd_sb *chip = dev_id;
 
        if (chip->open & SB_OPEN_PCM) {
                return snd_sb8dsp_interrupt(chip);
        } else {
                return snd_sb8dsp_midi_interrupt(chip);
        }
}
 
static void snd_sb8_free(struct snd_card *card)
{
        struct snd_sb8 *acard = (struct snd_sb8 *)card->private_data;
 
        if (acard == NULL)
                return;
        release_and_free_resource(acard->fm_res);
}
 
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)
{
        struct snd_sb *chip;
        struct snd_card *card;
        struct snd_sb8 *acard;
        struct snd_opl3 *opl3;
        int err;
 
        card = snd_card_new(index[dev], id[dev], THIS_MODULE,
                            sizeof(struct snd_sb8));
        if (card == NULL)
                return -ENOMEM;
        acard = card->private_data;
        card->private_free = snd_sb8_free;
 
        /* block the 0x388 port to avoid PnP conflicts */
        acard->fm_res = request_region(0x388, 4, "SoundBlaster FM");
 
        if (port[dev] != SNDRV_AUTO_PORT) {
                if ((err = snd_sbdsp_create(card, port[dev], irq[dev],
                                            snd_sb8_interrupt,
                                            dma8[dev],
                                            -1,
                                            SB_HW_AUTO,
                                            &chip)) < 0)
                        goto _err;
        } else {
                /* auto-probe legacy ports */
                static unsigned long possible_ports[] = {
                        0x220, 0x240, 0x260,
                };
                int i;
                for (i = 0; i < ARRAY_SIZE(possible_ports); i++) {
                        err = snd_sbdsp_create(card, possible_ports[i],
                                               irq[dev],
                                               snd_sb8_interrupt,
                                               dma8[dev],
                                               -1,
                                               SB_HW_AUTO,
                                               &chip);
                        if (err >= 0) {
                                port[dev] = possible_ports[i];
                                break;
                        }
                }
                if (i >= ARRAY_SIZE(possible_ports))
                        goto _err;
        }
        acard->chip = chip;
 
        if (chip->hardware >= SB_HW_16) {
                if (chip->hardware == SB_HW_ALS100)
                        snd_printk(KERN_WARNING "ALS100 chip detected at 0x%lx, try snd-als100 module\n",
                                    port[dev]);
                else
                        snd_printk(KERN_WARNING "SB 16 chip detected at 0x%lx, try snd-sb16 module\n",
                                   port[dev]);
                err = -ENODEV;
                goto _err;
        }
 
        if ((err = snd_sb8dsp_pcm(chip, 0, NULL)) < 0)
                goto _err;
 
        if ((err = snd_sbmixer_new(chip)) < 0)
                goto _err;
 
        if (chip->hardware == SB_HW_10 || chip->hardware == SB_HW_20) {
                if ((err = snd_opl3_create(card, chip->port + 8, 0,
                                           OPL3_HW_AUTO, 1,
                                           &opl3)) < 0) {
                        snd_printk(KERN_WARNING "sb8: no OPL device at 0x%lx\n", chip->port + 8);
                }
        } else {
                if ((err = snd_opl3_create(card, chip->port, chip->port + 2,
                                           OPL3_HW_AUTO, 1,
                                           &opl3)) < 0) {
                        snd_printk(KERN_WARNING "sb8: no OPL device at 0x%lx-0x%lx\n",
                                   chip->port, chip->port + 2);
                }
        }
        if (err >= 0) {
                if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0)
                        goto _err;
        }
 
        if ((err = snd_sb8dsp_midi(chip, 0, NULL)) < 0)
                goto _err;
 
        strcpy(card->driver, chip->hardware == SB_HW_PRO ? "SB Pro" : "SB8");
        strcpy(card->shortname, chip->name);
        sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
                chip->name,
                chip->port,
                irq[dev], dma8[dev]);
 
        snd_card_set_dev(card, pdev);
 
        if ((err = snd_card_register(card)) < 0)
                goto _err;
 
        dev_set_drvdata(pdev, card);
        return 0;
 
 _err:
        snd_card_free(card);
        return err;
}
 
static int __devexit snd_sb8_remove(struct device *pdev, unsigned int dev)
{
        snd_card_free(dev_get_drvdata(pdev));
        dev_set_drvdata(pdev, NULL);
        return 0;
}
 
#ifdef CONFIG_PM
static int snd_sb8_suspend(struct device *dev, unsigned int n,
                           pm_message_t state)
{
        struct snd_card *card = dev_get_drvdata(dev);
        struct snd_sb8 *acard = card->private_data;
        struct snd_sb *chip = acard->chip;
 
        snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
        snd_pcm_suspend_all(chip->pcm);
        snd_sbmixer_suspend(chip);
        return 0;
}
 
static int snd_sb8_resume(struct device *dev, unsigned int n)
{
        struct snd_card *card = dev_get_drvdata(dev);
        struct snd_sb8 *acard = card->private_data;
        struct snd_sb *chip = acard->chip;
 
        snd_sbdsp_reset(chip);
        snd_sbmixer_resume(chip);
        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
        return 0;
}
#endif
 
#define DEV_NAME "sb8"
 
static struct isa_driver snd_sb8_driver = {
        .match          = snd_sb8_match,
        .probe          = snd_sb8_probe,
        .remove         = __devexit_p(snd_sb8_remove),
#ifdef CONFIG_PM
        .suspend        = snd_sb8_suspend,
        .resume         = snd_sb8_resume,
#endif
        .driver         = {
                .name   = DEV_NAME
        },
};
 
static int __init alsa_card_sb8_init(void)
{
        return isa_register_driver(&snd_sb8_driver, SNDRV_CARDS);
}
 
static void __exit alsa_card_sb8_exit(void)
{
        isa_unregister_driver(&snd_sb8_driver);
}
 
module_init(alsa_card_sb8_init)
module_exit(alsa_card_sb8_exit)

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [isa/] [sb/] [sb8.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* Driver for SoundBlaster 1.0/2.0/Pro soundcards and compatible`
3			`* Copyright (c) by Jaroslav Kysela <perex@perex.cz>`
4			`*`
5			`*`
6			`* This program is free software; you can redistribute it and/or modify`
7			`* it under the terms of the GNU General Public License as published by`
8			`* the Free Software Foundation; either version 2 of the License, or`
9			`* (at your option) any later version.`
10			`*`
11			`* This program is distributed in the hope that it will be useful,`
12			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`* GNU General Public License for more details.`
15			`*`
16			`* You should have received a copy of the GNU General Public License`
17			`* along with this program; if not, write to the Free Software`
18			`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
19			`*`
20			`*/`
21
22			`#include <sound/driver.h>`
23			`#include <linux/init.h>`
24			`#include <linux/err.h>`
25			`#include <linux/isa.h>`
26			`#include <linux/slab.h>`
27			`#include <linux/ioport.h>`
28			`#include <linux/moduleparam.h>`
29			`#include <sound/core.h>`
30			`#include <sound/sb.h>`
31			`#include <sound/opl3.h>`
32			`#include <sound/initval.h>`
33
34			`MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");`
35			`MODULE_DESCRIPTION("Sound Blaster 1.0/2.0/Pro");`
36			`MODULE_LICENSE("GPL");`
37			`MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB 1.0/SB 2.0/SB Pro}}");`
38
39			`static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */`
40			`static char id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; / ID for this card */`
41			`static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */`
42			`static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x220,0x240,0x260 */`
43			`static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 5,7,9,10 */`
44			`static int dma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 1,3 */`
45
46			`module_param_array(index, int, NULL, 0444);`
47			`MODULE_PARM_DESC(index, "Index value for Sound Blaster soundcard.");`
48			`module_param_array(id, charp, NULL, 0444);`
49			`MODULE_PARM_DESC(id, "ID string for Sound Blaster soundcard.");`
50			`module_param_array(enable, bool, NULL, 0444);`
51			`MODULE_PARM_DESC(enable, "Enable Sound Blaster soundcard.");`
52			`module_param_array(port, long, NULL, 0444);`
53			`MODULE_PARM_DESC(port, "Port # for SB8 driver.");`
54			`module_param_array(irq, int, NULL, 0444);`
55			`MODULE_PARM_DESC(irq, "IRQ # for SB8 driver.");`
56			`module_param_array(dma8, int, NULL, 0444);`
57			`MODULE_PARM_DESC(dma8, "8-bit DMA # for SB8 driver.");`
58
59			`struct snd_sb8 {`
60			`struct resource fm_res; / used to block FM i/o region for legacy cards */`
61			`struct snd_sb *chip;`
62			`};`
63
64			`static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id)`
65			`{`
66			`struct snd_sb *chip = dev_id;`
67
68			`if (chip->open & SB_OPEN_PCM) {`
69			`return snd_sb8dsp_interrupt(chip);`
70			`} else {`
71			`return snd_sb8dsp_midi_interrupt(chip);`
72			`}`
73			`}`
74
75			`static void snd_sb8_free(struct snd_card *card)`
76			`{`
77			`struct snd_sb8 acard = (struct snd_sb8 )card->private_data;`
78
79			`if (acard == NULL)`
80			`return;`
81			`release_and_free_resource(acard->fm_res);`
82			`}`
83
84			`static int __devinit snd_sb8_match(struct device *pdev, unsigned int dev)`
85			`{`
86			`if (!enable[dev])`
87			`return 0;`
88			`if (irq[dev] == SNDRV_AUTO_IRQ) {`
89			`snd_printk(KERN_ERR "%s: please specify irq\n", pdev->bus_id);`
90			`return 0;`
91			`}`
92			`if (dma8[dev] == SNDRV_AUTO_DMA) {`
93			`snd_printk(KERN_ERR "%s: please specify dma8\n", pdev->bus_id);`
94			`return 0;`
95			`}`
96			`return 1;`
97			`}`
98
99			`static int __devinit snd_sb8_probe(struct device *pdev, unsigned int dev)`
100			`{`
101			`struct snd_sb *chip;`
102			`struct snd_card *card;`
103			`struct snd_sb8 *acard;`
104			`struct snd_opl3 *opl3;`
105			`int err;`
106
107			`card = snd_card_new(index[dev], id[dev], THIS_MODULE,`
108			`sizeof(struct snd_sb8));`
109			`if (card == NULL)`
110			`return -ENOMEM;`
111			`acard = card->private_data;`
112			`card->private_free = snd_sb8_free;`
113
114			`/* block the 0x388 port to avoid PnP conflicts */`
115			`acard->fm_res = request_region(0x388, 4, "SoundBlaster FM");`
116
117			`if (port[dev] != SNDRV_AUTO_PORT) {`
118			`if ((err = snd_sbdsp_create(card, port[dev], irq[dev],`
119			`snd_sb8_interrupt,`
120			`dma8[dev],`
121			`-1,`
122			`SB_HW_AUTO,`
123			`&chip)) < 0)`
124			`goto _err;`
125			`} else {`
126			`/* auto-probe legacy ports */`
127			`static unsigned long possible_ports[] = {`
128			`0x220, 0x240, 0x260,`
129			`};`
130			`int i;`
131			`for (i = 0; i < ARRAY_SIZE(possible_ports); i++) {`
132			`err = snd_sbdsp_create(card, possible_ports[i],`
133			`irq[dev],`
134			`snd_sb8_interrupt,`
135			`dma8[dev],`
136			`-1,`
137			`SB_HW_AUTO,`
138			`&chip);`
139			`if (err >= 0) {`
140			`port[dev] = possible_ports[i];`
141			`break;`
142			`}`
143			`}`
144			`if (i >= ARRAY_SIZE(possible_ports))`
145			`goto _err;`
146			`}`
147			`acard->chip = chip;`
148
149			`if (chip->hardware >= SB_HW_16) {`
150			`if (chip->hardware == SB_HW_ALS100)`
151			`snd_printk(KERN_WARNING "ALS100 chip detected at 0x%lx, try snd-als100 module\n",`
152			`port[dev]);`
153			`else`
154			`snd_printk(KERN_WARNING "SB 16 chip detected at 0x%lx, try snd-sb16 module\n",`
155			`port[dev]);`
156			`err = -ENODEV;`
157			`goto _err;`
158			`}`
159
160			`if ((err = snd_sb8dsp_pcm(chip, 0, NULL)) < 0)`
161			`goto _err;`
162
163			`if ((err = snd_sbmixer_new(chip)) < 0)`
164			`goto _err;`
165
166			`if (chip->hardware == SB_HW_10 \|\| chip->hardware == SB_HW_20) {`
167			`if ((err = snd_opl3_create(card, chip->port + 8, 0,`
168			`OPL3_HW_AUTO, 1,`
169			`&opl3)) < 0) {`
170			`snd_printk(KERN_WARNING "sb8: no OPL device at 0x%lx\n", chip->port + 8);`
171			`}`
172			`} else {`
173			`if ((err = snd_opl3_create(card, chip->port, chip->port + 2,`
174			`OPL3_HW_AUTO, 1,`
175			`&opl3)) < 0) {`
176			`snd_printk(KERN_WARNING "sb8: no OPL device at 0x%lx-0x%lx\n",`
177			`chip->port, chip->port + 2);`
178			`}`
179			`}`
180			`if (err >= 0) {`
181			`if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0)`
182			`goto _err;`
183			`}`
184
185			`if ((err = snd_sb8dsp_midi(chip, 0, NULL)) < 0)`
186			`goto _err;`
187
188			`strcpy(card->driver, chip->hardware == SB_HW_PRO ? "SB Pro" : "SB8");`
189			`strcpy(card->shortname, chip->name);`
190			`sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",`
191			`chip->name,`
192			`chip->port,`
193			`irq[dev], dma8[dev]);`
194
195			`snd_card_set_dev(card, pdev);`
196
197			`if ((err = snd_card_register(card)) < 0)`
198			`goto _err;`
199
200			`dev_set_drvdata(pdev, card);`
201			`return 0;`
202
203			`_err:`
204			`snd_card_free(card);`
205			`return err;`
206			`}`
207
208			`static int __devexit snd_sb8_remove(struct device *pdev, unsigned int dev)`
209			`{`
210			`snd_card_free(dev_get_drvdata(pdev));`
211			`dev_set_drvdata(pdev, NULL);`
212			`return 0;`
213			`}`
214
215			`#ifdef CONFIG_PM`
216			`static int snd_sb8_suspend(struct device *dev, unsigned int n,`
217			`pm_message_t state)`
218			`{`
219			`struct snd_card *card = dev_get_drvdata(dev);`
220			`struct snd_sb8 *acard = card->private_data;`
221			`struct snd_sb *chip = acard->chip;`
222
223			`snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);`
224			`snd_pcm_suspend_all(chip->pcm);`
225			`snd_sbmixer_suspend(chip);`
226			`return 0;`
227			`}`
228
229			`static int snd_sb8_resume(struct device *dev, unsigned int n)`
230			`{`
231			`struct snd_card *card = dev_get_drvdata(dev);`
232			`struct snd_sb8 *acard = card->private_data;`
233			`struct snd_sb *chip = acard->chip;`
234
235			`snd_sbdsp_reset(chip);`
236			`snd_sbmixer_resume(chip);`
237			`snd_power_change_state(card, SNDRV_CTL_POWER_D0);`
238			`return 0;`
239			`}`
240			`#endif`
241
242			`#define DEV_NAME "sb8"`
243
244			`static struct isa_driver snd_sb8_driver = {`
245			`.match = snd_sb8_match,`
246			`.probe = snd_sb8_probe,`
247			`.remove = __devexit_p(snd_sb8_remove),`
248			`#ifdef CONFIG_PM`
249			`.suspend = snd_sb8_suspend,`
250			`.resume = snd_sb8_resume,`
251			`#endif`
252			`.driver = {`
253			`.name = DEV_NAME`
254			`},`
255			`};`
256
257			`static int __init alsa_card_sb8_init(void)`
258			`{`
259			`return isa_register_driver(&snd_sb8_driver, SNDRV_CARDS);`
260			`}`
261
262			`static void __exit alsa_card_sb8_exit(void)`
263			`{`
264			`isa_unregister_driver(&snd_sb8_driver);`
265			`}`
266
267			`module_init(alsa_card_sb8_init)`
268			`module_exit(alsa_card_sb8_exit)`