URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [sound/] [sb_common.c] - Blame information for rev 1626

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * sound/sb_common.c
 *
 * Common routines for Sound Blaster compatible cards.
 */
/*
 * 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_SBDSP)
 
#ifndef CONFIG_AUDIO
#error You will need to configure the sound driver with CONFIG_AUDIO option.
#endif
 
#include "sb_mixer.h"
#include "sb.h"
 
static sb_devc *detected_devc = NULL;   /* For communication from probe to init */
static sb_devc *last_devc = NULL;       /* For MPU401 initialization */
static sb_devc *irq2devc[16] =
{NULL};
static unsigned char jazz_irq_bits[] =
{0, 0, 2, 3, 0, 1, 0, 4, 0, 2, 5, 0, 0, 0, 0, 6};
static unsigned char jazz_dma_bits[] =
{0, 1, 0, 2, 0, 3, 0, 4};
 
/*
 * Jazz16 chipset specific control variables
 */
 
static int      jazz16_base = 0; /* Not detected */
static unsigned char jazz16_bits = 0;    /* I/O relocation bits */
 
/*
 * Logitech SoundMan Wave specific initialization code
 */
 
#ifdef SMW_MIDI0001_INCLUDED
#include "smw-midi0001.h"
#else
unsigned char  *smw_ucode = NULL;
int             smw_ucodeLen = 0;
 
#endif
 
int
sb_dsp_command (sb_devc * devc, unsigned char val)
{
  int             i;
  unsigned long   limit;
 
  limit = jiffies + HZ / 10;    /*
                                   * The timeout is 0.1 seconds
                                 */
 
  /*
   * Note! the i<500000 is an emergency exit. The sb_dsp_command() is sometimes
   * called while interrupts are disabled. This means that the timer is
   * disabled also. However the timeout situation is a abnormal condition.
   * Normally the DSP should be ready to accept commands after just couple of
   * loops.
   */
 
  for (i = 0; i < 500000 && jiffies < limit; i++)
    {
      if ((inb (DSP_STATUS) & 0x80) == 0)
        {
          outb (val, DSP_COMMAND);
          return 1;
        }
    }
 
  printk ("Sound Blaster: DSP Command(%x) Timeout.\n", val);
  return 0;
}
 
int
sb_dsp_get_byte (sb_devc * devc)
{
  int             i;
 
  for (i = 1000; i; i--)
    if (inb (DSP_DATA_AVAIL) & 0x80)
      {
        return inb (DSP_READ);
      }
 
  return 0xffff;
}
 
int
ess_write (sb_devc * devc, unsigned char reg, unsigned char data)
{
  /* Write a byte to an extended mode register of ES1688 */
 
  if (!sb_dsp_command (devc, reg))
    return 0;
 
  return sb_dsp_command (devc, data);
}
 
int
ess_read (sb_devc * devc, unsigned char reg)
{
/* Read a byte from an extended mode register of ES1688 */
 
  if (!sb_dsp_command (devc, 0xc0))     /* Read register command */
    return -1;
 
  if (!sb_dsp_command (devc, reg))
    return -1;
 
  return sb_dsp_get_byte (devc);
}
 
void
sbintr (int irq, void *dev_id, struct pt_regs *dummy)
{
  int             status;
  unsigned char   src = 0xff;
 
  sb_devc        *devc = irq2devc[irq];
 
  if (devc == NULL || devc->irq != irq)
    {
      DEB (printk ("sbintr: Bogus interrupt IRQ%d\n", irq));
      return;
    }
 
  devc->irq_ok = 1;
 
  if (devc->model == MDL_SB16)
    {
 
      src = sb_getmixer (devc, IRQ_STAT);       /* Interrupt source register */
 
#if defined(CONFIG_MIDI) && defined(CONFIG_UART401)
      if (src & 4)
        uart401intr (devc->irq, NULL, NULL);    /* MPU401 interrupt */
#endif
 
      if (!(src & 3))
        return;                 /* Not a DSP interrupt */
    }
 
  if (devc->intr_active)
    switch (devc->irq_mode)
      {
      case IMODE_OUTPUT:
        DMAbuf_outputintr (devc->dev, 1);
        break;
 
      case IMODE_INPUT:
        DMAbuf_inputintr (devc->dev);
        break;
 
      case IMODE_INIT:
        break;
 
      case IMODE_MIDI:
#ifdef CONFIG_MIDI
        sb_midi_interrupt (devc);
#endif
        break;
 
      default:
        printk ("Sound Blaster: Unexpected interrupt\n");
      }
/*
 * Acknowledge interrupts
 */
 
  if (src & 0x01)
    status = inb (DSP_DATA_AVAIL);
 
  if (devc->model == MDL_SB16 && src & 0x02)
    status = inb (DSP_DATA_AVL16);
}
 
