1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Driver for Gravis UltraSound MAX soundcard |
4 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
5 | */ |
6 | |
7 | #include <linux/init.h> |
8 | #include <linux/err.h> |
9 | #include <linux/isa.h> |
10 | #include <linux/delay.h> |
11 | #include <linux/time.h> |
12 | #include <linux/module.h> |
13 | #include <asm/dma.h> |
14 | #include <sound/core.h> |
15 | #include <sound/gus.h> |
16 | #include <sound/wss.h> |
17 | #define SNDRV_LEGACY_FIND_FREE_IRQ |
18 | #define SNDRV_LEGACY_FIND_FREE_DMA |
19 | #include <sound/initval.h> |
20 | |
21 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>" ); |
22 | MODULE_DESCRIPTION("Gravis UltraSound MAX" ); |
23 | MODULE_LICENSE("GPL" ); |
24 | |
25 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ |
26 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ |
27 | static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */ |
28 | static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x220,0x230,0x240,0x250,0x260 */ |
29 | static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 2,3,5,9,11,12,15 */ |
30 | static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 1,3,5,6,7 */ |
31 | static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 1,3,5,6,7 */ |
32 | static int joystick_dac[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 29}; |
33 | /* 0 to 31, (0.59V-4.52V or 0.389V-2.98V) */ |
34 | static int channels[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 24}; |
35 | static int pcm_channels[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2}; |
36 | |
37 | module_param_array(index, int, NULL, 0444); |
38 | MODULE_PARM_DESC(index, "Index value for GUS MAX soundcard." ); |
39 | module_param_array(id, charp, NULL, 0444); |
40 | MODULE_PARM_DESC(id, "ID string for GUS MAX soundcard." ); |
41 | module_param_array(enable, bool, NULL, 0444); |
42 | MODULE_PARM_DESC(enable, "Enable GUS MAX soundcard." ); |
43 | module_param_hw_array(port, long, ioport, NULL, 0444); |
44 | MODULE_PARM_DESC(port, "Port # for GUS MAX driver." ); |
45 | module_param_hw_array(irq, int, irq, NULL, 0444); |
46 | MODULE_PARM_DESC(irq, "IRQ # for GUS MAX driver." ); |
47 | module_param_hw_array(dma1, int, dma, NULL, 0444); |
48 | MODULE_PARM_DESC(dma1, "DMA1 # for GUS MAX driver." ); |
49 | module_param_hw_array(dma2, int, dma, NULL, 0444); |
50 | MODULE_PARM_DESC(dma2, "DMA2 # for GUS MAX driver." ); |
51 | module_param_array(joystick_dac, int, NULL, 0444); |
52 | MODULE_PARM_DESC(joystick_dac, "Joystick DAC level 0.59V-4.52V or 0.389V-2.98V for GUS MAX driver." ); |
53 | module_param_array(channels, int, NULL, 0444); |
54 | MODULE_PARM_DESC(channels, "Used GF1 channels for GUS MAX driver." ); |
55 | module_param_array(pcm_channels, int, NULL, 0444); |
56 | MODULE_PARM_DESC(pcm_channels, "Reserved PCM channels for GUS MAX driver." ); |
57 | |
58 | struct snd_gusmax { |
59 | int irq; |
60 | struct snd_card *card; |
61 | struct snd_gus_card *gus; |
62 | struct snd_wss *wss; |
63 | unsigned short gus_status_reg; |
64 | unsigned short pcm_status_reg; |
65 | }; |
66 | |
67 | #define PFX "gusmax: " |
68 | |
69 | static int snd_gusmax_detect(struct snd_gus_card *gus) |
70 | { |
71 | unsigned char d; |
72 | |
73 | snd_gf1_i_write8(gus, SNDRV_GF1_GB_RESET, data: 0); /* reset GF1 */ |
74 | d = snd_gf1_i_look8(gus, SNDRV_GF1_GB_RESET); |
75 | if ((d & 0x07) != 0) { |
76 | snd_printdd("[0x%lx] check 1 failed - 0x%x\n" , gus->gf1.port, d); |
77 | return -ENODEV; |
78 | } |
79 | udelay(160); |
80 | snd_gf1_i_write8(gus, SNDRV_GF1_GB_RESET, data: 1); /* release reset */ |
81 | udelay(160); |
82 | d = snd_gf1_i_look8(gus, SNDRV_GF1_GB_RESET); |
83 | if ((d & 0x07) != 1) { |
84 | snd_printdd("[0x%lx] check 2 failed - 0x%x\n" , gus->gf1.port, d); |
85 | return -ENODEV; |
86 | } |
87 | |
88 | return 0; |
89 | } |
90 | |
91 | static irqreturn_t snd_gusmax_interrupt(int irq, void *dev_id) |
92 | { |
93 | struct snd_gusmax *maxcard = dev_id; |
94 | int loop, max = 5; |
95 | int handled = 0; |
96 | |
97 | do { |
98 | loop = 0; |
99 | if (inb(port: maxcard->gus_status_reg)) { |
100 | handled = 1; |
101 | snd_gus_interrupt(irq, dev_id: maxcard->gus); |
102 | loop++; |
103 | } |
104 | if (inb(port: maxcard->pcm_status_reg) & 0x01) { /* IRQ bit is set? */ |
105 | handled = 1; |
106 | snd_wss_interrupt(irq, dev_id: maxcard->wss); |
107 | loop++; |
108 | } |
109 | } while (loop && --max > 0); |
110 | return IRQ_RETVAL(handled); |
111 | } |
112 | |
113 | static void snd_gusmax_init(int dev, struct snd_card *card, |
114 | struct snd_gus_card *gus) |
115 | { |
116 | gus->equal_irq = 1; |
117 | gus->codec_flag = 1; |
118 | gus->joystick_dac = joystick_dac[dev]; |
119 | /* init control register */ |
120 | gus->max_cntrl_val = (gus->gf1.port >> 4) & 0x0f; |
121 | if (gus->gf1.dma1 > 3) |
122 | gus->max_cntrl_val |= 0x10; |
123 | if (gus->gf1.dma2 > 3) |
124 | gus->max_cntrl_val |= 0x20; |
125 | gus->max_cntrl_val |= 0x40; |
126 | outb(value: gus->max_cntrl_val, GUSP(gus, MAXCNTRLPORT)); |
127 | } |
128 | |
129 | static int snd_gusmax_mixer(struct snd_wss *chip) |
130 | { |
131 | struct snd_card *card = chip->card; |
132 | struct snd_ctl_elem_id id1, id2; |
133 | int err; |
134 | |
135 | memset(&id1, 0, sizeof(id1)); |
136 | memset(&id2, 0, sizeof(id2)); |
137 | id1.iface = id2.iface = SNDRV_CTL_ELEM_IFACE_MIXER; |
138 | /* reassign AUXA to SYNTHESIZER */ |
139 | strcpy(p: id1.name, q: "Aux Playback Switch" ); |
140 | strcpy(p: id2.name, q: "Synth Playback Switch" ); |
141 | err = snd_ctl_rename_id(card, src_id: &id1, dst_id: &id2); |
142 | if (err < 0) |
143 | return err; |
144 | strcpy(p: id1.name, q: "Aux Playback Volume" ); |
145 | strcpy(p: id2.name, q: "Synth Playback Volume" ); |
146 | err = snd_ctl_rename_id(card, src_id: &id1, dst_id: &id2); |
147 | if (err < 0) |
148 | return err; |
149 | /* reassign AUXB to CD */ |
150 | strcpy(p: id1.name, q: "Aux Playback Switch" ); id1.index = 1; |
151 | strcpy(p: id2.name, q: "CD Playback Switch" ); |
152 | err = snd_ctl_rename_id(card, src_id: &id1, dst_id: &id2); |
153 | if (err < 0) |
154 | return err; |
155 | strcpy(p: id1.name, q: "Aux Playback Volume" ); |
156 | strcpy(p: id2.name, q: "CD Playback Volume" ); |
157 | err = snd_ctl_rename_id(card, src_id: &id1, dst_id: &id2); |
158 | if (err < 0) |
159 | return err; |
160 | #if 0 |
161 | /* reassign Mono Input to MIC */ |
162 | if (snd_mixer_group_rename(mixer, |
163 | SNDRV_MIXER_IN_MONO, 0, |
164 | SNDRV_MIXER_IN_MIC, 0) < 0) |
165 | goto __error; |
166 | if (snd_mixer_elem_rename(mixer, |
167 | SNDRV_MIXER_IN_MONO, 0, SNDRV_MIXER_ETYPE_INPUT, |
168 | SNDRV_MIXER_IN_MIC, 0) < 0) |
169 | goto __error; |
170 | if (snd_mixer_elem_rename(mixer, |
171 | "Mono Capture Volume" , 0, SNDRV_MIXER_ETYPE_VOLUME1, |
172 | "Mic Capture Volume" , 0) < 0) |
173 | goto __error; |
174 | if (snd_mixer_elem_rename(mixer, |
175 | "Mono Capture Switch" , 0, SNDRV_MIXER_ETYPE_SWITCH1, |
176 | "Mic Capture Switch" , 0) < 0) |
177 | goto __error; |
178 | #endif |
179 | return 0; |
180 | } |
181 | |
182 | static int snd_gusmax_match(struct device *pdev, unsigned int dev) |
183 | { |
184 | return enable[dev]; |
185 | } |
186 | |
187 | static int snd_gusmax_probe(struct device *pdev, unsigned int dev) |
188 | { |
189 | static const int possible_irqs[] = {5, 11, 12, 9, 7, 15, 3, -1}; |
190 | static const int possible_dmas[] = {5, 6, 7, 1, 3, -1}; |
191 | int xirq, xdma1, xdma2, err; |
192 | struct snd_card *card; |
193 | struct snd_gus_card *gus = NULL; |
194 | struct snd_wss *wss; |
195 | struct snd_gusmax *maxcard; |
196 | |
197 | err = snd_devm_card_new(parent: pdev, idx: index[dev], xid: id[dev], THIS_MODULE, |
198 | extra_size: sizeof(struct snd_gusmax), card_ret: &card); |
199 | if (err < 0) |
200 | return err; |
201 | maxcard = card->private_data; |
202 | maxcard->card = card; |
203 | maxcard->irq = -1; |
204 | |
205 | xirq = irq[dev]; |
206 | if (xirq == SNDRV_AUTO_IRQ) { |
207 | xirq = snd_legacy_find_free_irq(irq_table: possible_irqs); |
208 | if (xirq < 0) { |
209 | snd_printk(KERN_ERR PFX "unable to find a free IRQ\n" ); |
210 | return -EBUSY; |
211 | } |
212 | } |
213 | xdma1 = dma1[dev]; |
214 | if (xdma1 == SNDRV_AUTO_DMA) { |
215 | xdma1 = snd_legacy_find_free_dma(dma_table: possible_dmas); |
216 | if (xdma1 < 0) { |
217 | snd_printk(KERN_ERR PFX "unable to find a free DMA1\n" ); |
218 | return -EBUSY; |
219 | } |
220 | } |
221 | xdma2 = dma2[dev]; |
222 | if (xdma2 == SNDRV_AUTO_DMA) { |
223 | xdma2 = snd_legacy_find_free_dma(dma_table: possible_dmas); |
224 | if (xdma2 < 0) { |
225 | snd_printk(KERN_ERR PFX "unable to find a free DMA2\n" ); |
226 | return -EBUSY; |
227 | } |
228 | } |
229 | |
230 | if (port[dev] != SNDRV_AUTO_PORT) { |
231 | err = snd_gus_create(card, |
232 | port: port[dev], |
233 | irq: -xirq, dma1: xdma1, dma2: xdma2, |
234 | timer_dev: 0, voices: channels[dev], |
235 | pcm_channels: pcm_channels[dev], |
236 | effect: 0, rgus: &gus); |
237 | } else { |
238 | static const unsigned long possible_ports[] = { |
239 | 0x220, 0x230, 0x240, 0x250, 0x260 |
240 | }; |
241 | int i; |
242 | for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { |
243 | err = snd_gus_create(card, |
244 | port: possible_ports[i], |
245 | irq: -xirq, dma1: xdma1, dma2: xdma2, |
246 | timer_dev: 0, voices: channels[dev], |
247 | pcm_channels: pcm_channels[dev], |
248 | effect: 0, rgus: &gus); |
249 | if (err >= 0) { |
250 | port[dev] = possible_ports[i]; |
251 | break; |
252 | } |
253 | } |
254 | } |
255 | if (err < 0) |
256 | return err; |
257 | |
258 | err = snd_gusmax_detect(gus); |
259 | if (err < 0) |
260 | return err; |
261 | |
262 | maxcard->gus_status_reg = gus->gf1.reg_irqstat; |
263 | maxcard->pcm_status_reg = gus->gf1.port + 0x10c + 2; |
264 | snd_gusmax_init(dev, card, gus); |
265 | err = snd_gus_initialize(gus); |
266 | if (err < 0) |
267 | return err; |
268 | |
269 | if (!gus->max_flag) { |
270 | snd_printk(KERN_ERR PFX "GUS MAX soundcard was not detected at 0x%lx\n" , gus->gf1.port); |
271 | return -ENODEV; |
272 | } |
273 | |
274 | if (devm_request_irq(dev: card->dev, irq: xirq, handler: snd_gusmax_interrupt, irqflags: 0, |
275 | devname: "GUS MAX" , dev_id: (void *)maxcard)) { |
276 | snd_printk(KERN_ERR PFX "unable to grab IRQ %d\n" , xirq); |
277 | return -EBUSY; |
278 | } |
279 | maxcard->irq = xirq; |
280 | card->sync_irq = maxcard->irq; |
281 | |
282 | err = snd_wss_create(card, |
283 | port: gus->gf1.port + 0x10c, cport: -1, irq: xirq, |
284 | dma1: xdma2 < 0 ? xdma1 : xdma2, dma2: xdma1, |
285 | WSS_HW_DETECT, |
286 | WSS_HWSHARE_IRQ | |
287 | WSS_HWSHARE_DMA1 | |
288 | WSS_HWSHARE_DMA2, |
289 | rchip: &wss); |
290 | if (err < 0) |
291 | return err; |
292 | |
293 | err = snd_wss_pcm(chip: wss, device: 0); |
294 | if (err < 0) |
295 | return err; |
296 | |
297 | err = snd_wss_mixer(chip: wss); |
298 | if (err < 0) |
299 | return err; |
300 | |
301 | err = snd_wss_timer(chip: wss, device: 2); |
302 | if (err < 0) |
303 | return err; |
304 | |
305 | if (pcm_channels[dev] > 0) { |
306 | err = snd_gf1_pcm_new(gus, pcm_dev: 1, control_index: 1); |
307 | if (err < 0) |
308 | return err; |
309 | } |
310 | err = snd_gusmax_mixer(chip: wss); |
311 | if (err < 0) |
312 | return err; |
313 | |
314 | err = snd_gf1_rawmidi_new(gus, device: 0); |
315 | if (err < 0) |
316 | return err; |
317 | |
318 | sprintf(buf: card->longname + strlen(card->longname), fmt: " at 0x%lx, irq %i, dma %i" , gus->gf1.port, xirq, xdma1); |
319 | if (xdma2 >= 0) |
320 | sprintf(buf: card->longname + strlen(card->longname), fmt: "&%i" , xdma2); |
321 | |
322 | err = snd_card_register(card); |
323 | if (err < 0) |
324 | return err; |
325 | |
326 | maxcard->gus = gus; |
327 | maxcard->wss = wss; |
328 | |
329 | dev_set_drvdata(dev: pdev, data: card); |
330 | return 0; |
331 | } |
332 | |
333 | #define DEV_NAME "gusmax" |
334 | |
335 | static struct isa_driver snd_gusmax_driver = { |
336 | .match = snd_gusmax_match, |
337 | .probe = snd_gusmax_probe, |
338 | /* FIXME: suspend/resume */ |
339 | .driver = { |
340 | .name = DEV_NAME |
341 | }, |
342 | }; |
343 | |
344 | module_isa_driver(snd_gusmax_driver, SNDRV_CARDS); |
345 | |