/*
* sound/pss.c
*
* The low level driver for the Personal Sound System (ECHO ESC614).
*/
/*
* Copyright (C) by Hannu Savolainen 1993-1996
*
* USS/Lite for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
* Version 2 (June 1991). See the "COPYING" file distributed with this software
* for more info.
*/
#include <linux/config.h>
#include "sound_config.h"
#if defined(CONFIG_PSS) && defined(CONFIG_AUDIO)
/*
* PSS registers.
*/
#define REG(x) (devc->base+x)
#define PSS_DATA 0
#define PSS_STATUS 2
#define PSS_CONTROL 2
#define PSS_ID 4
#define PSS_IRQACK 4
#define PSS_PIO 0x1a
/*
* Config registers
*/
#define CONF_PSS 0x10
#define CONF_WSS 0x12
#define CONF_SB 0x13
#define CONF_CDROM 0x16
#define CONF_MIDI 0x18
/*
* Status bits.
*/
#define PSS_FLAG3 0x0800
#define PSS_FLAG2 0x0400
#define PSS_FLAG1 0x1000
#define PSS_FLAG0 0x0800
#define PSS_WRITE_EMPTY 0x8000
#define PSS_READ_FULL 0x4000
#include "coproc.h"
#ifdef PSS_HAVE_LD
#include "synth-ld.h"
#else
static int pss_synthLen = 0;
static unsigned char *pss_synth =
NULL;
#endif
typedef struct pss_confdata
{
int base;
int irq;
int dma;
int *osp;
}
pss_confdata;
static pss_confdata pss_data;
static pss_confdata *devc = &pss_data;
static int pss_initialized = 0;
static int nonstandard_microcode = 0;
int
probe_pss (struct address_info *hw_config)
{
unsigned short id;
int irq, dma;
devc->base = hw_config->io_base;
irq = devc->irq = hw_config->irq;
dma = devc->dma = hw_config->dma;
devc->osp = hw_config->osp;
if (devc->base != 0x220 && devc->base != 0x240)
if (devc->base != 0x230 && devc->base != 0x250) /* Some cards use these */
return 0;
if (check_region (devc->base, 16))
{
printk ("PSS: I/O port conflict\n");
return 0;
}
id = inw (REG (PSS_ID));
if ((id >> 8) != 'E')
{
/* printk ("No PSS signature detected at 0x%x (0x%x)\n", devc->base, id); */
return 0;
}
return 1;
}
static int
set_irq (pss_confdata * devc, int dev, int irq)
{
static unsigned short irq_bits[16] =
{
0x0000, 0x0000, 0x0000, 0x0008,
0x0000, 0x0010, 0x0000, 0x0018,
0x0000, 0x0020, 0x0028, 0x0030,
0x0038, 0x0000, 0x0000, 0x0000
};
unsigned short tmp, bits;
if (irq < 0 || irq > 15)
return 0;
tmp = inw (REG (dev)) & ~0x38; /* Load confreg, mask IRQ bits out */
if ((bits = irq_bits[irq]) == 0 && irq != 0)
{
printk ("PSS: Invalid IRQ %d\n", irq);
return 0;
}
outw (tmp | bits, REG (dev));
return 1;
}
static int
set_io_base (pss_confdata * devc, int dev, int base)
{
unsigned short tmp = inw (REG (dev)) & 0x003f;
unsigned short bits = (base & 0x0ffc) << 4;
outw (bits | tmp, REG (dev));
return 1;
}
static int
set_dma (pss_confdata * devc, int dev, int dma)
{
static unsigned short dma_bits[8] =
{
0x0001, 0x0002, 0x0000, 0x0003,
0x0000, 0x0005, 0x0006, 0x0007
};
unsigned short tmp, bits;
if (dma < 0 || dma > 7)
return 0;
tmp = inw (REG (dev)) & ~0x07; /* Load confreg, mask DMA bits out */
if ((bits = dma_bits[dma]) == 0 && dma != 4)
{
printk ("PSS: Invalid DMA %d\n", dma);
return 0;
}
outw (tmp | bits, REG (dev));
return 1;
}
static int
pss_reset_dsp (pss_confdata * devc)
{
unsigned long i, limit = jiffies + 10;
outw (0x2000, REG (PSS_CONTROL));
for (i = 0; i < 32768 && jiffies < limit; i++)
inw (REG (PSS_CONTROL));
outw (0x0000, REG (PSS_CONTROL));
return 1;
}
static int
pss_put_dspword (pss_confdata * devc, unsigned short word)
{
int i, val;
for (i = 0; i < 327680; i++)
{
val = inw (REG (PSS_STATUS));
if (val & PSS_WRITE_EMPTY)
{
outw (word, REG (PSS_DATA));
return 1;
}
}
return 0;
}
static int
pss_get_dspword (pss_confdata * devc, unsigned short *word)
{
int i, val;
for (i = 0; i < 327680; i++)
{
val = inw (REG (PSS_STATUS));
if (val & PSS_READ_FULL)
{
*word = inw (REG (PSS_DATA));
return 1;
}
}
return 0;
}
static int
pss_download_boot (pss_confdata * devc, unsigned char *block, int size, int flags)
{
int i, limit, val, count;
if (flags & CPF_FIRST)
{
/*_____ Warn DSP software that a boot is coming */
outw (0x00fe, REG (PSS_DATA));
limit = jiffies + 10;
for (i = 0; i < 32768 && jiffies < limit; i++)
if (inw (REG (PSS_DATA)) == 0x5500)
break;
outw (*block++, REG (PSS_DATA));
pss_reset_dsp (devc);
}
count = 1;
while (1)
{
int j;
for (j = 0; j < 327670; j++)
{
/*_____ Wait for BG to appear */
if (inw (REG (PSS_STATUS)) & PSS_FLAG3)
break;
}
if (j == 327670)
{
/* It's ok we timed out when the file was empty */
if (count >= size && flags & CPF_LAST)
break;
else
{
printk ("\nPSS: Download timeout problems, byte %d=%d\n",
count, size);
return 0;
}
}
/*_____ Send the next byte */
outw (*block++, REG (PSS_DATA));
count++;
}
if (flags & CPF_LAST)
{
/*_____ Why */
outw (0, REG (PSS_DATA));
limit = jiffies + 10;
for (i = 0; i < 32768 && jiffies < limit; i++)
val = inw (REG (PSS_STATUS));
limit = jiffies + 10;
for (i = 0; i < 32768 && jiffies < limit; i++)
{
val = inw (REG (PSS_STATUS));
if (val & 0x4000)
break;
}
/* now read the version */
for (i = 0; i < 32000; i++)
{
val = inw (REG (PSS_STATUS));
if (val & PSS_READ_FULL)
break;
}
if (i == 32000)
return 0;
val = inw (REG (PSS_DATA));
/* printk("<PSS: microcode version %d.%d loaded>", val/16, val % 16); */
}
return 1;
}
void
attach_pss (struct address_info *hw_config)
{
unsigned short id;
char tmp[100];
devc->base = hw_config->io_base;
devc->irq = hw_config->irq;
devc->dma = hw_config->dma;
devc->osp = hw_config->osp;
if (!probe_pss (hw_config))
return;
id = inw (REG (PSS_ID)) & 0x00ff;
/*
* Disable all emulations. Will be enabled later (if required).
*/
outw (0x0000, REG (CONF_PSS));
outw (0x0000, REG (CONF_WSS));
outw (0x0000, REG (CONF_SB));
outw (0x0000, REG (CONF_MIDI));
outw (0x0000, REG (CONF_CDROM));
#if YOU_REALLY_WANT_TO_ALLOCATE_THESE_RESOURCES
if (sound_alloc_dma (hw_config->dma, "PSS"))
{
printk ("pss.c: Can't allocate DMA channel\n");
return;
}
if (!set_irq (devc, CONF_PSS, devc->irq))
{
printk ("PSS: IRQ error\n");
return;
}
if (!set_dma (devc, CONF_PSS, devc->dma))
{
printk ("PSS: DRQ error\n");
return;
}
#endif
pss_initialized = 1;
sprintf (tmp, "ECHO-PSS Rev. %d", id);
conf_printf (tmp, hw_config);
}
int
probe_pss_mpu (struct address_info *hw_config)
{
int timeout;
if (!pss_initialized)
return 0;
if (check_region (hw_config->io_base, 2))
{
printk ("PSS: MPU I/O port conflict\n");
return 0;
}
if (!set_io_base (devc, CONF_MIDI, hw_config->io_base))
{
printk ("PSS: MIDI base error.\n");
return 0;
}
if (!set_irq (devc, CONF_MIDI, hw_config->irq))
{
printk ("PSS: MIDI IRQ error.\n");
return 0;
}
if (!pss_synthLen)
{
printk ("PSS: Can't enable MPU. MIDI synth microcode not available.\n");
return 0;
}
if (!pss_download_boot (devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
{
printk ("PSS: Unable to load MIDI synth microcode to DSP.\n");
return 0;
}
/*
* Finally wait until the DSP algorithm has initialized itself and
* deactivates receive interrupt.
*/
for (timeout = 900000; timeout > 0; timeout--)
{
if ((inb (hw_config->io_base + 1) & 0x80) == 0) /* Input data avail */
inb (hw_config->io_base); /* Discard it */
else
break; /* No more input */
}
#if (defined(CONFIG_MPU401) || defined(CONFIG_MPU_EMU)) && defined(CONFIG_MIDI)
return probe_mpu401 (hw_config);
#else
return 0;
#endif
}
static int
pss_coproc_open (void *dev_info, int sub_device)
{
switch (sub_device)
{
case COPR_MIDI:
if (pss_synthLen == 0)
{
printk ("PSS: MIDI synth microcode not available.\n");
return -(EIO);
}
if (nonstandard_microcode)
if (!pss_download_boot (devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
{
printk ("PSS: Unable to load MIDI synth microcode to DSP.\n");
return -(EIO);
}
nonstandard_microcode = 0;
break;
default:;
}
return 0;
}
static void
pss_coproc_close (void *dev_info, int sub_device)
{
return;
}
static void
pss_coproc_reset (void *dev_info)
{
if (pss_synthLen)
if (!pss_download_boot (devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
{
printk ("PSS: Unable to load MIDI synth microcode to DSP.\n");
}
nonstandard_microcode = 0;
}
static int
download_boot_block (void *dev_info, copr_buffer * buf)
{
if (buf->len <= 0 || buf->len > sizeof (buf->data))
return -(EINVAL);
if (!pss_download_boot (devc, buf->data, buf->len, buf->flags))
{
printk ("PSS: Unable to load microcode block to DSP.\n");
return -(EIO);
}
nonstandard_microcode = 1; /* The MIDI microcode has been overwritten */
return 0;
}
static int
pss_coproc_ioctl (void *dev_info, unsigned int cmd, caddr_t arg, int local)
{
/* printk("PSS coproc ioctl %x %x %d\n", cmd, arg, local); */
switch (cmd)
{
case SNDCTL_COPR_RESET:
pss_coproc_reset (dev_info);
return 0;
break;
case SNDCTL_COPR_LOAD:
{
copr_buffer *buf;
int err;
buf = (copr_buffer *) vmalloc (sizeof (copr_buffer));
if (buf == NULL)
return -(ENOSPC);
memcpy_fromfs ((char *) buf, &((char *) arg)[0], sizeof (*buf));
err = download_boot_block (dev_info, buf);
vfree (buf);
return err;
}
break;
case SNDCTL_COPR_SENDMSG:
{
copr_msg *buf;
unsigned long flags;
unsigned short *data;
int i;
buf = (copr_msg *) vmalloc (sizeof (copr_msg));
if (buf == NULL)
return -(ENOSPC);
memcpy_fromfs ((char *) buf, &((char *) arg)[0], sizeof (*buf));
data = (unsigned short *) (buf->data);
save_flags (flags);
cli ();
for (i = 0; i < buf->len; i++)
{
if (!pss_put_dspword (devc, *data++))
{
restore_flags (flags);
buf->len = i; /* feed back number of WORDs sent */
memcpy_tofs (&((char *) arg)[0], &buf, sizeof (buf));
vfree (buf);
return -(EIO);
}
}
restore_flags (flags);
vfree (buf);
return 0;
}
break;
case SNDCTL_COPR_RCVMSG:
{
copr_msg *buf;
unsigned long flags;
unsigned short *data;
unsigned int i;
int err = 0;
buf = (copr_msg *) vmalloc (sizeof (copr_msg));
if (buf == NULL)
return -(ENOSPC);
data = (unsigned short *) buf->data;
save_flags (flags);
cli ();
for (i = 0; i < buf->len; i++)
{
buf->len = i; /* feed back number of WORDs read */
if (!pss_get_dspword (devc, data++))
{
if (i == 0)
err = -(EIO);
break;
}
}
restore_flags (flags);
memcpy_tofs (&((char *) arg)[0], &buf, sizeof (buf));
vfree (buf);
return err;
}
break;
case SNDCTL_COPR_RDATA:
{
copr_debug_buf buf;
unsigned long flags;
unsigned short tmp;
memcpy_fromfs ((char *) &buf, &((char *) arg)[0], sizeof (buf));
save_flags (flags);
cli ();
if (!pss_put_dspword (devc, 0x00d0))
{
restore_flags (flags);
return -(EIO);
}
if (!pss_put_dspword (devc, (unsigned short) (buf.parm1 & 0xffff)))
{
restore_flags (flags);
return -(EIO);
}
if (!pss_get_dspword (devc, &tmp))
{
restore_flags (flags);
return -(EIO);
}
buf.parm1 = tmp;
restore_flags (flags);
memcpy_tofs (&((char *) arg)[0], &buf, sizeof (buf));
return 0;
}
break;
case SNDCTL_COPR_WDATA:
{
copr_debug_buf buf;
unsigned long flags;
unsigned short tmp;
memcpy_fromfs ((char *) &buf, &((char *) arg)[0], sizeof (buf));
save_flags (flags);
cli ();
if (!pss_put_dspword (devc, 0x00d1))
{
restore_flags (flags);
return -(EIO);
}
if (!pss_put_dspword (devc, (unsigned short) (buf.parm1 & 0xffff)))
{
restore_flags (flags);
return -(EIO);
}
tmp = (unsigned int) buf.parm2 & 0xffff;
if (!pss_put_dspword (devc, tmp))
{
restore_flags (flags);
return -(EIO);
}
restore_flags (flags);
return 0;
}
break;
case SNDCTL_COPR_WCODE:
{
copr_debug_buf buf;
unsigned long flags;
unsigned short tmp;
memcpy_fromfs ((char *) &buf, &((char *) arg)[0], sizeof (buf));
save_flags (flags);
cli ();
if (!pss_put_dspword (devc, 0x00d3))
{
restore_flags (flags);
return -(EIO);
}
if (!pss_put_dspword (devc, (unsigned short) (buf.parm1 & 0xffff)))
{
restore_flags (flags);
return -(EIO);
}
tmp = (unsigned int) buf.parm2 & 0x00ff;
if (!pss_put_dspword (devc, tmp))
{
restore_flags (flags);
return -(EIO);
}
tmp = ((unsigned int) buf.parm2 >> 8) & 0xffff;
if (!pss_put_dspword (devc, tmp))
{
restore_flags (flags);
return -(EIO);
}
restore_flags (flags);
return 0;
}
break;
case SNDCTL_COPR_RCODE:
{
copr_debug_buf buf;
unsigned long flags;
unsigned short tmp;
memcpy_fromfs ((char *) &buf, &((char *) arg)[0], sizeof (buf));
save_flags (flags);
cli ();
if (!pss_put_dspword (devc, 0x00d2))
{
restore_flags (flags);
return -(EIO);
}
if (!pss_put_dspword (devc, (unsigned short) (buf.parm1 & 0xffff)))
{
restore_flags (flags);
return -(EIO);
}
if (!pss_get_dspword (devc, &tmp)) /* Read MSB */
{
restore_flags (flags);
return -(EIO);
}
buf.parm1 = tmp << 8;
if (!pss_get_dspword (devc, &tmp)) /* Read LSB */
{
restore_flags (flags);
return -(EIO);
}
buf.parm1 |= tmp & 0x00ff;
restore_flags (flags);
memcpy_tofs (&((char *) arg)[0], &buf, sizeof (buf));
return 0;
}
break;
default:
return -(EINVAL);
}
return -(EINVAL);
}
static coproc_operations pss_coproc_operations =
{
"ADSP-2115",
pss_coproc_open,
pss_coproc_close,
pss_coproc_ioctl,
pss_coproc_reset,
&pss_data
};
void
attach_pss_mpu (struct address_info *hw_config)
{
#if (defined(CONFIG_MPU401) || defined(CONFIG_MPU_EMU)) && defined(CONFIG_MIDI)
{
int prev_devs;
prev_devs = num_midis;
attach_mpu401 (hw_config);
if (num_midis == (prev_devs + 1)) /* The MPU driver installed itself */
midi_devs[prev_devs]->coproc = &pss_coproc_operations;
}
#endif
}
int
probe_pss_mss (struct address_info *hw_config)
{
int timeout;
if (!pss_initialized)
return 0;
if (check_region (hw_config->io_base, 8))
{
printk ("PSS: WSS I/O port conflict\n");
return 0;
}
if (!set_io_base (devc, CONF_WSS, hw_config->io_base))
{
printk ("PSS: WSS base error.\n");
return 0;
}
if (!set_irq (devc, CONF_WSS, hw_config->irq))
{
printk ("PSS: WSS IRQ error.\n");
return 0;
}
if (!set_dma (devc, CONF_WSS, hw_config->dma))
{
printk ("PSS: WSS DRQ error\n");
return 0;
}
/*
* For some reason the card returns 0xff in the WSS status register
* immediately after boot. Probably MIDI+SB emulation algorithm
* downloaded to the ADSP2115 spends some time initializing the card.
* Let's try to wait until it finishes this task.
*/
for (timeout = 0;
timeout < 100000 && (inb (hw_config->io_base + 3) & 0x3f) != 0x04;
timeout++);
outb (0x0b, hw_config->io_base + 4); /* Required by some cards */
return probe_ms_sound (hw_config);
}
void
attach_pss_mss (struct address_info *hw_config)
{
int prev_devs;
prev_devs = num_audiodevs;
attach_ms_sound (hw_config);
if (num_audiodevs == (prev_devs + 1)) /* The MSS driver installed itself */
audio_devs[prev_devs]->coproc = &pss_coproc_operations;
}
void
unload_pss (struct address_info *hw_config)
{
}
void
unload_pss_mpu (struct address_info *hw_config)
{
#if (defined(CONFIG_MPU401) || defined(CONFIG_MPU_EMU)) && defined(CONFIG_MIDI)
unload_mpu401 (hw_config);
#endif
}
void
unload_pss_mss (struct address_info *hw_config)
{
unload_ms_sound (hw_config);
}
#endif