int
sb_dsp_reset (sb_devc * devc)
{
  int             loopc;
 
  if (devc->model == MDL_ESS)
    outb (3, DSP_RESET);        /* Reset FIFO too */
  else
    outb (1, DSP_RESET);
 
  tenmicrosec (devc->osp);
  outb (0, DSP_RESET);
  tenmicrosec (devc->osp);
  tenmicrosec (devc->osp);
  tenmicrosec (devc->osp);
 
  for (loopc = 0; loopc < 1000 && !(inb (DSP_DATA_AVAIL) & 0x80); loopc++);
 
  if (inb (DSP_READ) != 0xAA)
    return 0;                    /* Sorry */
 
  if (devc->model == MDL_ESS)
    sb_dsp_command (devc, 0xc6);        /* Enable extended mode */
 
  return 1;
}
 
static void
dsp_get_vers (sb_devc * devc)
{
  int             i;
 
  unsigned long   flags;
 
  save_flags (flags);
  cli ();
  devc->major = devc->minor = 0;
  sb_dsp_command (devc, 0xe1);  /* Get version */
 
  for (i = 100000; i; i--)
    {
      if (inb (DSP_DATA_AVAIL) & 0x80)
        {
          if (devc->major == 0)
            devc->major = inb (DSP_READ);
          else
            {
              devc->minor = inb (DSP_READ);
              break;
            }
        }
    }
  restore_flags (flags);
}
 
static int
sb16_set_dma_hw (sb_devc * devc)
{
  int             bits;
 
  if (devc->dma8 != 0 && devc->dma8 != 1 && devc->dma8 != 3)
    {
      printk ("SB16: Invalid 8 bit DMA (%d)\n", devc->dma8);
      return 0;
    }
 
  bits = (1 << devc->dma8);
 
  if (devc->dma16 >= 5 && devc->dma16 <= 7)
    bits |= (1 << devc->dma16);
 
  sb_setmixer (devc, DMA_NR, bits);
  return 1;
}
 
#if defined(CONFIG_MIDI) && defined(CONFIG_UART401)
static void
sb16_set_mpu_port(sb_devc *devc, struct address_info *hw_config)
{
/*
 * This routine initializes new MIDI port setup register of SB Vibra.
 */
        unsigned char bits = sb_getmixer(devc, 0x84) & ~0x06;
        switch (hw_config->io_base)
        {
        case 0x300:
                sb_setmixer (devc, 0x84, bits | 0x04);
                break;
 
        case 0x330:
                sb_setmixer (devc, 0x84, bits | 0x00);
                break;
 
        default:
                sb_setmixer (devc, 0x84, bits | 0x02); /* Disable MPU */
                printk("SB16: Invalid MIDI I/O port %x\n", hw_config->io_base);
        }
}
#endif
 
static int
sb16_set_irq_hw (sb_devc * devc, int level)
{
  int             ival;
 
  switch (level)
    {
    case 5:
      ival = 2;
      break;
    case 7:
      ival = 4;
      break;
    case 9:
      ival = 1;
      break;
    case 10:
      ival = 8;
      break;
    default:
      printk ("SB16 IRQ%d is not possible\n", level);
      return 0;
    }
  sb_setmixer (devc, IRQ_NR, ival);
  return 1;
}
 
static void
relocate_Jazz16 (sb_devc * devc, struct address_info *hw_config)
{
  unsigned char   bits = 0;
  unsigned long   flags;
 
  if (jazz16_base != 0 && jazz16_base != hw_config->io_base)
    return;
 
  switch (hw_config->io_base)
    {
    case 0x220:
      bits = 1;
      break;
    case 0x240:
      bits = 2;
      break;
    case 0x260:
      bits = 3;
      break;
 
    default:
      return;
    }
 
  bits = jazz16_bits = bits << 5;
 
  jazz16_base = hw_config->io_base;
 
/*
 * Magic wake up sequence by writing to 0x201 (aka Joystick port)
 */
  save_flags (flags);
  cli ();
  outb (0xAF, 0x201);
  outb (0x50, 0x201);
  outb (bits, 0x201);
  restore_flags (flags);
}
 
