4 * Low level driver for Ensoniq SoundScape
7 * Copyright (C) by Hannu Savolainen 1993-1997
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
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
22 #include <linux/init.h>
23 #include <linux/module.h>
25 #include "sound_config.h"
26 #include "sound_firmware.h"
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>
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>
65 #define GA_INTSTAT_REG 0
66 #define GA_INTENA_REG 1
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
77 * DMA channel identifiers (A and B)
80 #define SSCAPE_DMA_A 0
81 #define SSCAPE_DMA_B 1
83 #define PORT(name) (devc->base+name)
86 * Host commands recognized by the OBP microcode
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
108 typedef struct sscape_info
112 int codec, codec_irq; /* required to setup pnp cards*/
116 unsigned long raw_buf_phys;
117 int buffsize; /* -------------------------- */
119 int ok; /* Properly detected */
128 static struct sscape_info adev_info = {
132 static struct sscape_info *devc = &adev_info;
133 static int sscape_mididev = -1;
135 /* Some older cards have assigned interrupt bits differently than new ones */
136 static char valid_interrupts_old[] = {
140 static char valid_interrupts_new[] = {
144 static char *valid_interrupts = valid_interrupts_new;
147 * See the bottom of the driver. This can be set by spea =0/1.
151 static char old_hardware = 1;
153 static char old_hardware;
156 static void sleep(unsigned howlong)
158 current->state = TASK_INTERRUPTIBLE;
159 schedule_timeout(howlong);
162 static unsigned char sscape_read(struct sscape_info *devc, int reg)
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);
174 static void __sscape_write(int reg, int data)
176 outb(reg, PORT(ODIE_ADDR));
177 outb(data, PORT(ODIE_DATA));
180 static void sscape_write(struct sscape_info *devc, int reg, int data)
184 spin_lock_irqsave(&devc->lock,flags);
185 __sscape_write(reg, data);
186 spin_unlock_irqrestore(&devc->lock,flags);
189 static unsigned char sscape_pnp_read_codec(sscape_info* devc, unsigned char reg)
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);
202 static void sscape_pnp_write_codec(sscape_info* devc, unsigned char reg, unsigned char data)
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);
212 static void host_open(struct sscape_info *devc)
214 outb((0x00), PORT(HOST_CTRL)); /* Put the board to the host mode */
217 static void host_close(struct sscape_info *devc)
219 outb((0x03), PORT(HOST_CTRL)); /* Put the board to the MIDI mode */
222 static int host_write(struct sscape_info *devc, unsigned char *data, int count)
227 spin_lock_irqsave(&devc->lock,flags);
229 * Send the command and data bytes
232 for (i = 0; i < count; i++)
234 for (timeout_val = 10000; timeout_val > 0; timeout_val--)
235 if (inb(PORT(HOST_CTRL)) & TX_READY)
238 if (timeout_val <= 0)
240 spin_unlock_irqrestore(&devc->lock,flags);
243 outb(data[i], PORT(HOST_DATA));
245 spin_unlock_irqrestore(&devc->lock,flags);
249 static int host_read(struct sscape_info *devc)
255 spin_lock_irqsave(&devc->lock,flags);
260 for (timeout_val = 10000; timeout_val > 0; timeout_val--)
261 if (inb(PORT(HOST_CTRL)) & RX_READY)
264 if (timeout_val <= 0)
266 spin_unlock_irqrestore(&devc->lock,flags);
269 data = inb(PORT(HOST_DATA));
270 spin_unlock_irqrestore(&devc->lock,flags);
275 static int host_command1(struct sscape_info *devc, int cmd)
277 unsigned char buf[10];
278 buf[0] = (unsigned char) (cmd & 0xff);
279 return host_write(devc, buf, 1);
284 static int host_command2(struct sscape_info *devc, int cmd, int parm1)
286 unsigned char buf[10];
288 buf[0] = (unsigned char) (cmd & 0xff);
289 buf[1] = (unsigned char) (parm1 & 0xff);
291 return host_write(devc, buf, 2);
294 static int host_command3(struct sscape_info *devc, int cmd, int parm1, int parm2)
296 unsigned char buf[10];
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);
304 static void set_mt32(struct sscape_info *devc, int value)
307 host_command2(devc, CMD_SET_MT32, value ? 1 : 0);
308 if (host_read(devc) != CMD_ACK)
310 /* printk( "SNDSCAPE: Setting MT32 mode failed\n"); */
315 static void set_control(struct sscape_info *devc, int ctrl, int value)
318 host_command3(devc, CMD_SET_CONTROL, ctrl, value);
319 if (host_read(devc) != CMD_ACK)
321 /* printk( "SNDSCAPE: Setting control (%d) failed\n", ctrl); */
326 static void do_dma(struct sscape_info *devc, int dma_chan, unsigned long buf, int blk_size, int mode)
330 if (dma_chan != SSCAPE_DMA_A)
332 printk(KERN_WARNING "soundscape: Tried to use DMA channel != A. Why?\n");
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;
339 temp = devc->dma << 4; /* Setup DMA channel select bits */
341 temp |= 0x80; /* 8 bit DMA channel */
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);
349 static int verify_mpu(struct sscape_info *devc)
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.
357 * Detect this by looking if there are more than 10 received MIDI bytes
358 * (0x00) in the buffer.
363 for (i = 0; i < 10; i++)
365 if (inb(devc->base + HOST_CTRL) & 0x80)
368 if (inb(devc->base) != 0x00)
371 printk(KERN_WARNING "SoundScape: The device is not in the MPU-401 mode\n");
375 static int sscape_coproc_open(void *dev_info, int sub_device)
377 if (sub_device == COPR_MIDI)
380 if (!verify_mpu(devc))
386 static void sscape_coproc_close(void *dev_info, int sub_device)
388 struct sscape_info *devc = dev_info;
391 spin_lock_irqsave(&devc->lock,flags);
392 if (devc->dma_allocated)
394 __sscape_write(GA_DMAA_REG, 0x20); /* DMA channel disabled */
395 devc->dma_allocated = 0;
397 spin_unlock_irqrestore(&devc->lock,flags);
401 static void sscape_coproc_reset(void *dev_info)
405 static int sscape_download_boot(struct sscape_info *devc, unsigned char *block, int size, int flag)
409 volatile int done, timeout_val;
410 static unsigned char codec_dma_bits;
412 if (flag & CPF_FIRST)
415 * First block. Have to allocate DMA and to reset the board
419 spin_lock_irqsave(&devc->lock,flags);
420 codec_dma_bits = sscape_read(devc, GA_CDCFG_REG);
422 if (devc->dma_allocated == 0)
423 devc->dma_allocated = 1;
425 spin_unlock_irqrestore(&devc->lock,flags);
427 sscape_write(devc, GA_HMCTL_REG,
428 (temp = sscape_read(devc, GA_HMCTL_REG)) & 0x3f); /*Reset */
430 for (timeout_val = 10000; timeout_val > 0; timeout_val--)
431 sscape_read(devc, GA_HMCTL_REG); /* Delay */
433 /* Take board out of reset */
434 sscape_write(devc, GA_HMCTL_REG,
435 (temp = sscape_read(devc, GA_HMCTL_REG)) | 0x80);
438 * Transfer one code block using DMA
440 if (audio_devs[devc->codec_audiodev]->dmap_out->raw_buf == NULL)
442 printk(KERN_WARNING "soundscape: DMA buffer not available\n");
445 memcpy(audio_devs[devc->codec_audiodev]->dmap_out->raw_buf, block, size);
447 spin_lock_irqsave(&devc->lock,flags);
449 /******** INTERRUPTS DISABLED NOW ********/
451 do_dma(devc, SSCAPE_DMA_A,
452 audio_devs[devc->codec_audiodev]->dmap_out->raw_buf_phys,
453 size, DMA_MODE_WRITE);
456 * Wait until transfer completes.
461 while (!done && timeout_val-- > 0)
467 clear_dma_ff(devc->dma);
468 if ((resid = get_dma_residue(devc->dma)) == 0)
472 spin_unlock_irqrestore(&devc->lock,flags);
479 * Take the board out of reset
481 outb((0x00), PORT(HOST_CTRL));
482 outb((0x00), PORT(MIDI_CTRL));
484 temp = sscape_read(devc, GA_HMCTL_REG);
486 sscape_write(devc, GA_HMCTL_REG, temp); /* Kickstart the board */
489 * Wait until the ODB wakes up
491 spin_lock_irqsave(&devc->lock,flags);
493 timeout_val = 5 * HZ;
494 while (!done && timeout_val-- > 0)
499 x = inb(PORT(HOST_DATA));
500 if (x == 0xff || x == 0xfe) /* OBP startup acknowledge */
502 DDB(printk("Soundscape: Acknowledge = %x\n", x));
506 sscape_write(devc, GA_CDCFG_REG, codec_dma_bits);
508 spin_unlock_irqrestore(&devc->lock,flags);
511 printk(KERN_ERR "soundscape: The OBP didn't respond after code download\n");
514 spin_lock_irqsave(&devc->lock,flags);
516 timeout_val = 5 * HZ;
517 while (!done && timeout_val-- > 0)
520 if (inb(PORT(HOST_DATA)) == 0xfe) /* Host startup acknowledge */
523 spin_unlock_irqrestore(&devc->lock,flags);
526 printk(KERN_ERR "soundscape: OBP Initialization failed.\n");
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);
535 * Temporary debugging aid. Print contents of the registers after
536 * downloading the code.
541 for (i = 0; i < 13; i++)
542 printk("I%d = %02x (new value)\n", i, sscape_read(devc, i));
550 static int download_boot_block(void *dev_info, copr_buffer * buf)
552 if (buf->len <= 0 || buf->len > sizeof(buf->data))
555 if (!sscape_download_boot(devc, buf->data, buf->len, buf->flags))
557 printk(KERN_ERR "soundscape: Unable to load microcode block to the OBP.\n");
563 static int sscape_coproc_ioctl(void *dev_info, unsigned int cmd, void __user *arg, int local)
570 case SNDCTL_COPR_RESET:
571 sscape_coproc_reset(dev_info);
574 case SNDCTL_COPR_LOAD:
575 buf = (copr_buffer *) vmalloc(sizeof(copr_buffer));
578 if (copy_from_user(buf, arg, sizeof(copr_buffer)))
583 err = download_boot_block(dev_info, buf);
592 static coproc_operations sscape_coproc_operations =
603 static int sscape_detected;
604 static int sscape_is_pnp;
606 void __init attach_sscape(struct address_info *hw_config)
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
622 #define SSCAPE_REGS { \
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 */ \
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 */ \
637 static unsigned char regs[10] = SSCAPE_REGS;
639 int i, irq_bits = 0xff;
641 if (sscape_detected != hw_config->io_base)
644 request_region(devc->base + 2, 6, "SoundScape");
647 valid_interrupts = valid_interrupts_old;
648 conf_printf("Ensoniq SoundScape (old)", hw_config);
651 conf_printf("Ensoniq SoundScape", hw_config);
653 for (i = 0; i < sizeof(valid_interrupts); i++)
655 if (hw_config->irq == valid_interrupts[i])
661 if (hw_config->irq > 15 || (regs[4] = irq_bits == 0xff))
663 printk(KERN_ERR "Invalid IRQ%d\n", hw_config->irq);
667 if (!sscape_is_pnp) {
669 spin_lock_irqsave(&devc->lock,flags);
670 for (i = 1; i < 10; i++)
674 case 1: /* Host interrupt enable */
675 sscape_write(devc, i, 0xf0); /* All interrupts enabled */
678 case 2: /* DMA A status/trigger register */
679 case 3: /* DMA B status/trigger register */
680 sscape_write(devc, i, 0x20); /* DMA channel disabled */
683 case 4: /* Host interrupt config reg */
684 sscape_write(devc, i, 0xf0 | (irq_bits << 2) | irq_bits);
687 case 5: /* Don't destroy CD-ROM DMA config bits (0xc0) */
688 sscape_write(devc, i, (regs[i] & 0x3f) | (sscape_read(devc, i) & 0xc0));
691 case 6: /* CD-ROM config (WSS codec actually) */
692 sscape_write(devc, i, regs[i]);
695 case 9: /* Master control reg. Don't modify CR-ROM bits. Disable SB emul */
696 sscape_write(devc, i, (sscape_read(devc, i) & 0xf0) | 0x08);
700 sscape_write(devc, i, regs[i]);
703 spin_unlock_irqrestore(&devc->lock,flags);
707 * Temporary debugging aid. Print contents of the registers after
713 for (i = 0; i < 13; i++)
714 printk("I%d = %02x (new value)\n", i, sscape_read(devc, i));
718 if (probe_mpu401(hw_config))
719 hw_config->always_detect = 1;
720 hw_config->name = "SoundScape";
722 hw_config->irq *= -1; /* Negative value signals IRQ sharing */
723 attach_mpu401(hw_config, THIS_MODULE);
724 hw_config->irq *= -1; /* Restore it */
726 if (hw_config->slots[1] != -1) /* The MPU driver installed itself */
728 sscape_mididev = hw_config->slots[1];
729 midi_devs[hw_config->slots[1]]->coproc = &sscape_coproc_operations;
731 sscape_write(devc, GA_INTENA_REG, 0x80); /* Master IRQ enable */
736 static int detect_ga(sscape_info * devc)
740 DDB(printk("Entered Soundscape detect_ga(%x)\n", devc->base));
742 if (check_region(devc->base, 8))
746 * First check that the address register of "ODIE" is
747 * there and that it has exactly 4 writable bits.
751 if ((save = inb(PORT(ODIE_ADDR))) & 0xf0)
753 DDB(printk("soundscape: Detect error A\n"));
756 outb((0x00), PORT(ODIE_ADDR));
757 if (inb(PORT(ODIE_ADDR)) != 0x00)
759 DDB(printk("soundscape: Detect error B\n"));
762 outb((0xff), PORT(ODIE_ADDR));
763 if (inb(PORT(ODIE_ADDR)) != 0x0f)
765 DDB(printk("soundscape: Detect error C\n"));
768 outb((save), PORT(ODIE_ADDR));
771 * Now verify that some indirect registers return zero on some bits.
772 * This may break the driver with some future revisions of "ODIE" but...
775 if (sscape_read(devc, 0) & 0x0c)
777 DDB(printk("soundscape: Detect error D (%x)\n", sscape_read(devc, 0)));
780 if (sscape_read(devc, 1) & 0x0f)
782 DDB(printk("soundscape: Detect error E\n"));
785 if (sscape_read(devc, 5) & 0x0f)
787 DDB(printk("soundscape: Detect error F\n"));
793 static int sscape_read_host_ctrl(sscape_info* devc)
795 return host_read(devc);
798 static void sscape_write_host_ctrl2(sscape_info *devc, int a, int b)
800 host_command2(devc, a, b);
803 static int sscape_alloc_dma(sscape_info *devc)
805 char *start_addr, *end_addr;
810 if (devc->raw_buf != NULL) return 0; /* Already done */
811 dma_pagesize = (devc->dma < 4) ? (64 * 1024) : (128 * 1024);
812 devc->raw_buf = NULL;
813 devc->buffsize = 8192*4;
814 if (devc->buffsize > dma_pagesize) devc->buffsize = dma_pagesize;
817 * Now loop until we get a free buffer. Try to get smaller buffer if
818 * it fails. Don't accept smaller than 8k buffer for performance
821 while (start_addr == NULL && devc->buffsize > PAGE_SIZE) {
822 for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
823 devc->buffsize = PAGE_SIZE * (1 << sz);
824 start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA, sz);
825 if (start_addr == NULL) devc->buffsize /= 2;
828 if (start_addr == NULL) {
829 printk(KERN_ERR "sscape pnp init error: Couldn't allocate DMA buffer\n");
832 /* make some checks */
833 end_addr = start_addr + devc->buffsize - 1;
834 /* now check if it fits into the same dma-pagesize */
836 if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
837 || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
838 printk(KERN_ERR "sscape pnp: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr, devc->buffsize);
842 devc->raw_buf = start_addr;
843 devc->raw_buf_phys = virt_to_bus(start_addr);
845 for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
846 SetPageReserved(page);
850 static void sscape_free_dma(sscape_info *devc)
853 unsigned long start_addr, end_addr;
856 if (devc->raw_buf == NULL) return;
857 for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
858 start_addr = (unsigned long) devc->raw_buf;
859 end_addr = start_addr + devc->buffsize;
861 for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
862 ClearPageReserved(page);
864 free_pages((unsigned long) devc->raw_buf, sz);
865 devc->raw_buf = NULL;
868 /* Intel version !!!!!!!!! */
870 static int sscape_start_dma(int chan, unsigned long physaddr, int count, int dma_mode)
874 flags = claim_dma_lock();
877 set_dma_mode(chan, dma_mode);
878 set_dma_addr(chan, physaddr);
879 set_dma_count(chan, count);
881 release_dma_lock(flags);
885 static void sscape_pnp_start_dma(sscape_info* devc, int arg )
888 if (arg == 0) reg = 2;
891 sscape_write(devc, reg, sscape_read( devc, reg) | 0x01);
892 sscape_write(devc, reg, sscape_read( devc, reg) & 0xFE);
895 static int sscape_pnp_wait_dma (sscape_info* devc, int arg )
901 if (arg == 0) reg = 2;
907 d = sscape_read(devc, reg) & 1;
910 } while (i < 500000);
911 d = sscape_read(devc, reg) & 1;
915 static int sscape_pnp_alloc_dma(sscape_info* devc)
917 /* printk(KERN_INFO "sscape: requesting dma\n"); */
918 if (request_dma(devc -> dma, "sscape")) return 0;
919 /* printk(KERN_INFO "sscape: dma channel allocated\n"); */
920 if (!sscape_alloc_dma(devc)) {
921 free_dma(devc -> dma);
927 static void sscape_pnp_free_dma(sscape_info* devc)
929 sscape_free_dma( devc);
930 free_dma(devc -> dma );
931 /* printk(KERN_INFO "sscape: dma released\n"); */
934 static int sscape_pnp_upload_file(sscape_info* devc, char* fn)
942 sscape_write( devc, 9, sscape_read(devc, 9 ) & 0x3F );
943 sscape_write( devc, 2, (devc -> dma << 4) | 0x80 );
944 sscape_write( devc, 3, 0x20 );
945 sscape_write( devc, 9, sscape_read( devc, 9 ) | 0x80 );
947 len = mod_firmware_load(fn, &data);
949 printk(KERN_ERR "sscape: file not found: %s\n", fn);
953 spin_lock_irqsave(&devc->lock,flags);
955 if (len > devc -> buffsize) l = devc->buffsize;
958 memcpy(devc->raw_buf, dt, l); dt += l;
959 sscape_start_dma(devc->dma, devc->raw_buf_phys, l, 0x48);
960 sscape_pnp_start_dma ( devc, 0 );
961 if (sscape_pnp_wait_dma ( devc, 0 ) == 0) {
962 spin_unlock_irqrestore(&devc->lock,flags);
967 spin_unlock_irqrestore(&devc->lock,flags);
970 outb(0, devc -> base + 2);
971 outb(0, devc -> base);
973 sscape_write ( devc, 9, sscape_read( devc, 9 ) | 0x40);
975 timeout_val = 5 * HZ;
976 while (!done && timeout_val-- > 0)
980 x = inb( devc -> base + 3);
981 if (x == 0xff || x == 0xfe) /* OBP startup acknowledge */
983 //printk(KERN_ERR "Soundscape: Acknowledge = %x\n", x);
987 timeout_val = 5 * HZ;
989 while (!done && timeout_val-- > 0)
993 x = inb( devc -> base + 3);
994 if (x == 0xfe) /* OBP startup acknowledge */
996 //printk(KERN_ERR "Soundscape: Acknowledge = %x\n", x);
1001 if ( !done ) printk(KERN_ERR "soundscape: OBP Initialization failed.\n");
1003 sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
1004 sscape_write( devc, 3, (devc -> dma << 4) + 0x80);
1008 static void __init sscape_pnp_init_hw(sscape_info* devc)
1010 unsigned char midi_irq = 0, sb_irq = 0;
1012 static char code_file_name[23] = "/sndscape/sndscape.cox";
1014 int sscape_sb_enable = 0;
1015 int sscape_joystic_enable = 0x7f;
1016 int sscape_mic_enable = 0;
1017 int sscape_ext_midi = 0;
1019 if ( !sscape_pnp_alloc_dma(devc) ) {
1020 printk(KERN_ERR "sscape: faild to allocate dma\n");
1024 for (i = 0; i < 4; i++) {
1025 if ( devc -> irq == valid_interrupts[i] )
1027 if ( devc -> codec_irq == valid_interrupts[i] )
1031 sscape_write( devc, 5, 0x50);
1032 sscape_write( devc, 7, 0x2e);
1033 sscape_write( devc, 8, 0x00);
1035 sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
1036 sscape_write( devc, 3, ( devc -> dma << 4) | 0x80);
1038 if ( sscape_sb_enable )
1039 sscape_write (devc, 4, 0xF0 | (sb_irq << 2) | midi_irq);
1041 sscape_write (devc, 4, 0xF0 | (midi_irq<<2) | midi_irq);
1043 i = 0x10; //sscape_read(devc, 9) & (devc->ic_type == IC_ODIE ? 0xf0 : 0xc0);
1044 if ( sscape_sb_enable )
1045 i |= devc->ic_type == IC_ODIE ? 0x05 : 0x07;
1046 if (sscape_joystic_enable) i |= 8;
1048 sscape_write (devc, 9, i);
1049 sscape_write (devc, 6, 0x80);
1050 sscape_write (devc, 1, 0x80);
1052 if (devc -> codec_type == 2) {
1053 sscape_pnp_write_codec( devc, 0x0C, 0x50);
1054 sscape_pnp_write_codec( devc, 0x10, sscape_pnp_read_codec( devc, 0x10) & 0x3F);
1055 sscape_pnp_write_codec( devc, 0x11, sscape_pnp_read_codec( devc, 0x11) | 0xC0);
1056 sscape_pnp_write_codec( devc, 29, 0x20);
1059 if (sscape_pnp_upload_file(devc, "/sndscape/scope.cod") == 0 ) {
1060 printk(KERN_ERR "sscape: faild to upload file /sndscape/scope.cod\n");
1061 sscape_pnp_free_dma(devc);
1065 i = sscape_read_host_ctrl( devc );
1067 if ( (i & 0x0F) > 7 ) {
1068 printk(KERN_ERR "sscape: scope.cod faild\n");
1069 sscape_pnp_free_dma(devc);
1072 if ( i & 0x10 ) sscape_write( devc, 7, 0x2F);
1073 code_file_name[21] = (char) ( i & 0x0F) + 0x30;
1074 if (sscape_pnp_upload_file( devc, code_file_name) == 0) {
1075 printk(KERN_ERR "sscape: faild to upload file %s\n", code_file_name);
1076 sscape_pnp_free_dma(devc);
1080 if (devc->ic_type != IC_ODIE) {
1081 sscape_pnp_write_codec( devc, 10, (sscape_pnp_read_codec(devc, 10) & 0x7f) |
1082 ( sscape_mic_enable == 0 ? 0x00 : 0x80) );
1084 sscape_write_host_ctrl2( devc, 0x84, 0x64 ); /* MIDI volume */
1085 sscape_write_host_ctrl2( devc, 0x86, 0x64 ); /* MIDI volume?? */
1086 sscape_write_host_ctrl2( devc, 0x8A, sscape_ext_midi);
1088 sscape_pnp_write_codec ( devc, 6, 0x3f ); //WAV_VOL
1089 sscape_pnp_write_codec ( devc, 7, 0x3f ); //WAV_VOL
1090 sscape_pnp_write_codec ( devc, 2, 0x1F ); //WD_CDXVOLL
1091 sscape_pnp_write_codec ( devc, 3, 0x1F ); //WD_CDXVOLR
1093 if (devc -> codec_type == 1) {
1094 sscape_pnp_write_codec ( devc, 4, 0x1F );
1095 sscape_pnp_write_codec ( devc, 5, 0x1F );
1096 sscape_write_host_ctrl2( devc, 0x88, sscape_mic_enable);
1099 sscape_pnp_write_codec ( devc, 0x10, 0x1F << 1);
1100 sscape_pnp_write_codec ( devc, 0x11, 0xC0 | (0x1F << 1));
1102 t = sscape_pnp_read_codec( devc, 0x00) & 0xDF;
1103 if ( (sscape_mic_enable == 0)) t |= 0;
1105 sscape_pnp_write_codec ( devc, 0x00, t);
1106 t = sscape_pnp_read_codec( devc, 0x01) & 0xDF;
1107 if ( (sscape_mic_enable == 0) ) t |= 0;
1109 sscape_pnp_write_codec ( devc, 0x01, t);
1110 sscape_pnp_write_codec ( devc, 0x40 | 29 , 0x20);
1111 outb(0, devc -> codec);
1113 if (devc -> ic_type == IC_OPUS ) {
1114 int i = sscape_read( devc, 9 );
1115 sscape_write( devc, 9, i | 3 );
1116 sscape_write( devc, 3, 0x40);
1118 if (check_region(0x228, 1)) {
1120 release_region(0x228,1);
1122 sscape_write( devc, 3, (devc -> dma << 4) | 0x80);
1123 sscape_write( devc, 9, i );
1126 host_close ( devc );
1127 sscape_pnp_free_dma(devc);
1130 static int __init detect_sscape_pnp(sscape_info* devc)
1132 long i, irq_bits = 0xff;
1135 DDB(printk("Entered detect_sscape_pnp(%x)\n", devc->base));
1137 if (check_region(devc->base, 8)) {
1138 printk(KERN_ERR "detect_sscape_pnp: port %x is not free\n", devc->base);
1142 if (check_region(devc->codec, 2)) {
1143 printk(KERN_ERR "detect_sscape_pnp: port %x is not free\n", devc->codec);
1147 if ( (inb( devc -> base + 2) & 0x78) != 0) return 0;
1149 d = inb ( devc -> base + 4) & 0xF0;
1150 if ( (d & 0x80) != 0) return 0;
1153 devc->codec_type = 1;
1154 devc->ic_type = IC_ODIE;
1156 else if ( (d & 0x60) != 0) {
1157 devc->codec_type = 2;
1158 devc->ic_type = IC_OPUS;
1160 else if ( (d & 0x40) != 0) {
1161 devc->codec_type = 2;
1162 devc->ic_type = IC_ODIE;
1168 outb(0xFA, devc -> base+4);
1169 if ((inb( devc -> base+4) & 0x9F) != 0x0A)
1171 outb(0xFE, devc -> base+4);
1172 if ( (inb(devc -> base+4) & 0x9F) != 0x0E)
1174 if ( (inb(devc -> base+5) & 0x9F) != 0x0E)
1177 if (devc->codec_type == 2) {
1178 if (devc -> codec != devc -> base + 8)
1179 printk("soundscape warning: incorrect codec port specified\n");
1180 devc -> codec = devc -> base + 8;
1181 d = 0x10 | (sscape_read(devc, 9) & 0xCF);
1182 sscape_write(devc, 9, d);
1183 sscape_write(devc, 6, 0x80);
1185 //todo: check codec is not base + 8
1188 d = (sscape_read(devc, 9) & 0x3F) | 0xC0;
1189 sscape_write(devc, 9, d);
1191 for (i = 0; i < 550000; i++)
1192 if ( !(inb(devc -> codec) & 0x80) ) break;
1194 d = inb(devc -> codec);
1197 if ( inb(devc -> codec + 2) == 0xFF)
1200 sscape_write(devc, 9, sscape_read(devc, 9) & 0x3F );
1202 d = inb(devc -> codec) & 0x80;
1204 printk(KERN_INFO "soundscape: hardware detected\n");
1205 valid_interrupts = valid_interrupts_new;
1207 printk(KERN_INFO "soundscape: board looks like media fx\n");
1208 valid_interrupts = valid_interrupts_old;
1212 sscape_write( devc, 9, 0xC0 | (sscape_read(devc, 9) & 0x3F) );
1214 for (i = 0; i < 550000; i++)
1215 if ( !(inb(devc -> codec) & 0x80))
1218 sscape_pnp_init_hw(devc);
1220 for (i = 0; i < sizeof(valid_interrupts); i++)
1222 if (devc->codec_irq == valid_interrupts[i]) {
1227 sscape_write(devc, GA_INTENA_REG, 0x00);
1228 sscape_write(devc, GA_DMACFG_REG, 0x50);
1229 sscape_write(devc, GA_DMAA_REG, 0x70);
1230 sscape_write(devc, GA_DMAB_REG, 0x20);
1231 sscape_write(devc, GA_INTCFG_REG, 0xf0);
1232 sscape_write(devc, GA_CDCFG_REG, 0x89 | (devc->dma << 4) | (irq_bits << 1));
1234 sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 0) | 0x20);
1235 sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 1) | 0x20);
1240 static int __init probe_sscape(struct address_info *hw_config)
1243 if (sscape_detected != 0 && sscape_detected != hw_config->io_base)
1246 devc->base = hw_config->io_base;
1247 devc->irq = hw_config->irq;
1248 devc->dma = hw_config->dma;
1249 devc->osp = hw_config->osp;
1251 #ifdef SSCAPE_DEBUG1
1253 * Temporary debugging aid. Print contents of the registers before
1259 for (i = 0; i < 13; i++)
1260 printk("I%d = %02x (old value)\n", i, sscape_read(devc, i));
1265 if (!detect_ga(devc)) {
1266 if (detect_sscape_pnp(devc)) {
1267 sscape_detected = hw_config->io_base;
1273 if (old_hardware) /* Check that it's really an old Spea/Reveal card. */
1278 if (!((tmp = sscape_read(devc, GA_HMCTL_REG)) & 0xc0))
1280 sscape_write(devc, GA_HMCTL_REG, tmp | 0x80);
1281 for (cc = 0; cc < 200000; ++cc)
1282 inb(devc->base + ODIE_ADDR);
1285 sscape_detected = hw_config->io_base;
1289 static int __init probe_ss_ms_sound(struct address_info *hw_config)
1291 int i, irq_bits = 0xff;
1296 printk(KERN_ERR "soundscape: Card not detected\n");
1301 printk(KERN_ERR "soundscape: Invalid initialization order.\n");
1304 for (i = 0; i < sizeof(valid_interrupts); i++)
1306 if (hw_config->irq == valid_interrupts[i])
1312 if (hw_config->irq > 15 || irq_bits == 0xff)
1314 printk(KERN_ERR "soundscape: Invalid MSS IRQ%d\n", hw_config->irq);
1318 if (!sscape_is_pnp) {
1320 ad_flags = 0x12345677; /* Tell that we may have a CS4248 chip (Spea-V7 Media FX) */
1321 return ad1848_detect(hw_config->io_base, &ad_flags, hw_config->osp);
1325 ad_flags = 0x12345677; /* Tell that we may have a CS4248 chip (Spea-V7 Media FX) */
1327 ad_flags = 0x87654321; /* Tell that we have a soundscape pnp with 1845 chip */
1328 return ad1848_detect(hw_config->io_base, &ad_flags, hw_config->osp);
1332 static void __init attach_ss_ms_sound(struct address_info *hw_config)
1335 * This routine configures the SoundScape card for use with the
1336 * Win Sound System driver. The AD1848 codec interface uses the CD-ROM
1337 * config registers of the "ODIE".
1340 int i, irq_bits = 0xff;
1343 if (!sscape_is_pnp) /*pnp is already setup*/
1346 * Setup the DMA polarity.
1348 sscape_write(devc, GA_DMACFG_REG, 0x50);
1351 * Take the gate-array off of the DMA channel.
1353 sscape_write(devc, GA_DMAB_REG, 0x20);
1356 * Init the AD1848 (CD-ROM) config reg.
1358 for (i = 0; i < sizeof(valid_interrupts); i++)
1360 if (hw_config->irq == valid_interrupts[i])
1366 sscape_write(devc, GA_CDCFG_REG, 0x89 | (hw_config->dma << 4) | (irq_bits << 1));
1369 if (hw_config->irq == devc->irq)
1370 printk(KERN_WARNING "soundscape: Warning! The WSS mode can't share IRQ with MIDI\n");
1372 hw_config->slots[0] = ad1848_init(
1373 sscape_is_pnp ? "SoundScape" : "SoundScape PNP",
1383 if (hw_config->slots[0] != -1) /* The AD1848 driver installed itself */
1385 audio_devs[hw_config->slots[0]]->coproc = &sscape_coproc_operations;
1386 devc->codec_audiodev = hw_config->slots[0];
1387 devc->my_audiodev = hw_config->slots[0];
1389 /* Set proper routings here (what are they) */
1390 AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_LINE);
1393 #ifdef SSCAPE_DEBUG5
1395 * Temporary debugging aid. Print contents of the registers
1396 * after the AD1848 device has been initialized.
1401 for (i = 0; i < 13; i++)
1402 printk("I%d = %02x\n", i, sscape_read(devc, i));
1408 static void __exit unload_sscape(struct address_info *hw_config)
1410 release_region(devc->base + 2, 6);
1411 unload_mpu401(hw_config);
1414 static void __exit unload_ss_ms_sound(struct address_info *hw_config)
1416 ad1848_unload(hw_config->io_base,
1421 sound_unload_audiodev(hw_config->slots[0]);
1424 static struct address_info cfg;
1425 static struct address_info cfg_mpu;
1427 static int __initdata spea = -1;
1428 static int __initdata mss = 0;
1429 static int __initdata dma = -1;
1430 static int __initdata irq = -1;
1431 static int __initdata io = -1;
1432 static int __initdata mpu_irq = -1;
1433 static int __initdata mpu_io = -1;
1435 MODULE_PARM(dma, "i");
1436 MODULE_PARM(irq, "i");
1437 MODULE_PARM(io, "i");
1438 MODULE_PARM(spea, "i"); /* spea=0/1 set the old_hardware */
1439 MODULE_PARM(mpu_irq, "i");
1440 MODULE_PARM(mpu_io, "i");
1441 MODULE_PARM(mss, "i");
1443 static int __init init_sscape(void)
1445 printk(KERN_INFO "Soundscape driver Copyright (C) by Hannu Savolainen 1993-1996\n");
1451 cfg_mpu.irq = mpu_irq;
1452 cfg_mpu.io_base = mpu_io;
1453 /* WEH - Try to get right dma channel */
1456 devc->codec = cfg.io_base;
1457 devc->codec_irq = cfg.irq;
1458 devc->codec_type = 0;
1460 devc->raw_buf = NULL;
1461 spin_lock_init(&devc->lock);
1463 if (cfg.dma == -1 || cfg.irq == -1 || cfg.io_base == -1) {
1464 printk(KERN_ERR "DMA, IRQ, and IO port must be specified.\n");
1468 if (cfg_mpu.irq == -1 && cfg_mpu.io_base != -1) {
1469 printk(KERN_ERR "MPU_IRQ must be specified if MPU_IO is set.\n");
1474 old_hardware = spea;
1475 printk(KERN_INFO "Forcing %s hardware support.\n",
1478 if (probe_sscape(&cfg_mpu) == 0)
1481 attach_sscape(&cfg_mpu);
1483 mss = probe_ss_ms_sound(&cfg);
1486 attach_ss_ms_sound(&cfg);
1491 static void __exit cleanup_sscape(void)
1494 unload_ss_ms_sound(&cfg);
1495 unload_sscape(&cfg_mpu);
1498 module_init(init_sscape);
1499 module_exit(cleanup_sscape);
1502 static int __init setup_sscape(char *str)
1504 /* io, irq, dma, mpu_io, mpu_irq */
1507 str = get_options(str, ARRAY_SIZE(ints), ints);
1518 __setup("sscape=", setup_sscape);
1520 MODULE_LICENSE("GPL");