OpenCores
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/] [sb_common.c] - Blame information for rev 3

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 3 xianfeng 
/*
2 
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
3 
 *                   Uros Bizjak <uros@kss-loka.si>
4 
 *
5 
 *  Lowlevel routines for control of Sound Blaster cards
6 
 *
7 
 *   This program is free software; you can redistribute it and/or modify
8 
 *   it under the terms of the GNU General Public License as published by
9 
 *   the Free Software Foundation; either version 2 of the License, or
10 
 *   (at your option) any later version.
11 
 *
12 
 *   This program is distributed in the hope that it will be useful,
13 
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14 
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 
 *   GNU General Public License for more details.
16 
 *
17 
 *   You should have received a copy of the GNU General Public License
18 
 *   along with this program; if not, write to the Free Software
19 
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
20 
 *
21 
 */
22 
 
23 
#include <sound/driver.h>
24 
#include <linux/delay.h>
25 
#include <linux/init.h>
26 
#include <linux/interrupt.h>
27 
#include <linux/slab.h>
28 
#include <linux/ioport.h>
29 
#include <sound/core.h>
30 
#include <sound/sb.h>
31 
#include <sound/initval.h>
32 
 
33 
#include <asm/io.h>
34 
#include <asm/dma.h>
35 
 
36 
MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
37 
MODULE_DESCRIPTION("ALSA lowlevel driver for Sound Blaster cards");
38 
MODULE_LICENSE("GPL");
39 
 
40 
#define BUSY_LOOPS 100000
41 
 
42 
#undef IO_DEBUG
43 
 
44 
int snd_sbdsp_command(struct snd_sb *chip, unsigned char val)
45 
{
46 
        int i;
47 
#ifdef IO_DEBUG
48 
        snd_printk(KERN_DEBUG "command 0x%x\n", val);
49 
#endif
50 
        for (i = BUSY_LOOPS; i; i--)
51 
                if ((inb(SBP(chip, STATUS)) & 0x80) == 0) {
52 
                        outb(val, SBP(chip, COMMAND));
53 
                        return 1;
54 
                }
55 
        snd_printd("%s [0x%lx]: timeout (0x%x)\n", __FUNCTION__, chip->port, val);
56 
        return 0;
57 
}
58 
 
59 
int snd_sbdsp_get_byte(struct snd_sb *chip)
60 
{
61 
        int val;
62 
        int i;
63 
        for (i = BUSY_LOOPS; i; i--) {
64 
                if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
65 
                        val = inb(SBP(chip, READ));
66 
#ifdef IO_DEBUG
67 
                        snd_printk(KERN_DEBUG "get_byte 0x%x\n", val);
68 
#endif
69 
                        return val;
70 
                }
71 
        }
72 
        snd_printd("%s [0x%lx]: timeout\n", __FUNCTION__, chip->port);
73 
        return -ENODEV;
74 
}
75 
 
76 
int snd_sbdsp_reset(struct snd_sb *chip)
77 
{
78 
        int i;
79 
 
80 
        outb(1, SBP(chip, RESET));
81 
        udelay(10);
82 
        outb(0, SBP(chip, RESET));
83 
        udelay(30);
84 
        for (i = BUSY_LOOPS; i; i--)
85 
                if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
86 
                        if (inb(SBP(chip, READ)) == 0xaa)
87 
                                return 0;
88 
                        else
89 
                                break;
90 
                }
91 
        snd_printdd("%s [0x%lx] failed...\n", __FUNCTION__, chip->port);
92 
        return -ENODEV;
93 
}
94 
 
95 
static int snd_sbdsp_version(struct snd_sb * chip)
96 
{
97 
        unsigned int result = -ENODEV;
98 
 
99 
        snd_sbdsp_command(chip, SB_DSP_GET_VERSION);
100 
        result = (short) snd_sbdsp_get_byte(chip) << 8;
101 
        result |= (short) snd_sbdsp_get_byte(chip);
102 
        return result;
103 
}
104 
 