static int
init_Jazz16 (sb_devc * devc, struct address_info *hw_config)
{
  char            name[100];
 
/*
 * First try to check that the card has Jazz16 chip. It identifies itself
 * by returning 0x12 as response to DSP command 0xfa.
 */
 
  if (!sb_dsp_command (devc, 0xfa))
    return 0;
 
  if (sb_dsp_get_byte (devc) != 0x12)
    return 0;
 
/*
 * OK so far. Now configure the IRQ and DMA channel used by the card.
 */
  if (hw_config->irq < 1 || hw_config->irq > 15 ||
      jazz_irq_bits[hw_config->irq] == 0)
    {
      printk ("Jazz16: Invalid interrupt (IRQ%d)\n", hw_config->irq);
      return 0;
    }
 
  if (hw_config->dma < 0 || hw_config->dma > 3 ||
      jazz_dma_bits[hw_config->dma] == 0)
    {
      printk ("Jazz16: Invalid 8 bit DMA (DMA%d)\n", hw_config->dma);
      return 0;
    }
 
  if (hw_config->dma2 < 0)
    {
      printk ("Jazz16: No 16 bit DMA channel defined\n");
      return 0;
    }
 
  if (hw_config->dma2 < 5 || hw_config->dma2 > 7 ||
      jazz_dma_bits[hw_config->dma2] == 0)
    {
      printk ("Jazz16: Invalid 16 bit DMA (DMA%d)\n", hw_config->dma2);
      return 0;
    }
 
  devc->dma16 = hw_config->dma2;
 
  if (!sb_dsp_command (devc, 0xfb))
    return 0;
 
  if (!sb_dsp_command (devc, jazz_dma_bits[hw_config->dma] |
                       (jazz_dma_bits[hw_config->dma2] << 4)))
    return 0;
 
  if (!sb_dsp_command (devc, jazz_irq_bits[hw_config->irq]))
    return 0;
 
/*
 * Now we have configured a standard Jazz16 device.
 */
  devc->model = MDL_JAZZ;
  strcpy (name, "Jazz16");
 
 
  hw_config->name = (char *) (sound_mem_blocks[sound_nblocks] = vmalloc (strlen (name + 1)));
  if (sound_nblocks < 1024)
    sound_nblocks++;;
  if (hw_config->name != NULL)
    strcpy (hw_config->name, name);
  devc->caps |= SB_NO_MIDI;
  return 1;
}
 
static int
ess_init (sb_devc * devc, struct address_info *hw_config)
{
  unsigned char   cfg, irq_bits = 0, dma_bits = 0;
  int             ess_major = 0, ess_minor = 0;
  int             i;
  char            name[100];
 
/*
 * Try to detect ESS chips.
 */
 
  sb_dsp_command (devc, 0xe7);  /* Return identification */
 
  for (i = 1000; i; i--)
    {
      if (inb (DSP_DATA_AVAIL) & 0x80)
        {
          if (ess_major == 0)
            ess_major = inb (DSP_READ);
          else
            {
              ess_minor = inb (DSP_READ);
              break;
            }
        }
    }
 
  if (ess_major == 0)
    return 0;
 
  if (ess_major == 0x48 && (ess_minor & 0xf0) == 0x80)
    {
      sprintf (name, "ESS ES488 AudioDrive (rev %d)",
               ess_minor & 0x0f);
      hw_config->name = name;
      devc->model = MDL_SBPRO;
      return 1;
    }
  else if (ess_major == 0x68 && (ess_minor & 0xf0) == 0x80)
    {
      sprintf (name,
               "ESS ES1688 AudioDrive (rev %d)",
               ess_minor & 0x0f);
    }
  else
    strcpy (name, "Jazz16");
 
  devc->model = MDL_ESS;
  devc->submodel = ess_minor & 0x0f;
 
  hw_config->name = (char *) (sound_mem_blocks[sound_nblocks] = vmalloc (strlen (name + 1)));
  if (sound_nblocks < 1024)
    sound_nblocks++;;
  if (hw_config->name != NULL)
    strcpy (hw_config->name, name);
 
 
  sb_dsp_reset (devc);          /* Turn on extended mode */
 
/*
 *    Set IRQ configuration register
 */
 
  cfg = 0x50;                   /* Enable only DMA counter interrupt */
 
  switch (devc->irq)
    {
    case 2:
    case 9:
      irq_bits = 0;
      break;
 
    case 5:
      irq_bits = 1;
      break;
 
    case 7:
      irq_bits = 2;
      break;
 
    case 10:
      irq_bits = 3;
      break;
 
    default:
      irq_bits = 0;
      cfg = 0x10;               /* Disable all interrupts */
      printk ("\nESS1688: Invalid IRQ %d\n", devc->irq);
      return 0;
    }
 
  if (!ess_write (devc, 0xb1, cfg | (irq_bits << 2)))
    printk ("\nESS1688: Failed to write to IRQ config register\n");
 
/*
 *    Set DMA configuration register
 */
 
  cfg = 0x50;                   /* Extended mode DMA enable */
 
  if (devc->dma8 > 3 || devc->dma8 < 0 || devc->dma8 == 2)
    {
      dma_bits = 0;
      cfg = 0x00;               /* Disable all DMA */
      printk ("\nESS1688: Invalid DMA %d\n", devc->dma8);
    }
  else
    {
      if (devc->dma8 == 3)
        dma_bits = 3;
      else
        dma_bits = devc->dma8 + 1;
    }
 
  if (!ess_write (devc, 0xb2, cfg | (dma_bits << 2)))
    printk ("\nESS1688: Failed to write to DMA config register\n");
 
/*
 * Enable joystick and OPL3
 */
 
  cfg = sb_getmixer (devc, 0x40);
  sb_setmixer (devc, 0x40, cfg | 0x03);
  if (devc->submodel >= 8)      /* ES1688 */
    devc->caps |= SB_NO_MIDI;   /* ES1688 uses MPU401 MIDI mode */
  sb_dsp_reset (devc);
  return 1;
}
 
