Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
acd47100 | 2 | * Low-level ALSA driver for the ENSONIQ SoundScape |
1da177e4 LT |
3 | * Copyright (c) by Chris Rankin |
4 | * | |
5 | * This driver was written in part using information obtained from | |
6 | * the OSS/Free SoundScape driver, written by Hannu Savolainen. | |
7 | * | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
22 | */ | |
23 | ||
1da177e4 | 24 | #include <linux/init.h> |
277e926c | 25 | #include <linux/err.h> |
5e24c1c1 | 26 | #include <linux/isa.h> |
1da177e4 | 27 | #include <linux/delay.h> |
acd47100 | 28 | #include <linux/firmware.h> |
1da177e4 LT |
29 | #include <linux/pnp.h> |
30 | #include <linux/spinlock.h> | |
65a77217 | 31 | #include <linux/module.h> |
1da177e4 LT |
32 | #include <asm/dma.h> |
33 | #include <sound/core.h> | |
61ef19d7 | 34 | #include <sound/wss.h> |
1da177e4 LT |
35 | #include <sound/mpu401.h> |
36 | #include <sound/initval.h> | |
37 | ||
1da177e4 LT |
38 | |
39 | MODULE_AUTHOR("Chris Rankin"); | |
acd47100 | 40 | MODULE_DESCRIPTION("ENSONIQ SoundScape driver"); |
1da177e4 | 41 | MODULE_LICENSE("GPL"); |
acd47100 KH |
42 | MODULE_FIRMWARE("sndscape.co0"); |
43 | MODULE_FIRMWARE("sndscape.co1"); | |
44 | MODULE_FIRMWARE("sndscape.co2"); | |
45 | MODULE_FIRMWARE("sndscape.co3"); | |
46 | MODULE_FIRMWARE("sndscape.co4"); | |
47 | MODULE_FIRMWARE("scope.cod"); | |
1da177e4 | 48 | |
ed76f652 TI |
49 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; |
50 | static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; | |
51 | static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; | |
52 | static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; | |
53 | static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; | |
54 | static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; | |
55 | static int dma[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; | |
56 | static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; | |
57 | static bool joystick[SNDRV_CARDS]; | |
1da177e4 LT |
58 | |
59 | module_param_array(index, int, NULL, 0444); | |
60 | MODULE_PARM_DESC(index, "Index number for SoundScape soundcard"); | |
61 | ||
62 | module_param_array(id, charp, NULL, 0444); | |
63 | MODULE_PARM_DESC(id, "Description for SoundScape card"); | |
64 | ||
65 | module_param_array(port, long, NULL, 0444); | |
66 | MODULE_PARM_DESC(port, "Port # for SoundScape driver."); | |
67 | ||
4996bca9 KH |
68 | module_param_array(wss_port, long, NULL, 0444); |
69 | MODULE_PARM_DESC(wss_port, "WSS Port # for SoundScape driver."); | |
70 | ||
1da177e4 LT |
71 | module_param_array(irq, int, NULL, 0444); |
72 | MODULE_PARM_DESC(irq, "IRQ # for SoundScape driver."); | |
73 | ||
74 | module_param_array(mpu_irq, int, NULL, 0444); | |
75 | MODULE_PARM_DESC(mpu_irq, "MPU401 IRQ # for SoundScape driver."); | |
76 | ||
77 | module_param_array(dma, int, NULL, 0444); | |
78 | MODULE_PARM_DESC(dma, "DMA # for SoundScape driver."); | |
f7a9275d | 79 | |
4996bca9 KH |
80 | module_param_array(dma2, int, NULL, 0444); |
81 | MODULE_PARM_DESC(dma2, "DMA2 # for SoundScape driver."); | |
82 | ||
1cb0fdeb KH |
83 | module_param_array(joystick, bool, NULL, 0444); |
84 | MODULE_PARM_DESC(joystick, "Enable gameport."); | |
85 | ||
1da177e4 | 86 | #ifdef CONFIG_PNP |
609d7694 | 87 | static int isa_registered; |
59b1b34f | 88 | static int pnp_registered; |
609d7694 | 89 | |
1da177e4 | 90 | static struct pnp_card_device_id sscape_pnpids[] = { |
4996bca9 KH |
91 | { .id = "ENS3081", .devs = { { "ENS0000" } } }, /* Soundscape PnP */ |
92 | { .id = "ENS4081", .devs = { { "ENS1011" } } }, /* VIVO90 */ | |
1da177e4 LT |
93 | { .id = "" } /* end */ |
94 | }; | |
95 | ||
96 | MODULE_DEVICE_TABLE(pnp_card, sscape_pnpids); | |
97 | #endif | |
98 | ||
1da177e4 | 99 | |
1da177e4 LT |
100 | #define HOST_CTRL_IO(i) ((i) + 2) |
101 | #define HOST_DATA_IO(i) ((i) + 3) | |
102 | #define ODIE_ADDR_IO(i) ((i) + 4) | |
103 | #define ODIE_DATA_IO(i) ((i) + 5) | |
104 | #define CODEC_IO(i) ((i) + 8) | |
105 | ||
106 | #define IC_ODIE 1 | |
107 | #define IC_OPUS 2 | |
108 | ||
109 | #define RX_READY 0x01 | |
110 | #define TX_READY 0x02 | |
111 | ||
6fcfa395 KH |
112 | #define CMD_ACK 0x80 |
113 | #define CMD_SET_MIDI_VOL 0x84 | |
114 | #define CMD_GET_MIDI_VOL 0x85 | |
115 | #define CMD_XXX_MIDI_VOL 0x86 | |
116 | #define CMD_SET_EXTMIDI 0x8a | |
117 | #define CMD_GET_EXTMIDI 0x8b | |
118 | #define CMD_SET_MT32 0x8c | |
119 | #define CMD_GET_MT32 0x8d | |
1da177e4 LT |
120 | |
121 | enum GA_REG { | |
122 | GA_INTSTAT_REG = 0, | |
123 | GA_INTENA_REG, | |
124 | GA_DMAA_REG, | |
125 | GA_DMAB_REG, | |
126 | GA_INTCFG_REG, | |
127 | GA_DMACFG_REG, | |
128 | GA_CDCFG_REG, | |
129 | GA_SMCFGA_REG, | |
130 | GA_SMCFGB_REG, | |
131 | GA_HMCTL_REG | |
132 | }; | |
133 | ||
134 | #define DMA_8BIT 0x80 | |
135 | ||
136 | ||
4996bca9 | 137 | enum card_type { |
f0968e3f KH |
138 | MEDIA_FX, /* Sequoia S-1000 */ |
139 | SSCAPE, /* Sequoia S-2000 */ | |
4996bca9 KH |
140 | SSCAPE_PNP, |
141 | SSCAPE_VIVO, | |
142 | }; | |
143 | ||
1da177e4 LT |
144 | struct soundscape { |
145 | spinlock_t lock; | |
146 | unsigned io_base; | |
1da177e4 | 147 | int ic_type; |
4996bca9 | 148 | enum card_type type; |
1da177e4 | 149 | struct resource *io_res; |
ec1e7949 | 150 | struct resource *wss_res; |
7779f75f | 151 | struct snd_wss *chip; |
1da177e4 | 152 | |
1da177e4 LT |
153 | unsigned char midi_vol; |
154 | }; | |
155 | ||
156 | #define INVALID_IRQ ((unsigned)-1) | |
157 | ||
158 | ||
be624537 | 159 | static inline struct soundscape *get_card_soundscape(struct snd_card *c) |
1da177e4 LT |
160 | { |
161 | return (struct soundscape *) (c->private_data); | |
162 | } | |
163 | ||
1da177e4 LT |
164 | /* |
165 | * Allocates some kernel memory that we can use for DMA. | |
166 | * I think this means that the memory has to map to | |
167 | * contiguous pages of physical memory. | |
168 | */ | |
6fcfa395 KH |
169 | static struct snd_dma_buffer *get_dmabuf(struct snd_dma_buffer *buf, |
170 | unsigned long size) | |
1da177e4 LT |
171 | { |
172 | if (buf) { | |
6fcfa395 KH |
173 | if (snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV, |
174 | snd_dma_isa_data(), | |
1da177e4 | 175 | size, buf) < 0) { |
bcde1f8a KH |
176 | snd_printk(KERN_ERR "sscape: Failed to allocate " |
177 | "%lu bytes for DMA\n", | |
178 | size); | |
1da177e4 LT |
179 | return NULL; |
180 | } | |
181 | } | |
182 | ||
183 | return buf; | |
184 | } | |
185 | ||
186 | /* | |
187 | * Release the DMA-able kernel memory ... | |
188 | */ | |
189 | static void free_dmabuf(struct snd_dma_buffer *buf) | |
190 | { | |
191 | if (buf && buf->area) | |
192 | snd_dma_free_pages(buf); | |
193 | } | |
194 | ||
1da177e4 LT |
195 | /* |
196 | * This function writes to the SoundScape's control registers, | |
197 | * but doesn't do any locking. It's up to the caller to do that. | |
198 | * This is why this function is "unsafe" ... | |
199 | */ | |
6fcfa395 KH |
200 | static inline void sscape_write_unsafe(unsigned io_base, enum GA_REG reg, |
201 | unsigned char val) | |
1da177e4 LT |
202 | { |
203 | outb(reg, ODIE_ADDR_IO(io_base)); | |
204 | outb(val, ODIE_DATA_IO(io_base)); | |
205 | } | |
206 | ||
207 | /* | |
208 | * Write to the SoundScape's control registers, and do the | |
209 | * necessary locking ... | |
210 | */ | |
6fcfa395 KH |
211 | static void sscape_write(struct soundscape *s, enum GA_REG reg, |
212 | unsigned char val) | |
1da177e4 LT |
213 | { |
214 | unsigned long flags; | |
215 | ||
216 | spin_lock_irqsave(&s->lock, flags); | |
217 | sscape_write_unsafe(s->io_base, reg, val); | |
218 | spin_unlock_irqrestore(&s->lock, flags); | |
219 | } | |
220 | ||
221 | /* | |
222 | * Read from the SoundScape's control registers, but leave any | |
223 | * locking to the caller. This is why the function is "unsafe" ... | |
224 | */ | |
6fcfa395 KH |
225 | static inline unsigned char sscape_read_unsafe(unsigned io_base, |
226 | enum GA_REG reg) | |
1da177e4 LT |
227 | { |
228 | outb(reg, ODIE_ADDR_IO(io_base)); | |
229 | return inb(ODIE_DATA_IO(io_base)); | |
230 | } | |
231 | ||
232 | /* | |
233 | * Puts the SoundScape into "host" mode, as compared to "MIDI" mode | |
234 | */ | |
235 | static inline void set_host_mode_unsafe(unsigned io_base) | |
236 | { | |
237 | outb(0x0, HOST_CTRL_IO(io_base)); | |
238 | } | |
239 | ||
240 | /* | |
241 | * Puts the SoundScape into "MIDI" mode, as compared to "host" mode | |
242 | */ | |
243 | static inline void set_midi_mode_unsafe(unsigned io_base) | |
244 | { | |
245 | outb(0x3, HOST_CTRL_IO(io_base)); | |
246 | } | |
247 | ||
248 | /* | |
249 | * Read the SoundScape's host-mode control register, but leave | |
250 | * any locking issues to the caller ... | |
251 | */ | |
252 | static inline int host_read_unsafe(unsigned io_base) | |
253 | { | |
254 | int data = -1; | |
6fcfa395 | 255 | if ((inb(HOST_CTRL_IO(io_base)) & RX_READY) != 0) |
1da177e4 | 256 | data = inb(HOST_DATA_IO(io_base)); |
1da177e4 LT |
257 | |
258 | return data; | |
259 | } | |
260 | ||
261 | /* | |
262 | * Read the SoundScape's host-mode control register, performing | |
263 | * a limited amount of busy-waiting if the register isn't ready. | |
264 | * Also leaves all locking-issues to the caller ... | |
265 | */ | |
266 | static int host_read_ctrl_unsafe(unsigned io_base, unsigned timeout) | |
267 | { | |
268 | int data; | |
269 | ||
270 | while (((data = host_read_unsafe(io_base)) < 0) && (timeout != 0)) { | |
271 | udelay(100); | |
272 | --timeout; | |
273 | } /* while */ | |
274 | ||
275 | return data; | |
276 | } | |
277 | ||
278 | /* | |
279 | * Write to the SoundScape's host-mode control registers, but | |
280 | * leave any locking issues to the caller ... | |
281 | */ | |
282 | static inline int host_write_unsafe(unsigned io_base, unsigned char data) | |
283 | { | |
284 | if ((inb(HOST_CTRL_IO(io_base)) & TX_READY) != 0) { | |
285 | outb(data, HOST_DATA_IO(io_base)); | |
286 | return 1; | |
287 | } | |
288 | ||
289 | return 0; | |
290 | } | |
291 | ||
292 | /* | |
293 | * Write to the SoundScape's host-mode control registers, performing | |
294 | * a limited amount of busy-waiting if the register isn't ready. | |
295 | * Also leaves all locking-issues to the caller ... | |
296 | */ | |
297 | static int host_write_ctrl_unsafe(unsigned io_base, unsigned char data, | |
6fcfa395 | 298 | unsigned timeout) |
1da177e4 LT |
299 | { |
300 | int err; | |
301 | ||
302 | while (!(err = host_write_unsafe(io_base, data)) && (timeout != 0)) { | |
303 | udelay(100); | |
304 | --timeout; | |
305 | } /* while */ | |
306 | ||
307 | return err; | |
308 | } | |
309 | ||
310 | ||
311 | /* | |
312 | * Check that the MIDI subsystem is operational. If it isn't, | |
313 | * then we will hang the computer if we try to use it ... | |
314 | * | |
315 | * NOTE: This check is based upon observation, not documentation. | |
316 | */ | |
6fcfa395 | 317 | static inline int verify_mpu401(const struct snd_mpu401 *mpu) |
1da177e4 | 318 | { |
c9864fd3 | 319 | return ((inb(MPU401C(mpu)) & 0xc0) == 0x80); |
1da177e4 LT |
320 | } |
321 | ||
322 | /* | |
323 | * This is apparently the standard way to initailise an MPU-401 | |
324 | */ | |
6fcfa395 | 325 | static inline void initialise_mpu401(const struct snd_mpu401 *mpu) |
1da177e4 | 326 | { |
c9864fd3 | 327 | outb(0, MPU401D(mpu)); |
1da177e4 LT |
328 | } |
329 | ||
330 | /* | |
331 | * Tell the SoundScape to activate the AD1845 chip (I think). | |
332 | * The AD1845 detection fails if we *don't* do this, so I | |
333 | * think that this is a good idea ... | |
334 | */ | |
6fcfa395 | 335 | static void activate_ad1845_unsafe(unsigned io_base) |
1da177e4 | 336 | { |
6fcfa395 KH |
337 | unsigned char val = sscape_read_unsafe(io_base, GA_HMCTL_REG); |
338 | sscape_write_unsafe(io_base, GA_HMCTL_REG, (val & 0xcf) | 0x10); | |
1da177e4 LT |
339 | sscape_write_unsafe(io_base, GA_CDCFG_REG, 0x80); |
340 | } | |
341 | ||
342 | /* | |
343 | * Do the necessary ALSA-level cleanup to deallocate our driver ... | |
344 | */ | |
be624537 | 345 | static void soundscape_free(struct snd_card *c) |
1da177e4 | 346 | { |
ec1e7949 | 347 | struct soundscape *sscape = get_card_soundscape(c); |
b1d5776d | 348 | release_and_free_resource(sscape->io_res); |
ec1e7949 | 349 | release_and_free_resource(sscape->wss_res); |
1da177e4 LT |
350 | free_dma(sscape->chip->dma1); |
351 | } | |
352 | ||
1da177e4 LT |
353 | /* |
354 | * Tell the SoundScape to begin a DMA tranfer using the given channel. | |
355 | * All locking issues are left to the caller. | |
356 | */ | |
6fcfa395 | 357 | static void sscape_start_dma_unsafe(unsigned io_base, enum GA_REG reg) |
1da177e4 | 358 | { |
6fcfa395 KH |
359 | sscape_write_unsafe(io_base, reg, |
360 | sscape_read_unsafe(io_base, reg) | 0x01); | |
361 | sscape_write_unsafe(io_base, reg, | |
362 | sscape_read_unsafe(io_base, reg) & 0xfe); | |
1da177e4 LT |
363 | } |
364 | ||
365 | /* | |
366 | * Wait for a DMA transfer to complete. This is a "limited busy-wait", | |
367 | * and all locking issues are left to the caller. | |
368 | */ | |
6fcfa395 KH |
369 | static int sscape_wait_dma_unsafe(unsigned io_base, enum GA_REG reg, |
370 | unsigned timeout) | |
1da177e4 LT |
371 | { |
372 | while (!(sscape_read_unsafe(io_base, reg) & 0x01) && (timeout != 0)) { | |
373 | udelay(100); | |
374 | --timeout; | |
375 | } /* while */ | |
376 | ||
6fcfa395 | 377 | return sscape_read_unsafe(io_base, reg) & 0x01; |
1da177e4 LT |
378 | } |
379 | ||
380 | /* | |
381 | * Wait for the On-Board Processor to return its start-up | |
382 | * acknowledgement sequence. This wait is too long for | |
383 | * us to perform "busy-waiting", and so we must sleep. | |
384 | * This in turn means that we must not be holding any | |
385 | * spinlocks when we call this function. | |
386 | */ | |
387 | static int obp_startup_ack(struct soundscape *s, unsigned timeout) | |
388 | { | |
554b91ed KH |
389 | unsigned long end_time = jiffies + msecs_to_jiffies(timeout); |
390 | ||
391 | do { | |
1da177e4 | 392 | unsigned long flags; |
acd47100 | 393 | int x; |
1da177e4 | 394 | |
1da177e4 | 395 | spin_lock_irqsave(&s->lock, flags); |
acd47100 | 396 | x = host_read_unsafe(s->io_base); |
1da177e4 | 397 | spin_unlock_irqrestore(&s->lock, flags); |
acd47100 | 398 | if (x == 0xfe || x == 0xff) |
1da177e4 LT |
399 | return 1; |
400 | ||
554b91ed KH |
401 | msleep(10); |
402 | } while (time_before(jiffies, end_time)); | |
1da177e4 LT |
403 | |
404 | return 0; | |
405 | } | |
406 | ||
407 | /* | |
408 | * Wait for the host to return its start-up acknowledgement | |
409 | * sequence. This wait is too long for us to perform | |
410 | * "busy-waiting", and so we must sleep. This in turn means | |
411 | * that we must not be holding any spinlocks when we call | |
412 | * this function. | |
413 | */ | |
414 | static int host_startup_ack(struct soundscape *s, unsigned timeout) | |
415 | { | |
554b91ed KH |
416 | unsigned long end_time = jiffies + msecs_to_jiffies(timeout); |
417 | ||
418 | do { | |
1da177e4 | 419 | unsigned long flags; |
acd47100 | 420 | int x; |
1da177e4 | 421 | |
1da177e4 | 422 | spin_lock_irqsave(&s->lock, flags); |
acd47100 | 423 | x = host_read_unsafe(s->io_base); |
1da177e4 LT |
424 | spin_unlock_irqrestore(&s->lock, flags); |
425 | if (x == 0xfe) | |
426 | return 1; | |
427 | ||
554b91ed KH |
428 | msleep(10); |
429 | } while (time_before(jiffies, end_time)); | |
1da177e4 LT |
430 | |
431 | return 0; | |
432 | } | |
433 | ||
434 | /* | |
435 | * Upload a byte-stream into the SoundScape using DMA channel A. | |
436 | */ | |
6fcfa395 KH |
437 | static int upload_dma_data(struct soundscape *s, const unsigned char *data, |
438 | size_t size) | |
1da177e4 LT |
439 | { |
440 | unsigned long flags; | |
441 | struct snd_dma_buffer dma; | |
442 | int ret; | |
6fcfa395 | 443 | unsigned char val; |
1da177e4 | 444 | |
acd47100 | 445 | if (!get_dmabuf(&dma, PAGE_ALIGN(32 * 1024))) |
1da177e4 LT |
446 | return -ENOMEM; |
447 | ||
448 | spin_lock_irqsave(&s->lock, flags); | |
449 | ||
450 | /* | |
451 | * Reset the board ... | |
452 | */ | |
6fcfa395 KH |
453 | val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG); |
454 | sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val & 0x3f); | |
1da177e4 LT |
455 | |
456 | /* | |
457 | * Enable the DMA channels and configure them ... | |
458 | */ | |
6fcfa395 KH |
459 | val = (s->chip->dma1 << 4) | DMA_8BIT; |
460 | sscape_write_unsafe(s->io_base, GA_DMAA_REG, val); | |
1da177e4 LT |
461 | sscape_write_unsafe(s->io_base, GA_DMAB_REG, 0x20); |
462 | ||
463 | /* | |
464 | * Take the board out of reset ... | |
465 | */ | |
6fcfa395 KH |
466 | val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG); |
467 | sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val | 0x80); | |
1da177e4 LT |
468 | |
469 | /* | |
acd47100 | 470 | * Upload the firmware to the SoundScape |
1da177e4 LT |
471 | * board through the DMA channel ... |
472 | */ | |
473 | while (size != 0) { | |
474 | unsigned long len; | |
475 | ||
1da177e4 | 476 | len = min(size, dma.bytes); |
acd47100 | 477 | memcpy(dma.area, data, len); |
1da177e4 LT |
478 | data += len; |
479 | size -= len; | |
480 | ||
1da177e4 LT |
481 | snd_dma_program(s->chip->dma1, dma.addr, len, DMA_MODE_WRITE); |
482 | sscape_start_dma_unsafe(s->io_base, GA_DMAA_REG); | |
483 | if (!sscape_wait_dma_unsafe(s->io_base, GA_DMAA_REG, 5000)) { | |
484 | /* | |
6fcfa395 | 485 | * Don't forget to release this spinlock we're holding |
1da177e4 LT |
486 | */ |
487 | spin_unlock_irqrestore(&s->lock, flags); | |
488 | ||
bcde1f8a KH |
489 | snd_printk(KERN_ERR |
490 | "sscape: DMA upload has timed out\n"); | |
1da177e4 LT |
491 | ret = -EAGAIN; |
492 | goto _release_dma; | |
493 | } | |
494 | } /* while */ | |
495 | ||
496 | set_host_mode_unsafe(s->io_base); | |
acd47100 | 497 | outb(0x0, s->io_base); |
1da177e4 LT |
498 | |
499 | /* | |
500 | * Boot the board ... (I think) | |
501 | */ | |
6fcfa395 KH |
502 | val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG); |
503 | sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val | 0x40); | |
1da177e4 LT |
504 | spin_unlock_irqrestore(&s->lock, flags); |
505 | ||
506 | /* | |
507 | * If all has gone well, then the board should acknowledge | |
508 | * the new upload and tell us that it has rebooted OK. We | |
509 | * give it 5 seconds (max) ... | |
510 | */ | |
511 | ret = 0; | |
554b91ed | 512 | if (!obp_startup_ack(s, 5000)) { |
bcde1f8a KH |
513 | snd_printk(KERN_ERR "sscape: No response " |
514 | "from on-board processor after upload\n"); | |
1da177e4 | 515 | ret = -EAGAIN; |
554b91ed | 516 | } else if (!host_startup_ack(s, 5000)) { |
bcde1f8a KH |
517 | snd_printk(KERN_ERR |
518 | "sscape: SoundScape failed to initialise\n"); | |
1da177e4 LT |
519 | ret = -EAGAIN; |
520 | } | |
521 | ||
4996bca9 | 522 | _release_dma: |
1da177e4 LT |
523 | /* |
524 | * NOTE!!! We are NOT holding any spinlocks at this point !!! | |
525 | */ | |
acd47100 | 526 | sscape_write(s, GA_DMAA_REG, (s->ic_type == IC_OPUS ? 0x40 : 0x70)); |
1da177e4 LT |
527 | free_dmabuf(&dma); |
528 | ||
529 | return ret; | |
530 | } | |
531 | ||
532 | /* | |
533 | * Upload the bootblock(?) into the SoundScape. The only | |
534 | * purpose of this block of code seems to be to tell | |
535 | * us which version of the microcode we should be using. | |
1da177e4 | 536 | */ |
acd47100 | 537 | static int sscape_upload_bootblock(struct snd_card *card) |
1da177e4 | 538 | { |
acd47100 | 539 | struct soundscape *sscape = get_card_soundscape(card); |
1da177e4 | 540 | unsigned long flags; |
acd47100 | 541 | const struct firmware *init_fw = NULL; |
1da177e4 LT |
542 | int data = 0; |
543 | int ret; | |
544 | ||
acd47100 KH |
545 | ret = request_firmware(&init_fw, "scope.cod", card->dev); |
546 | if (ret < 0) { | |
bcde1f8a | 547 | snd_printk(KERN_ERR "sscape: Error loading scope.cod"); |
acd47100 | 548 | return ret; |
1da177e4 | 549 | } |
acd47100 | 550 | ret = upload_dma_data(sscape, init_fw->data, init_fw->size); |
1da177e4 | 551 | |
acd47100 | 552 | release_firmware(init_fw); |
1da177e4 | 553 | |
acd47100 KH |
554 | spin_lock_irqsave(&sscape->lock, flags); |
555 | if (ret == 0) | |
556 | data = host_read_ctrl_unsafe(sscape->io_base, 100); | |
1da177e4 | 557 | |
acd47100 KH |
558 | if (data & 0x10) |
559 | sscape_write_unsafe(sscape->io_base, GA_SMCFGA_REG, 0x2f); | |
1da177e4 | 560 | |
1da177e4 LT |
561 | spin_unlock_irqrestore(&sscape->lock, flags); |
562 | ||
acd47100 KH |
563 | data &= 0xf; |
564 | if (ret == 0 && data > 7) { | |
bcde1f8a KH |
565 | snd_printk(KERN_ERR |
566 | "sscape: timeout reading firmware version\n"); | |
acd47100 KH |
567 | ret = -EAGAIN; |
568 | } | |
1da177e4 | 569 | |
acd47100 | 570 | return (ret == 0) ? data : ret; |
1da177e4 LT |
571 | } |
572 | ||
573 | /* | |
acd47100 | 574 | * Upload the microcode into the SoundScape. |
1da177e4 | 575 | */ |
acd47100 | 576 | static int sscape_upload_microcode(struct snd_card *card, int version) |
1da177e4 | 577 | { |
acd47100 KH |
578 | struct soundscape *sscape = get_card_soundscape(card); |
579 | const struct firmware *init_fw = NULL; | |
580 | char name[14]; | |
1da177e4 LT |
581 | int err; |
582 | ||
acd47100 | 583 | snprintf(name, sizeof(name), "sndscape.co%d", version); |
1da177e4 | 584 | |
acd47100 KH |
585 | err = request_firmware(&init_fw, name, card->dev); |
586 | if (err < 0) { | |
bcde1f8a KH |
587 | snd_printk(KERN_ERR "sscape: Error loading sndscape.co%d", |
588 | version); | |
acd47100 | 589 | return err; |
1da177e4 | 590 | } |
acd47100 KH |
591 | err = upload_dma_data(sscape, init_fw->data, init_fw->size); |
592 | if (err == 0) | |
bcde1f8a | 593 | snd_printk(KERN_INFO "sscape: MIDI firmware loaded %d KBs\n", |
acd47100 | 594 | init_fw->size >> 10); |
1da177e4 | 595 | |
acd47100 | 596 | release_firmware(init_fw); |
1da177e4 LT |
597 | |
598 | return err; | |
599 | } | |
600 | ||
1da177e4 LT |
601 | /* |
602 | * Mixer control for the SoundScape's MIDI device. | |
603 | */ | |
be624537 | 604 | static int sscape_midi_info(struct snd_kcontrol *ctl, |
6fcfa395 | 605 | struct snd_ctl_elem_info *uinfo) |
1da177e4 LT |
606 | { |
607 | uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; | |
608 | uinfo->count = 1; | |
609 | uinfo->value.integer.min = 0; | |
610 | uinfo->value.integer.max = 127; | |
611 | return 0; | |
612 | } | |
613 | ||
be624537 | 614 | static int sscape_midi_get(struct snd_kcontrol *kctl, |
6fcfa395 | 615 | struct snd_ctl_elem_value *uctl) |
1da177e4 | 616 | { |
7779f75f | 617 | struct snd_wss *chip = snd_kcontrol_chip(kctl); |
be624537 | 618 | struct snd_card *card = chip->card; |
1da177e4 LT |
619 | register struct soundscape *s = get_card_soundscape(card); |
620 | unsigned long flags; | |
621 | ||
622 | spin_lock_irqsave(&s->lock, flags); | |
453e37b3 | 623 | uctl->value.integer.value[0] = s->midi_vol; |
1da177e4 LT |
624 | spin_unlock_irqrestore(&s->lock, flags); |
625 | return 0; | |
626 | } | |
627 | ||
be624537 | 628 | static int sscape_midi_put(struct snd_kcontrol *kctl, |
6fcfa395 | 629 | struct snd_ctl_elem_value *uctl) |
1da177e4 | 630 | { |
7779f75f | 631 | struct snd_wss *chip = snd_kcontrol_chip(kctl); |
be624537 | 632 | struct snd_card *card = chip->card; |
6fcfa395 | 633 | struct soundscape *s = get_card_soundscape(card); |
1da177e4 LT |
634 | unsigned long flags; |
635 | int change; | |
6fcfa395 | 636 | unsigned char new_val; |
1da177e4 LT |
637 | |
638 | spin_lock_irqsave(&s->lock, flags); | |
639 | ||
6fcfa395 | 640 | new_val = uctl->value.integer.value[0] & 127; |
1da177e4 LT |
641 | /* |
642 | * We need to put the board into HOST mode before we | |
643 | * can send any volume-changing HOST commands ... | |
644 | */ | |
645 | set_host_mode_unsafe(s->io_base); | |
646 | ||
647 | /* | |
648 | * To successfully change the MIDI volume setting, you seem to | |
649 | * have to write a volume command, write the new volume value, | |
650 | * and then perform another volume-related command. Perhaps the | |
651 | * first command is an "open" and the second command is a "close"? | |
652 | */ | |
6fcfa395 | 653 | if (s->midi_vol == new_val) { |
1da177e4 LT |
654 | change = 0; |
655 | goto __skip_change; | |
656 | } | |
6fcfa395 KH |
657 | change = host_write_ctrl_unsafe(s->io_base, CMD_SET_MIDI_VOL, 100) |
658 | && host_write_ctrl_unsafe(s->io_base, new_val, 100) | |
659 | && host_write_ctrl_unsafe(s->io_base, CMD_XXX_MIDI_VOL, 100) | |
660 | && host_write_ctrl_unsafe(s->io_base, new_val, 100); | |
661 | s->midi_vol = new_val; | |
662 | __skip_change: | |
1da177e4 LT |
663 | |
664 | /* | |
665 | * Take the board out of HOST mode and back into MIDI mode ... | |
666 | */ | |
667 | set_midi_mode_unsafe(s->io_base); | |
668 | ||
669 | spin_unlock_irqrestore(&s->lock, flags); | |
670 | return change; | |
671 | } | |
672 | ||
be624537 | 673 | static struct snd_kcontrol_new midi_mixer_ctl = { |
1da177e4 LT |
674 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
675 | .name = "MIDI", | |
676 | .info = sscape_midi_info, | |
677 | .get = sscape_midi_get, | |
678 | .put = sscape_midi_put | |
679 | }; | |
680 | ||
681 | /* | |
682 | * The SoundScape can use two IRQs from a possible set of four. | |
683 | * These IRQs are encoded as bit patterns so that they can be | |
684 | * written to the control registers. | |
685 | */ | |
1bff292e | 686 | static unsigned get_irq_config(int sscape_type, int irq) |
1da177e4 LT |
687 | { |
688 | static const int valid_irq[] = { 9, 5, 7, 10 }; | |
f0968e3f | 689 | static const int old_irq[] = { 9, 7, 5, 15 }; |
1da177e4 LT |
690 | unsigned cfg; |
691 | ||
f0968e3f KH |
692 | if (sscape_type == MEDIA_FX) { |
693 | for (cfg = 0; cfg < ARRAY_SIZE(old_irq); ++cfg) | |
694 | if (irq == old_irq[cfg]) | |
695 | return cfg; | |
696 | } else { | |
697 | for (cfg = 0; cfg < ARRAY_SIZE(valid_irq); ++cfg) | |
698 | if (irq == valid_irq[cfg]) | |
699 | return cfg; | |
700 | } | |
1da177e4 LT |
701 | |
702 | return INVALID_IRQ; | |
703 | } | |
704 | ||
1da177e4 LT |
705 | /* |
706 | * Perform certain arcane port-checks to see whether there | |
707 | * is a SoundScape board lurking behind the given ports. | |
708 | */ | |
1bff292e | 709 | static int detect_sscape(struct soundscape *s, long wss_io) |
1da177e4 LT |
710 | { |
711 | unsigned long flags; | |
712 | unsigned d; | |
713 | int retval = 0; | |
714 | ||
715 | spin_lock_irqsave(&s->lock, flags); | |
716 | ||
717 | /* | |
718 | * The following code is lifted from the original OSS driver, | |
719 | * and as I don't have a datasheet I cannot really comment | |
720 | * on what it is doing... | |
721 | */ | |
722 | if ((inb(HOST_CTRL_IO(s->io_base)) & 0x78) != 0) | |
723 | goto _done; | |
724 | ||
725 | d = inb(ODIE_ADDR_IO(s->io_base)) & 0xf0; | |
726 | if ((d & 0x80) != 0) | |
727 | goto _done; | |
728 | ||
453e37b3 | 729 | if (d == 0) |
1da177e4 | 730 | s->ic_type = IC_ODIE; |
453e37b3 | 731 | else if ((d & 0x60) != 0) |
1da177e4 | 732 | s->ic_type = IC_OPUS; |
453e37b3 | 733 | else |
1da177e4 LT |
734 | goto _done; |
735 | ||
736 | outb(0xfa, ODIE_ADDR_IO(s->io_base)); | |
737 | if ((inb(ODIE_ADDR_IO(s->io_base)) & 0x9f) != 0x0a) | |
738 | goto _done; | |
739 | ||
740 | outb(0xfe, ODIE_ADDR_IO(s->io_base)); | |
741 | if ((inb(ODIE_ADDR_IO(s->io_base)) & 0x9f) != 0x0e) | |
742 | goto _done; | |
ec1e7949 KH |
743 | |
744 | outb(0xfe, ODIE_ADDR_IO(s->io_base)); | |
745 | d = inb(ODIE_DATA_IO(s->io_base)); | |
746 | if (s->type != SSCAPE_VIVO && (d & 0x9f) != 0x0e) | |
1da177e4 LT |
747 | goto _done; |
748 | ||
f0968e3f KH |
749 | if (s->ic_type == IC_OPUS) |
750 | activate_ad1845_unsafe(s->io_base); | |
ec1e7949 KH |
751 | |
752 | if (s->type == SSCAPE_VIVO) | |
453e37b3 | 753 | wss_io += 4; |
f0968e3f | 754 | |
6fcfa395 | 755 | d = sscape_read_unsafe(s->io_base, GA_HMCTL_REG); |
f0968e3f KH |
756 | sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0); |
757 | ||
758 | /* wait for WSS codec */ | |
759 | for (d = 0; d < 500; d++) { | |
760 | if ((inb(wss_io) & 0x80) == 0) | |
761 | break; | |
762 | spin_unlock_irqrestore(&s->lock, flags); | |
763 | msleep(1); | |
764 | spin_lock_irqsave(&s->lock, flags); | |
765 | } | |
f0968e3f KH |
766 | |
767 | if ((inb(wss_io) & 0x80) != 0) | |
768 | goto _done; | |
769 | ||
770 | if (inb(wss_io + 2) == 0xff) | |
771 | goto _done; | |
772 | ||
773 | d = sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f; | |
774 | sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d); | |
775 | ||
776 | if ((inb(wss_io) & 0x80) != 0) | |
777 | s->type = MEDIA_FX; | |
778 | ||
6fcfa395 | 779 | d = sscape_read_unsafe(s->io_base, GA_HMCTL_REG); |
f0968e3f | 780 | sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0); |
ec1e7949 KH |
781 | /* wait for WSS codec */ |
782 | for (d = 0; d < 500; d++) { | |
453e37b3 | 783 | if ((inb(wss_io) & 0x80) == 0) |
ec1e7949 KH |
784 | break; |
785 | spin_unlock_irqrestore(&s->lock, flags); | |
786 | msleep(1); | |
787 | spin_lock_irqsave(&s->lock, flags); | |
788 | } | |
ec1e7949 | 789 | |
1da177e4 LT |
790 | /* |
791 | * SoundScape successfully detected! | |
792 | */ | |
793 | retval = 1; | |
794 | ||
6fcfa395 | 795 | _done: |
1da177e4 LT |
796 | spin_unlock_irqrestore(&s->lock, flags); |
797 | return retval; | |
798 | } | |
799 | ||
800 | /* | |
801 | * ALSA callback function, called when attempting to open the MIDI device. | |
802 | * Check that the MIDI firmware has been loaded, because we don't want | |
803 | * to crash the machine. Also check that someone isn't using the hardware | |
804 | * IOCTL device. | |
805 | */ | |
6fcfa395 | 806 | static int mpu401_open(struct snd_mpu401 *mpu) |
1da177e4 | 807 | { |
1da177e4 | 808 | if (!verify_mpu401(mpu)) { |
bcde1f8a KH |
809 | snd_printk(KERN_ERR "sscape: MIDI disabled, " |
810 | "please load firmware\n"); | |
811 | return -ENODEV; | |
1da177e4 LT |
812 | } |
813 | ||
bcde1f8a | 814 | return 0; |
1da177e4 LT |
815 | } |
816 | ||
817 | /* | |
818 | * Initialse an MPU-401 subdevice for MIDI support on the SoundScape. | |
819 | */ | |
1bff292e BP |
820 | static int create_mpu401(struct snd_card *card, int devnum, |
821 | unsigned long port, int irq) | |
1da177e4 LT |
822 | { |
823 | struct soundscape *sscape = get_card_soundscape(card); | |
be624537 | 824 | struct snd_rawmidi *rawmidi; |
1da177e4 LT |
825 | int err; |
826 | ||
6fcfa395 | 827 | err = snd_mpu401_uart_new(card, devnum, MPU401_HW_MPU401, port, |
dba8b469 | 828 | MPU401_INFO_INTEGRATED, irq, &rawmidi); |
6fcfa395 KH |
829 | if (err == 0) { |
830 | struct snd_mpu401 *mpu = rawmidi->private_data; | |
1da177e4 LT |
831 | mpu->open_input = mpu401_open; |
832 | mpu->open_output = mpu401_open; | |
1da177e4 | 833 | mpu->private_data = sscape; |
1da177e4 LT |
834 | |
835 | initialise_mpu401(mpu); | |
836 | } | |
837 | ||
838 | return err; | |
839 | } | |
840 | ||
841 | ||
1da177e4 LT |
842 | /* |
843 | * Create an AD1845 PCM subdevice on the SoundScape. The AD1845 | |
844 | * is very much like a CS4231, with a few extra bits. We will | |
845 | * try to support at least some of the extra bits by overriding | |
846 | * some of the CS4231 callback. | |
847 | */ | |
1bff292e BP |
848 | static int create_ad1845(struct snd_card *card, unsigned port, |
849 | int irq, int dma1, int dma2) | |
1da177e4 LT |
850 | { |
851 | register struct soundscape *sscape = get_card_soundscape(card); | |
7779f75f | 852 | struct snd_wss *chip; |
1da177e4 | 853 | int err; |
1cb0fdeb KH |
854 | int codec_type = WSS_HW_DETECT; |
855 | ||
856 | switch (sscape->type) { | |
857 | case MEDIA_FX: | |
858 | case SSCAPE: | |
859 | /* | |
860 | * There are some freak examples of early Soundscape cards | |
861 | * with CS4231 instead of AD1848/CS4248. Unfortunately, the | |
862 | * CS4231 works only in CS4248 compatibility mode on | |
863 | * these cards so force it. | |
864 | */ | |
865 | if (sscape->ic_type != IC_OPUS) | |
866 | codec_type = WSS_HW_AD1848; | |
867 | break; | |
1da177e4 | 868 | |
1cb0fdeb | 869 | case SSCAPE_VIVO: |
ec1e7949 | 870 | port += 4; |
1cb0fdeb KH |
871 | break; |
872 | default: | |
873 | break; | |
874 | } | |
ec1e7949 | 875 | |
7779f75f | 876 | err = snd_wss_create(card, port, -1, irq, dma1, dma2, |
1cb0fdeb | 877 | codec_type, WSS_HWSHARE_DMA1, &chip); |
4996bca9 | 878 | if (!err) { |
1da177e4 | 879 | unsigned long flags; |
be624537 | 880 | struct snd_pcm *pcm; |
1da177e4 | 881 | |
ec1e7949 | 882 | if (sscape->type != SSCAPE_VIVO) { |
ec1e7949 KH |
883 | /* |
884 | * The input clock frequency on the SoundScape must | |
885 | * be 14.31818 MHz, because we must set this register | |
886 | * to get the playback to sound correct ... | |
887 | */ | |
7779f75f | 888 | snd_wss_mce_up(chip); |
ec1e7949 | 889 | spin_lock_irqsave(&chip->reg_lock, flags); |
199f7978 | 890 | snd_wss_out(chip, AD1845_CLOCK, 0x20); |
ec1e7949 | 891 | spin_unlock_irqrestore(&chip->reg_lock, flags); |
7779f75f | 892 | snd_wss_mce_down(chip); |
1da177e4 | 893 | |
ec1e7949 | 894 | } |
1da177e4 | 895 | |
7779f75f | 896 | err = snd_wss_pcm(chip, 0, &pcm); |
ec1e7949 KH |
897 | if (err < 0) { |
898 | snd_printk(KERN_ERR "sscape: No PCM device " | |
899 | "for AD1845 chip\n"); | |
1da177e4 LT |
900 | goto _error; |
901 | } | |
902 | ||
7779f75f | 903 | err = snd_wss_mixer(chip); |
ec1e7949 KH |
904 | if (err < 0) { |
905 | snd_printk(KERN_ERR "sscape: No mixer device " | |
906 | "for AD1845 chip\n"); | |
1da177e4 LT |
907 | goto _error; |
908 | } | |
199f7978 KH |
909 | if (chip->hardware != WSS_HW_AD1848) { |
910 | err = snd_wss_timer(chip, 0, NULL); | |
911 | if (err < 0) { | |
912 | snd_printk(KERN_ERR "sscape: No timer device " | |
913 | "for AD1845 chip\n"); | |
914 | goto _error; | |
915 | } | |
1da177e4 LT |
916 | } |
917 | ||
ec1e7949 KH |
918 | if (sscape->type != SSCAPE_VIVO) { |
919 | err = snd_ctl_add(card, | |
920 | snd_ctl_new1(&midi_mixer_ctl, chip)); | |
921 | if (err < 0) { | |
922 | snd_printk(KERN_ERR "sscape: Could not create " | |
923 | "MIDI mixer control\n"); | |
924 | goto _error; | |
925 | } | |
ec1e7949 KH |
926 | } |
927 | ||
1da177e4 LT |
928 | sscape->chip = chip; |
929 | } | |
930 | ||
6fcfa395 | 931 | _error: |
1da177e4 LT |
932 | return err; |
933 | } | |
934 | ||
935 | ||
1da177e4 LT |
936 | /* |
937 | * Create an ALSA soundcard entry for the SoundScape, using | |
938 | * the given list of port, IRQ and DMA resources. | |
939 | */ | |
1bff292e | 940 | static int create_sscape(int dev, struct snd_card *card) |
1da177e4 | 941 | { |
ec1e7949 KH |
942 | struct soundscape *sscape = get_card_soundscape(card); |
943 | unsigned dma_cfg; | |
1da177e4 LT |
944 | unsigned irq_cfg; |
945 | unsigned mpu_irq_cfg; | |
946 | struct resource *io_res; | |
ec1e7949 | 947 | struct resource *wss_res; |
1da177e4 LT |
948 | unsigned long flags; |
949 | int err; | |
1cb0fdeb | 950 | int val; |
f0968e3f | 951 | const char *name; |
1da177e4 LT |
952 | |
953 | /* | |
954 | * Grab IO ports that we will need to probe so that we | |
955 | * can detect and control this hardware ... | |
956 | */ | |
453e37b3 | 957 | io_res = request_region(port[dev], 8, "SoundScape"); |
ec1e7949 | 958 | if (!io_res) { |
453e37b3 KH |
959 | snd_printk(KERN_ERR |
960 | "sscape: can't grab port 0x%lx\n", port[dev]); | |
1da177e4 LT |
961 | return -EBUSY; |
962 | } | |
ec1e7949 KH |
963 | wss_res = NULL; |
964 | if (sscape->type == SSCAPE_VIVO) { | |
965 | wss_res = request_region(wss_port[dev], 4, "SoundScape"); | |
966 | if (!wss_res) { | |
967 | snd_printk(KERN_ERR "sscape: can't grab port 0x%lx\n", | |
968 | wss_port[dev]); | |
969 | err = -EBUSY; | |
970 | goto _release_region; | |
971 | } | |
972 | } | |
1da177e4 LT |
973 | |
974 | /* | |
ec1e7949 | 975 | * Grab one DMA channel ... |
1da177e4 | 976 | */ |
4996bca9 KH |
977 | err = request_dma(dma[dev], "SoundScape"); |
978 | if (err < 0) { | |
277e926c | 979 | snd_printk(KERN_ERR "sscape: can't grab DMA %d\n", dma[dev]); |
1da177e4 LT |
980 | goto _release_region; |
981 | } | |
982 | ||
1da177e4 | 983 | spin_lock_init(&sscape->lock); |
1da177e4 | 984 | sscape->io_res = io_res; |
ec1e7949 | 985 | sscape->wss_res = wss_res; |
453e37b3 | 986 | sscape->io_base = port[dev]; |
1da177e4 | 987 | |
453e37b3 | 988 | if (!detect_sscape(sscape, wss_port[dev])) { |
bcde1f8a KH |
989 | printk(KERN_ERR "sscape: hardware not detected at 0x%x\n", |
990 | sscape->io_base); | |
1da177e4 | 991 | err = -ENODEV; |
4996bca9 | 992 | goto _release_dma; |
1da177e4 LT |
993 | } |
994 | ||
f0968e3f KH |
995 | switch (sscape->type) { |
996 | case MEDIA_FX: | |
997 | name = "MediaFX/SoundFX"; | |
998 | break; | |
999 | case SSCAPE: | |
1000 | name = "Soundscape"; | |
1001 | break; | |
1002 | case SSCAPE_PNP: | |
1003 | name = "Soundscape PnP"; | |
1004 | break; | |
1005 | case SSCAPE_VIVO: | |
1006 | name = "Soundscape VIVO"; | |
1007 | break; | |
1008 | default: | |
1009 | name = "unknown Soundscape"; | |
1010 | break; | |
1011 | } | |
1012 | ||
1013 | printk(KERN_INFO "sscape: %s card detected at 0x%x, using IRQ %d, DMA %d\n", | |
1014 | name, sscape->io_base, irq[dev], dma[dev]); | |
1015 | ||
1016 | /* | |
1017 | * Check that the user didn't pass us garbage data ... | |
1018 | */ | |
1019 | irq_cfg = get_irq_config(sscape->type, irq[dev]); | |
1020 | if (irq_cfg == INVALID_IRQ) { | |
1021 | snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", irq[dev]); | |
38be95dd JL |
1022 | err = -ENXIO; |
1023 | goto _release_dma; | |
f0968e3f KH |
1024 | } |
1025 | ||
1026 | mpu_irq_cfg = get_irq_config(sscape->type, mpu_irq[dev]); | |
1027 | if (mpu_irq_cfg == INVALID_IRQ) { | |
bcde1f8a | 1028 | snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", mpu_irq[dev]); |
38be95dd JL |
1029 | err = -ENXIO; |
1030 | goto _release_dma; | |
f0968e3f | 1031 | } |
1da177e4 | 1032 | |
1da177e4 LT |
1033 | /* |
1034 | * Tell the on-board devices where their resources are (I think - | |
1035 | * I can't be sure without a datasheet ... So many magic values!) | |
1036 | */ | |
1037 | spin_lock_irqsave(&sscape->lock, flags); | |
1038 | ||
1da177e4 LT |
1039 | sscape_write_unsafe(sscape->io_base, GA_SMCFGA_REG, 0x2e); |
1040 | sscape_write_unsafe(sscape->io_base, GA_SMCFGB_REG, 0x00); | |
1041 | ||
1042 | /* | |
1043 | * Enable and configure the DMA channels ... | |
1044 | */ | |
1045 | sscape_write_unsafe(sscape->io_base, GA_DMACFG_REG, 0x50); | |
f0968e3f | 1046 | dma_cfg = (sscape->ic_type == IC_OPUS ? 0x40 : 0x70); |
1da177e4 LT |
1047 | sscape_write_unsafe(sscape->io_base, GA_DMAA_REG, dma_cfg); |
1048 | sscape_write_unsafe(sscape->io_base, GA_DMAB_REG, 0x20); | |
1049 | ||
f0968e3f | 1050 | mpu_irq_cfg |= mpu_irq_cfg << 2; |
1cb0fdeb KH |
1051 | val = sscape_read_unsafe(sscape->io_base, GA_HMCTL_REG) & 0xF7; |
1052 | if (joystick[dev]) | |
1053 | val |= 8; | |
1054 | sscape_write_unsafe(sscape->io_base, GA_HMCTL_REG, val | 0x10); | |
f0968e3f | 1055 | sscape_write_unsafe(sscape->io_base, GA_INTCFG_REG, 0xf0 | mpu_irq_cfg); |
1da177e4 | 1056 | sscape_write_unsafe(sscape->io_base, |
4996bca9 KH |
1057 | GA_CDCFG_REG, 0x09 | DMA_8BIT |
1058 | | (dma[dev] << 4) | (irq_cfg << 1)); | |
6fcfa395 KH |
1059 | /* |
1060 | * Enable the master IRQ ... | |
1061 | */ | |
1062 | sscape_write_unsafe(sscape->io_base, GA_INTENA_REG, 0x80); | |
1da177e4 LT |
1063 | |
1064 | spin_unlock_irqrestore(&sscape->lock, flags); | |
1065 | ||
1066 | /* | |
1067 | * We have now enabled the codec chip, and so we should | |
1068 | * detect the AD1845 device ... | |
1069 | */ | |
4996bca9 KH |
1070 | err = create_ad1845(card, wss_port[dev], irq[dev], |
1071 | dma[dev], dma2[dev]); | |
1072 | if (err < 0) { | |
bcde1f8a KH |
1073 | snd_printk(KERN_ERR |
1074 | "sscape: No AD1845 device at 0x%lx, IRQ %d\n", | |
1075 | wss_port[dev], irq[dev]); | |
4996bca9 | 1076 | goto _release_dma; |
1da177e4 | 1077 | } |
acd47100 KH |
1078 | strcpy(card->driver, "SoundScape"); |
1079 | strcpy(card->shortname, name); | |
1080 | snprintf(card->longname, sizeof(card->longname), | |
1081 | "%s at 0x%lx, IRQ %d, DMA1 %d, DMA2 %d\n", | |
1082 | name, sscape->chip->port, sscape->chip->irq, | |
1083 | sscape->chip->dma1, sscape->chip->dma2); | |
1084 | ||
1da177e4 | 1085 | #define MIDI_DEVNUM 0 |
ec1e7949 | 1086 | if (sscape->type != SSCAPE_VIVO) { |
acd47100 KH |
1087 | err = sscape_upload_bootblock(card); |
1088 | if (err >= 0) | |
1089 | err = sscape_upload_microcode(card, err); | |
1da177e4 | 1090 | |
acd47100 KH |
1091 | if (err == 0) { |
1092 | err = create_mpu401(card, MIDI_DEVNUM, port[dev], | |
1093 | mpu_irq[dev]); | |
1094 | if (err < 0) { | |
bcde1f8a | 1095 | snd_printk(KERN_ERR "sscape: Failed to create " |
acd47100 KH |
1096 | "MPU-401 device at 0x%lx\n", |
1097 | port[dev]); | |
1098 | goto _release_dma; | |
1099 | } | |
1100 | ||
acd47100 KH |
1101 | /* |
1102 | * Initialize mixer | |
1103 | */ | |
1104 | spin_lock_irqsave(&sscape->lock, flags); | |
1105 | sscape->midi_vol = 0; | |
1106 | host_write_ctrl_unsafe(sscape->io_base, | |
1107 | CMD_SET_MIDI_VOL, 100); | |
1108 | host_write_ctrl_unsafe(sscape->io_base, | |
1109 | sscape->midi_vol, 100); | |
1110 | host_write_ctrl_unsafe(sscape->io_base, | |
1111 | CMD_XXX_MIDI_VOL, 100); | |
1112 | host_write_ctrl_unsafe(sscape->io_base, | |
1113 | sscape->midi_vol, 100); | |
1114 | host_write_ctrl_unsafe(sscape->io_base, | |
1115 | CMD_SET_EXTMIDI, 100); | |
1116 | host_write_ctrl_unsafe(sscape->io_base, | |
1117 | 0, 100); | |
1118 | host_write_ctrl_unsafe(sscape->io_base, CMD_ACK, 100); | |
1119 | ||
1120 | set_midi_mode_unsafe(sscape->io_base); | |
1121 | spin_unlock_irqrestore(&sscape->lock, flags); | |
1122 | } | |
ec1e7949 | 1123 | } |
1da177e4 LT |
1124 | |
1125 | /* | |
1126 | * Now that we have successfully created this sound card, | |
1127 | * it is safe to store the pointer. | |
1128 | * NOTE: we only register the sound card's "destructor" | |
1129 | * function now that our "constructor" has completed. | |
1130 | */ | |
1131 | card->private_free = soundscape_free; | |
1da177e4 LT |
1132 | |
1133 | return 0; | |
1134 | ||
4996bca9 | 1135 | _release_dma: |
277e926c | 1136 | free_dma(dma[dev]); |
1da177e4 | 1137 | |
4996bca9 | 1138 | _release_region: |
ec1e7949 | 1139 | release_and_free_resource(wss_res); |
b1d5776d | 1140 | release_and_free_resource(io_res); |
1da177e4 LT |
1141 | |
1142 | return err; | |
1143 | } | |
1144 | ||
1145 | ||
1bff292e | 1146 | static int snd_sscape_match(struct device *pdev, unsigned int i) |
5e24c1c1 TI |
1147 | { |
1148 | /* | |
1149 | * Make sure we were given ALL of the other parameters. | |
1150 | */ | |
1151 | if (port[i] == SNDRV_AUTO_PORT) | |
1152 | return 0; | |
1153 | ||
1154 | if (irq[i] == SNDRV_AUTO_IRQ || | |
1155 | mpu_irq[i] == SNDRV_AUTO_IRQ || | |
1156 | dma[i] == SNDRV_AUTO_DMA) { | |
1157 | printk(KERN_INFO | |
6fcfa395 KH |
1158 | "sscape: insufficient parameters, " |
1159 | "need IO, IRQ, MPU-IRQ and DMA\n"); | |
5e24c1c1 TI |
1160 | return 0; |
1161 | } | |
1162 | ||
1163 | return 1; | |
1164 | } | |
1165 | ||
1bff292e | 1166 | static int snd_sscape_probe(struct device *pdev, unsigned int dev) |
277e926c | 1167 | { |
277e926c | 1168 | struct snd_card *card; |
4996bca9 | 1169 | struct soundscape *sscape; |
277e926c TI |
1170 | int ret; |
1171 | ||
c95eadd2 TI |
1172 | ret = snd_card_create(index[dev], id[dev], THIS_MODULE, |
1173 | sizeof(struct soundscape), &card); | |
1174 | if (ret < 0) | |
1175 | return ret; | |
4996bca9 KH |
1176 | |
1177 | sscape = get_card_soundscape(card); | |
1178 | sscape->type = SSCAPE; | |
1179 | ||
277e926c | 1180 | dma[dev] &= 0x03; |
acd47100 KH |
1181 | snd_card_set_dev(card, pdev); |
1182 | ||
4996bca9 | 1183 | ret = create_sscape(dev, card); |
277e926c | 1184 | if (ret < 0) |
4996bca9 KH |
1185 | goto _release_card; |
1186 | ||
6fcfa395 KH |
1187 | ret = snd_card_register(card); |
1188 | if (ret < 0) { | |
bcde1f8a | 1189 | snd_printk(KERN_ERR "sscape: Failed to register sound card\n"); |
4996bca9 | 1190 | goto _release_card; |
277e926c | 1191 | } |
5e24c1c1 | 1192 | dev_set_drvdata(pdev, card); |
277e926c | 1193 | return 0; |
4996bca9 KH |
1194 | |
1195 | _release_card: | |
1196 | snd_card_free(card); | |
1197 | return ret; | |
277e926c TI |
1198 | } |
1199 | ||
1bff292e | 1200 | static int snd_sscape_remove(struct device *devptr, unsigned int dev) |
277e926c | 1201 | { |
5e24c1c1 | 1202 | snd_card_free(dev_get_drvdata(devptr)); |
277e926c TI |
1203 | return 0; |
1204 | } | |
1205 | ||
83c51c0a | 1206 | #define DEV_NAME "sscape" |
277e926c | 1207 | |
5e24c1c1 TI |
1208 | static struct isa_driver snd_sscape_driver = { |
1209 | .match = snd_sscape_match, | |
277e926c | 1210 | .probe = snd_sscape_probe, |
1bff292e | 1211 | .remove = snd_sscape_remove, |
277e926c TI |
1212 | /* FIXME: suspend/resume */ |
1213 | .driver = { | |
83c51c0a | 1214 | .name = DEV_NAME |
277e926c TI |
1215 | }, |
1216 | }; | |
1da177e4 LT |
1217 | |
1218 | #ifdef CONFIG_PNP | |
1bff292e | 1219 | static inline int get_next_autoindex(int i) |
1da177e4 | 1220 | { |
277e926c | 1221 | while (i < SNDRV_CARDS && port[i] != SNDRV_AUTO_PORT) |
1da177e4 | 1222 | ++i; |
1da177e4 LT |
1223 | return i; |
1224 | } | |
1225 | ||
1226 | ||
1bff292e BP |
1227 | static int sscape_pnp_detect(struct pnp_card_link *pcard, |
1228 | const struct pnp_card_device_id *pid) | |
1da177e4 | 1229 | { |
1da177e4 | 1230 | static int idx = 0; |
277e926c TI |
1231 | struct pnp_dev *dev; |
1232 | struct snd_card *card; | |
4996bca9 | 1233 | struct soundscape *sscape; |
1da177e4 LT |
1234 | int ret; |
1235 | ||
1236 | /* | |
1237 | * Allow this function to fail *quietly* if all the ISA PnP | |
1238 | * devices were configured using module parameters instead. | |
1239 | */ | |
6fcfa395 KH |
1240 | idx = get_next_autoindex(idx); |
1241 | if (idx >= SNDRV_CARDS) | |
1da177e4 | 1242 | return -ENOSPC; |
1da177e4 | 1243 | |
1da177e4 LT |
1244 | /* |
1245 | * Check that we still have room for another sound card ... | |
1246 | */ | |
1da177e4 | 1247 | dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL); |
6fcfa395 | 1248 | if (!dev) |
277e926c | 1249 | return -ENODEV; |
1da177e4 | 1250 | |
277e926c TI |
1251 | if (!pnp_is_active(dev)) { |
1252 | if (pnp_activate_dev(dev) < 0) { | |
bcde1f8a | 1253 | snd_printk(KERN_INFO "sscape: device is inactive\n"); |
277e926c | 1254 | return -EBUSY; |
1da177e4 LT |
1255 | } |
1256 | } | |
1257 | ||
4996bca9 KH |
1258 | /* |
1259 | * Create a new ALSA sound card entry, in anticipation | |
1260 | * of detecting our hardware ... | |
1261 | */ | |
c95eadd2 TI |
1262 | ret = snd_card_create(index[idx], id[idx], THIS_MODULE, |
1263 | sizeof(struct soundscape), &card); | |
1264 | if (ret < 0) | |
1265 | return ret; | |
4996bca9 KH |
1266 | |
1267 | sscape = get_card_soundscape(card); | |
1268 | ||
1269 | /* | |
1270 | * Identify card model ... | |
1271 | */ | |
1272 | if (!strncmp("ENS4081", pid->id, 7)) | |
1273 | sscape->type = SSCAPE_VIVO; | |
1274 | else | |
1275 | sscape->type = SSCAPE_PNP; | |
1276 | ||
277e926c TI |
1277 | /* |
1278 | * Read the correct parameters off the ISA PnP bus ... | |
1279 | */ | |
1280 | port[idx] = pnp_port_start(dev, 0); | |
1281 | irq[idx] = pnp_irq(dev, 0); | |
1282 | mpu_irq[idx] = pnp_irq(dev, 1); | |
1283 | dma[idx] = pnp_dma(dev, 0) & 0x03; | |
ec1e7949 KH |
1284 | if (sscape->type == SSCAPE_PNP) { |
1285 | dma2[idx] = dma[idx]; | |
1286 | wss_port[idx] = CODEC_IO(port[idx]); | |
1287 | } else { | |
1288 | wss_port[idx] = pnp_port_start(dev, 1); | |
1289 | dma2[idx] = pnp_dma(dev, 1); | |
1290 | } | |
acd47100 | 1291 | snd_card_set_dev(card, &pcard->card->dev); |
277e926c | 1292 | |
4996bca9 | 1293 | ret = create_sscape(idx, card); |
277e926c | 1294 | if (ret < 0) |
4996bca9 KH |
1295 | goto _release_card; |
1296 | ||
6fcfa395 KH |
1297 | ret = snd_card_register(card); |
1298 | if (ret < 0) { | |
bcde1f8a | 1299 | snd_printk(KERN_ERR "sscape: Failed to register sound card\n"); |
4996bca9 | 1300 | goto _release_card; |
277e926c TI |
1301 | } |
1302 | ||
1303 | pnp_set_card_drvdata(pcard, card); | |
1304 | ++idx; | |
4996bca9 | 1305 | return 0; |
277e926c | 1306 | |
4996bca9 KH |
1307 | _release_card: |
1308 | snd_card_free(card); | |
1da177e4 LT |
1309 | return ret; |
1310 | } | |
1311 | ||
1bff292e | 1312 | static void sscape_pnp_remove(struct pnp_card_link *pcard) |
1da177e4 | 1313 | { |
277e926c | 1314 | snd_card_free(pnp_get_card_drvdata(pcard)); |
1da177e4 | 1315 | pnp_set_card_drvdata(pcard, NULL); |
1da177e4 LT |
1316 | } |
1317 | ||
1318 | static struct pnp_card_driver sscape_pnpc_driver = { | |
1319 | .flags = PNP_DRIVER_RES_DO_NOT_CHANGE, | |
1320 | .name = "sscape", | |
1321 | .id_table = sscape_pnpids, | |
1322 | .probe = sscape_pnp_detect, | |
1bff292e | 1323 | .remove = sscape_pnp_remove, |
1da177e4 LT |
1324 | }; |
1325 | ||
1326 | #endif /* CONFIG_PNP */ | |
1327 | ||
1da177e4 LT |
1328 | static int __init sscape_init(void) |
1329 | { | |
609d7694 | 1330 | int err; |
1da177e4 | 1331 | |
609d7694 | 1332 | err = isa_register_driver(&snd_sscape_driver, SNDRV_CARDS); |
59b1b34f | 1333 | #ifdef CONFIG_PNP |
609d7694 RH |
1334 | if (!err) |
1335 | isa_registered = 1; | |
1336 | ||
1337 | err = pnp_register_card_driver(&sscape_pnpc_driver); | |
1338 | if (!err) | |
f7a9275d | 1339 | pnp_registered = 1; |
609d7694 RH |
1340 | |
1341 | if (isa_registered) | |
1342 | err = 0; | |
59b1b34f | 1343 | #endif |
609d7694 | 1344 | return err; |
1da177e4 LT |
1345 | } |
1346 | ||
5e24c1c1 TI |
1347 | static void __exit sscape_exit(void) |
1348 | { | |
1349 | #ifdef CONFIG_PNP | |
1350 | if (pnp_registered) | |
1351 | pnp_unregister_card_driver(&sscape_pnpc_driver); | |
609d7694 | 1352 | if (isa_registered) |
5e24c1c1 | 1353 | #endif |
609d7694 | 1354 | isa_unregister_driver(&snd_sscape_driver); |
5e24c1c1 TI |
1355 | } |
1356 | ||
1da177e4 LT |
1357 | module_init(sscape_init); |
1358 | module_exit(sscape_exit); |