105 
static int snd_sbdsp_probe(struct snd_sb * chip)
106 
{
107 
        int version;
108 
        int major, minor;
109 
        char *str;
110 
        unsigned long flags;
111 
 
112 
        /*
113 
         *  initialization sequence
114 
         */
115 
 
116 
        spin_lock_irqsave(&chip->reg_lock, flags);
117 
        if (snd_sbdsp_reset(chip) < 0) {
118 
                spin_unlock_irqrestore(&chip->reg_lock, flags);
119 
                return -ENODEV;
120 
        }
121 
        version = snd_sbdsp_version(chip);
122 
        if (version < 0) {
123 
                spin_unlock_irqrestore(&chip->reg_lock, flags);
124 
                return -ENODEV;
125 
        }
126 
        spin_unlock_irqrestore(&chip->reg_lock, flags);
127 
        major = version >> 8;
128 
        minor = version & 0xff;
129 
        snd_printdd("SB [0x%lx]: DSP chip found, version = %i.%i\n",
130 
                    chip->port, major, minor);
131 
 
132 
        switch (chip->hardware) {
133 
        case SB_HW_AUTO:
134 
                switch (major) {
135 
                case 1:
136 
                        chip->hardware = SB_HW_10;
137 
                        str = "1.0";
138 
                        break;
139 
                case 2:
140 
                        if (minor) {
141 
                                chip->hardware = SB_HW_201;
142 
                                str = "2.01+";
143 
                        } else {
144 
                                chip->hardware = SB_HW_20;
145 
                                str = "2.0";
146 
                        }
147 
                        break;
148 
                case 3:
149 
                        chip->hardware = SB_HW_PRO;
150 
                        str = "Pro";
151 
                        break;
152 
                case 4:
153 
                        chip->hardware = SB_HW_16;
154 
                        str = "16";
155 
                        break;
156 
                default:
157 
                        snd_printk(KERN_INFO "SB [0x%lx]: unknown DSP chip version %i.%i\n",
158 
                                   chip->port, major, minor);
159 
                        return -ENODEV;
160 
                }
161 
                break;
162 
        case SB_HW_ALS100:
163 
                str = "16 (ALS-100)";
164 
                break;
165 
        case SB_HW_ALS4000:
166 
                str = "16 (ALS-4000)";
167 
                break;
168 
        case SB_HW_DT019X:
169 
                str = "(DT019X/ALS007)";
170 
                break;
171 
        case SB_HW_CS5530:
172 
                str = "16 (CS5530)";
173 
                break;
174 
        default:
175 
                return -ENODEV;
176 
        }
177 
        sprintf(chip->name, "Sound Blaster %s", str);
178 
        chip->version = (major << 8) | minor;
179 
        return 0;
180 
}
181 
 
182 
static int snd_sbdsp_free(struct snd_sb *chip)
183 
{
184 
        if (chip->res_port)
185 
                release_and_free_resource(chip->res_port);
186 
        if (chip->irq >= 0)
187 
                free_irq(chip->irq, (void *) chip);
188 
#ifdef CONFIG_ISA
189 
        if (chip->dma8 >= 0) {
190 
                disable_dma(chip->dma8);
191 
                free_dma(chip->dma8);
192 
        }
193 
        if (chip->dma16 >= 0 && chip->dma16 != chip->dma8) {
194 
                disable_dma(chip->dma16);
195 
                free_dma(chip->dma16);
196 
        }
197 
#endif
198 
        kfree(chip);
199 
        return 0;
200 
}
201 
 
202 
static int snd_sbdsp_dev_free(struct snd_device *device)
203 
{
204 
        struct snd_sb *chip = device->device_data;
205 
        return snd_sbdsp_free(chip);
206 
}
207 
 
208 
int snd_sbdsp_create(struct snd_card *card,
209 
                     unsigned long port,
210 
                     int irq,
211 
                     irq_handler_t irq_handler,
212 
                     int dma8,
213 
                     int dma16,
214 
                     unsigned short hardware,
215 
                     struct snd_sb **r_chip)