int
sb_dsp_detect (struct address_info *hw_config)
{
  sb_devc         sb_info;
  sb_devc        *devc = &sb_info;
 
/*
 * Initialize variables
 */
  DDB (printk ("sb_dsp_detect(%x) entered\n", hw_config->io_base));
  if (check_region (hw_config->io_base, 16))
    return 0;
 
  memset ((char *) &sb_info, 0, sizeof (sb_info));       /* Zero everything */
 
  devc->osp = hw_config->osp;
  devc->type = hw_config->card_subtype;
 
  devc->base = hw_config->io_base;
  devc->irq = hw_config->irq;
  devc->dma8 = hw_config->dma;
 
  devc->dma16 = -1;
 
/*
 * Detect the device
 */
 
  cli();                        /* Some ESS1688 cards need this */
  inb (devc->base + 0x9);
  inb (devc->base + 0x9);
  inb (devc->base + 0x9);
  inb (devc->base + 0xb);
  inb (devc->base + 0x9);
  inb (devc->base + 0xb);
  inb (devc->base + 0x9);
  inb (devc->base + 0x9);
  inb (devc->base + 0xb);
  inb (devc->base + 0x9);
  inb (devc->base);
  sti();
 
  if (sb_dsp_reset (devc))
    dsp_get_vers (devc);
  else
    devc->major = 0;
 
  if (devc->type == 0 || devc->type == MDL_JAZZ || devc->type == MDL_SMW)
    if (devc->major == 0 || (devc->major == 3 && devc->minor == 1))
      relocate_Jazz16 (devc, hw_config);
 
  if (!sb_dsp_reset (devc))
    {
      DDB (printk ("SB reset failed\n"));
      return 0;
    }
 
  if (devc->major == 0)
    dsp_get_vers (devc);
 
  if (devc->major == 3 && devc->minor == 1)
    if (devc->type == MDL_AZTECH)       /* SG Washington? */
      {
        if (sb_dsp_command (devc, 0x09))
          if (sb_dsp_command (devc, 0x00))      /* Enter WSS mode */
            {
              int             i;
 
              /* Have some delay */
              for (i = 0; i < 10000; i++)
                inb (DSP_DATA_AVAIL);
              devc->caps = SB_NO_AUDIO | SB_NO_MIDI;    /* Mixer only */
            }
      }
 
/*
 * Save device information for sb_dsp_init()
 */
 
 
  detected_devc = (sb_devc *) (sound_mem_blocks[sound_nblocks] = vmalloc (sizeof (sb_devc)));
  if (sound_nblocks < 1024)
    sound_nblocks++;;
 
  if (detected_devc == NULL)
    {
      printk ("sb: Can't allocate memory for device information\n");
      return 0;
    }
 
  memcpy ((char *) detected_devc, (char *) devc, sizeof (sb_devc));
 
  DDB (printk ("SB %d.%d detected OK (%x)\n", devc->major, devc->minor,
               hw_config->io_base));
  return 1;
}
 
