Merge master.kernel.org:/pub/scm/linux/kernel/git/mchehab/v4l-dvb
[linux-2.6] / sound / oss / sscape.c
1 /*
2  * sound/sscape.c
3  *
4  * Low level driver for Ensoniq SoundScape
5  *
6  *
7  * Copyright (C) by Hannu Savolainen 1993-1997
8  *
9  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10  * Version 2 (June 1991). See the "COPYING" file distributed with this software
11  * for more info.
12  *
13  *
14  * Thomas Sailer        : ioctl code reworked (vmalloc/vfree removed)
15  * Sergey Smitienko     : ensoniq p'n'p support
16  * Christoph Hellwig    : adapted to module_init/module_exit
17  * Bartlomiej Zolnierkiewicz : added __init to attach_sscape()
18  * Chris Rankin         : Specify that this module owns the coprocessor
19  * Arnaldo C. de Melo   : added missing restore_flags in sscape_pnp_upload_file
20  */
21
22 #include <linux/init.h>
23 #include <linux/module.h>
24
25 #include "sound_config.h"
26 #include "sound_firmware.h"
27
28 #include <linux/types.h>
29 #include <linux/errno.h>
30 #include <linux/signal.h>
31 #include <linux/fcntl.h>
32 #include <linux/ctype.h>
33 #include <linux/stddef.h>
34 #include <linux/kmod.h>
35 #include <asm/dma.h>
36 #include <asm/io.h>
37 #include <linux/wait.h>
38 #include <linux/slab.h>
39 #include <linux/ioport.h>
40 #include <linux/delay.h>
41 #include <linux/proc_fs.h>
42 #include <linux/spinlock.h>
43
44 #include "coproc.h"
45
46 #include "ad1848.h"
47 #include "mpu401.h"
48
49 /*
50  *    I/O ports
51  */
52 #define MIDI_DATA       0
53 #define MIDI_CTRL       1
54 #define HOST_CTRL       2
55 #define TX_READY        0x02
56 #define RX_READY        0x01
57 #define HOST_DATA       3
58 #define ODIE_ADDR       4
59 #define ODIE_DATA       5
60
61 /*
62  *    Indirect registers
63  */
64
65 #define GA_INTSTAT_REG  0
66 #define GA_INTENA_REG   1
67 #define GA_DMAA_REG     2
68 #define GA_DMAB_REG     3
69 #define GA_INTCFG_REG   4
70 #define GA_DMACFG_REG   5
71 #define GA_CDCFG_REG    6
72 #define GA_SMCFGA_REG   7
73 #define GA_SMCFGB_REG   8
74 #define GA_HMCTL_REG    9
75
76 /*
77  * DMA channel identifiers (A and B)
78  */
79
80 #define SSCAPE_DMA_A    0
81 #define SSCAPE_DMA_B    1
82
83 #define PORT(name)      (devc->base+name)
84
85 /*
86  * Host commands recognized by the OBP microcode
87  */
88  
89 #define CMD_GEN_HOST_ACK        0x80
90 #define CMD_GEN_MPU_ACK         0x81
91 #define CMD_GET_BOARD_TYPE      0x82
92 #define CMD_SET_CONTROL         0x88    /* Old firmware only */
93 #define CMD_GET_CONTROL         0x89    /* Old firmware only */
94 #define CTL_MASTER_VOL          0
95 #define CTL_MIC_MODE            2
96 #define CTL_SYNTH_VOL           4
97 #define CTL_WAVE_VOL            7
98 #define CMD_SET_EXTMIDI         0x8a
99 #define CMD_GET_EXTMIDI         0x8b
100 #define CMD_SET_MT32            0x8c
101 #define CMD_GET_MT32            0x8d
102
103 #define CMD_ACK                 0x80
104
105 #define IC_ODIE                 1
106 #define IC_OPUS                 2
107
108 typedef struct sscape_info
109 {
110         int     base, irq, dma;
111         
112         int     codec, codec_irq;       /* required to setup pnp cards*/
113         int     codec_type;
114         int     ic_type;
115         char*   raw_buf;
116         unsigned long   raw_buf_phys;
117         int     buffsize;               /* -------------------------- */
118         spinlock_t lock;
119         int     ok;     /* Properly detected */
120         int     failed;
121         int     dma_allocated;
122         int     codec_audiodev;
123         int     opened;
124         int     *osp;
125         int     my_audiodev;
126 } sscape_info;
127
128 static struct sscape_info adev_info = {
129         0
130 };
131
132 static struct sscape_info *devc = &adev_info;
133 static int sscape_mididev = -1;
134
135 /* Some older cards have assigned interrupt bits differently than new ones */
136 static char valid_interrupts_old[] = {
137         9, 7, 5, 15
138 };
139
140 static char valid_interrupts_new[] = {
141         9, 5, 7, 10
142 };
143
144 static char *valid_interrupts = valid_interrupts_new;
145
146 /*
147  *      See the bottom of the driver. This can be set by spea =0/1.
148  */
149  
150 #ifdef REVEAL_SPEA
151 static char old_hardware = 1;
152 #else
153 static char old_hardware;
154 #endif
155
156 static void sleep(unsigned howlong)
157 {
158         current->state = TASK_INTERRUPTIBLE;
159         schedule_timeout(howlong);
160 }
161
162 static unsigned char sscape_read(struct sscape_info *devc, int reg)
163 {
164         unsigned long flags;
165         unsigned char val;
166
167         spin_lock_irqsave(&devc->lock,flags);
168         outb(reg, PORT(ODIE_ADDR));
169         val = inb(PORT(ODIE_DATA));
170         spin_unlock_irqrestore(&devc->lock,flags);
171         return val;
172 }
173
174 static void __sscape_write(int reg, int data)
175 {
176         outb(reg, PORT(ODIE_ADDR));
177         outb(data, PORT(ODIE_DATA));
178 }
179
180 static void sscape_write(struct sscape_info *devc, int reg, int data)
181 {
182         unsigned long flags;
183
184         spin_lock_irqsave(&devc->lock,flags);
185         __sscape_write(reg, data);
186         spin_unlock_irqrestore(&devc->lock,flags);
187 }
188
189 static unsigned char sscape_pnp_read_codec(sscape_info* devc, unsigned char reg)
190 {
191         unsigned char res;
192         unsigned long flags;
193
194         spin_lock_irqsave(&devc->lock,flags);
195         outb( reg, devc -> codec);
196         res = inb (devc -> codec + 1);
197         spin_unlock_irqrestore(&devc->lock,flags);
198         return res;
199
200 }
201
202 static void sscape_pnp_write_codec(sscape_info* devc, unsigned char reg, unsigned char data)
203 {
204         unsigned long flags;
205         
206         spin_lock_irqsave(&devc->lock,flags);
207         outb( reg, devc -> codec);
208         outb( data, devc -> codec + 1);
209         spin_unlock_irqrestore(&devc->lock,flags);
210 }
211
212 static void host_open(struct sscape_info *devc)
213 {
214         outb((0x00), PORT(HOST_CTRL));  /* Put the board to the host mode */
215 }
216
217 static void host_close(struct sscape_info *devc)
218 {
219         outb((0x03), PORT(HOST_CTRL));  /* Put the board to the MIDI mode */
220 }
221
222 static int host_write(struct sscape_info *devc, unsigned char *data, int count)
223 {
224         unsigned long flags;
225         int i, timeout_val;
226
227         spin_lock_irqsave(&devc->lock,flags);
228         /*
229          * Send the command and data bytes
230          */
231
232         for (i = 0; i < count; i++)
233         {
234                 for (timeout_val = 10000; timeout_val > 0; timeout_val--)
235                         if (inb(PORT(HOST_CTRL)) & TX_READY)
236                                 break;
237
238                 if (timeout_val <= 0)
239                 {
240                                 spin_unlock_irqrestore(&devc->lock,flags);
241                             return 0;
242                 }
243                 outb(data[i], PORT(HOST_DATA));
244         }
245         spin_unlock_irqrestore(&devc->lock,flags);
246         return 1;
247 }
248
249 static int host_read(struct sscape_info *devc)
250 {
251         unsigned long flags;
252         int timeout_val;
253         unsigned char data;
254
255         spin_lock_irqsave(&devc->lock,flags);
256         /*
257          * Read a byte
258          */
259
260         for (timeout_val = 10000; timeout_val > 0; timeout_val--)
261                 if (inb(PORT(HOST_CTRL)) & RX_READY)
262                         break;
263
264         if (timeout_val <= 0)
265         {
266                 spin_unlock_irqrestore(&devc->lock,flags);
267                 return -1;
268         }
269         data = inb(PORT(HOST_DATA));
270         spin_unlock_irqrestore(&devc->lock,flags);
271         return data;
272 }
273
274 #if 0 /* unused */
275 static int host_command1(struct sscape_info *devc, int cmd)
276 {
277         unsigned char buf[10];
278         buf[0] = (unsigned char) (cmd & 0xff);
279         return host_write(devc, buf, 1);
280 }
281 #endif /* unused */
282
283
284 static int host_command2(struct sscape_info *devc, int cmd, int parm1)
285 {
286         unsigned char buf[10];
287
288         buf[0] = (unsigned char) (cmd & 0xff);
289         buf[1] = (unsigned char) (parm1 & 0xff);
290
291         return host_write(devc, buf, 2);
292 }
293
294 static int host_command3(struct sscape_info *devc, int cmd, int parm1, int parm2)
295 {
296         unsigned char buf[10];
297
298         buf[0] = (unsigned char) (cmd & 0xff);
299         buf[1] = (unsigned char) (parm1 & 0xff);
300         buf[2] = (unsigned char) (parm2 & 0xff);
301         return host_write(devc, buf, 3);
302 }
303
304 static void set_mt32(struct sscape_info *devc, int value)
305 {
306         host_open(devc);
307         host_command2(devc, CMD_SET_MT32, value ? 1 : 0);
308         if (host_read(devc) != CMD_ACK)
309         {
310                 /* printk( "SNDSCAPE: Setting MT32 mode failed\n"); */
311         }
312         host_close(devc);
313 }
314
315 static void set_control(struct sscape_info *devc, int ctrl, int value)
316 {
317         host_open(devc);
318         host_command3(devc, CMD_SET_CONTROL, ctrl, value);
319         if (host_read(devc) != CMD_ACK)
320         {
321                 /* printk( "SNDSCAPE: Setting control (%d) failed\n",  ctrl); */
322         }
323         host_close(devc);
324 }
325
326 static void do_dma(struct sscape_info *devc, int dma_chan, unsigned long buf, int blk_size, int mode)
327 {
328         unsigned char temp;
329
330         if (dma_chan != SSCAPE_DMA_A)
331         {
332                 printk(KERN_WARNING "soundscape: Tried to use DMA channel  != A. Why?\n");
333                 return;
334         }
335         audio_devs[devc->codec_audiodev]->flags &= ~DMA_AUTOMODE;
336         DMAbuf_start_dma(devc->codec_audiodev, buf, blk_size, mode);
337         audio_devs[devc->codec_audiodev]->flags |= DMA_AUTOMODE;
338
339         temp = devc->dma << 4;  /* Setup DMA channel select bits */
340         if (devc->dma <= 3)
341                 temp |= 0x80;   /* 8 bit DMA channel */
342
343         temp |= 1;              /* Trigger DMA */
344         sscape_write(devc, GA_DMAA_REG, temp);
345         temp &= 0xfe;           /* Clear DMA trigger */
346         sscape_write(devc, GA_DMAA_REG, temp);
347 }
348
349 static int verify_mpu(struct sscape_info *devc)
350 {
351         /*
352          * The SoundScape board could be in three modes (MPU, 8250 and host).
353          * If the card is not in the MPU mode, enabling the MPU driver will
354          * cause infinite loop (the driver believes that there is always some
355          * received data in the buffer.
356          *
357          * Detect this by looking if there are more than 10 received MIDI bytes
358          * (0x00) in the buffer.
359          */
360
361         int i;
362
363         for (i = 0; i < 10; i++)
364         {
365                 if (inb(devc->base + HOST_CTRL) & 0x80)
366                         return 1;
367
368                 if (inb(devc->base) != 0x00)
369                         return 1;
370         }
371         printk(KERN_WARNING "SoundScape: The device is not in the MPU-401 mode\n");
372         return 0;
373 }
374
375 static int sscape_coproc_open(void *dev_info, int sub_device)
376 {
377         if (sub_device == COPR_MIDI)
378         {
379                 set_mt32(devc, 0);
380                 if (!verify_mpu(devc))
381                         return -EIO;
382         }
383         return 0;
384 }
385
386 static void sscape_coproc_close(void *dev_info, int sub_device)
387 {
388         struct sscape_info *devc = dev_info;
389         unsigned long   flags;
390
391         spin_lock_irqsave(&devc->lock,flags);
392         if (devc->dma_allocated)
393         {
394                 __sscape_write(GA_DMAA_REG, 0x20);      /* DMA channel disabled */
395                 devc->dma_allocated = 0;
396         }
397         spin_unlock_irqrestore(&devc->lock,flags);
398         return;
399 }
400
401 static void sscape_coproc_reset(void *dev_info)
402 {
403 }
404
405 static int sscape_download_boot(struct sscape_info *devc, unsigned char *block, int size, int flag)
406 {
407         unsigned long flags;
408         unsigned char temp;
409         volatile int done, timeout_val;
410         static unsigned char codec_dma_bits;
411
412         if (flag & CPF_FIRST)
413         {
414                 /*
415                  * First block. Have to allocate DMA and to reset the board
416                  * before continuing.
417                  */
418
419                 spin_lock_irqsave(&devc->lock,flags);
420                 codec_dma_bits = sscape_read(devc, GA_CDCFG_REG);
421
422                 if (devc->dma_allocated == 0)
423                         devc->dma_allocated = 1;
424
425                 spin_unlock_irqrestore(&devc->lock,flags);
426
427                 sscape_write(devc, GA_HMCTL_REG, 
428                         (temp = sscape_read(devc, GA_HMCTL_REG)) & 0x3f);       /*Reset */
429
430                 for (timeout_val = 10000; timeout_val > 0; timeout_val--)
431                         sscape_read(devc, GA_HMCTL_REG);        /* Delay */
432
433                 /* Take board out of reset */
434                 sscape_write(devc, GA_HMCTL_REG,
435                         (temp = sscape_read(devc, GA_HMCTL_REG)) | 0x80);
436         }
437         /*
438          * Transfer one code block using DMA
439          */
440         if (audio_devs[devc->codec_audiodev]->dmap_out->raw_buf == NULL)
441         {
442                 printk(KERN_WARNING "soundscape: DMA buffer not available\n");
443                 return 0;
444         }
445         memcpy(audio_devs[devc->codec_audiodev]->dmap_out->raw_buf, block, size);
446
447         spin_lock_irqsave(&devc->lock,flags);
448         
449         /******** INTERRUPTS DISABLED NOW ********/
450         
451         do_dma(devc, SSCAPE_DMA_A,
452                audio_devs[devc->codec_audiodev]->dmap_out->raw_buf_phys,
453                size, DMA_MODE_WRITE);
454
455         /*
456          * Wait until transfer completes.
457          */
458         
459         done = 0;
460         timeout_val = 30;
461         while (!done && timeout_val-- > 0)
462         {
463                 int resid;
464
465                 if (HZ / 50)
466                         sleep(HZ / 50);
467                 clear_dma_ff(devc->dma);
468                 if ((resid = get_dma_residue(devc->dma)) == 0)
469                         done = 1;
470         }
471
472         spin_unlock_irqrestore(&devc->lock,flags);
473         if (!done)
474                 return 0;
475
476         if (flag & CPF_LAST)
477         {
478                 /*
479                  * Take the board out of reset
480                  */
481                 outb((0x00), PORT(HOST_CTRL));
482                 outb((0x00), PORT(MIDI_CTRL));
483
484                 temp = sscape_read(devc, GA_HMCTL_REG);
485                 temp |= 0x40;
486                 sscape_write(devc, GA_HMCTL_REG, temp); /* Kickstart the board */
487
488                 /*
489                  * Wait until the ODB wakes up
490                  */
491                 spin_lock_irqsave(&devc->lock,flags);
492                 done = 0;
493                 timeout_val = 5 * HZ;
494                 while (!done && timeout_val-- > 0)
495                 {
496                         unsigned char x;
497                         
498                         sleep(1);
499                         x = inb(PORT(HOST_DATA));
500                         if (x == 0xff || x == 0xfe)             /* OBP startup acknowledge */
501                         {
502                                 DDB(printk("Soundscape: Acknowledge = %x\n", x));
503                                 done = 1;
504                         }
505                 }
506                 sscape_write(devc, GA_CDCFG_REG, codec_dma_bits);
507
508                 spin_unlock_irqrestore(&devc->lock,flags);
509                 if (!done)
510                 {
511                         printk(KERN_ERR "soundscape: The OBP didn't respond after code download\n");
512                         return 0;
513                 }
514                 spin_lock_irqsave(&devc->lock,flags);
515                 done = 0;
516                 timeout_val = 5 * HZ;
517                 while (!done && timeout_val-- > 0)
518                 {
519                         sleep(1);
520                         if (inb(PORT(HOST_DATA)) == 0xfe)       /* Host startup acknowledge */
521                                 done = 1;
522                 }
523                 spin_unlock_irqrestore(&devc->lock,flags);
524                 if (!done)
525                 {
526                         printk(KERN_ERR "soundscape: OBP Initialization failed.\n");
527                         return 0;
528                 }
529                 printk(KERN_INFO "SoundScape board initialized OK\n");
530                 set_control(devc, CTL_MASTER_VOL, 100);
531                 set_control(devc, CTL_SYNTH_VOL, 100);
532
533 #ifdef SSCAPE_DEBUG3
534                 /*
535                  * Temporary debugging aid. Print contents of the registers after
536                  * downloading the code.
537                  */
538                 {
539                         int i;
540
541                         for (i = 0; i < 13; i++)
542                                 printk("I%d = %02x (new value)\n", i, sscape_read(devc, i));
543                 }
544 #endif
545
546         }
547         return 1;
548 }
549
550 static int download_boot_block(void *dev_info, copr_buffer * buf)
551 {
552         if (buf->len <= 0 || buf->len > sizeof(buf->data))
553                 return -EINVAL;
554
555         if (!sscape_download_boot(devc, buf->data, buf->len, buf->flags))
556         {
557                 printk(KERN_ERR "soundscape: Unable to load microcode block to the OBP.\n");
558                 return -EIO;
559         }
560         return 0;
561 }
562
563 static int sscape_coproc_ioctl(void *dev_info, unsigned int cmd, void __user *arg, int local)
564 {
565         copr_buffer *buf;
566         int err;
567
568         switch (cmd) 
569         {
570                 case SNDCTL_COPR_RESET:
571                         sscape_coproc_reset(dev_info);
572                         return 0;
573
574                 case SNDCTL_COPR_LOAD:
575                         buf = (copr_buffer *) vmalloc(sizeof(copr_buffer));
576                         if (buf == NULL)
577                                 return -ENOSPC;
578                         if (copy_from_user(buf, arg, sizeof(copr_buffer))) 
579                         {
580                                 vfree(buf);
581                                 return -EFAULT;
582                         }
583                         err = download_boot_block(dev_info, buf);
584                         vfree(buf);
585                         return err;
586                 
587                 default:
588                         return -EINVAL;
589         }
590 }
591
592 static coproc_operations sscape_coproc_operations =
593 {
594         "SoundScape M68K",
595         THIS_MODULE,
596         sscape_coproc_open,
597         sscape_coproc_close,
598         sscape_coproc_ioctl,
599         sscape_coproc_reset,
600         &adev_info
601 };
602
603 static struct resource *sscape_ports;
604 static int sscape_is_pnp;
605
606 static void __init attach_sscape(struct address_info *hw_config)
607 {
608 #ifndef SSCAPE_REGS
609         /*
610          * Config register values for Spea/V7 Media FX and Ensoniq S-2000.
611          * These values are card
612          * dependent. If you have another SoundScape based card, you have to
613          * find the correct values. Do the following:
614          *  - Compile this driver with SSCAPE_DEBUG1 defined.
615          *  - Shut down and power off your machine.
616          *  - Boot with DOS so that the SSINIT.EXE program is run.
617          *  - Warm boot to {Linux|SYSV|BSD} and write down the lines displayed
618          *    when detecting the SoundScape.
619          *  - Modify the following list to use the values printed during boot.
620          *    Undefine the SSCAPE_DEBUG1
621          */
622 #define SSCAPE_REGS { \
623 /* I0 */        0x00, \
624 /* I1 */        0xf0, /* Note! Ignored. Set always to 0xf0 */ \
625 /* I2 */        0x20, /* Note! Ignored. Set always to 0x20 */ \
626 /* I3 */        0x20, /* Note! Ignored. Set always to 0x20 */ \
627 /* I4 */        0xf5, /* Ignored */ \
628 /* I5 */        0x10, \
629 /* I6 */        0x00, \
630 /* I7 */        0x2e, /* I7 MEM config A. Likely to vary between models */ \
631 /* I8 */        0x00, /* I8 MEM config B. Likely to vary between models */ \
632 /* I9 */        0x40 /* Ignored */ \
633         }
634 #endif
635
636         unsigned long   flags;
637         static unsigned char regs[10] = SSCAPE_REGS;
638
639         int i, irq_bits = 0xff;
640
641         if (old_hardware)
642         {
643                 valid_interrupts = valid_interrupts_old;
644                 conf_printf("Ensoniq SoundScape (old)", hw_config);
645         }
646         else
647                 conf_printf("Ensoniq SoundScape", hw_config);
648
649         for (i = 0; i < 4; i++)
650         {
651                 if (hw_config->irq == valid_interrupts[i])
652                 {
653                         irq_bits = i;
654                         break;
655                 }
656         }
657         if (hw_config->irq > 15 || (regs[4] = irq_bits == 0xff))
658         {
659                 printk(KERN_ERR "Invalid IRQ%d\n", hw_config->irq);
660                 release_region(devc->base, 2);
661                 release_region(devc->base + 2, 6);
662                 if (sscape_is_pnp)
663                         release_region(devc->codec, 2);
664                 return;
665         }
666         
667         if (!sscape_is_pnp) {
668         
669                 spin_lock_irqsave(&devc->lock,flags);
670                 /* Host interrupt enable */
671                 sscape_write(devc, 1, 0xf0);    /* All interrupts enabled */
672                 /* DMA A status/trigger register */
673                 sscape_write(devc, 2, 0x20);    /* DMA channel disabled */
674                 /* DMA B status/trigger register */
675                 sscape_write(devc, 3, 0x20);    /* DMA channel disabled */
676                 /* Host interrupt config reg */
677                 sscape_write(devc, 4, 0xf0 | (irq_bits << 2) | irq_bits);
678                 /* Don't destroy CD-ROM DMA config bits (0xc0) */
679                 sscape_write(devc, 5, (regs[5] & 0x3f) | (sscape_read(devc, 5) & 0xc0));
680                 /* CD-ROM config (WSS codec actually) */
681                 sscape_write(devc, 6, regs[6]);
682                 sscape_write(devc, 7, regs[7]);
683                 sscape_write(devc, 8, regs[8]);
684                 /* Master control reg. Don't modify CR-ROM bits. Disable SB emul */
685                 sscape_write(devc, 9, (sscape_read(devc, 9) & 0xf0) | 0x08);
686                 spin_unlock_irqrestore(&devc->lock,flags);
687         }
688 #ifdef SSCAPE_DEBUG2
689         /*
690          * Temporary debugging aid. Print contents of the registers after
691          * changing them.
692          */
693         {
694                 int i;
695
696                 for (i = 0; i < 13; i++)
697                         printk("I%d = %02x (new value)\n", i, sscape_read(devc, i));
698         }
699 #endif
700
701         if (probe_mpu401(hw_config, sscape_ports))
702                 hw_config->always_detect = 1;
703         hw_config->name = "SoundScape";
704
705         hw_config->irq *= -1;   /* Negative value signals IRQ sharing */
706         attach_mpu401(hw_config, THIS_MODULE);
707         hw_config->irq *= -1;   /* Restore it */
708
709         if (hw_config->slots[1] != -1)  /* The MPU driver installed itself */
710         {
711                 sscape_mididev = hw_config->slots[1];
712                 midi_devs[hw_config->slots[1]]->coproc = &sscape_coproc_operations;
713         }
714         sscape_write(devc, GA_INTENA_REG, 0x80);        /* Master IRQ enable */
715         devc->ok = 1;
716         devc->failed = 0;
717 }
718
719 static int detect_ga(sscape_info * devc)
720 {
721         unsigned char save;
722
723         DDB(printk("Entered Soundscape detect_ga(%x)\n", devc->base));
724
725         /*
726          * First check that the address register of "ODIE" is
727          * there and that it has exactly 4 writable bits.
728          * First 4 bits
729          */
730         
731         if ((save = inb(PORT(ODIE_ADDR))) & 0xf0)
732         {
733                 DDB(printk("soundscape: Detect error A\n"));
734                 return 0;
735         }
736         outb((0x00), PORT(ODIE_ADDR));
737         if (inb(PORT(ODIE_ADDR)) != 0x00)
738         {
739                 DDB(printk("soundscape: Detect error B\n"));
740                 return 0;
741         }
742         outb((0xff), PORT(ODIE_ADDR));
743         if (inb(PORT(ODIE_ADDR)) != 0x0f)
744         {
745                 DDB(printk("soundscape: Detect error C\n"));
746                 return 0;
747         }
748         outb((save), PORT(ODIE_ADDR));
749
750         /*
751          * Now verify that some indirect registers return zero on some bits.
752          * This may break the driver with some future revisions of "ODIE" but...
753          */
754
755         if (sscape_read(devc, 0) & 0x0c)
756         {
757                 DDB(printk("soundscape: Detect error D (%x)\n", sscape_read(devc, 0)));
758                 return 0;
759         }
760         if (sscape_read(devc, 1) & 0x0f)
761         {
762                 DDB(printk("soundscape: Detect error E\n"));
763                 return 0;
764         }
765         if (sscape_read(devc, 5) & 0x0f)
766         {
767                 DDB(printk("soundscape: Detect error F\n"));
768                 return 0;
769         }
770         return 1;
771 }
772
773 static  int sscape_read_host_ctrl(sscape_info* devc)
774 {
775         return host_read(devc);
776 }
777
778 static  void sscape_write_host_ctrl2(sscape_info *devc, int a, int b)
779 {
780         host_command2(devc, a, b);
781 }
782
783 static int sscape_alloc_dma(sscape_info *devc)
784 {
785         char *start_addr, *end_addr;
786         int dma_pagesize;
787         int sz, size;
788         struct page *page;
789
790         if (devc->raw_buf != NULL) return 0;    /* Already done */
791         dma_pagesize = (devc->dma < 4) ? (64 * 1024) : (128 * 1024);
792         devc->raw_buf = NULL;
793         devc->buffsize = 8192*4;
794         if (devc->buffsize > dma_pagesize) devc->buffsize = dma_pagesize;
795         start_addr = NULL;
796         /*
797          * Now loop until we get a free buffer. Try to get smaller buffer if
798          * it fails. Don't accept smaller than 8k buffer for performance
799          * reasons.
800          */
801         while (start_addr == NULL && devc->buffsize > PAGE_SIZE) {
802                 for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
803                 devc->buffsize = PAGE_SIZE * (1 << sz);
804                 start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA, sz);
805                 if (start_addr == NULL) devc->buffsize /= 2;
806         }
807
808         if (start_addr == NULL) {
809                 printk(KERN_ERR "sscape pnp init error: Couldn't allocate DMA buffer\n");
810                 return 0;
811         } else {
812                 /* make some checks */
813                 end_addr = start_addr + devc->buffsize - 1;             
814                 /* now check if it fits into the same dma-pagesize */
815
816                 if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
817                     || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
818                         printk(KERN_ERR "sscape pnp: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr, devc->buffsize);
819                         return 0;
820                 }
821         }
822         devc->raw_buf = start_addr;
823         devc->raw_buf_phys = virt_to_bus(start_addr);
824
825         for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
826                 SetPageReserved(page);
827         return 1;
828 }
829
830 static void sscape_free_dma(sscape_info *devc)
831 {
832         int sz, size;
833         unsigned long start_addr, end_addr;
834         struct page *page;
835
836         if (devc->raw_buf == NULL) return;
837         for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
838         start_addr = (unsigned long) devc->raw_buf;
839         end_addr = start_addr + devc->buffsize;
840
841         for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
842                 ClearPageReserved(page);
843
844         free_pages((unsigned long) devc->raw_buf, sz);
845         devc->raw_buf = NULL;
846 }
847
848 /* Intel version !!!!!!!!! */
849
850 static int sscape_start_dma(int chan, unsigned long physaddr, int count, int dma_mode)
851 {
852         unsigned long flags;
853
854         flags = claim_dma_lock();
855         disable_dma(chan);
856         clear_dma_ff(chan);
857         set_dma_mode(chan, dma_mode);
858         set_dma_addr(chan, physaddr);
859         set_dma_count(chan, count);
860         enable_dma(chan);
861         release_dma_lock(flags);
862         return 0;
863 }
864
865 static void sscape_pnp_start_dma(sscape_info* devc, int arg )
866 {
867         int reg;
868         if (arg == 0) reg = 2;
869         else reg = 3;
870
871         sscape_write(devc, reg, sscape_read( devc, reg) | 0x01);
872         sscape_write(devc, reg, sscape_read( devc, reg) & 0xFE);
873 }
874
875 static int sscape_pnp_wait_dma (sscape_info* devc, int arg )
876 {
877         int             reg;
878         unsigned long   i;
879         unsigned char   d;
880
881         if (arg == 0) reg = 2;
882         else reg = 3;
883
884         sleep ( 1 );
885         i = 0;
886         do {
887                 d = sscape_read(devc, reg) & 1;
888                 if ( d == 1)  break;
889                 i++;
890         } while (i < 500000);
891         d = sscape_read(devc, reg) & 1; 
892         return d;
893 }
894
895 static  int     sscape_pnp_alloc_dma(sscape_info* devc)
896 {
897         /* printk(KERN_INFO "sscape: requesting dma\n"); */
898         if (request_dma(devc -> dma, "sscape")) return 0;
899         /* printk(KERN_INFO "sscape: dma channel allocated\n"); */
900         if (!sscape_alloc_dma(devc)) {
901                 free_dma(devc -> dma);
902                 return 0;
903         };
904         return 1;
905 }
906
907 static  void    sscape_pnp_free_dma(sscape_info* devc)
908 {
909         sscape_free_dma( devc);
910         free_dma(devc -> dma ); 
911         /* printk(KERN_INFO "sscape: dma released\n"); */
912 }
913
914 static  int     sscape_pnp_upload_file(sscape_info* devc, char* fn)
915 {       
916         int             done = 0;
917         int             timeout_val;
918         char*           data,*dt;
919         int             len,l;
920         unsigned long   flags;
921
922         sscape_write( devc, 9, sscape_read(devc, 9 )  & 0x3F );
923         sscape_write( devc, 2, (devc -> dma << 4) | 0x80 );
924         sscape_write( devc, 3, 0x20 );
925         sscape_write( devc, 9, sscape_read( devc, 9 )  | 0x80 );
926         
927         len = mod_firmware_load(fn, &data);
928         if (len == 0) {
929                     printk(KERN_ERR "sscape: file not found: %s\n", fn);
930                     return 0;
931         }
932         dt = data;
933         spin_lock_irqsave(&devc->lock,flags);
934         while ( len > 0 ) {
935                 if (len > devc -> buffsize) l = devc->buffsize;
936                 else l = len;
937                 len -= l;               
938                 memcpy(devc->raw_buf, dt, l); dt += l;
939                 sscape_start_dma(devc->dma, devc->raw_buf_phys, l, 0x48);
940                 sscape_pnp_start_dma ( devc, 0 );
941                 if (sscape_pnp_wait_dma ( devc, 0 ) == 0) {
942                         spin_unlock_irqrestore(&devc->lock,flags);
943                         return 0;
944                 }
945         }
946         
947         spin_unlock_irqrestore(&devc->lock,flags);
948         vfree(data);
949         
950         outb(0, devc -> base + 2);
951         outb(0, devc -> base);
952
953         sscape_write ( devc, 9, sscape_read( devc, 9 ) | 0x40);
954
955         timeout_val = 5 * HZ; 
956         while (!done && timeout_val-- > 0)
957         {
958                 unsigned char x;
959                 sleep(1);
960                 x = inb( devc -> base + 3);
961                 if (x == 0xff || x == 0xfe)             /* OBP startup acknowledge */
962                 {
963                         //printk(KERN_ERR "Soundscape: Acknowledge = %x\n", x);
964                         done = 1;
965                 }
966         }
967         timeout_val = 5 * HZ;
968         done = 0;
969         while (!done && timeout_val-- > 0)
970         {
971                 unsigned char x;
972                 sleep(1);
973                 x = inb( devc -> base + 3);
974                 if (x == 0xfe)          /* OBP startup acknowledge */
975                 {
976                         //printk(KERN_ERR "Soundscape: Acknowledge = %x\n", x);
977                         done = 1;
978                 }
979         }
980
981         if ( !done ) printk(KERN_ERR "soundscape: OBP Initialization failed.\n");
982
983         sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
984         sscape_write( devc, 3, (devc -> dma << 4) + 0x80);
985         return 1;
986 }
987
988 static void __init sscape_pnp_init_hw(sscape_info* devc)
989 {       
990         unsigned char midi_irq = 0, sb_irq = 0;
991         unsigned i;
992         static  char code_file_name[23] = "/sndscape/sndscape.cox";
993         
994         int sscape_joystic_enable       = 0x7f;
995         int sscape_mic_enable           = 0;
996         int sscape_ext_midi             = 0;            
997
998         if ( !sscape_pnp_alloc_dma(devc) ) {
999                 printk(KERN_ERR "sscape: faild to allocate dma\n");
1000                 return;
1001         }
1002
1003         for (i = 0; i < 4; i++) {
1004                 if ( devc -> irq   == valid_interrupts[i] ) 
1005                         midi_irq = i;
1006                 if ( devc -> codec_irq == valid_interrupts[i] ) 
1007                         sb_irq = i;
1008         }
1009
1010         sscape_write( devc, 5, 0x50);
1011         sscape_write( devc, 7, 0x2e);
1012         sscape_write( devc, 8, 0x00);
1013
1014         sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
1015         sscape_write( devc, 3, ( devc -> dma << 4) | 0x80);
1016
1017         sscape_write (devc, 4, 0xF0 | (midi_irq<<2) | midi_irq);
1018
1019         i = 0x10; //sscape_read(devc, 9) & (devc->ic_type == IC_ODIE ? 0xf0 : 0xc0);
1020         if (sscape_joystic_enable) i |= 8;
1021         
1022         sscape_write (devc, 9, i);
1023         sscape_write (devc, 6, 0x80);
1024         sscape_write (devc, 1, 0x80);
1025
1026         if (devc -> codec_type == 2) {
1027                 sscape_pnp_write_codec( devc, 0x0C, 0x50);
1028                 sscape_pnp_write_codec( devc, 0x10, sscape_pnp_read_codec( devc, 0x10) & 0x3F);
1029                 sscape_pnp_write_codec( devc, 0x11, sscape_pnp_read_codec( devc, 0x11) | 0xC0);
1030                 sscape_pnp_write_codec( devc, 29, 0x20);
1031         }
1032
1033         if (sscape_pnp_upload_file(devc, "/sndscape/scope.cod") == 0 ) {
1034                 printk(KERN_ERR "sscape: faild to upload file /sndscape/scope.cod\n");
1035                 sscape_pnp_free_dma(devc);
1036                 return;
1037         }
1038
1039         i = sscape_read_host_ctrl( devc );
1040         
1041         if ( (i & 0x0F) >  7 ) {
1042                 printk(KERN_ERR "sscape: scope.cod faild\n");
1043                 sscape_pnp_free_dma(devc);
1044                 return;
1045         }
1046         if ( i & 0x10 ) sscape_write( devc, 7, 0x2F);
1047         code_file_name[21] = (char) ( i & 0x0F) + 0x30;
1048         if (sscape_pnp_upload_file( devc, code_file_name) == 0) {
1049                 printk(KERN_ERR "sscape: faild to upload file %s\n", code_file_name);
1050                 sscape_pnp_free_dma(devc);
1051                 return;
1052         }
1053         
1054         if (devc->ic_type != IC_ODIE) {
1055                 sscape_pnp_write_codec( devc, 10, (sscape_pnp_read_codec(devc, 10) & 0x7f) |
1056                  ( sscape_mic_enable == 0 ? 0x00 : 0x80) );
1057         }
1058         sscape_write_host_ctrl2( devc, 0x84, 0x64 );  /* MIDI volume */
1059         sscape_write_host_ctrl2( devc, 0x86, 0x64 );  /* MIDI volume?? */
1060         sscape_write_host_ctrl2( devc, 0x8A, sscape_ext_midi);
1061
1062         sscape_pnp_write_codec ( devc, 6, 0x3f ); //WAV_VOL
1063         sscape_pnp_write_codec ( devc, 7, 0x3f ); //WAV_VOL
1064         sscape_pnp_write_codec ( devc, 2, 0x1F ); //WD_CDXVOLL
1065         sscape_pnp_write_codec ( devc, 3, 0x1F ); //WD_CDXVOLR
1066
1067         if (devc -> codec_type == 1) {
1068                 sscape_pnp_write_codec ( devc, 4, 0x1F );
1069                 sscape_pnp_write_codec ( devc, 5, 0x1F );
1070                 sscape_write_host_ctrl2( devc, 0x88, sscape_mic_enable);
1071         } else {
1072                 int t;
1073                 sscape_pnp_write_codec ( devc, 0x10, 0x1F << 1);
1074                 sscape_pnp_write_codec ( devc, 0x11, 0xC0 | (0x1F << 1));
1075
1076                 t = sscape_pnp_read_codec( devc, 0x00) & 0xDF;
1077                 if ( (sscape_mic_enable == 0)) t |= 0;
1078                 else t |= 0x20;
1079                 sscape_pnp_write_codec ( devc, 0x00, t);
1080                 t = sscape_pnp_read_codec( devc, 0x01) & 0xDF;
1081                 if ( (sscape_mic_enable == 0) ) t |= 0;
1082                 else t |= 0x20;
1083                 sscape_pnp_write_codec ( devc, 0x01, t);
1084                 sscape_pnp_write_codec ( devc, 0x40 | 29 , 0x20);
1085                 outb(0, devc -> codec);
1086         }
1087         if (devc -> ic_type == IC_OPUS ) {
1088                 int i = sscape_read( devc, 9 );
1089                 sscape_write( devc, 9, i | 3 );
1090                 sscape_write( devc, 3, 0x40);
1091
1092                 if (request_region(0x228, 1, "sscape setup junk")) {
1093                         outb(0, 0x228);
1094                         release_region(0x228,1);
1095                 }
1096                 sscape_write( devc, 3, (devc -> dma << 4) | 0x80);
1097                 sscape_write( devc, 9, i );
1098         }
1099         
1100         host_close ( devc );
1101         sscape_pnp_free_dma(devc);
1102 }
1103
1104 static int __init detect_sscape_pnp(sscape_info* devc)
1105 {
1106         long     i, irq_bits = 0xff;
1107         unsigned int d;
1108
1109         DDB(printk("Entered detect_sscape_pnp(%x)\n", devc->base));
1110
1111         if (!request_region(devc->codec, 2, "sscape codec")) {
1112                 printk(KERN_ERR "detect_sscape_pnp: port %x is not free\n", devc->codec);       
1113                 return 0;
1114         }
1115
1116         if ((inb(devc->base + 2) & 0x78) != 0)
1117                 goto fail;
1118
1119         d = inb ( devc -> base + 4) & 0xF0;
1120         if (d & 0x80)
1121                 goto fail;
1122         
1123         if (d == 0) {
1124                 devc->codec_type = 1;
1125                 devc->ic_type = IC_ODIE;
1126         } else if ( (d & 0x60) != 0) {
1127                 devc->codec_type = 2;
1128                 devc->ic_type = IC_OPUS;
1129         } else if ( (d & 0x40) != 0) {  /* WTF? */
1130                 devc->codec_type = 2;
1131                 devc->ic_type = IC_ODIE;
1132         } else
1133                 goto fail;
1134         
1135         sscape_is_pnp = 1;
1136                 
1137         outb(0xFA, devc -> base+4);
1138         if  ((inb( devc -> base+4) & 0x9F) != 0x0A)
1139                 goto fail;
1140         outb(0xFE, devc -> base+4);
1141         if  ( (inb(devc -> base+4) & 0x9F) != 0x0E)
1142                 goto fail;
1143         if  ( (inb(devc -> base+5) & 0x9F) != 0x0E)
1144                 goto fail;
1145
1146         if (devc->codec_type == 2) {
1147                 if (devc->codec != devc->base + 8) {
1148                         printk("soundscape warning: incorrect codec port specified\n");
1149                         goto fail;
1150                 }
1151                 d = 0x10 | (sscape_read(devc, 9)  & 0xCF);
1152                 sscape_write(devc, 9, d);
1153                 sscape_write(devc, 6, 0x80);
1154         } else {
1155                 //todo: check codec is not base + 8
1156         }
1157
1158         d  = (sscape_read(devc, 9) & 0x3F) | 0xC0;
1159         sscape_write(devc, 9, d);
1160
1161         for (i = 0; i < 550000; i++)
1162                 if ( !(inb(devc -> codec) & 0x80) ) break;
1163
1164         d = inb(devc -> codec);
1165         if (d & 0x80)
1166                 goto fail;
1167         if ( inb(devc -> codec + 2) == 0xFF)
1168                 goto fail;
1169
1170         sscape_write(devc, 9, sscape_read(devc, 9)  & 0x3F );
1171
1172         d  = inb(devc -> codec) & 0x80;
1173         if ( d == 0) {
1174                 printk(KERN_INFO "soundscape: hardware detected\n");
1175                 valid_interrupts = valid_interrupts_new;
1176         } else  {
1177                 printk(KERN_INFO "soundscape: board looks like media fx\n");
1178                 valid_interrupts = valid_interrupts_old;
1179                 old_hardware = 1;
1180         }
1181
1182         sscape_write( devc, 9, 0xC0 | (sscape_read(devc, 9)  & 0x3F) );
1183
1184         for (i = 0; i < 550000; i++)
1185                 if ( !(inb(devc -> codec) & 0x80)) 
1186                         break;
1187                 
1188         sscape_pnp_init_hw(devc);
1189
1190         for (i = 0; i < 4; i++)
1191         {
1192                 if (devc->codec_irq == valid_interrupts[i]) {
1193                         irq_bits = i;
1194                         break;
1195                 }
1196         }       
1197         sscape_write(devc, GA_INTENA_REG, 0x00);
1198         sscape_write(devc, GA_DMACFG_REG, 0x50);
1199         sscape_write(devc, GA_DMAA_REG, 0x70);
1200         sscape_write(devc, GA_DMAB_REG, 0x20);
1201         sscape_write(devc, GA_INTCFG_REG, 0xf0);
1202         sscape_write(devc, GA_CDCFG_REG, 0x89 | (devc->dma << 4) | (irq_bits << 1));
1203
1204         sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 0) | 0x20);
1205         sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 1) | 0x20);
1206
1207         return 1;
1208 fail:
1209         release_region(devc->codec, 2);
1210         return 0;
1211 }
1212
1213 static int __init probe_sscape(struct address_info *hw_config)
1214 {
1215         devc->base = hw_config->io_base;
1216         devc->irq = hw_config->irq;
1217         devc->dma = hw_config->dma;
1218         devc->osp = hw_config->osp;
1219
1220 #ifdef SSCAPE_DEBUG1
1221         /*
1222          * Temporary debugging aid. Print contents of the registers before
1223          * changing them.
1224          */
1225         {
1226                 int i;
1227
1228                 for (i = 0; i < 13; i++)
1229                         printk("I%d = %02x (old value)\n", i, sscape_read(devc, i));
1230         }
1231 #endif
1232         devc->failed = 1;
1233
1234         sscape_ports = request_region(devc->base, 2, "mpu401");
1235         if (!sscape_ports)
1236                 return 0;
1237
1238         if (!request_region(devc->base + 2, 6, "SoundScape")) {
1239                 release_region(devc->base, 2);
1240                 return 0;
1241         }
1242
1243         if (!detect_ga(devc)) {
1244                 if (detect_sscape_pnp(devc))
1245                         return 1;
1246                 release_region(devc->base, 2);
1247                 release_region(devc->base + 2, 6);
1248                 return 0;
1249         }
1250
1251         if (old_hardware)       /* Check that it's really an old Spea/Reveal card. */
1252         {
1253                 unsigned char   tmp;
1254                 int             cc;
1255
1256                 if (!((tmp = sscape_read(devc, GA_HMCTL_REG)) & 0xc0))
1257                 {
1258                         sscape_write(devc, GA_HMCTL_REG, tmp | 0x80);
1259                         for (cc = 0; cc < 200000; ++cc)
1260                                 inb(devc->base + ODIE_ADDR);
1261                 }
1262         }
1263         return 1;
1264 }
1265
1266 static int __init init_ss_ms_sound(struct address_info *hw_config)
1267 {
1268         int i, irq_bits = 0xff;
1269         int ad_flags = 0;
1270         struct resource *ports;
1271         
1272         if (devc->failed)
1273         {
1274                 printk(KERN_ERR "soundscape: Card not detected\n");
1275                 return 0;
1276         }
1277         if (devc->ok == 0)
1278         {
1279                 printk(KERN_ERR "soundscape: Invalid initialization order.\n");
1280                 return 0;
1281         }
1282         for (i = 0; i < 4; i++)
1283         {
1284                 if (hw_config->irq == valid_interrupts[i])
1285                 {
1286                         irq_bits = i;
1287                         break;
1288                 }
1289         }
1290         if (irq_bits == 0xff) {
1291                 printk(KERN_ERR "soundscape: Invalid MSS IRQ%d\n", hw_config->irq);
1292                 return 0;
1293         }
1294         
1295         if (old_hardware)
1296                 ad_flags = 0x12345677;  /* Tell that we may have a CS4248 chip (Spea-V7 Media FX) */
1297         else if (sscape_is_pnp)
1298                 ad_flags = 0x87654321;  /* Tell that we have a soundscape pnp with 1845 chip */
1299
1300         ports = request_region(hw_config->io_base, 4, "ad1848");
1301         if (!ports) {
1302                 printk(KERN_ERR "soundscape: ports busy\n");
1303                 return 0;
1304         }
1305
1306         if (!ad1848_detect(ports, &ad_flags, hw_config->osp)) {
1307                 release_region(hw_config->io_base, 4);
1308                 return 0;
1309         }
1310
1311         if (!sscape_is_pnp)  /*pnp is already setup*/
1312         {
1313                 /*
1314                  * Setup the DMA polarity.
1315                  */
1316                 sscape_write(devc, GA_DMACFG_REG, 0x50);
1317         
1318                 /*
1319                  * Take the gate-array off of the DMA channel.
1320                  */
1321                 sscape_write(devc, GA_DMAB_REG, 0x20);
1322         
1323                 /*
1324                  * Init the AD1848 (CD-ROM) config reg.
1325                  */
1326                 sscape_write(devc, GA_CDCFG_REG, 0x89 | (hw_config->dma << 4) | (irq_bits << 1));
1327         }
1328         
1329         if (hw_config->irq == devc->irq)
1330                 printk(KERN_WARNING "soundscape: Warning! The WSS mode can't share IRQ with MIDI\n");
1331                                 
1332         hw_config->slots[0] = ad1848_init(
1333                         sscape_is_pnp ? "SoundScape" : "SoundScape PNP",
1334                         ports,
1335                         hw_config->irq,
1336                         hw_config->dma,
1337                         hw_config->dma,
1338                         0,
1339                         devc->osp,
1340                         THIS_MODULE);
1341
1342                                           
1343         if (hw_config->slots[0] != -1)  /* The AD1848 driver installed itself */
1344         {
1345                 audio_devs[hw_config->slots[0]]->coproc = &sscape_coproc_operations;
1346                 devc->codec_audiodev = hw_config->slots[0];
1347                 devc->my_audiodev = hw_config->slots[0];
1348
1349                 /* Set proper routings here (what are they) */
1350                 AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_LINE);
1351         }
1352                 
1353 #ifdef SSCAPE_DEBUG5
1354         /*
1355          * Temporary debugging aid. Print contents of the registers
1356          * after the AD1848 device has been initialized.
1357          */
1358         {
1359                 int i;
1360
1361                 for (i = 0; i < 13; i++)
1362                         printk("I%d = %02x\n", i, sscape_read(devc, i));
1363         }
1364 #endif
1365         return 1;
1366 }
1367
1368 static void __exit unload_sscape(struct address_info *hw_config)
1369 {
1370         release_region(devc->base + 2, 6);
1371         unload_mpu401(hw_config);
1372         if (sscape_is_pnp)
1373                 release_region(devc->codec, 2);
1374 }
1375
1376 static void __exit unload_ss_ms_sound(struct address_info *hw_config)
1377 {
1378         ad1848_unload(hw_config->io_base,
1379                       hw_config->irq,
1380                       devc->dma,
1381                       devc->dma,
1382                       0);
1383         sound_unload_audiodev(hw_config->slots[0]);
1384 }
1385
1386 static struct address_info cfg;
1387 static struct address_info cfg_mpu;
1388
1389 static int __initdata spea = -1;
1390 static int mss = 0;
1391 static int __initdata dma = -1;
1392 static int __initdata irq = -1;
1393 static int __initdata io = -1;
1394 static int __initdata mpu_irq = -1;
1395 static int __initdata mpu_io = -1;
1396
1397 module_param(dma, int, 0);
1398 module_param(irq, int, 0);
1399 module_param(io, int, 0);
1400 module_param(spea, int, 0);             /* spea=0/1 set the old_hardware */
1401 module_param(mpu_irq, int, 0);
1402 module_param(mpu_io, int, 0);
1403 module_param(mss, int, 0);
1404
1405 static int __init init_sscape(void)
1406 {
1407         printk(KERN_INFO "Soundscape driver Copyright (C) by Hannu Savolainen 1993-1996\n");
1408         
1409         cfg.irq = irq;
1410         cfg.dma = dma;
1411         cfg.io_base = io;
1412
1413         cfg_mpu.irq = mpu_irq;
1414         cfg_mpu.io_base = mpu_io;
1415         /* WEH - Try to get right dma channel */
1416         cfg_mpu.dma = dma;
1417         
1418         devc->codec = cfg.io_base;
1419         devc->codec_irq = cfg.irq;
1420         devc->codec_type = 0;
1421         devc->ic_type = 0;
1422         devc->raw_buf = NULL;
1423         spin_lock_init(&devc->lock);
1424
1425         if (cfg.dma == -1 || cfg.irq == -1 || cfg.io_base == -1) {
1426                 printk(KERN_ERR "DMA, IRQ, and IO port must be specified.\n");
1427                 return -EINVAL;
1428         }
1429         
1430         if (cfg_mpu.irq == -1 && cfg_mpu.io_base != -1) {
1431                 printk(KERN_ERR "MPU_IRQ must be specified if MPU_IO is set.\n");
1432                 return -EINVAL;
1433         }
1434         
1435         if(spea != -1) {
1436                 old_hardware = spea;
1437                 printk(KERN_INFO "Forcing %s hardware support.\n",
1438                         spea?"new":"old");
1439         }       
1440         if (probe_sscape(&cfg_mpu) == 0)
1441                 return -ENODEV;
1442
1443         attach_sscape(&cfg_mpu);
1444         
1445         mss = init_ss_ms_sound(&cfg);
1446
1447         return 0;
1448 }
1449
1450 static void __exit cleanup_sscape(void)
1451 {
1452         if (mss)
1453                 unload_ss_ms_sound(&cfg);
1454         unload_sscape(&cfg_mpu);
1455 }
1456
1457 module_init(init_sscape);
1458 module_exit(cleanup_sscape);
1459
1460 #ifndef MODULE
1461 static int __init setup_sscape(char *str)
1462 {
1463         /* io, irq, dma, mpu_io, mpu_irq */
1464         int ints[6];
1465         
1466         str = get_options(str, ARRAY_SIZE(ints), ints);
1467         
1468         io      = ints[1];
1469         irq     = ints[2];
1470         dma     = ints[3];
1471         mpu_io  = ints[4];
1472         mpu_irq = ints[5];
1473
1474         return 1;
1475 }
1476
1477 __setup("sscape=", setup_sscape);
1478 #endif
1479 MODULE_LICENSE("GPL");