216 
{
217 
        struct snd_sb *chip;
218 
        int err;
219 
        static struct snd_device_ops ops = {
220 
                .dev_free =     snd_sbdsp_dev_free,
221 
        };
222 
 
223 
        snd_assert(r_chip != NULL, return -EINVAL);
224 
        *r_chip = NULL;
225 
        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
226 
        if (chip == NULL)
227 
                return -ENOMEM;
228 
        spin_lock_init(&chip->reg_lock);
229 
        spin_lock_init(&chip->open_lock);
230 
        spin_lock_init(&chip->midi_input_lock);
231 
        spin_lock_init(&chip->mixer_lock);
232 
        chip->irq = -1;
233 
        chip->dma8 = -1;
234 
        chip->dma16 = -1;
235 
        chip->port = port;
236 
 
237 
        if (request_irq(irq, irq_handler,
238 
                        (hardware == SB_HW_ALS4000 ||
239 
                         hardware == SB_HW_CS5530) ?
240 
                        IRQF_SHARED : IRQF_DISABLED,
241 
                        "SoundBlaster", (void *) chip)) {
242 
                snd_printk(KERN_ERR "sb: can't grab irq %d\n", irq);
243 
                snd_sbdsp_free(chip);
244 
                return -EBUSY;
245 
        }
246 
        chip->irq = irq;
247 
 
248 
        if (hardware == SB_HW_ALS4000)
249 
                goto __skip_allocation;
250 
 
251 
        if ((chip->res_port = request_region(port, 16, "SoundBlaster")) == NULL) {
252 
                snd_printk(KERN_ERR "sb: can't grab port 0x%lx\n", port);
253 
                snd_sbdsp_free(chip);
254 
                return -EBUSY;
255 
        }
256 
 
257 
#ifdef CONFIG_ISA
258 
        if (dma8 >= 0 && request_dma(dma8, "SoundBlaster - 8bit")) {
259 
                snd_printk(KERN_ERR "sb: can't grab DMA8 %d\n", dma8);
260 
                snd_sbdsp_free(chip);
261 
                return -EBUSY;
262 
        }
263 
        chip->dma8 = dma8;
264 
        if (dma16 >= 0) {
265 
                if (hardware != SB_HW_ALS100 && (dma16 < 5 || dma16 > 7)) {
266 
                        /* no duplex */
267 
                        dma16 = -1;
268 
                } else if (request_dma(dma16, "SoundBlaster - 16bit")) {
269 
                        snd_printk(KERN_ERR "sb: can't grab DMA16 %d\n", dma16);
270 
                        snd_sbdsp_free(chip);
271 
                        return -EBUSY;
272 
                }
273 
        }
274 
        chip->dma16 = dma16;
275 
#endif
276 
 
277 
      __skip_allocation:
278 
        chip->card = card;
279 
        chip->hardware = hardware;
280 
        if ((err = snd_sbdsp_probe(chip)) < 0) {
281 
                snd_sbdsp_free(chip);
282 
                return err;
283 
        }
284 
        if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
285 
                snd_sbdsp_free(chip);
286 
                return err;
287 
        }
288 
        *r_chip = chip;
289 
        return 0;
290 
}
291 
 
292 
EXPORT_SYMBOL(snd_sbdsp_command);
293 
EXPORT_SYMBOL(snd_sbdsp_get_byte);
294 
EXPORT_SYMBOL(snd_sbdsp_reset);
295 
EXPORT_SYMBOL(snd_sbdsp_create);
296 
/* sb_mixer.c */
297 
EXPORT_SYMBOL(snd_sbmixer_write);
298 
EXPORT_SYMBOL(snd_sbmixer_read);
299 
EXPORT_SYMBOL(snd_sbmixer_new);
300 
EXPORT_SYMBOL(snd_sbmixer_add_ctl);
301 
#ifdef CONFIG_PM
302 
EXPORT_SYMBOL(snd_sbmixer_suspend);
303 
EXPORT_SYMBOL(snd_sbmixer_resume);
304 
#endif
305 
 
306 
/*
307 
 *  INIT part
308 
 */
309 
 
310 
static int __init alsa_sb_common_init(void)
311 
{
312 
        return 0;
313 
}
314 
 
315 
static void __exit alsa_sb_common_exit(void)
316 
{
317 
}
318 
 
319 
module_init(alsa_sb_common_init)
320 
module_exit(alsa_sb_common_exit)

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.