void
sb_dsp_init (struct address_info *hw_config)
{
  sb_devc        *devc;
  char            name[100];
 
#ifndef NO_SB_IRQ_TEST
  int             n;
#endif
 
/*
 * Check if we had detected a SB device earlier
 */
  DDB (printk ("sb_dsp_init(%x) entered\n", hw_config->io_base));
 
  if (detected_devc == NULL)
    {
      DDB (printk ("No detected device\n"));
      return;
    }
 
  devc = detected_devc;
  detected_devc = NULL;
 
  if (devc->base != hw_config->io_base)
    {
      DDB (printk ("I/O port mismatch\n"));
      return;
    }
 
/*
 * Now continue initialization of the device
 */
  devc->dev = num_audiodevs;
  devc->caps = hw_config->driver_use_1;
 
  if (snd_set_irq_handler (hw_config->irq,
                           sbintr, "sound blaster", devc->osp) < 0)
    {
      printk ("SB: Can't allocate IRQ%d\n", hw_config->irq);
      irq2devc[hw_config->irq] = NULL;
      return;
    }
 
  irq2devc[hw_config->irq] = devc;
  devc->irq_ok = 0;
 
  if (devc->major == 4)
    if (!sb16_set_irq_hw (devc, devc->irq))     /* Unsupported IRQ */
      {
        snd_release_irq (devc->irq);
        return;
      }
 
  if ((devc->type == 0 || devc->type == MDL_ESS) &&
      devc->major == 3 && devc->minor == 1)
    {                           /* Handle various chipsets which claim they are SB Pro compatible */
      if ((devc->type != 0 && devc->type != MDL_ESS) ||
          !ess_init (devc, hw_config))
        if ((devc->type != 0 && devc->type != MDL_JAZZ &&
             devc->type != MDL_SMW) || !init_Jazz16 (devc, hw_config))
          {
            DDB (printk ("This is a genuine SB Pro\n"));
          }
    }
 
#ifndef NO_SB_IRQ_TEST
  if (devc->major != 4 || devc->minor > 11) /* Not Sb16 v4.5 or v4.11 */
  {
    for (n = 0; n < 3 && devc->irq_ok == 0; n++)
    if (sb_dsp_command (devc, 0xf2))    /* Cause interrupt immediately */
      {
        int             i;
 
        for (i = 0; !devc->irq_ok && i < 10000; i++);
      }
 
  if (!devc->irq_ok)
    {
      printk ("sb: Interrupt test on IRQ%d failed - device disabled\n", devc->irq);
      snd_release_irq (devc->irq);
      return;
    }
  else
    {
      DDB (printk ("IRQ test OK (IRQ%d)\n", devc->irq));
    }
  }
#endif
 
  request_region (hw_config->io_base, 16, "sound blaster");
 
  switch (devc->major)
    {
    case 1:                     /* SB 1.0 or 1.5 */
      devc->model = hw_config->card_subtype = MDL_SB1;
      break;
 
    case 2:                     /* SB 2.x */
      if (devc->minor == 0)
        devc->model = hw_config->card_subtype = MDL_SB2;
      else
        devc->model = hw_config->card_subtype = MDL_SB201;
      break;
 
    case 3:                     /* SB Pro and most clones */
      if (devc->model == 0)
        {
          devc->model = hw_config->card_subtype = MDL_SBPRO;
          if (hw_config->name == NULL)
            hw_config->name = "Sound Blaster Pro";
        }
      break;
 
    case 4:
      devc->model = hw_config->card_subtype = MDL_SB16;
      if (hw_config->name == NULL)
        hw_config->name = "Sound Blaster 16";
 
      if (hw_config->dma2 == -1)
        devc->dma16 = devc->dma8;
      else if (hw_config->dma2 < 5 || hw_config->dma2 > 7)
        {
          printk ("SB16: Bad or missing 16 bit DMA channel\n");
          devc->dma16 = devc->dma8;
        }
      else
        devc->dma16 = hw_config->dma2;
 
      sb16_set_dma_hw (devc);
      devc->caps |= SB_NO_MIDI;
    }
 
  if (!(devc->caps & SB_NO_MIXER))
    if (devc->major == 3 || devc->major == 4)
      sb_mixer_init (devc);
 
#ifdef CONFIG_MIDI
  if (!(devc->caps & SB_NO_MIDI))
    sb_dsp_midi_init (devc);
#endif
 
  if (hw_config->name == NULL)
    hw_config->name = "Sound Blaster";
 
  sprintf (name, "%s (%d.%d)", hw_config->name, devc->major, devc->minor);
  conf_printf (name, hw_config);
  hw_config->card_subtype = devc->model;
  last_devc = devc;             /* For SB MPU detection */
 
  if (!(devc->caps & SB_NO_AUDIO))
    {
      if (sound_alloc_dma (devc->dma8, "Sound Blaster8"))
        {
          printk ("SB: Can't allocate 8 bit DMA channel %d\n", devc->dma8);
        }
      if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
        if (sound_alloc_dma (devc->dma16, "Sound Blaster16"))
          {
            printk ("SB: Can't allocate 16 bit DMA channel %d\n", devc->dma16);
          }
      sb_audio_init (devc, name);
    }
}
 
