blob: 06ad7863dff577362c0af9dacafbc5fd6f964f8b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Low-level ALSA driver for the ENSONIQ SoundScape PnP
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/init.h>
Takashi Iwai277e9262005-11-17 17:13:12 +010025#include <linux/err.h>
Takashi Iwai5e24c1c2007-02-22 12:50:54 +010026#include <linux/isa.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/delay.h>
28#include <linux/pnp.h>
29#include <linux/spinlock.h>
30#include <linux/moduleparam.h>
31#include <asm/dma.h>
32#include <sound/core.h>
33#include <sound/hwdep.h>
34#include <sound/cs4231.h>
35#include <sound/mpu401.h>
36#include <sound/initval.h>
37
38#include <sound/sscape_ioctl.h>
39
40
41MODULE_AUTHOR("Chris Rankin");
42MODULE_DESCRIPTION("ENSONIQ SoundScape PnP driver");
43MODULE_LICENSE("GPL");
44
45static int index[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IDX;
46static char* id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_STR;
Krzysztof Helt4996bca2007-09-17 16:23:13 +020047static long port[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PORT;
48static long wss_port[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049static int irq[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IRQ;
50static int mpu_irq[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_IRQ;
51static int dma[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_DMA;
Krzysztof Helt4996bca2007-09-17 16:23:13 +020052static int dma2[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_DMA;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54module_param_array(index, int, NULL, 0444);
55MODULE_PARM_DESC(index, "Index number for SoundScape soundcard");
56
57module_param_array(id, charp, NULL, 0444);
58MODULE_PARM_DESC(id, "Description for SoundScape card");
59
60module_param_array(port, long, NULL, 0444);
61MODULE_PARM_DESC(port, "Port # for SoundScape driver.");
62
Krzysztof Helt4996bca2007-09-17 16:23:13 +020063module_param_array(wss_port, long, NULL, 0444);
64MODULE_PARM_DESC(wss_port, "WSS Port # for SoundScape driver.");
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066module_param_array(irq, int, NULL, 0444);
67MODULE_PARM_DESC(irq, "IRQ # for SoundScape driver.");
68
69module_param_array(mpu_irq, int, NULL, 0444);
70MODULE_PARM_DESC(mpu_irq, "MPU401 IRQ # for SoundScape driver.");
71
72module_param_array(dma, int, NULL, 0444);
73MODULE_PARM_DESC(dma, "DMA # for SoundScape driver.");
Clemens Ladischf7a92752005-12-07 09:13:42 +010074
Krzysztof Helt4996bca2007-09-17 16:23:13 +020075module_param_array(dma2, int, NULL, 0444);
76MODULE_PARM_DESC(dma2, "DMA2 # for SoundScape driver.");
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078#ifdef CONFIG_PNP
Rene Herman609d7692007-05-15 11:42:56 +020079static int isa_registered;
Takashi Iwai59b1b342006-01-04 15:06:44 +010080static int pnp_registered;
Rene Herman609d7692007-05-15 11:42:56 +020081
Linus Torvalds1da177e2005-04-16 15:20:36 -070082static struct pnp_card_device_id sscape_pnpids[] = {
Krzysztof Helt4996bca2007-09-17 16:23:13 +020083 { .id = "ENS3081", .devs = { { "ENS0000" } } }, /* Soundscape PnP */
84 { .id = "ENS4081", .devs = { { "ENS1011" } } }, /* VIVO90 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 { .id = "" } /* end */
86};
87
88MODULE_DEVICE_TABLE(pnp_card, sscape_pnpids);
89#endif
90
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92#define MPU401_IO(i) ((i) + 0)
93#define MIDI_DATA_IO(i) ((i) + 0)
94#define MIDI_CTRL_IO(i) ((i) + 1)
95#define HOST_CTRL_IO(i) ((i) + 2)
96#define HOST_DATA_IO(i) ((i) + 3)
97#define ODIE_ADDR_IO(i) ((i) + 4)
98#define ODIE_DATA_IO(i) ((i) + 5)
99#define CODEC_IO(i) ((i) + 8)
100
101#define IC_ODIE 1
102#define IC_OPUS 2
103
104#define RX_READY 0x01
105#define TX_READY 0x02
106
107#define CMD_ACK 0x80
108#define CMD_SET_MIDI_VOL 0x84
109#define CMD_GET_MIDI_VOL 0x85
110#define CMD_XXX_MIDI_VOL 0x86
111#define CMD_SET_EXTMIDI 0x8a
112#define CMD_GET_EXTMIDI 0x8b
113#define CMD_SET_MT32 0x8c
114#define CMD_GET_MT32 0x8d
115
116enum GA_REG {
117 GA_INTSTAT_REG = 0,
118 GA_INTENA_REG,
119 GA_DMAA_REG,
120 GA_DMAB_REG,
121 GA_INTCFG_REG,
122 GA_DMACFG_REG,
123 GA_CDCFG_REG,
124 GA_SMCFGA_REG,
125 GA_SMCFGB_REG,
126 GA_HMCTL_REG
127};
128
129#define DMA_8BIT 0x80
130
131
132#define AD1845_FREQ_SEL_MSB 0x16
133#define AD1845_FREQ_SEL_LSB 0x17
134
Krzysztof Helt4996bca2007-09-17 16:23:13 +0200135enum card_type {
136 SSCAPE,
137 SSCAPE_PNP,
138 SSCAPE_VIVO,
139};
140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141struct soundscape {
142 spinlock_t lock;
143 unsigned io_base;
Krzysztof Heltec1e7942007-09-17 17:57:37 +0200144 unsigned wss_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 int codec_type;
146 int ic_type;
Krzysztof Helt4996bca2007-09-17 16:23:13 +0200147 enum card_type type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 struct resource *io_res;
Krzysztof Heltec1e7942007-09-17 17:57:37 +0200149 struct resource *wss_res;
Takashi Iwaibe624532005-11-17 14:42:05 +0100150 struct snd_cs4231 *chip;
151 struct snd_mpu401 *mpu;
152 struct snd_hwdep *hw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 /*
155 * The MIDI device won't work until we've loaded
156 * its firmware via a hardware-dependent device IOCTL
157 */
158 spinlock_t fwlock;
159 int hw_in_use;
160 unsigned long midi_usage;
161 unsigned char midi_vol;
162};
163
164#define INVALID_IRQ ((unsigned)-1)
165
166
Takashi Iwaibe624532005-11-17 14:42:05 +0100167static inline struct soundscape *get_card_soundscape(struct snd_card *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
169 return (struct soundscape *) (c->private_data);
170}
171
Takashi Iwaibe624532005-11-17 14:42:05 +0100172static inline struct soundscape *get_mpu401_soundscape(struct snd_mpu401 * mpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173{
174 return (struct soundscape *) (mpu->private_data);
175}
176
Takashi Iwaibe624532005-11-17 14:42:05 +0100177static inline struct soundscape *get_hwdep_soundscape(struct snd_hwdep * hw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
179 return (struct soundscape *) (hw->private_data);
180}
181
182
183/*
184 * Allocates some kernel memory that we can use for DMA.
185 * I think this means that the memory has to map to
186 * contiguous pages of physical memory.
187 */
188static struct snd_dma_buffer *get_dmabuf(struct snd_dma_buffer *buf, unsigned long size)
189{
190 if (buf) {
191 if (snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV, snd_dma_isa_data(),
192 size, buf) < 0) {
193 snd_printk(KERN_ERR "sscape: Failed to allocate %lu bytes for DMA\n", size);
194 return NULL;
195 }
196 }
197
198 return buf;
199}
200
201/*
202 * Release the DMA-able kernel memory ...
203 */
204static void free_dmabuf(struct snd_dma_buffer *buf)
205{
206 if (buf && buf->area)
207 snd_dma_free_pages(buf);
208}
209
210
211/*
212 * This function writes to the SoundScape's control registers,
213 * but doesn't do any locking. It's up to the caller to do that.
214 * This is why this function is "unsafe" ...
215 */
216static inline void sscape_write_unsafe(unsigned io_base, enum GA_REG reg, unsigned char val)
217{
218 outb(reg, ODIE_ADDR_IO(io_base));
219 outb(val, ODIE_DATA_IO(io_base));
220}
221
222/*
223 * Write to the SoundScape's control registers, and do the
224 * necessary locking ...
225 */
226static void sscape_write(struct soundscape *s, enum GA_REG reg, unsigned char val)
227{
228 unsigned long flags;
229
230 spin_lock_irqsave(&s->lock, flags);
231 sscape_write_unsafe(s->io_base, reg, val);
232 spin_unlock_irqrestore(&s->lock, flags);
233}
234
235/*
236 * Read from the SoundScape's control registers, but leave any
237 * locking to the caller. This is why the function is "unsafe" ...
238 */
239static inline unsigned char sscape_read_unsafe(unsigned io_base, enum GA_REG reg)
240{
241 outb(reg, ODIE_ADDR_IO(io_base));
242 return inb(ODIE_DATA_IO(io_base));
243}
244
245/*
246 * Puts the SoundScape into "host" mode, as compared to "MIDI" mode
247 */
248static inline void set_host_mode_unsafe(unsigned io_base)
249{
250 outb(0x0, HOST_CTRL_IO(io_base));
251}
252
253/*
254 * Puts the SoundScape into "MIDI" mode, as compared to "host" mode
255 */
256static inline void set_midi_mode_unsafe(unsigned io_base)
257{
258 outb(0x3, HOST_CTRL_IO(io_base));
259}
260
261/*
262 * Read the SoundScape's host-mode control register, but leave
263 * any locking issues to the caller ...
264 */
265static inline int host_read_unsafe(unsigned io_base)
266{
267 int data = -1;
268 if ((inb(HOST_CTRL_IO(io_base)) & RX_READY) != 0) {
269 data = inb(HOST_DATA_IO(io_base));
270 }
271
272 return data;
273}
274
275/*
276 * Read the SoundScape's host-mode control register, performing
277 * a limited amount of busy-waiting if the register isn't ready.
278 * Also leaves all locking-issues to the caller ...
279 */
280static int host_read_ctrl_unsafe(unsigned io_base, unsigned timeout)
281{
282 int data;
283
284 while (((data = host_read_unsafe(io_base)) < 0) && (timeout != 0)) {
285 udelay(100);
286 --timeout;
287 } /* while */
288
289 return data;
290}
291
292/*
293 * Write to the SoundScape's host-mode control registers, but
294 * leave any locking issues to the caller ...
295 */
296static inline int host_write_unsafe(unsigned io_base, unsigned char data)
297{
298 if ((inb(HOST_CTRL_IO(io_base)) & TX_READY) != 0) {
299 outb(data, HOST_DATA_IO(io_base));
300 return 1;
301 }
302
303 return 0;
304}
305
306/*
307 * Write to the SoundScape's host-mode control registers, performing
308 * a limited amount of busy-waiting if the register isn't ready.
309 * Also leaves all locking-issues to the caller ...
310 */
311static int host_write_ctrl_unsafe(unsigned io_base, unsigned char data,
312 unsigned timeout)
313{
314 int err;
315
316 while (!(err = host_write_unsafe(io_base, data)) && (timeout != 0)) {
317 udelay(100);
318 --timeout;
319 } /* while */
320
321 return err;
322}
323
324
325/*
326 * Check that the MIDI subsystem is operational. If it isn't,
327 * then we will hang the computer if we try to use it ...
328 *
329 * NOTE: This check is based upon observation, not documentation.
330 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100331static inline int verify_mpu401(const struct snd_mpu401 * mpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332{
333 return ((inb(MIDI_CTRL_IO(mpu->port)) & 0xc0) == 0x80);
334}
335
336/*
337 * This is apparently the standard way to initailise an MPU-401
338 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100339static inline void initialise_mpu401(const struct snd_mpu401 * mpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
341 outb(0, MIDI_DATA_IO(mpu->port));
342}
343
344/*
345 * Tell the SoundScape to activate the AD1845 chip (I think).
346 * The AD1845 detection fails if we *don't* do this, so I
347 * think that this is a good idea ...
348 */
349static inline void activate_ad1845_unsafe(unsigned io_base)
350{
351 sscape_write_unsafe(io_base, GA_HMCTL_REG, (sscape_read_unsafe(io_base, GA_HMCTL_REG) & 0xcf) | 0x10);
352 sscape_write_unsafe(io_base, GA_CDCFG_REG, 0x80);
353}
354
355/*
356 * Do the necessary ALSA-level cleanup to deallocate our driver ...
357 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100358static void soundscape_free(struct snd_card *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Krzysztof Heltec1e7942007-09-17 17:57:37 +0200360 struct soundscape *sscape = get_card_soundscape(c);
Takashi Iwaib1d57762005-10-10 11:56:31 +0200361 release_and_free_resource(sscape->io_res);
Krzysztof Heltec1e7942007-09-17 17:57:37 +0200362 release_and_free_resource(sscape->wss_res);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 free_dma(sscape->chip->dma1);
364}
365
366/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 * Tell the SoundScape to begin a DMA tranfer using the given channel.
368 * All locking issues are left to the caller.
369 */
370static inline void sscape_start_dma_unsafe(unsigned io_base, enum GA_REG reg)
371{
372 sscape_write_unsafe(io_base, reg, sscape_read_unsafe(io_base, reg) | 0x01);
373 sscape_write_unsafe(io_base, reg, sscape_read_unsafe(io_base, reg) & 0xfe);
374}
375
376/*
377 * Wait for a DMA transfer to complete. This is a "limited busy-wait",
378 * and all locking issues are left to the caller.
379 */
380static int sscape_wait_dma_unsafe(unsigned io_base, enum GA_REG reg, unsigned timeout)
381{
382 while (!(sscape_read_unsafe(io_base, reg) & 0x01) && (timeout != 0)) {
383 udelay(100);
384 --timeout;
385 } /* while */
386
387 return (sscape_read_unsafe(io_base, reg) & 0x01);
388}
389
390/*
391 * Wait for the On-Board Processor to return its start-up
392 * acknowledgement sequence. This wait is too long for
393 * us to perform "busy-waiting", and so we must sleep.
394 * This in turn means that we must not be holding any
395 * spinlocks when we call this function.
396 */
397static int obp_startup_ack(struct soundscape *s, unsigned timeout)
398{
399 while (timeout != 0) {
400 unsigned long flags;
401 unsigned char x;
402
Rene Hermand86d0192007-09-18 18:10:49 +0200403 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405 spin_lock_irqsave(&s->lock, flags);
406 x = inb(HOST_DATA_IO(s->io_base));
407 spin_unlock_irqrestore(&s->lock, flags);
408 if ((x & 0xfe) == 0xfe)
409 return 1;
410
411 --timeout;
412 } /* while */
413
414 return 0;
415}
416
417/*
418 * Wait for the host to return its start-up acknowledgement
419 * sequence. This wait is too long for us to perform
420 * "busy-waiting", and so we must sleep. This in turn means
421 * that we must not be holding any spinlocks when we call
422 * this function.
423 */
424static int host_startup_ack(struct soundscape *s, unsigned timeout)
425{
426 while (timeout != 0) {
427 unsigned long flags;
428 unsigned char x;
429
Rene Hermand86d0192007-09-18 18:10:49 +0200430 schedule_timeout_uninterruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
432 spin_lock_irqsave(&s->lock, flags);
433 x = inb(HOST_DATA_IO(s->io_base));
434 spin_unlock_irqrestore(&s->lock, flags);
435 if (x == 0xfe)
436 return 1;
437
438 --timeout;
439 } /* while */
440
441 return 0;
442}
443
444/*
445 * Upload a byte-stream into the SoundScape using DMA channel A.
446 */
447static int upload_dma_data(struct soundscape *s,
448 const unsigned char __user *data,
449 size_t size)
450{
451 unsigned long flags;
452 struct snd_dma_buffer dma;
453 int ret;
454
455 if (!get_dmabuf(&dma, PAGE_ALIGN(size)))
456 return -ENOMEM;
457
458 spin_lock_irqsave(&s->lock, flags);
459
460 /*
461 * Reset the board ...
462 */
463 sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f);
464
465 /*
466 * Enable the DMA channels and configure them ...
467 */
468 sscape_write_unsafe(s->io_base, GA_DMACFG_REG, 0x50);
469 sscape_write_unsafe(s->io_base, GA_DMAA_REG, (s->chip->dma1 << 4) | DMA_8BIT);
470 sscape_write_unsafe(s->io_base, GA_DMAB_REG, 0x20);
471
472 /*
473 * Take the board out of reset ...
474 */
475 sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) | 0x80);
476
477 /*
478 * Upload the user's data (firmware?) to the SoundScape
479 * board through the DMA channel ...
480 */
481 while (size != 0) {
482 unsigned long len;
483
484 /*
485 * Apparently, copying to/from userspace can sleep.
486 * We are therefore forbidden from holding any
487 * spinlocks while we copy ...
488 */
489 spin_unlock_irqrestore(&s->lock, flags);
490
491 /*
492 * Remember that the data that we want to DMA
493 * comes from USERSPACE. We have already verified
494 * the userspace pointer ...
495 */
496 len = min(size, dma.bytes);
497 len -= __copy_from_user(dma.area, data, len);
498 data += len;
499 size -= len;
500
501 /*
502 * Grab that spinlock again, now that we've
503 * finished copying!
504 */
505 spin_lock_irqsave(&s->lock, flags);
506
507 snd_dma_program(s->chip->dma1, dma.addr, len, DMA_MODE_WRITE);
508 sscape_start_dma_unsafe(s->io_base, GA_DMAA_REG);
509 if (!sscape_wait_dma_unsafe(s->io_base, GA_DMAA_REG, 5000)) {
510 /*
511 * Don't forget to release this spinlock we're holding ...
512 */
513 spin_unlock_irqrestore(&s->lock, flags);
514
515 snd_printk(KERN_ERR "sscape: DMA upload has timed out\n");
516 ret = -EAGAIN;
517 goto _release_dma;
518 }
519 } /* while */
520
521 set_host_mode_unsafe(s->io_base);
522
523 /*
524 * Boot the board ... (I think)
525 */
526 sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) | 0x40);
527 spin_unlock_irqrestore(&s->lock, flags);
528
529 /*
530 * If all has gone well, then the board should acknowledge
531 * the new upload and tell us that it has rebooted OK. We
532 * give it 5 seconds (max) ...
533 */
534 ret = 0;
535 if (!obp_startup_ack(s, 5)) {
536 snd_printk(KERN_ERR "sscape: No response from on-board processor after upload\n");
537 ret = -EAGAIN;
538 } else if (!host_startup_ack(s, 5)) {
539 snd_printk(KERN_ERR "sscape: SoundScape failed to initialise\n");
540 ret = -EAGAIN;
541 }
542
Krzysztof Helt4996bca2007-09-17 16:23:13 +0200543_release_dma:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 /*
545 * NOTE!!! We are NOT holding any spinlocks at this point !!!
546 */
547 sscape_write(s, GA_DMAA_REG, (s->ic_type == IC_ODIE ? 0x70 : 0x40));
548 free_dmabuf(&dma);
549
550 return ret;
551}
552
553/*
554 * Upload the bootblock(?) into the SoundScape. The only
555 * purpose of this block of code seems to be to tell
556 * us which version of the microcode we should be using.
557 *
558 * NOTE: The boot-block data resides in USER-SPACE!!!
559 * However, we have already verified its memory
560 * addresses by the time we get here.
561 */
562static int sscape_upload_bootblock(struct soundscape *sscape, struct sscape_bootblock __user *bb)
563{
564 unsigned long flags;
565 int data = 0;
566 int ret;
567
568 ret = upload_dma_data(sscape, bb->code, sizeof(bb->code));
569
570 spin_lock_irqsave(&sscape->lock, flags);
571 if (ret == 0) {
572 data = host_read_ctrl_unsafe(sscape->io_base, 100);
573 }
574 set_midi_mode_unsafe(sscape->io_base);
575 spin_unlock_irqrestore(&sscape->lock, flags);
576
577 if (ret == 0) {
578 if (data < 0) {
579 snd_printk(KERN_ERR "sscape: timeout reading firmware version\n");
580 ret = -EAGAIN;
581 }
582 else if (__copy_to_user(&bb->version, &data, sizeof(bb->version))) {
583 ret = -EFAULT;
584 }
585 }
586
587 return ret;
588}
589
590/*
591 * Upload the microcode into the SoundScape. The
592 * microcode is 64K of data, and if we try to copy
593 * it into a local variable then we will SMASH THE
594 * KERNEL'S STACK! We therefore leave it in USER
595 * SPACE, and save ourselves from copying it at all.
596 */
597static int sscape_upload_microcode(struct soundscape *sscape,
598 const struct sscape_microcode __user *mc)
599{
600 unsigned long flags;
601 char __user *code;
602 int err;
603
604 /*
605 * We are going to have to copy this data into a special
606 * DMA-able buffer before we can upload it. We shall therefore
607 * just check that the data pointer is valid for now.
608 *
609 * NOTE: This buffer is 64K long! That's WAY too big to
610 * copy into a stack-temporary anyway.
611 */
612 if ( get_user(code, &mc->code) ||
613 !access_ok(VERIFY_READ, code, SSCAPE_MICROCODE_SIZE) )
614 return -EFAULT;
615
616 if ((err = upload_dma_data(sscape, code, SSCAPE_MICROCODE_SIZE)) == 0) {
617 snd_printk(KERN_INFO "sscape: MIDI firmware loaded\n");
618 }
619
620 spin_lock_irqsave(&sscape->lock, flags);
621 set_midi_mode_unsafe(sscape->io_base);
622 spin_unlock_irqrestore(&sscape->lock, flags);
623
624 initialise_mpu401(sscape->mpu);
625
626 return err;
627}
628
629/*
630 * Hardware-specific device functions, to implement special
631 * IOCTLs for the SoundScape card. This is how we upload
632 * the microcode into the card, for example, and so we
633 * must ensure that no two processes can open this device
634 * simultaneously, and that we can't open it at all if
635 * someone is using the MIDI device.
636 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100637static int sscape_hw_open(struct snd_hwdep * hw, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
639 register struct soundscape *sscape = get_hwdep_soundscape(hw);
640 unsigned long flags;
641 int err;
642
643 spin_lock_irqsave(&sscape->fwlock, flags);
644
645 if ((sscape->midi_usage != 0) || sscape->hw_in_use) {
646 err = -EBUSY;
647 } else {
648 sscape->hw_in_use = 1;
649 err = 0;
650 }
651
652 spin_unlock_irqrestore(&sscape->fwlock, flags);
653 return err;
654}
655
Takashi Iwaibe624532005-11-17 14:42:05 +0100656static int sscape_hw_release(struct snd_hwdep * hw, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657{
658 register struct soundscape *sscape = get_hwdep_soundscape(hw);
659 unsigned long flags;
660
661 spin_lock_irqsave(&sscape->fwlock, flags);
662 sscape->hw_in_use = 0;
663 spin_unlock_irqrestore(&sscape->fwlock, flags);
664 return 0;
665}
666
Takashi Iwaibe624532005-11-17 14:42:05 +0100667static int sscape_hw_ioctl(struct snd_hwdep * hw, struct file *file,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 unsigned int cmd, unsigned long arg)
669{
670 struct soundscape *sscape = get_hwdep_soundscape(hw);
671 int err = -EBUSY;
672
673 switch (cmd) {
674 case SND_SSCAPE_LOAD_BOOTB:
675 {
676 register struct sscape_bootblock __user *bb = (struct sscape_bootblock __user *) arg;
677
678 /*
679 * We are going to have to copy this data into a special
680 * DMA-able buffer before we can upload it. We shall therefore
681 * just check that the data pointer is valid for now ...
682 */
683 if ( !access_ok(VERIFY_READ, bb->code, sizeof(bb->code)) )
684 return -EFAULT;
685
686 /*
687 * Now check that we can write the firmware version number too...
688 */
689 if ( !access_ok(VERIFY_WRITE, &bb->version, sizeof(bb->version)) )
690 return -EFAULT;
691
692 err = sscape_upload_bootblock(sscape, bb);
693 }
694 break;
695
696 case SND_SSCAPE_LOAD_MCODE:
697 {
698 register const struct sscape_microcode __user *mc = (const struct sscape_microcode __user *) arg;
699
700 err = sscape_upload_microcode(sscape, mc);
701 }
702 break;
703
704 default:
705 err = -EINVAL;
706 break;
707 } /* switch */
708
709 return err;
710}
711
712
713/*
714 * Mixer control for the SoundScape's MIDI device.
715 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100716static int sscape_midi_info(struct snd_kcontrol *ctl,
717 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718{
719 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
720 uinfo->count = 1;
721 uinfo->value.integer.min = 0;
722 uinfo->value.integer.max = 127;
723 return 0;
724}
725
Takashi Iwaibe624532005-11-17 14:42:05 +0100726static int sscape_midi_get(struct snd_kcontrol *kctl,
727 struct snd_ctl_elem_value *uctl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728{
Takashi Iwaibe624532005-11-17 14:42:05 +0100729 struct snd_cs4231 *chip = snd_kcontrol_chip(kctl);
730 struct snd_card *card = chip->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 register struct soundscape *s = get_card_soundscape(card);
732 unsigned long flags;
733
734 spin_lock_irqsave(&s->lock, flags);
735 set_host_mode_unsafe(s->io_base);
736
737 if (host_write_ctrl_unsafe(s->io_base, CMD_GET_MIDI_VOL, 100)) {
738 uctl->value.integer.value[0] = host_read_ctrl_unsafe(s->io_base, 100);
739 }
740
741 set_midi_mode_unsafe(s->io_base);
742 spin_unlock_irqrestore(&s->lock, flags);
743 return 0;
744}
745
Takashi Iwaibe624532005-11-17 14:42:05 +0100746static int sscape_midi_put(struct snd_kcontrol *kctl,
747 struct snd_ctl_elem_value *uctl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748{
Takashi Iwaibe624532005-11-17 14:42:05 +0100749 struct snd_cs4231 *chip = snd_kcontrol_chip(kctl);
750 struct snd_card *card = chip->card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 register struct soundscape *s = get_card_soundscape(card);
752 unsigned long flags;
753 int change;
754
755 spin_lock_irqsave(&s->lock, flags);
756
757 /*
758 * We need to put the board into HOST mode before we
759 * can send any volume-changing HOST commands ...
760 */
761 set_host_mode_unsafe(s->io_base);
762
763 /*
764 * To successfully change the MIDI volume setting, you seem to
765 * have to write a volume command, write the new volume value,
766 * and then perform another volume-related command. Perhaps the
767 * first command is an "open" and the second command is a "close"?
768 */
769 if (s->midi_vol == ((unsigned char) uctl->value.integer. value[0] & 127)) {
770 change = 0;
771 goto __skip_change;
772 }
773 change = (host_write_ctrl_unsafe(s->io_base, CMD_SET_MIDI_VOL, 100)
774 && host_write_ctrl_unsafe(s->io_base, ((unsigned char) uctl->value.integer. value[0]) & 127, 100)
775 && host_write_ctrl_unsafe(s->io_base, CMD_XXX_MIDI_VOL, 100));
776 __skip_change:
777
778 /*
779 * Take the board out of HOST mode and back into MIDI mode ...
780 */
781 set_midi_mode_unsafe(s->io_base);
782
783 spin_unlock_irqrestore(&s->lock, flags);
784 return change;
785}
786
Takashi Iwaibe624532005-11-17 14:42:05 +0100787static struct snd_kcontrol_new midi_mixer_ctl = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
789 .name = "MIDI",
790 .info = sscape_midi_info,
791 .get = sscape_midi_get,
792 .put = sscape_midi_put
793};
794
795/*
796 * The SoundScape can use two IRQs from a possible set of four.
797 * These IRQs are encoded as bit patterns so that they can be
798 * written to the control registers.
799 */
800static unsigned __devinit get_irq_config(int irq)
801{
802 static const int valid_irq[] = { 9, 5, 7, 10 };
803 unsigned cfg;
804
805 for (cfg = 0; cfg < ARRAY_SIZE(valid_irq); ++cfg) {
806 if (irq == valid_irq[cfg])
807 return cfg;
808 } /* for */
809
810 return INVALID_IRQ;
811}
812
813
814/*
815 * Perform certain arcane port-checks to see whether there
816 * is a SoundScape board lurking behind the given ports.
817 */
818static int __devinit detect_sscape(struct soundscape *s)
819{
820 unsigned long flags;
821 unsigned d;
822 int retval = 0;
Krzysztof Heltec1e7942007-09-17 17:57:37 +0200823 int codec = s->wss_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 spin_lock_irqsave(&s->lock, flags);
826
827 /*
828 * The following code is lifted from the original OSS driver,
829 * and as I don't have a datasheet I cannot really comment
830 * on what it is doing...
831 */
832 if ((inb(HOST_CTRL_IO(s->io_base)) & 0x78) != 0)
833 goto _done;
834
835 d = inb(ODIE_ADDR_IO(s->io_base)) & 0xf0;
836 if ((d & 0x80) != 0)
837 goto _done;
838
839 if (d == 0) {
840 s->codec_type = 1;
841 s->ic_type = IC_ODIE;
842 } else if ((d & 0x60) != 0) {
843 s->codec_type = 2;
844 s->ic_type = IC_OPUS;
845 } else
846 goto _done;
847
848 outb(0xfa, ODIE_ADDR_IO(s->io_base));
849 if ((inb(ODIE_ADDR_IO(s->io_base)) & 0x9f) != 0x0a)
850 goto _done;
851
852 outb(0xfe, ODIE_ADDR_IO(s->io_base));
853 if ((inb(ODIE_ADDR_IO(s->io_base)) & 0x9f) != 0x0e)
854 goto _done;
Krzysztof Heltec1e7942007-09-17 17:57:37 +0200855
856 outb(0xfe, ODIE_ADDR_IO(s->io_base));
857 d = inb(ODIE_DATA_IO(s->io_base));
858 if (s->type != SSCAPE_VIVO && (d & 0x9f) != 0x0e)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 goto _done;
860
Krzysztof Heltec1e7942007-09-17 17:57:37 +0200861 d = sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f;
862 sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0);
863
864 if (s->type == SSCAPE_VIVO)
865 codec += 4;
866 /* wait for WSS codec */
867 for (d = 0; d < 500; d++) {
868 if ((inb(codec) & 0x80) == 0)
869 break;
870 spin_unlock_irqrestore(&s->lock, flags);
871 msleep(1);
872 spin_lock_irqsave(&s->lock, flags);
873 }
874 snd_printd(KERN_INFO "init delay = %d ms\n", d);
875
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 /*
877 * SoundScape successfully detected!
878 */
879 retval = 1;
880
881 _done:
882 spin_unlock_irqrestore(&s->lock, flags);
883 return retval;
884}
885
886/*
887 * ALSA callback function, called when attempting to open the MIDI device.
888 * Check that the MIDI firmware has been loaded, because we don't want
889 * to crash the machine. Also check that someone isn't using the hardware
890 * IOCTL device.
891 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100892static int mpu401_open(struct snd_mpu401 * mpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
894 int err;
895
896 if (!verify_mpu401(mpu)) {
897 snd_printk(KERN_ERR "sscape: MIDI disabled, please load firmware\n");
898 err = -ENODEV;
899 } else {
900 register struct soundscape *sscape = get_mpu401_soundscape(mpu);
901 unsigned long flags;
902
903 spin_lock_irqsave(&sscape->fwlock, flags);
904
905 if (sscape->hw_in_use || (sscape->midi_usage == ULONG_MAX)) {
906 err = -EBUSY;
907 } else {
908 ++(sscape->midi_usage);
909 err = 0;
910 }
911
912 spin_unlock_irqrestore(&sscape->fwlock, flags);
913 }
914
915 return err;
916}
917
Takashi Iwaibe624532005-11-17 14:42:05 +0100918static void mpu401_close(struct snd_mpu401 * mpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919{
920 register struct soundscape *sscape = get_mpu401_soundscape(mpu);
921 unsigned long flags;
922
923 spin_lock_irqsave(&sscape->fwlock, flags);
924 --(sscape->midi_usage);
925 spin_unlock_irqrestore(&sscape->fwlock, flags);
926}
927
928/*
929 * Initialse an MPU-401 subdevice for MIDI support on the SoundScape.
930 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100931static int __devinit create_mpu401(struct snd_card *card, int devnum, unsigned long port, int irq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932{
933 struct soundscape *sscape = get_card_soundscape(card);
Takashi Iwaibe624532005-11-17 14:42:05 +0100934 struct snd_rawmidi *rawmidi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 int err;
936
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 if ((err = snd_mpu401_uart_new(card, devnum,
938 MPU401_HW_MPU401,
Takashi Iwai302e4c22006-05-23 13:24:30 +0200939 port, MPU401_INFO_INTEGRATED,
Thomas Gleixner65ca68b2006-07-01 19:29:46 -0700940 irq, IRQF_DISABLED,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 &rawmidi)) == 0) {
Takashi Iwaibe624532005-11-17 14:42:05 +0100942 struct snd_mpu401 *mpu = (struct snd_mpu401 *) rawmidi->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 mpu->open_input = mpu401_open;
944 mpu->open_output = mpu401_open;
945 mpu->close_input = mpu401_close;
946 mpu->close_output = mpu401_close;
947 mpu->private_data = sscape;
948 sscape->mpu = mpu;
949
950 initialise_mpu401(mpu);
951 }
952
953 return err;
954}
955
956
957/*
958 * Override for the CS4231 playback format function.
959 * The AD1845 has much simpler format and rate selection.
960 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100961static void ad1845_playback_format(struct snd_cs4231 * chip, struct snd_pcm_hw_params *params, unsigned char format)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962{
963 unsigned long flags;
964 unsigned rate = params_rate(params);
965
966 /*
967 * The AD1845 can't handle sample frequencies
968 * outside of 4 kHZ to 50 kHZ
969 */
970 if (rate > 50000)
971 rate = 50000;
972 else if (rate < 4000)
973 rate = 4000;
974
975 spin_lock_irqsave(&chip->reg_lock, flags);
976
977 /*
978 * Program the AD1845 correctly for the playback stream.
979 * Note that we do NOT need to toggle the MCE bit because
980 * the PLAYBACK_ENABLE bit of the Interface Configuration
981 * register is set.
982 *
983 * NOTE: We seem to need to write to the MSB before the LSB
984 * to get the correct sample frequency.
985 */
986 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, (format & 0xf0));
987 snd_cs4231_out(chip, AD1845_FREQ_SEL_MSB, (unsigned char) (rate >> 8));
988 snd_cs4231_out(chip, AD1845_FREQ_SEL_LSB, (unsigned char) rate);
989
990 spin_unlock_irqrestore(&chip->reg_lock, flags);
991}
992
993/*
994 * Override for the CS4231 capture format function.
995 * The AD1845 has much simpler format and rate selection.
996 */
Takashi Iwaibe624532005-11-17 14:42:05 +0100997static void ad1845_capture_format(struct snd_cs4231 * chip, struct snd_pcm_hw_params *params, unsigned char format)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998{
999 unsigned long flags;
1000 unsigned rate = params_rate(params);
1001
1002 /*
1003 * The AD1845 can't handle sample frequencies
1004 * outside of 4 kHZ to 50 kHZ
1005 */
1006 if (rate > 50000)
1007 rate = 50000;
1008 else if (rate < 4000)
1009 rate = 4000;
1010
1011 spin_lock_irqsave(&chip->reg_lock, flags);
1012
1013 /*
1014 * Program the AD1845 correctly for the playback stream.
1015 * Note that we do NOT need to toggle the MCE bit because
1016 * the CAPTURE_ENABLE bit of the Interface Configuration
1017 * register is set.
1018 *
1019 * NOTE: We seem to need to write to the MSB before the LSB
1020 * to get the correct sample frequency.
1021 */
1022 snd_cs4231_out(chip, CS4231_REC_FORMAT, (format & 0xf0));
1023 snd_cs4231_out(chip, AD1845_FREQ_SEL_MSB, (unsigned char) (rate >> 8));
1024 snd_cs4231_out(chip, AD1845_FREQ_SEL_LSB, (unsigned char) rate);
1025
1026 spin_unlock_irqrestore(&chip->reg_lock, flags);
1027}
1028
1029/*
1030 * Create an AD1845 PCM subdevice on the SoundScape. The AD1845
1031 * is very much like a CS4231, with a few extra bits. We will
1032 * try to support at least some of the extra bits by overriding
1033 * some of the CS4231 callback.
1034 */
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001035static int __devinit create_ad1845(struct snd_card *card, unsigned port,
1036 int irq, int dma1, int dma2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037{
1038 register struct soundscape *sscape = get_card_soundscape(card);
Takashi Iwaibe624532005-11-17 14:42:05 +01001039 struct snd_cs4231 *chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 int err;
1041
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001042 if (sscape->type == SSCAPE_VIVO)
1043 port += 4;
1044
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001045 if (dma1 == dma2)
1046 dma2 = -1;
1047
1048 err = snd_cs4231_create(card,
1049 port, -1, irq, dma1, dma2,
1050 CS4231_HW_DETECT, CS4231_HWSHARE_DMA1, &chip);
1051 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 unsigned long flags;
Takashi Iwaibe624532005-11-17 14:42:05 +01001053 struct snd_pcm *pcm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
1055#define AD1845_FREQ_SEL_ENABLE 0x08
1056
1057#define AD1845_PWR_DOWN_CTRL 0x1b
1058#define AD1845_CRYS_CLOCK_SEL 0x1d
1059
1060/*
1061 * It turns out that the PLAYBACK_ENABLE bit is set
1062 * by the lowlevel driver ...
1063 *
1064#define AD1845_IFACE_CONFIG \
1065 (CS4231_AUTOCALIB | CS4231_RECORD_ENABLE | CS4231_PLAYBACK_ENABLE)
1066 snd_cs4231_mce_up(chip);
1067 spin_lock_irqsave(&chip->reg_lock, flags);
1068 snd_cs4231_out(chip, CS4231_IFACE_CTRL, AD1845_IFACE_CONFIG);
1069 spin_unlock_irqrestore(&chip->reg_lock, flags);
1070 snd_cs4231_mce_down(chip);
1071 */
1072
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001073 if (sscape->type != SSCAPE_VIVO) {
1074 int val;
1075 /*
1076 * The input clock frequency on the SoundScape must
1077 * be 14.31818 MHz, because we must set this register
1078 * to get the playback to sound correct ...
1079 */
1080 snd_cs4231_mce_up(chip);
1081 spin_lock_irqsave(&chip->reg_lock, flags);
1082 snd_cs4231_out(chip, AD1845_CRYS_CLOCK_SEL, 0x20);
1083 spin_unlock_irqrestore(&chip->reg_lock, flags);
1084 snd_cs4231_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001086 /*
1087 * More custom configuration:
1088 * a) select "mode 2" and provide a current drive of 8mA
1089 * b) enable frequency selection (for capture/playback)
1090 */
1091 spin_lock_irqsave(&chip->reg_lock, flags);
1092 snd_cs4231_out(chip, CS4231_MISC_INFO,
1093 CS4231_MODE2 | 0x10);
1094 val = snd_cs4231_in(chip, AD1845_PWR_DOWN_CTRL);
1095 snd_cs4231_out(chip, AD1845_PWR_DOWN_CTRL,
1096 val | AD1845_FREQ_SEL_ENABLE);
1097 spin_unlock_irqrestore(&chip->reg_lock, flags);
1098 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001100 err = snd_cs4231_pcm(chip, 0, &pcm);
1101 if (err < 0) {
1102 snd_printk(KERN_ERR "sscape: No PCM device "
1103 "for AD1845 chip\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 goto _error;
1105 }
1106
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001107 err = snd_cs4231_mixer(chip);
1108 if (err < 0) {
1109 snd_printk(KERN_ERR "sscape: No mixer device "
1110 "for AD1845 chip\n");
1111 goto _error;
1112 }
1113 err = snd_cs4231_timer(chip, 0, NULL);
1114 if (err < 0) {
1115 snd_printk(KERN_ERR "sscape: No timer device "
1116 "for AD1845 chip\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 goto _error;
1118 }
1119
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001120 if (sscape->type != SSCAPE_VIVO) {
1121 err = snd_ctl_add(card,
1122 snd_ctl_new1(&midi_mixer_ctl, chip));
1123 if (err < 0) {
1124 snd_printk(KERN_ERR "sscape: Could not create "
1125 "MIDI mixer control\n");
1126 goto _error;
1127 }
1128 chip->set_playback_format = ad1845_playback_format;
1129 chip->set_capture_format = ad1845_capture_format;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 }
1131
1132 strcpy(card->driver, "SoundScape");
1133 strcpy(card->shortname, pcm->name);
1134 snprintf(card->longname, sizeof(card->longname),
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001135 "%s at 0x%lx, IRQ %d, DMA1 %d, DMA2 %d\n",
1136 pcm->name, chip->port, chip->irq,
1137 chip->dma1, chip->dma2);
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 sscape->chip = chip;
1140 }
1141
1142 _error:
1143 return err;
1144}
1145
1146
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147/*
1148 * Create an ALSA soundcard entry for the SoundScape, using
1149 * the given list of port, IRQ and DMA resources.
1150 */
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001151static int __devinit create_sscape(int dev, struct snd_card *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152{
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001153 struct soundscape *sscape = get_card_soundscape(card);
1154 unsigned dma_cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 unsigned irq_cfg;
1156 unsigned mpu_irq_cfg;
Takashi Iwai277e9262005-11-17 17:13:12 +01001157 unsigned xport;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 struct resource *io_res;
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001159 struct resource *wss_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 unsigned long flags;
1161 int err;
1162
1163 /*
1164 * Check that the user didn't pass us garbage data ...
1165 */
Takashi Iwai277e9262005-11-17 17:13:12 +01001166 irq_cfg = get_irq_config(irq[dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 if (irq_cfg == INVALID_IRQ) {
Takashi Iwai277e9262005-11-17 17:13:12 +01001168 snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", irq[dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 return -ENXIO;
1170 }
1171
Takashi Iwai277e9262005-11-17 17:13:12 +01001172 mpu_irq_cfg = get_irq_config(mpu_irq[dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 if (mpu_irq_cfg == INVALID_IRQ) {
Takashi Iwai277e9262005-11-17 17:13:12 +01001174 printk(KERN_ERR "sscape: Invalid IRQ %d\n", mpu_irq[dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 return -ENXIO;
1176 }
Takashi Iwai277e9262005-11-17 17:13:12 +01001177 xport = port[dev];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
1179 /*
1180 * Grab IO ports that we will need to probe so that we
1181 * can detect and control this hardware ...
1182 */
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001183 io_res = request_region(xport, 8, "SoundScape");
1184 if (!io_res) {
Takashi Iwai277e9262005-11-17 17:13:12 +01001185 snd_printk(KERN_ERR "sscape: can't grab port 0x%x\n", xport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 return -EBUSY;
1187 }
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001188 wss_res = NULL;
1189 if (sscape->type == SSCAPE_VIVO) {
1190 wss_res = request_region(wss_port[dev], 4, "SoundScape");
1191 if (!wss_res) {
1192 snd_printk(KERN_ERR "sscape: can't grab port 0x%lx\n",
1193 wss_port[dev]);
1194 err = -EBUSY;
1195 goto _release_region;
1196 }
1197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
1199 /*
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001200 * Grab one DMA channel ...
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 */
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001202 err = request_dma(dma[dev], "SoundScape");
1203 if (err < 0) {
Takashi Iwai277e9262005-11-17 17:13:12 +01001204 snd_printk(KERN_ERR "sscape: can't grab DMA %d\n", dma[dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 goto _release_region;
1206 }
1207
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 spin_lock_init(&sscape->lock);
1209 spin_lock_init(&sscape->fwlock);
1210 sscape->io_res = io_res;
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001211 sscape->wss_res = wss_res;
Takashi Iwai277e9262005-11-17 17:13:12 +01001212 sscape->io_base = xport;
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001213 sscape->wss_base = wss_port[dev];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
1215 if (!detect_sscape(sscape)) {
1216 printk(KERN_ERR "sscape: hardware not detected at 0x%x\n", sscape->io_base);
1217 err = -ENODEV;
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001218 goto _release_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 }
1220
1221 printk(KERN_INFO "sscape: hardware detected at 0x%x, using IRQ %d, DMA %d\n",
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001222 sscape->io_base, irq[dev], dma[dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001224 if (sscape->type != SSCAPE_VIVO) {
1225 /*
1226 * Now create the hardware-specific device so that we can
1227 * load the microcode into the on-board processor.
1228 * We cannot use the MPU-401 MIDI system until this firmware
1229 * has been loaded into the card.
1230 */
1231 err = snd_hwdep_new(card, "MC68EC000", 0, &(sscape->hw));
1232 if (err < 0) {
1233 printk(KERN_ERR "sscape: Failed to create "
1234 "firmware device\n");
1235 goto _release_dma;
1236 }
1237 strlcpy(sscape->hw->name, "SoundScape M68K",
1238 sizeof(sscape->hw->name));
1239 sscape->hw->name[sizeof(sscape->hw->name) - 1] = '\0';
1240 sscape->hw->iface = SNDRV_HWDEP_IFACE_SSCAPE;
1241 sscape->hw->ops.open = sscape_hw_open;
1242 sscape->hw->ops.release = sscape_hw_release;
1243 sscape->hw->ops.ioctl = sscape_hw_ioctl;
1244 sscape->hw->private_data = sscape;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246
1247 /*
1248 * Tell the on-board devices where their resources are (I think -
1249 * I can't be sure without a datasheet ... So many magic values!)
1250 */
1251 spin_lock_irqsave(&sscape->lock, flags);
1252
1253 activate_ad1845_unsafe(sscape->io_base);
1254
1255 sscape_write_unsafe(sscape->io_base, GA_INTENA_REG, 0x00); /* disable */
1256 sscape_write_unsafe(sscape->io_base, GA_SMCFGA_REG, 0x2e);
1257 sscape_write_unsafe(sscape->io_base, GA_SMCFGB_REG, 0x00);
1258
1259 /*
1260 * Enable and configure the DMA channels ...
1261 */
1262 sscape_write_unsafe(sscape->io_base, GA_DMACFG_REG, 0x50);
1263 dma_cfg = (sscape->ic_type == IC_ODIE ? 0x70 : 0x40);
1264 sscape_write_unsafe(sscape->io_base, GA_DMAA_REG, dma_cfg);
1265 sscape_write_unsafe(sscape->io_base, GA_DMAB_REG, 0x20);
1266
1267 sscape_write_unsafe(sscape->io_base,
1268 GA_INTCFG_REG, 0xf0 | (mpu_irq_cfg << 2) | mpu_irq_cfg);
1269 sscape_write_unsafe(sscape->io_base,
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001270 GA_CDCFG_REG, 0x09 | DMA_8BIT
1271 | (dma[dev] << 4) | (irq_cfg << 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272
1273 spin_unlock_irqrestore(&sscape->lock, flags);
1274
1275 /*
1276 * We have now enabled the codec chip, and so we should
1277 * detect the AD1845 device ...
1278 */
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001279 err = create_ad1845(card, wss_port[dev], irq[dev],
1280 dma[dev], dma2[dev]);
1281 if (err < 0) {
1282 printk(KERN_ERR "sscape: No AD1845 device at 0x%lx, IRQ %d\n",
1283 wss_port[dev], irq[dev]);
1284 goto _release_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 }
1286#define MIDI_DEVNUM 0
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001287 if (sscape->type != SSCAPE_VIVO) {
1288 err = create_mpu401(card, MIDI_DEVNUM,
1289 MPU401_IO(xport), mpu_irq[dev]);
1290 if (err < 0) {
1291 printk(KERN_ERR "sscape: Failed to create "
1292 "MPU-401 device at 0x%x\n",
1293 MPU401_IO(xport));
1294 goto _release_dma;
1295 }
1296
1297 /*
1298 * Enable the master IRQ ...
1299 */
1300 sscape_write(sscape, GA_INTENA_REG, 0x80);
1301
1302 /*
1303 * Initialize mixer
1304 */
1305 sscape->midi_vol = 0;
1306 host_write_ctrl_unsafe(sscape->io_base, CMD_SET_MIDI_VOL, 100);
1307 host_write_ctrl_unsafe(sscape->io_base, 0, 100);
1308 host_write_ctrl_unsafe(sscape->io_base, CMD_XXX_MIDI_VOL, 100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 }
1310
1311 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 * Now that we have successfully created this sound card,
1313 * it is safe to store the pointer.
1314 * NOTE: we only register the sound card's "destructor"
1315 * function now that our "constructor" has completed.
1316 */
1317 card->private_free = soundscape_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
1319 return 0;
1320
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001321_release_dma:
Takashi Iwai277e9262005-11-17 17:13:12 +01001322 free_dma(dma[dev]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001324_release_region:
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001325 release_and_free_resource(wss_res);
Takashi Iwaib1d57762005-10-10 11:56:31 +02001326 release_and_free_resource(io_res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
1328 return err;
1329}
1330
1331
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001332static int __devinit snd_sscape_match(struct device *pdev, unsigned int i)
Takashi Iwai277e9262005-11-17 17:13:12 +01001333{
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001334 /*
1335 * Make sure we were given ALL of the other parameters.
1336 */
1337 if (port[i] == SNDRV_AUTO_PORT)
1338 return 0;
1339
1340 if (irq[i] == SNDRV_AUTO_IRQ ||
1341 mpu_irq[i] == SNDRV_AUTO_IRQ ||
1342 dma[i] == SNDRV_AUTO_DMA) {
1343 printk(KERN_INFO
1344 "sscape: insufficient parameters, need IO, IRQ, MPU-IRQ and DMA\n");
1345 return 0;
1346 }
1347
1348 return 1;
1349}
1350
1351static int __devinit snd_sscape_probe(struct device *pdev, unsigned int dev)
1352{
Takashi Iwai277e9262005-11-17 17:13:12 +01001353 struct snd_card *card;
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001354 struct soundscape *sscape;
Takashi Iwai277e9262005-11-17 17:13:12 +01001355 int ret;
1356
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001357 card = snd_card_new(index[dev], id[dev], THIS_MODULE,
1358 sizeof(struct soundscape));
1359 if (!card)
1360 return -ENOMEM;
1361
1362 sscape = get_card_soundscape(card);
1363 sscape->type = SSCAPE;
1364
Takashi Iwai277e9262005-11-17 17:13:12 +01001365 dma[dev] &= 0x03;
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001366 ret = create_sscape(dev, card);
Takashi Iwai277e9262005-11-17 17:13:12 +01001367 if (ret < 0)
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001368 goto _release_card;
1369
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001370 snd_card_set_dev(card, pdev);
Takashi Iwai277e9262005-11-17 17:13:12 +01001371 if ((ret = snd_card_register(card)) < 0) {
1372 printk(KERN_ERR "sscape: Failed to register sound card\n");
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001373 goto _release_card;
Takashi Iwai277e9262005-11-17 17:13:12 +01001374 }
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001375 dev_set_drvdata(pdev, card);
Takashi Iwai277e9262005-11-17 17:13:12 +01001376 return 0;
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001377
1378_release_card:
1379 snd_card_free(card);
1380 return ret;
Takashi Iwai277e9262005-11-17 17:13:12 +01001381}
1382
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001383static int __devexit snd_sscape_remove(struct device *devptr, unsigned int dev)
Takashi Iwai277e9262005-11-17 17:13:12 +01001384{
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001385 snd_card_free(dev_get_drvdata(devptr));
1386 dev_set_drvdata(devptr, NULL);
Takashi Iwai277e9262005-11-17 17:13:12 +01001387 return 0;
1388}
1389
Rene Herman83c51c02007-03-20 11:33:46 +01001390#define DEV_NAME "sscape"
Takashi Iwai277e9262005-11-17 17:13:12 +01001391
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001392static struct isa_driver snd_sscape_driver = {
1393 .match = snd_sscape_match,
Takashi Iwai277e9262005-11-17 17:13:12 +01001394 .probe = snd_sscape_probe,
1395 .remove = __devexit_p(snd_sscape_remove),
1396 /* FIXME: suspend/resume */
1397 .driver = {
Rene Herman83c51c02007-03-20 11:33:46 +01001398 .name = DEV_NAME
Takashi Iwai277e9262005-11-17 17:13:12 +01001399 },
1400};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
1402#ifdef CONFIG_PNP
1403static inline int __devinit get_next_autoindex(int i)
1404{
Takashi Iwai277e9262005-11-17 17:13:12 +01001405 while (i < SNDRV_CARDS && port[i] != SNDRV_AUTO_PORT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 ++i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 return i;
1408}
1409
1410
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411static int __devinit sscape_pnp_detect(struct pnp_card_link *pcard,
1412 const struct pnp_card_device_id *pid)
1413{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 static int idx = 0;
Takashi Iwai277e9262005-11-17 17:13:12 +01001415 struct pnp_dev *dev;
1416 struct snd_card *card;
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001417 struct soundscape *sscape;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 int ret;
1419
1420 /*
1421 * Allow this function to fail *quietly* if all the ISA PnP
1422 * devices were configured using module parameters instead.
1423 */
Takashi Iwai277e9262005-11-17 17:13:12 +01001424 if ((idx = get_next_autoindex(idx)) >= SNDRV_CARDS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426
1427 /*
1428 * We have found a candidate ISA PnP card. Now we
1429 * have to check that it has the devices that we
1430 * expect it to have.
1431 *
1432 * We will NOT try and autoconfigure all of the resources
1433 * needed and then activate the card as we are assuming that
1434 * has already been done at boot-time using /proc/isapnp.
1435 * We shall simply try to give each active card the resources
1436 * that it wants. This is a sensible strategy for a modular
1437 * system where unused modules are unloaded regularly.
1438 *
1439 * This strategy is utterly useless if we compile the driver
1440 * into the kernel, of course.
1441 */
1442 // printk(KERN_INFO "sscape: %s\n", card->name);
1443
1444 /*
1445 * Check that we still have room for another sound card ...
1446 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL);
Takashi Iwai277e9262005-11-17 17:13:12 +01001448 if (! dev)
1449 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450
Takashi Iwai277e9262005-11-17 17:13:12 +01001451 if (!pnp_is_active(dev)) {
1452 if (pnp_activate_dev(dev) < 0) {
1453 printk(KERN_INFO "sscape: device is inactive\n");
1454 return -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 }
1456 }
1457
Takashi Iwai277e9262005-11-17 17:13:12 +01001458 /*
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001459 * Create a new ALSA sound card entry, in anticipation
1460 * of detecting our hardware ...
1461 */
1462 card = snd_card_new(index[idx], id[idx], THIS_MODULE,
1463 sizeof(struct soundscape));
1464 if (!card)
1465 return -ENOMEM;
1466
1467 sscape = get_card_soundscape(card);
1468
1469 /*
1470 * Identify card model ...
1471 */
1472 if (!strncmp("ENS4081", pid->id, 7))
1473 sscape->type = SSCAPE_VIVO;
1474 else
1475 sscape->type = SSCAPE_PNP;
1476
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001477 /*
Takashi Iwai277e9262005-11-17 17:13:12 +01001478 * Read the correct parameters off the ISA PnP bus ...
1479 */
1480 port[idx] = pnp_port_start(dev, 0);
1481 irq[idx] = pnp_irq(dev, 0);
1482 mpu_irq[idx] = pnp_irq(dev, 1);
1483 dma[idx] = pnp_dma(dev, 0) & 0x03;
Krzysztof Heltec1e7942007-09-17 17:57:37 +02001484 if (sscape->type == SSCAPE_PNP) {
1485 dma2[idx] = dma[idx];
1486 wss_port[idx] = CODEC_IO(port[idx]);
1487 } else {
1488 wss_port[idx] = pnp_port_start(dev, 1);
1489 dma2[idx] = pnp_dma(dev, 1);
1490 }
Takashi Iwai277e9262005-11-17 17:13:12 +01001491
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001492 ret = create_sscape(idx, card);
Takashi Iwai277e9262005-11-17 17:13:12 +01001493 if (ret < 0)
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001494 goto _release_card;
1495
Takashi Iwai277e9262005-11-17 17:13:12 +01001496 snd_card_set_dev(card, &pcard->card->dev);
1497 if ((ret = snd_card_register(card)) < 0) {
1498 printk(KERN_ERR "sscape: Failed to register sound card\n");
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001499 goto _release_card;
Takashi Iwai277e9262005-11-17 17:13:12 +01001500 }
1501
1502 pnp_set_card_drvdata(pcard, card);
1503 ++idx;
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001504 return 0;
Takashi Iwai277e9262005-11-17 17:13:12 +01001505
Krzysztof Helt4996bca2007-09-17 16:23:13 +02001506_release_card:
1507 snd_card_free(card);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 return ret;
1509}
1510
1511static void __devexit sscape_pnp_remove(struct pnp_card_link * pcard)
1512{
Takashi Iwai277e9262005-11-17 17:13:12 +01001513 snd_card_free(pnp_get_card_drvdata(pcard));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 pnp_set_card_drvdata(pcard, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515}
1516
1517static struct pnp_card_driver sscape_pnpc_driver = {
1518 .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1519 .name = "sscape",
1520 .id_table = sscape_pnpids,
1521 .probe = sscape_pnp_detect,
1522 .remove = __devexit_p(sscape_pnp_remove),
1523};
1524
1525#endif /* CONFIG_PNP */
1526
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527static int __init sscape_init(void)
1528{
Rene Herman609d7692007-05-15 11:42:56 +02001529 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
Rene Herman609d7692007-05-15 11:42:56 +02001531 err = isa_register_driver(&snd_sscape_driver, SNDRV_CARDS);
Takashi Iwai59b1b342006-01-04 15:06:44 +01001532#ifdef CONFIG_PNP
Rene Herman609d7692007-05-15 11:42:56 +02001533 if (!err)
1534 isa_registered = 1;
1535
1536 err = pnp_register_card_driver(&sscape_pnpc_driver);
1537 if (!err)
Clemens Ladischf7a92752005-12-07 09:13:42 +01001538 pnp_registered = 1;
Rene Herman609d7692007-05-15 11:42:56 +02001539
1540 if (isa_registered)
1541 err = 0;
Takashi Iwai59b1b342006-01-04 15:06:44 +01001542#endif
Rene Herman609d7692007-05-15 11:42:56 +02001543 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544}
1545
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001546static void __exit sscape_exit(void)
1547{
1548#ifdef CONFIG_PNP
1549 if (pnp_registered)
1550 pnp_unregister_card_driver(&sscape_pnpc_driver);
Rene Herman609d7692007-05-15 11:42:56 +02001551 if (isa_registered)
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001552#endif
Rene Herman609d7692007-05-15 11:42:56 +02001553 isa_unregister_driver(&snd_sscape_driver);
Takashi Iwai5e24c1c2007-02-22 12:50:54 +01001554}
1555
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556module_init(sscape_init);
1557module_exit(sscape_exit);