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