void
sb_dsp_disable_midi (int io_base)
{
}
 
void
sb_dsp_disable_recording (int io_base)
{
}
 
void
sb_dsp_unload (struct address_info *hw_config)
{
  sb_devc        *devc;
  int             irq = hw_config->irq;
 
  if (irq < 0)
    irq *= -1;
 
  devc = irq2devc[irq];
 
  if (devc && devc->base == hw_config->io_base)
    {
      release_region (devc->base, 16);
      if (!(devc->caps & SB_NO_AUDIO))
        {
          sound_free_dma (devc->dma8);
 
          if (devc->dma16 >= 0)
            sound_free_dma (devc->dma16);
        }
 
      snd_release_irq (devc->irq);
      irq2devc[devc->irq] = NULL;
    }
}
 
/*
 * Mixer access routines
 */
 
void
sb_setmixer (sb_devc * devc, unsigned int port, unsigned int value)
{
  unsigned long   flags;
 
  save_flags (flags);
  cli ();
  outb ((unsigned char) (port & 0xff), MIXER_ADDR);
 
  tenmicrosec (devc->osp);
  outb ((unsigned char) (value & 0xff), MIXER_DATA);
  tenmicrosec (devc->osp);
  restore_flags (flags);
}
 
unsigned int
sb_getmixer (sb_devc * devc, unsigned int port)
{
  unsigned int    val;
  unsigned long   flags;
 
  save_flags (flags);
  cli ();
  outb ((unsigned char) (port & 0xff), MIXER_ADDR);
 
  tenmicrosec (devc->osp);
  val = inb (MIXER_DATA);
  tenmicrosec (devc->osp);
  restore_flags (flags);
 
  return val;
}
 
#ifdef CONFIG_MIDI
/*
 * MPU401 MIDI initialization.
 */
 
static void
smw_putmem (sb_devc * devc, int base, int addr, unsigned char val)
{
  unsigned long   flags;
 
  save_flags (flags);
  cli ();
 
  outb (addr & 0xff, base + 1); /* Low address bits */
  outb (addr >> 8, base + 2);   /* High address bits */
  outb (val, base);             /* Data */
 
  restore_flags (flags);
}
 
static unsigned char
smw_getmem (sb_devc * devc, int base, int addr)
{
  unsigned long   flags;
  unsigned char   val;
 
  save_flags (flags);
  cli ();
 
  outb (addr & 0xff, base + 1); /* Low address bits */
  outb (addr >> 8, base + 2);   /* High address bits */
  val = inb (base);             /* Data */
 
  restore_flags (flags);
  return val;
}
 
static int
smw_midi_init (sb_devc * devc, struct address_info *hw_config)
{
  int             mpu_base = hw_config->io_base;
  int             mp_base = mpu_base + 4;       /* Microcontroller base */
  int             i;
  unsigned char   control;
 
 
  /*
     *  Reset the microcontroller so that the RAM can be accessed
   */
 
  control = inb (mpu_base + 7);
  outb (control | 3, mpu_base + 7);     /* Set last two bits to 1 (?) */
  outb ((control & 0xfe) | 2, mpu_base + 7);    /* xxxxxxx0 resets the mc */
 
  for (i = 0; i < 300; i++)      /* Wait at least 1ms */
    tenmicrosec (devc->osp);
 
  outb (control & 0xfc, mpu_base + 7);  /* xxxxxx00 enables RAM */
 
  /*
     *  Detect microcontroller by probing the 8k RAM area
   */
  smw_putmem (devc, mp_base, 0, 0x00);
  smw_putmem (devc, mp_base, 1, 0xff);
  tenmicrosec (devc->osp);
 
  if (smw_getmem (devc, mp_base, 0) != 0x00 || smw_getmem (devc, mp_base, 1) != 0xff)
    {
      DDB (printk ("\nSM Wave: No microcontroller RAM detected (%02x, %02x)\n",
             smw_getmem (devc, mp_base, 0), smw_getmem (devc, mp_base, 1)));
      return 0;                  /* No RAM */
    }
 
  /*
     *  There is RAM so assume it's really a SM Wave
   */
 
  devc->model = MDL_SMW;
  smw_mixer_init (devc);
 
  if (smw_ucodeLen > 0)
    {
      if (smw_ucodeLen != 8192)
        {
          printk ("\nSM Wave: Invalid microcode (MIDI0001.BIN) length\n");
          return 1;
        }
 
      /*
       *  Download microcode
       */
 
      for (i = 0; i < 8192; i++)
        smw_putmem (devc, mp_base, i, smw_ucode[i]);
 
      /*
       *  Verify microcode
       */
 
      for (i = 0; i < 8192; i++)
        if (smw_getmem (devc, mp_base, i) != smw_ucode[i])
          {
            printk ("SM Wave: Microcode verification failed\n");
            return 0;
          }
    }
 
  control = 0;
#ifdef SMW_SCSI_IRQ
  /*
     * Set the SCSI interrupt (IRQ2/9, IRQ3 or IRQ10). The SCSI interrupt
     * is disabled by default.
     *
     * BTW the Zilog 5380 SCSI controller is located at MPU base + 0x10.
   */
  {
    static unsigned char scsi_irq_bits[] =
    {0, 0, 3, 1, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0};
 
    control |= scsi_irq_bits[SMW_SCSI_IRQ] << 6;
  }
#endif
 
#ifdef SMW_OPL4_ENABLE
  /*
     *  Make the OPL4 chip visible on the PC bus at 0x380.
     *
     *  There is no need to enable this feature since this driver
     *  doesn't support OPL4 yet. Also there is no RAM in SM Wave so
     *  enabling OPL4 is pretty useless.
   */
  control |= 0x10;              /* Uses IRQ12 if bit 0x20 == 0 */
  /* control |= 0x20;      Uncomment this if you want to use IRQ7 */
#endif
 
  outb (control | 0x03, mpu_base + 7);  /* xxxxxx11 restarts */
  hw_config->name = "SoundMan Wave";
  return 1;
}
 
static int
ess_midi_init (sb_devc * devc, struct address_info *hw_config)
{
  unsigned char   cfg, tmp;
 
  cfg = sb_getmixer (devc, 0x40) & 0x03;
 
  if (devc->submodel < 8)
    {
      sb_setmixer (devc, 0x40, cfg | 0x03);     /* Enable OPL3 & joystick */
      return 0;                  /* ES688 doesn't support MPU401 mode */
    }
 
  tmp = (hw_config->io_base & 0x0f0) >> 4;
 
  if (tmp > 3)
    {
      sb_setmixer (devc, 0x40, cfg);
      return 0;
    }
 
  cfg |= tmp << 3;
 
  tmp = 1;                      /* MPU enabled without interrupts */
 
  switch (hw_config->irq)
    {
    case 9:
      tmp = 0x4;
      break;
    case 5:
      tmp = 0x5;
      break;
    case 7:
      tmp = 0x6;
      break;
    case 10:
      tmp = 0x7;
      break;
    default:
      return 0;
    }
 
  cfg |= tmp << 5;
 
  sb_setmixer (devc, 0x40, cfg | 0x03);
  return 1;
}
 
static int
init_Jazz16_midi (sb_devc * devc, struct address_info *hw_config)
{
  int             mpu_base = hw_config->io_base;
  int             sb_base = devc->base;
  int             irq = hw_config->irq;
 
  unsigned char   bits = 0;
  unsigned long   flags;
 
  if (irq < 0)
    irq *= -1;
 
  if (irq < 1 || irq > 15 ||
      jazz_irq_bits[irq] == 0)
    {
      printk ("Jazz16: Invalid MIDI interrupt (IRQ%d)\n", irq);
      return 0;
    }
 
  switch (sb_base)
    {
    case 0x220:
      bits = 1;
      break;
    case 0x240:
      bits = 2;
      break;
    case 0x260:
      bits = 3;
      break;
 
    default:
      return 0;
    }
 
  bits = jazz16_bits = bits << 5;
 
  switch (mpu_base)
    {
    case 0x310:
      bits |= 1;
      break;
    case 0x320:
      bits |= 2;
      break;
    case 0x330:
      bits |= 3;
      break;
 
    default:
      printk ("Jazz16: Invalid MIDI I/O port %x\n", mpu_base);
      return 0;
    }
/*
 * Magic wake up sequence by writing to 0x201 (aka Joystick port)
 */
  save_flags (flags);
  cli ();
  outb (0xAF, 0x201);
  outb (0x50, 0x201);
  outb (bits, 0x201);
  restore_flags (flags);
 
  hw_config->name = "Jazz16";
  smw_midi_init (devc, hw_config);
 
  if (!sb_dsp_command (devc, 0xfb))
    return 0;
 
  if (!sb_dsp_command (devc, jazz_dma_bits[devc->dma8] |
                       (jazz_dma_bits[devc->dma16] << 4)))
    return 0;
 
  if (!sb_dsp_command (devc, jazz_irq_bits[devc->irq] |
                       (jazz_irq_bits[irq] << 4)))
    return 0;
 
  return 1;
}
 
void
attach_sbmpu (struct address_info *hw_config)
{
#if defined(CONFIG_MIDI) && defined(CONFIG_UART401)
  attach_uart401 (hw_config);
#endif
}
 
int
probe_sbmpu (struct address_info *hw_config)
{
#if defined(CONFIG_MIDI) && defined(CONFIG_UART401)
  sb_devc        *devc = last_devc;
 
  if (last_devc == NULL)
    return 0;
 
  last_devc = 0;
 
  if (hw_config->io_base <= 0)
     return 0;
 
  if (check_region (hw_config->io_base, 4))
    {
      printk ("sbmpu: I/O port conflict (%x)\n", hw_config->io_base);
      return 0;
    }
 
  switch (devc->model)
    {
    case MDL_SB16:
      if (hw_config->io_base != 0x300 && hw_config->io_base != 0x330)
        {
          printk ("SB16: Invalid MIDI port %x\n", hw_config->io_base);
          return 0;
        }
      hw_config->name = "Sound Blaster 16";
      hw_config->irq = -devc->irq;
      hw_config->dma = -1;
      hw_config->dma2 = -1;
      sb16_set_mpu_port(devc, hw_config);
      break;
 
    case MDL_ESS:
      if (hw_config->irq < 3 || hw_config->irq == devc->irq)
        hw_config->irq = -devc->irq;
      if (!ess_midi_init (devc, hw_config))
        return 0;
      hw_config->name = "ESS ES1688";
      break;
 
    case MDL_JAZZ:
      if (hw_config->irq < 3 || hw_config->irq == devc->irq)
        hw_config->irq = -devc->irq;
      if (!init_Jazz16_midi (devc, hw_config))
        return 0;
      break;
 
    default:
      return 0;
    }
 
  return probe_uart401 (hw_config);
#else
  return 0;
#endif
}
 
void
unload_sbmpu (struct address_info *hw_config)
{
#if defined(CONFIG_MIDI) && defined(CONFIG_UART401)
  unload_uart401 (hw_config);
#endif
}
#else /* !CONFIG_MIDI */
 
void
unload_sbmpu (struct address_info *hw_config)
{
}
 
int
probe_sbmpu (struct address_info *hw_config)
{
  return 0;
}
 
void
attach_sbmpu (struct address_info *hw_config)
{
}
#endif
 
 
#endif
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [drivers/] [sound/] [sb_common.c] - Blame information for rev 1626

Line No.	Rev	Author	Line
1	1626	jcastillo	`/*`
2			`* sound/sb_common.c`
3			`*`
4			`* Common routines for Sound Blaster compatible cards.`
5			`*/`
6			`/*`
7			`* Copyright (C) by Hannu Savolainen 1993-1996`
8			`*`
9			`* USS/Lite 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			`#include <linux/config.h>`
14
15
16			`#include "sound_config.h"`
17
18			`#if defined(CONFIG_SBDSP)`
19
20			`#ifndef CONFIG_AUDIO`
21			`#error You will need to configure the sound driver with CONFIG_AUDIO option.`
22			`#endif`
23
24			`#include "sb_mixer.h"`
25			`#include "sb.h"`
26
27			`static sb_devc detected_devc = NULL; / For communication from probe to init */`
28			`static sb_devc last_devc = NULL; / For MPU401 initialization */`
29			`static sb_devc *irq2devc[16] =`
30			`{NULL};`
31			`static unsigned char jazz_irq_bits[] =`
32			`{0, 0, 2, 3, 0, 1, 0, 4, 0, 2, 5, 0, 0, 0, 0, 6};`
33			`static unsigned char jazz_dma_bits[] =`
34			`{0, 1, 0, 2, 0, 3, 0, 4};`
35
36			`/*`
37			`* Jazz16 chipset specific control variables`
38			`*/`
39
40			`static int jazz16_base = 0; /* Not detected */`