Quelle  dmasound_atari.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  linux/sound/oss/dmasound/dmasound_atari.c
 *
 *  Atari TT and Falcon DMA Sound Driver
 *
 *  See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits
 *  prior to 28/01/2001
 *
 *  28/01/2001 [0.1] Iain Sandoe
 *      - added versioning
 *      - put in and populated the hardware_afmts field.
 *             [0.2] - put in SNDCTL_DSP_GETCAPS value.
 *  01/02/2001 [0.3] - put in default hard/soft settings.
 */


#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/soundcard.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>

#include <linux/uaccess.h>
#include <asm/atariints.h>
#include <asm/atari_stram.h>

#include "dmasound.h"

#define DMASOUND_ATARI_REVISION 0
#define DMASOUND_ATARI_EDITION 3

extern void atari_microwire_cmd(int cmd);

static int is_falcon;
static int write_sq_ignore_int; /* ++TeSche: used for Falcon */

static int expand_bal; /* Balance factor for expanding (not volume!) */
static int expand_data; /* Data for expanding */


/*** Translations ************************************************************/


/* ++TeSche: radically changed for new expanding purposes...
 *
 * These two routines now deal with copying/expanding/translating the samples
 * from user space into our buffer at the right frequency. They take care about
 * how much data there's actually to read, how much buffer space there is and
 * to convert samples into the right frequency/encoding. They will only work on
 * complete samples so it may happen they leave some bytes in the input stream
 * if the user didn't write a multiple of the current sample size. They both
 * return the number of bytes they've used from both streams so you may detect
 * such a situation. Luckily all programs should be able to cope with that.
 *
 * I think I've optimized anything as far as one can do in plain C, all
 * variables should fit in registers and the loops are really short. There's
 * one loop for every possible situation. Writing a more generalized and thus
 * parameterized loop would only produce slower code. Feel free to optimize
 * this in assembler if you like. :)
 *
 * I think these routines belong here because they're not yet really hardware
 * independent, especially the fact that the Falcon can play 16bit samples
 * only in stereo is hardcoded in both of them!
 *
 * ++geert: split in even more functions (one per format)
 */

static ssize_t ata_ct_law(const u_char __user *userPtr, size_t userCount,
     u_char frame[], ssize_t *frameUsed,
     ssize_t frameLeft);
static ssize_t ata_ct_s8(const u_char __user *userPtr, size_t userCount,
    u_char frame[], ssize_t *frameUsed,
    ssize_t frameLeft);
static ssize_t ata_ct_u8(const u_char __user *userPtr, size_t userCount,
    u_char frame[], ssize_t *frameUsed,
    ssize_t frameLeft);
static ssize_t ata_ct_s16be(const u_char __user *userPtr, size_t userCount,
       u_char frame[], ssize_t *frameUsed,
       ssize_t frameLeft);
static ssize_t ata_ct_u16be(const u_char __user *userPtr, size_t userCount,
       u_char frame[], ssize_t *frameUsed,
       ssize_t frameLeft);
static ssize_t ata_ct_s16le(const u_char __user *userPtr, size_t userCount,
       u_char frame[], ssize_t *frameUsed,
       ssize_t frameLeft);
static ssize_t ata_ct_u16le(const u_char __user *userPtr, size_t userCount,
       u_char frame[], ssize_t *frameUsed,
       ssize_t frameLeft);
static ssize_t ata_ctx_law(const u_char __user *userPtr, size_t userCount,
      u_char frame[], ssize_t *frameUsed,
      ssize_t frameLeft);
static ssize_t ata_ctx_s8(const u_char __user *userPtr, size_t userCount,
     u_char frame[], ssize_t *frameUsed,
     ssize_t frameLeft);
static ssize_t ata_ctx_u8(const u_char __user *userPtr, size_t userCount,
     u_char frame[], ssize_t *frameUsed,
     ssize_t frameLeft);
static ssize_t ata_ctx_s16be(const u_char __user *userPtr, size_t userCount,
        u_char frame[], ssize_t *frameUsed,
        ssize_t frameLeft);
static ssize_t ata_ctx_u16be(const u_char __user *userPtr, size_t userCount,
        u_char frame[], ssize_t *frameUsed,
        ssize_t frameLeft);
static ssize_t ata_ctx_s16le(const u_char __user *userPtr, size_t userCount,
        u_char frame[], ssize_t *frameUsed,
        ssize_t frameLeft);
static ssize_t ata_ctx_u16le(const u_char __user *userPtr, size_t userCount,
        u_char frame[], ssize_t *frameUsed,
        ssize_t frameLeft);


/*** Low level stuff *********************************************************/


static void *AtaAlloc(unsigned int size, gfp_t flags);
static void AtaFree(void *, unsigned int size);
static int AtaIrqInit(void);
#ifdef MODULE
static void AtaIrqCleanUp(void);
#endif /* MODULE */
static int AtaSetBass(int bass);
static int AtaSetTreble(int treble);
static void TTSilence(void);
static void TTInit(void);
static int TTSetFormat(int format);
static int TTSetVolume(int volume);
static int TTSetGain(int gain);
static void FalconSilence(void);
static void FalconInit(void);
static int FalconSetFormat(int format);
static int FalconSetVolume(int volume);
static void AtaPlayNextFrame(int index);
static void AtaPlay(void);
static irqreturn_t AtaInterrupt(int irq, void *dummy);

/*** Mid level stuff *********************************************************/

static void TTMixerInit(void);
static void FalconMixerInit(void);
static int AtaMixerIoctl(u_int cmd, u_long arg);
static int TTMixerIoctl(u_int cmd, u_long arg);
static int FalconMixerIoctl(u_int cmd, u_long arg);
static int AtaWriteSqSetup(void);
static int AtaSqOpen(fmode_t mode);
static int TTStateInfo(char *buffer, size_t space);
static int FalconStateInfo(char *buffer, size_t space);


/*** Translations ************************************************************/


static ssize_t ata_ct_law(const u_char __user *userPtr, size_t userCount,
     u_char frame[], ssize_t *frameUsed,
     ssize_t frameLeft)
{
 char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8
         : dmasound_alaw2dma8;
 ssize_t count, used;
 u_char *p = &frame[*frameUsed];

 count = min_t(unsigned long, userCount, frameLeft);
 if (dmasound.soft.stereo)
  count &= ~1;
 used = count;
 while (count > 0) {
  u_char data;
  if (get_user(data, userPtr++))
   return -EFAULT;
  *p++ = table[data];
  count--;
 }
 *frameUsed += used;
 return used;
}


static ssize_t ata_ct_s8(const u_char __user *userPtr, size_t userCount,
    u_char frame[], ssize_t *frameUsed,
    ssize_t frameLeft)
{
 ssize_t count, used;
 void *p = &frame[*frameUsed];

 count = min_t(unsigned long, userCount, frameLeft);
 if (dmasound.soft.stereo)
  count &= ~1;
 used = count;
 if (copy_from_user(p, userPtr, count))
  return -EFAULT;
 *frameUsed += used;
 return used;
}


static ssize_t ata_ct_u8(const u_char __user *userPtr, size_t userCount,
    u_char frame[], ssize_t *frameUsed,
    ssize_t frameLeft)
{
 ssize_t count, used;

 if (!dmasound.soft.stereo) {
  u_char *p = &frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft);
  used = count;
  while (count > 0) {
   u_char data;
   if (get_user(data, userPtr++))
    return -EFAULT;
   *p++ = data ^ 0x80;
   count--;
  }
 } else {
  u_short *p = (u_short *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft)>>1;
  used = count*2;
  while (count > 0) {
   u_short data;
   if (get_user(data, (u_short __user *)userPtr))
    return -EFAULT;
   userPtr += 2;
   *p++ = data ^ 0x8080;
   count--;
  }
 }
 *frameUsed += used;
 return used;
}


static ssize_t ata_ct_s16be(const u_char __user *userPtr, size_t userCount,
       u_char frame[], ssize_t *frameUsed,
       ssize_t frameLeft)
{
 ssize_t count, used;

 if (!dmasound.soft.stereo) {
  u_short *p = (u_short *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft)>>1;
  used = count*2;
  while (count > 0) {
   u_short data;
   if (get_user(data, (u_short __user *)userPtr))
    return -EFAULT;
   userPtr += 2;
   *p++ = data;
   *p++ = data;
   count--;
  }
  *frameUsed += used*2;
 } else {
  void *p = (u_short *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft) & ~3;
  used = count;
  if (copy_from_user(p, userPtr, count))
   return -EFAULT;
  *frameUsed += used;
 }
 return used;
}


static ssize_t ata_ct_u16be(const u_char __user *userPtr, size_t userCount,
       u_char frame[], ssize_t *frameUsed,
       ssize_t frameLeft)
{
 ssize_t count, used;

 if (!dmasound.soft.stereo) {
  u_short *p = (u_short *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft)>>1;
  used = count*2;
  while (count > 0) {
   u_short data;
   if (get_user(data, (u_short __user *)userPtr))
    return -EFAULT;
   userPtr += 2;
   data ^= 0x8000;
   *p++ = data;
   *p++ = data;
   count--;
  }
  *frameUsed += used*2;
 } else {
  u_long *p = (u_long *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft)>>2;
  used = count*4;
  while (count > 0) {
   u_int data;
   if (get_user(data, (u_int __user *)userPtr))
    return -EFAULT;
   userPtr += 4;
   *p++ = data ^ 0x80008000;
   count--;
  }
  *frameUsed += used;
 }
 return used;
}


static ssize_t ata_ct_s16le(const u_char __user *userPtr, size_t userCount,
       u_char frame[], ssize_t *frameUsed,
       ssize_t frameLeft)
{
 ssize_t count, used;

 count = frameLeft;
 if (!dmasound.soft.stereo) {
  u_short *p = (u_short *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft)>>1;
  used = count*2;
  while (count > 0) {
   u_short data;
   if (get_user(data, (u_short __user *)userPtr))
    return -EFAULT;
   userPtr += 2;
   data = le2be16(data);
   *p++ = data;
   *p++ = data;
   count--;
  }
  *frameUsed += used*2;
 } else {
  u_long *p = (u_long *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft)>>2;
  used = count*4;
  while (count > 0) {
   u_long data;
   if (get_user(data, (u_int __user *)userPtr))
    return -EFAULT;
   userPtr += 4;
   data = le2be16dbl(data);
   *p++ = data;
   count--;
  }
  *frameUsed += used;
 }
 return used;
}


static ssize_t ata_ct_u16le(const u_char __user *userPtr, size_t userCount,
       u_char frame[], ssize_t *frameUsed,
       ssize_t frameLeft)
{
 ssize_t count, used;

 count = frameLeft;
 if (!dmasound.soft.stereo) {
  u_short *p = (u_short *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft)>>1;
  used = count*2;
  while (count > 0) {
   u_short data;
   if (get_user(data, (u_short __user *)userPtr))
    return -EFAULT;
   userPtr += 2;
   data = le2be16(data) ^ 0x8000;
   *p++ = data;
   *p++ = data;
  }
  *frameUsed += used*2;
 } else {
  u_long *p = (u_long *)&frame[*frameUsed];
  count = min_t(unsigned long, userCount, frameLeft)>>2;
  used = count;
  while (count > 0) {
   u_long data;
   if (get_user(data, (u_int __user *)userPtr))
    return -EFAULT;
   userPtr += 4;
   data = le2be16dbl(data) ^ 0x80008000;
   *p++ = data;
   count--;
  }
  *frameUsed += used;
 }
 return used;
}


static ssize_t ata_ctx_law(const u_char __user *userPtr, size_t userCount,
      u_char frame[], ssize_t *frameUsed,
      ssize_t frameLeft)
{
 char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8
         : dmasound_alaw2dma8;
 /* this should help gcc to stuff everything into registers */
 long bal = expand_bal;
 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 ssize_t used, usedf;

 used = userCount;
 usedf = frameLeft;
 if (!dmasound.soft.stereo) {
  u_char *p = &frame[*frameUsed];
  u_char data = expand_data;
  while (frameLeft) {
   u_char c;
   if (bal < 0) {
    if (!userCount)
     break;
    if (get_user(c, userPtr++))
     return -EFAULT;
    data = table[c];
    userCount--;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft--;
   bal -= sSpeed;
  }
  expand_data = data;
 } else {
  u_short *p = (u_short *)&frame[*frameUsed];
  u_short data = expand_data;
  while (frameLeft >= 2) {
   u_char c;
   if (bal < 0) {
    if (userCount < 2)
     break;
    if (get_user(c, userPtr++))
     return -EFAULT;
    data = table[c] << 8;
    if (get_user(c, userPtr++))
     return -EFAULT;
    data |= table[c];
    userCount -= 2;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft -= 2;
   bal -= sSpeed;
  }
  expand_data = data;
 }
 expand_bal = bal;
 used -= userCount;
 *frameUsed += usedf-frameLeft;
 return used;
}


static ssize_t ata_ctx_s8(const u_char __user *userPtr, size_t userCount,
     u_char frame[], ssize_t *frameUsed,
     ssize_t frameLeft)
{
 /* this should help gcc to stuff everything into registers */
 long bal = expand_bal;
 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 ssize_t used, usedf;

 used = userCount;
 usedf = frameLeft;
 if (!dmasound.soft.stereo) {
  u_char *p = &frame[*frameUsed];
  u_char data = expand_data;
  while (frameLeft) {
   if (bal < 0) {
    if (!userCount)
     break;
    if (get_user(data, userPtr++))
     return -EFAULT;
    userCount--;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft--;
   bal -= sSpeed;
  }
  expand_data = data;
 } else {
  u_short *p = (u_short *)&frame[*frameUsed];
  u_short data = expand_data;
  while (frameLeft >= 2) {
   if (bal < 0) {
    if (userCount < 2)
     break;
    if (get_user(data, (u_short __user *)userPtr))
     return -EFAULT;
    userPtr += 2;
    userCount -= 2;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft -= 2;
   bal -= sSpeed;
  }
  expand_data = data;
 }
 expand_bal = bal;
 used -= userCount;
 *frameUsed += usedf-frameLeft;
 return used;
}


static ssize_t ata_ctx_u8(const u_char __user *userPtr, size_t userCount,
     u_char frame[], ssize_t *frameUsed,
     ssize_t frameLeft)
{
 /* this should help gcc to stuff everything into registers */
 long bal = expand_bal;
 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 ssize_t used, usedf;

 used = userCount;
 usedf = frameLeft;
 if (!dmasound.soft.stereo) {
  u_char *p = &frame[*frameUsed];
  u_char data = expand_data;
  while (frameLeft) {
   if (bal < 0) {
    if (!userCount)
     break;
    if (get_user(data, userPtr++))
     return -EFAULT;
    data ^= 0x80;
    userCount--;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft--;
   bal -= sSpeed;
  }
  expand_data = data;
 } else {
  u_short *p = (u_short *)&frame[*frameUsed];
  u_short data = expand_data;
  while (frameLeft >= 2) {
   if (bal < 0) {
    if (userCount < 2)
     break;
    if (get_user(data, (u_short __user *)userPtr))
     return -EFAULT;
    userPtr += 2;
    data ^= 0x8080;
    userCount -= 2;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft -= 2;
   bal -= sSpeed;
  }
  expand_data = data;
 }
 expand_bal = bal;
 used -= userCount;
 *frameUsed += usedf-frameLeft;
 return used;
}


static ssize_t ata_ctx_s16be(const u_char __user *userPtr, size_t userCount,
        u_char frame[], ssize_t *frameUsed,
        ssize_t frameLeft)
{
 /* this should help gcc to stuff everything into registers */
 long bal = expand_bal;
 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 ssize_t used, usedf;

 used = userCount;
 usedf = frameLeft;
 if (!dmasound.soft.stereo) {
  u_short *p = (u_short *)&frame[*frameUsed];
  u_short data = expand_data;
  while (frameLeft >= 4) {
   if (bal < 0) {
    if (userCount < 2)
     break;
    if (get_user(data, (u_short __user *)userPtr))
     return -EFAULT;
    userPtr += 2;
    userCount -= 2;
    bal += hSpeed;
   }
   *p++ = data;
   *p++ = data;
   frameLeft -= 4;
   bal -= sSpeed;
  }
  expand_data = data;
 } else {
  u_long *p = (u_long *)&frame[*frameUsed];
  u_long data = expand_data;
  while (frameLeft >= 4) {
   if (bal < 0) {
    if (userCount < 4)
     break;
    if (get_user(data, (u_int __user *)userPtr))
     return -EFAULT;
    userPtr += 4;
    userCount -= 4;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft -= 4;
   bal -= sSpeed;
  }
  expand_data = data;
 }
 expand_bal = bal;
 used -= userCount;
 *frameUsed += usedf-frameLeft;
 return used;
}


static ssize_t ata_ctx_u16be(const u_char __user *userPtr, size_t userCount,
        u_char frame[], ssize_t *frameUsed,
        ssize_t frameLeft)
{
 /* this should help gcc to stuff everything into registers */
 long bal = expand_bal;
 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 ssize_t used, usedf;

 used = userCount;
 usedf = frameLeft;
 if (!dmasound.soft.stereo) {
  u_short *p = (u_short *)&frame[*frameUsed];
  u_short data = expand_data;
  while (frameLeft >= 4) {
   if (bal < 0) {
    if (userCount < 2)
     break;
    if (get_user(data, (u_short __user *)userPtr))
     return -EFAULT;
    userPtr += 2;
    data ^= 0x8000;
    userCount -= 2;
    bal += hSpeed;
   }
   *p++ = data;
   *p++ = data;
   frameLeft -= 4;
   bal -= sSpeed;
  }
  expand_data = data;
 } else {
  u_long *p = (u_long *)&frame[*frameUsed];
  u_long data = expand_data;
  while (frameLeft >= 4) {
   if (bal < 0) {
    if (userCount < 4)
     break;
    if (get_user(data, (u_int __user *)userPtr))
     return -EFAULT;
    userPtr += 4;
    data ^= 0x80008000;
    userCount -= 4;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft -= 4;
   bal -= sSpeed;
  }
  expand_data = data;
 }
 expand_bal = bal;
 used -= userCount;
 *frameUsed += usedf-frameLeft;
 return used;
}


static ssize_t ata_ctx_s16le(const u_char __user *userPtr, size_t userCount,
        u_char frame[], ssize_t *frameUsed,
        ssize_t frameLeft)
{
 /* this should help gcc to stuff everything into registers */
 long bal = expand_bal;
 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 ssize_t used, usedf;

 used = userCount;
 usedf = frameLeft;
 if (!dmasound.soft.stereo) {
  u_short *p = (u_short *)&frame[*frameUsed];
  u_short data = expand_data;
  while (frameLeft >= 4) {
   if (bal < 0) {
    if (userCount < 2)
     break;
    if (get_user(data, (u_short __user *)userPtr))
     return -EFAULT;
    userPtr += 2;
    data = le2be16(data);
    userCount -= 2;
    bal += hSpeed;
   }
   *p++ = data;
   *p++ = data;
   frameLeft -= 4;
   bal -= sSpeed;
  }
  expand_data = data;
 } else {
  u_long *p = (u_long *)&frame[*frameUsed];
  u_long data = expand_data;
  while (frameLeft >= 4) {
   if (bal < 0) {
    if (userCount < 4)
     break;
    if (get_user(data, (u_int __user *)userPtr))
     return -EFAULT;
    userPtr += 4;
    data = le2be16dbl(data);
    userCount -= 4;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft -= 4;
   bal -= sSpeed;
  }
  expand_data = data;
 }
 expand_bal = bal;
 used -= userCount;
 *frameUsed += usedf-frameLeft;
 return used;
}


static ssize_t ata_ctx_u16le(const u_char __user *userPtr, size_t userCount,
        u_char frame[], ssize_t *frameUsed,
        ssize_t frameLeft)
{
 /* this should help gcc to stuff everything into registers */
 long bal = expand_bal;
 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 ssize_t used, usedf;

 used = userCount;
 usedf = frameLeft;
 if (!dmasound.soft.stereo) {
  u_short *p = (u_short *)&frame[*frameUsed];
  u_short data = expand_data;
  while (frameLeft >= 4) {
   if (bal < 0) {
    if (userCount < 2)
     break;
    if (get_user(data, (u_short __user *)userPtr))
     return -EFAULT;
    userPtr += 2;
    data = le2be16(data) ^ 0x8000;
    userCount -= 2;
    bal += hSpeed;
   }
   *p++ = data;
   *p++ = data;
   frameLeft -= 4;
   bal -= sSpeed;
  }
  expand_data = data;
 } else {
  u_long *p = (u_long *)&frame[*frameUsed];
  u_long data = expand_data;
  while (frameLeft >= 4) {
   if (bal < 0) {
    if (userCount < 4)
     break;
    if (get_user(data, (u_int __user *)userPtr))
     return -EFAULT;
    userPtr += 4;
    data = le2be16dbl(data) ^ 0x80008000;
    userCount -= 4;
    bal += hSpeed;
   }
   *p++ = data;
   frameLeft -= 4;
   bal -= sSpeed;
  }
  expand_data = data;
 }
 expand_bal = bal;
 used -= userCount;
 *frameUsed += usedf-frameLeft;
 return used;
}


static TRANS transTTNormal = {
 .ct_ulaw = ata_ct_law,
 .ct_alaw = ata_ct_law,
 .ct_s8  = ata_ct_s8,
 .ct_u8  = ata_ct_u8,
};

static TRANS transTTExpanding = {
 .ct_ulaw = ata_ctx_law,
 .ct_alaw = ata_ctx_law,
 .ct_s8  = ata_ctx_s8,
 .ct_u8  = ata_ctx_u8,
};

static TRANS transFalconNormal = {
 .ct_ulaw = ata_ct_law,
 .ct_alaw = ata_ct_law,
 .ct_s8  = ata_ct_s8,
 .ct_u8  = ata_ct_u8,
 .ct_s16be = ata_ct_s16be,
 .ct_u16be = ata_ct_u16be,
 .ct_s16le = ata_ct_s16le,
 .ct_u16le = ata_ct_u16le
};

static TRANS transFalconExpanding = {
 .ct_ulaw = ata_ctx_law,
 .ct_alaw = ata_ctx_law,
 .ct_s8  = ata_ctx_s8,
 .ct_u8  = ata_ctx_u8,
 .ct_s16be = ata_ctx_s16be,
 .ct_u16be = ata_ctx_u16be,
 .ct_s16le = ata_ctx_s16le,
 .ct_u16le = ata_ctx_u16le,
};


/*** Low level stuff *********************************************************/



/*
 * Atari (TT/Falcon)
 */

static void *AtaAlloc(unsigned int size, gfp_t flags)
{
 return atari_stram_alloc(size, "dmasound");
}

static void AtaFree(void *obj, unsigned int size)
{
 atari_stram_free( obj );
}

static int __init AtaIrqInit(void)
{
 /* Set up timer A. Timer A
   will receive a signal upon end of playing from the sound
   hardware. Furthermore Timer A is able to count events
   and will cause an interrupt after a programmed number
   of events. So all we need to keep the music playing is
   to provide the sound hardware with new data upon
   an interrupt from timer A. */
 st_mfp.tim_ct_a = 0; /* ++roman: Stop timer before programming! */
 st_mfp.tim_dt_a = 1; /* Cause interrupt after first event. */
 st_mfp.tim_ct_a = 8; /* Turn on event counting. */
 /* Register interrupt handler. */
 if (request_irq(IRQ_MFP_TIMA, AtaInterrupt, 0, "DMA sound",
   AtaInterrupt))
  return 0;
 st_mfp.int_en_a |= 0x20; /* Turn interrupt on. */
 st_mfp.int_mk_a |= 0x20;
 return 1;
}

#ifdef MODULE
static void AtaIrqCleanUp(void)
{
 st_mfp.tim_ct_a = 0;  /* stop timer */
 st_mfp.int_en_a &= ~0x20; /* turn interrupt off */
 free_irq(IRQ_MFP_TIMA, AtaInterrupt);
}
#endif /* MODULE */


#define TONE_VOXWARE_TO_DB(v) \
 (((v) < 0) ? -12 : ((v) > 100) ? 12 : ((v) - 50) * 6 / 25)
#define TONE_DB_TO_VOXWARE(v) (((v) * 25 + ((v) > 0 ? 5 : -5)) / 6 + 50)


static int AtaSetBass(int bass)
{
 dmasound.bass = TONE_VOXWARE_TO_DB(bass);
 atari_microwire_cmd(MW_LM1992_BASS(dmasound.bass));
 return TONE_DB_TO_VOXWARE(dmasound.bass);
}


static int AtaSetTreble(int treble)
{
 dmasound.treble = TONE_VOXWARE_TO_DB(treble);
 atari_microwire_cmd(MW_LM1992_TREBLE(dmasound.treble));
 return TONE_DB_TO_VOXWARE(dmasound.treble);
}



/*
 * TT
 */


static void TTSilence(void)
{
 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
 atari_microwire_cmd(MW_LM1992_PSG_HIGH); /* mix in PSG signal 1:1 */
}


static void TTInit(void)
{
 int mode, i, idx;
 const int freq[4] = {50066, 25033, 12517, 6258};

 /* search a frequency that fits into the allowed error range */

 idx = -1;
 for (i = 0; i < ARRAY_SIZE(freq); i++)
  /* this isn't as much useful for a TT than for a Falcon, but
 * then it doesn't hurt very much to implement it for a TT too.
 */
  if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) < catchRadius)
   idx = i;
 if (idx > -1) {
  dmasound.soft.speed = freq[idx];
  dmasound.trans_write = &transTTNormal;
 } else
  dmasound.trans_write = &transTTExpanding;

 TTSilence();
 dmasound.hard = dmasound.soft;

 if (dmasound.hard.speed > 50066) {
  /* we would need to squeeze the sound, but we won't do that */
  dmasound.hard.speed = 50066;
  mode = DMASND_MODE_50KHZ;
  dmasound.trans_write = &transTTNormal;
 } else if (dmasound.hard.speed > 25033) {
  dmasound.hard.speed = 50066;
  mode = DMASND_MODE_50KHZ;
 } else if (dmasound.hard.speed > 12517) {
  dmasound.hard.speed = 25033;
  mode = DMASND_MODE_25KHZ;
 } else if (dmasound.hard.speed > 6258) {
  dmasound.hard.speed = 12517;
  mode = DMASND_MODE_12KHZ;
 } else {
  dmasound.hard.speed = 6258;
  mode = DMASND_MODE_6KHZ;
 }

 tt_dmasnd.mode = (dmasound.hard.stereo ?
     DMASND_MODE_STEREO : DMASND_MODE_MONO) |
  DMASND_MODE_8BIT | mode;

 expand_bal = -dmasound.soft.speed;
}


static int TTSetFormat(int format)
{
 /* TT sound DMA supports only 8bit modes */

 switch (format) {
 case AFMT_QUERY:
  return dmasound.soft.format;
 case AFMT_MU_LAW:
 case AFMT_A_LAW:
 case AFMT_S8:
 case AFMT_U8:
  break;
 default:
  format = AFMT_S8;
 }

 dmasound.soft.format = format;
 dmasound.soft.size = 8;
 if (dmasound.minDev == SND_DEV_DSP) {
  dmasound.dsp.format = format;
  dmasound.dsp.size = 8;
 }
 TTInit();

 return format;
}


#define VOLUME_VOXWARE_TO_DB(v) \
 (((v) < 0) ? -40 : ((v) > 100) ? 0 : ((v) * 2) / 5 - 40)
#define VOLUME_DB_TO_VOXWARE(v) ((((v) + 40) * 5 + 1) / 2)


static int TTSetVolume(int volume)
{
 dmasound.volume_left = VOLUME_VOXWARE_TO_DB(volume & 0xff);
 atari_microwire_cmd(MW_LM1992_BALLEFT(dmasound.volume_left));
 dmasound.volume_right = VOLUME_VOXWARE_TO_DB((volume & 0xff00) >> 8);
 atari_microwire_cmd(MW_LM1992_BALRIGHT(dmasound.volume_right));
 return VOLUME_DB_TO_VOXWARE(dmasound.volume_left) |
        (VOLUME_DB_TO_VOXWARE(dmasound.volume_right) << 8);
}


#define GAIN_VOXWARE_TO_DB(v) \
 (((v) < 0) ? -80 : ((v) > 100) ? 0 : ((v) * 4) / 5 - 80)
#define GAIN_DB_TO_VOXWARE(v) ((((v) + 80) * 5 + 1) / 4)

static int TTSetGain(int gain)
{
 dmasound.gain = GAIN_VOXWARE_TO_DB(gain);
 atari_microwire_cmd(MW_LM1992_VOLUME(dmasound.gain));
 return GAIN_DB_TO_VOXWARE(dmasound.gain);
}



/*
 * Falcon
 */


static void FalconSilence(void)
{
 /* stop playback, set sample rate 50kHz for PSG sound */
 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
 tt_dmasnd.mode = DMASND_MODE_50KHZ | DMASND_MODE_STEREO | DMASND_MODE_8BIT;
 tt_dmasnd.int_div = 0; /* STE compatible divider */
 tt_dmasnd.int_ctrl = 0x0;
 tt_dmasnd.cbar_src = 0x0000; /* no matrix inputs */
 tt_dmasnd.cbar_dst = 0x0000; /* no matrix outputs */
 tt_dmasnd.dac_src = 1; /* connect ADC to DAC, disconnect matrix */
 tt_dmasnd.adc_src = 3; /* ADC Input = PSG */
}


static void FalconInit(void)
{
 int divider, i, idx;
 const int freq[8] = {49170, 32780, 24585, 19668, 16390, 12292, 9834, 8195};

 /* search a frequency that fits into the allowed error range */

 idx = -1;
 for (i = 0; i < ARRAY_SIZE(freq); i++)
  /* if we will tolerate 3% error 8000Hz->8195Hz (2.38%) would
 * be playable without expanding, but that now a kernel runtime
 * option
 */
  if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) < catchRadius)
   idx = i;
 if (idx > -1) {
  dmasound.soft.speed = freq[idx];
  dmasound.trans_write = &transFalconNormal;
 } else
  dmasound.trans_write = &transFalconExpanding;

 FalconSilence();
 dmasound.hard = dmasound.soft;

 if (dmasound.hard.size == 16) {
  /* the Falcon can play 16bit samples only in stereo */
  dmasound.hard.stereo = 1;
 }

 if (dmasound.hard.speed > 49170) {
  /* we would need to squeeze the sound, but we won't do that */
  dmasound.hard.speed = 49170;
  divider = 1;
  dmasound.trans_write = &transFalconNormal;
 } else if (dmasound.hard.speed > 32780) {
  dmasound.hard.speed = 49170;
  divider = 1;
 } else if (dmasound.hard.speed > 24585) {
  dmasound.hard.speed = 32780;
  divider = 2;
 } else if (dmasound.hard.speed > 19668) {
  dmasound.hard.speed = 24585;
  divider = 3;
 } else if (dmasound.hard.speed > 16390) {
  dmasound.hard.speed = 19668;
  divider = 4;
 } else if (dmasound.hard.speed > 12292) {
  dmasound.hard.speed = 16390;
  divider = 5;
 } else if (dmasound.hard.speed > 9834) {
  dmasound.hard.speed = 12292;
  divider = 7;
 } else if (dmasound.hard.speed > 8195) {
  dmasound.hard.speed = 9834;
  divider = 9;
 } else {
  dmasound.hard.speed = 8195;
  divider = 11;
 }
 tt_dmasnd.int_div = divider;

 /* Setup Falcon sound DMA for playback */
 tt_dmasnd.int_ctrl = 0x4; /* Timer A int at play end */
 tt_dmasnd.track_select = 0x0; /* play 1 track, track 1 */
 tt_dmasnd.cbar_src = 0x0001; /* DMA(25MHz) --> DAC */
 tt_dmasnd.cbar_dst = 0x0000;
 tt_dmasnd.rec_track_select = 0;
 tt_dmasnd.dac_src = 2; /* connect matrix to DAC */
 tt_dmasnd.adc_src = 0; /* ADC Input = Mic */

 tt_dmasnd.mode = (dmasound.hard.stereo ?
     DMASND_MODE_STEREO : DMASND_MODE_MONO) |
  ((dmasound.hard.size == 8) ?
   DMASND_MODE_8BIT : DMASND_MODE_16BIT) |
  DMASND_MODE_6KHZ;

 expand_bal = -dmasound.soft.speed;
}


static int FalconSetFormat(int format)
{
 int size;
 /* Falcon sound DMA supports 8bit and 16bit modes */

 switch (format) {
 case AFMT_QUERY:
  return dmasound.soft.format;
 case AFMT_MU_LAW:
 case AFMT_A_LAW:
 case AFMT_U8:
 case AFMT_S8:
  size = 8;
  break;
 case AFMT_S16_BE:
 case AFMT_U16_BE:
 case AFMT_S16_LE:
 case AFMT_U16_LE:
  size = 16;
  break;
 default: /* :-) */
  size = 8;
  format = AFMT_S8;
 }

 dmasound.soft.format = format;
 dmasound.soft.size = size;
 if (dmasound.minDev == SND_DEV_DSP) {
  dmasound.dsp.format = format;
  dmasound.dsp.size = dmasound.soft.size;
 }

 FalconInit();

 return format;
}


/* This is for the Falcon output *attenuation* in 1.5dB steps,
 * i.e. output level from 0 to -22.5dB in -1.5dB steps.
 */
#define VOLUME_VOXWARE_TO_ATT(v) \
 ((v) < 0 ? 15 : (v) > 100 ? 0 : 15 - (v) * 3 / 20)
#define VOLUME_ATT_TO_VOXWARE(v) (100 - (v) * 20 / 3)


static int FalconSetVolume(int volume)
{
 dmasound.volume_left = VOLUME_VOXWARE_TO_ATT(volume & 0xff);
 dmasound.volume_right = VOLUME_VOXWARE_TO_ATT((volume & 0xff00) >> 8);
 tt_dmasnd.output_atten = dmasound.volume_left << 8 | dmasound.volume_right << 4;
 return VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) |
        VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8;
}


static void AtaPlayNextFrame(int index)
{
 char *start, *end;

 /* used by AtaPlay() if all doubts whether there really is something
 * to be played are already wiped out.
 */
 start = write_sq.buffers[write_sq.front];
 end = start+((write_sq.count == index) ? write_sq.rear_size
            : write_sq.block_size);
 /* end might not be a legal virtual address. */
 DMASNDSetEnd(virt_to_phys(end - 1) + 1);
 DMASNDSetBase(virt_to_phys(start));
 /* Since only an even number of samples per frame can
   be played, we might lose one byte here. (TO DO) */
 write_sq.front = (write_sq.front+1) % write_sq.max_count;
 write_sq.active++;
 tt_dmasnd.ctrl = DMASND_CTRL_ON | DMASND_CTRL_REPEAT;
}


static void AtaPlay(void)
{
 /* ++TeSche: Note that write_sq.active is no longer just a flag but
 * holds the number of frames the DMA is currently programmed for
 * instead, may be 0, 1 (currently being played) or 2 (pre-programmed).
 *
 * Changes done to write_sq.count and write_sq.active are a bit more
 * subtle again so now I must admit I also prefer disabling the irq
 * here rather than considering all possible situations. But the point
 * is that disabling the irq doesn't have any bad influence on this
 * version of the driver as we benefit from having pre-programmed the
 * DMA wherever possible: There's no need to reload the DMA at the
 * exact time of an interrupt but only at some time while the
 * pre-programmed frame is playing!
 */
 atari_disable_irq(IRQ_MFP_TIMA);

 if (write_sq.active == 2 || /* DMA is 'full' */
     write_sq.count <= 0) { /* nothing to do */
  atari_enable_irq(IRQ_MFP_TIMA);
  return;
 }

 if (write_sq.active == 0) {
  /* looks like there's nothing 'in' the DMA yet, so try
 * to put two frames into it (at least one is available).
 */
  if (write_sq.count == 1 &&
      write_sq.rear_size < write_sq.block_size &&
      !write_sq.syncing) {
   /* hmmm, the only existing frame is not
 * yet filled and we're not syncing?
 */
   atari_enable_irq(IRQ_MFP_TIMA);
   return;
  }
  AtaPlayNextFrame(1);
  if (write_sq.count == 1) {
   /* no more frames */
   atari_enable_irq(IRQ_MFP_TIMA);
   return;
  }
  if (write_sq.count == 2 &&
      write_sq.rear_size < write_sq.block_size &&
      !write_sq.syncing) {
   /* hmmm, there were two frames, but the second
 * one is not yet filled and we're not syncing?
 */
   atari_enable_irq(IRQ_MFP_TIMA);
   return;
  }
  AtaPlayNextFrame(2);
 } else {
  /* there's already a frame being played so we may only stuff
 * one new into the DMA, but even if this may be the last
 * frame existing the previous one is still on write_sq.count.
 */
  if (write_sq.count == 2 &&
      write_sq.rear_size < write_sq.block_size &&
      !write_sq.syncing) {
   /* hmmm, the only existing frame is not
 * yet filled and we're not syncing?
 */
   atari_enable_irq(IRQ_MFP_TIMA);
   return;
  }
  AtaPlayNextFrame(2);
 }
 atari_enable_irq(IRQ_MFP_TIMA);
}


static irqreturn_t AtaInterrupt(int irq, void *dummy)
{
#if 0
 /* ++TeSche: if you should want to test this... */
 static int cnt;
 if (write_sq.active == 2)
  if (++cnt == 10) {
   /* simulate losing an interrupt */
   cnt = 0;
   return IRQ_HANDLED;
  }
#endif
 spin_lock(&dmasound.lock);
 if (write_sq_ignore_int && is_falcon) {
  /* ++TeSche: Falcon only: ignore first irq because it comes
 * immediately after starting a frame. after that, irqs come
 * (almost) like on the TT.
 */
  write_sq_ignore_int = 0;
  goto out;
 }

 if (!write_sq.active) {
  /* playing was interrupted and sq_reset() has already cleared
 * the sq variables, so better don't do anything here.
 */
  WAKE_UP(write_sq.sync_queue);
  goto out;
 }

 /* Probably ;) one frame is finished. Well, in fact it may be that a
 * pre-programmed one is also finished because there has been a long
 * delay in interrupt delivery and we've completely lost one, but
 * there's no way to detect such a situation. In such a case the last
 * frame will be played more than once and the situation will recover
 * as soon as the irq gets through.
 */
 write_sq.count--;
 write_sq.active--;

 if (!write_sq.active) {
  tt_dmasnd.ctrl = DMASND_CTRL_OFF;
  write_sq_ignore_int = 1;
 }

 WAKE_UP(write_sq.action_queue);
 /* At least one block of the queue is free now
   so wake up a writing process blocked because
   of a full queue. */

 if ((write_sq.active != 1) || (write_sq.count != 1))
  /* We must be a bit carefully here: write_sq.count indicates the
 * number of buffers used and not the number of frames to be
 * played. If write_sq.count==1 and write_sq.active==1 that
 * means the only remaining frame was already programmed
 * earlier (and is currently running) so we mustn't call
 * AtaPlay() here, otherwise we'll play one frame too much.
 */
  AtaPlay();

 if (!write_sq.active) WAKE_UP(write_sq.sync_queue);
 /* We are not playing after AtaPlay(), so there
   is nothing to play any more. Wake up a process
   waiting for audio output to drain. */
out:
 spin_unlock(&dmasound.lock);
 return IRQ_HANDLED;
}


/*** Mid level stuff *********************************************************/


/*
 * /dev/mixer abstraction
 */

#define RECLEVEL_VOXWARE_TO_GAIN(v) \
 ((v) < 0 ? 0 : (v) > 100 ? 15 : (v) * 3 / 20)
#define RECLEVEL_GAIN_TO_VOXWARE(v) (((v) * 20 + 2) / 3)


static void __init TTMixerInit(void)
{
 atari_microwire_cmd(MW_LM1992_VOLUME(0));
 dmasound.volume_left = 0;
 atari_microwire_cmd(MW_LM1992_BALLEFT(0));
 dmasound.volume_right = 0;
 atari_microwire_cmd(MW_LM1992_BALRIGHT(0));
 atari_microwire_cmd(MW_LM1992_TREBLE(0));
 atari_microwire_cmd(MW_LM1992_BASS(0));
}

static void __init FalconMixerInit(void)
{
 dmasound.volume_left = (tt_dmasnd.output_atten & 0xf00) >> 8;
 dmasound.volume_right = (tt_dmasnd.output_atten & 0xf0) >> 4;
}

static int AtaMixerIoctl(u_int cmd, u_long arg)
{
 int data;
 unsigned long flags;
 switch (cmd) {
     case SOUND_MIXER_READ_SPEAKER:
      if (is_falcon || MACH_IS_TT) {
       int porta;
       spin_lock_irqsave(&dmasound.lock, flags);
       sound_ym.rd_data_reg_sel = 14;
       porta = sound_ym.rd_data_reg_sel;
       spin_unlock_irqrestore(&dmasound.lock, flags);
       return IOCTL_OUT(arg, porta & 0x40 ? 0 : 100);
      }
      break;
     case SOUND_MIXER_WRITE_VOLUME:
      IOCTL_IN(arg, data);
      return IOCTL_OUT(arg, dmasound_set_volume(data));
     case SOUND_MIXER_WRITE_SPEAKER:
      if (is_falcon || MACH_IS_TT) {
       int porta;
       IOCTL_IN(arg, data);
       spin_lock_irqsave(&dmasound.lock, flags);
       sound_ym.rd_data_reg_sel = 14;
       porta = (sound_ym.rd_data_reg_sel & ~0x40) |
        (data < 50 ? 0x40 : 0);
       sound_ym.wd_data = porta;
       spin_unlock_irqrestore(&dmasound.lock, flags);
       return IOCTL_OUT(arg, porta & 0x40 ? 0 : 100);
      }
 }
 return -EINVAL;
}


static int TTMixerIoctl(u_int cmd, u_long arg)
{
 int data;
 switch (cmd) {
     case SOUND_MIXER_READ_RECMASK:
  return IOCTL_OUT(arg, 0);
     case SOUND_MIXER_READ_DEVMASK:
  return IOCTL_OUT(arg,
     SOUND_MASK_VOLUME | SOUND_MASK_TREBLE | SOUND_MASK_BASS |
     (MACH_IS_TT ? SOUND_MASK_SPEAKER : 0));
     case SOUND_MIXER_READ_STEREODEVS:
  return IOCTL_OUT(arg, SOUND_MASK_VOLUME);
     case SOUND_MIXER_READ_VOLUME:
  return IOCTL_OUT(arg,
     VOLUME_DB_TO_VOXWARE(dmasound.volume_left) |
     (VOLUME_DB_TO_VOXWARE(dmasound.volume_right) << 8));
     case SOUND_MIXER_READ_BASS:
  return IOCTL_OUT(arg, TONE_DB_TO_VOXWARE(dmasound.bass));
     case SOUND_MIXER_READ_TREBLE:
  return IOCTL_OUT(arg, TONE_DB_TO_VOXWARE(dmasound.treble));
     case SOUND_MIXER_READ_OGAIN:
  return IOCTL_OUT(arg, GAIN_DB_TO_VOXWARE(dmasound.gain));
     case SOUND_MIXER_WRITE_BASS:
  IOCTL_IN(arg, data);
  return IOCTL_OUT(arg, dmasound_set_bass(data));
     case SOUND_MIXER_WRITE_TREBLE:
  IOCTL_IN(arg, data);
  return IOCTL_OUT(arg, dmasound_set_treble(data));
     case SOUND_MIXER_WRITE_OGAIN:
  IOCTL_IN(arg, data);
  return IOCTL_OUT(arg, dmasound_set_gain(data));
 }
 return AtaMixerIoctl(cmd, arg);
}

static int FalconMixerIoctl(u_int cmd, u_long arg)
{
 int data;
 switch (cmd) {
 case SOUND_MIXER_READ_RECMASK:
  return IOCTL_OUT(arg, SOUND_MASK_MIC);
 case SOUND_MIXER_READ_DEVMASK:
  return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC | SOUND_MASK_SPEAKER);
 case SOUND_MIXER_READ_STEREODEVS:
  return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC);
 case SOUND_MIXER_READ_VOLUME:
  return IOCTL_OUT(arg,
   VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) |
   VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8);
 case SOUND_MIXER_READ_CAPS:
  return IOCTL_OUT(arg, SOUND_CAP_EXCL_INPUT);
 case SOUND_MIXER_WRITE_MIC:
  IOCTL_IN(arg, data);
  tt_dmasnd.input_gain =
   RECLEVEL_VOXWARE_TO_GAIN(data & 0xff) << 4 |
   RECLEVEL_VOXWARE_TO_GAIN(data >> 8 & 0xff);
  fallthrough; /* return set value */
 case SOUND_MIXER_READ_MIC:
  return IOCTL_OUT(arg,
   RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain >> 4 & 0xf) |
   RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain & 0xf) << 8);
 }
 return AtaMixerIoctl(cmd, arg);
}

static int AtaWriteSqSetup(void)
{
 write_sq_ignore_int = 0;
 return 0 ;
}

static int AtaSqOpen(fmode_t mode)
{
 write_sq_ignore_int = 1;
 return 0 ;
}

static int TTStateInfo(char *buffer, size_t space)
{
 int len = 0;
 len += sprintf(buffer+len, "\tvol left %ddB [-40... 0]\n",
         dmasound.volume_left);
 len += sprintf(buffer+len, "\tvol right %ddB [-40... 0]\n",
         dmasound.volume_right);
 len += sprintf(buffer+len, "\tbass %ddB [-12...+12]\n",
         dmasound.bass);
 len += sprintf(buffer+len, "\ttreble %ddB [-12...+12]\n",
         dmasound.treble);
 if (len >= space) {
  printk(KERN_ERR "dmasound_atari: overflowed state buffer alloc.\n") ;
  len = space ;
 }
 return len;
}

static int FalconStateInfo(char *buffer, size_t space)
{
 int len = 0;
 len += sprintf(buffer+len, "\tvol left %ddB [-22.5 ... 0]\n",
         dmasound.volume_left);
 len += sprintf(buffer+len, "\tvol right %ddB [-22.5 ... 0]\n",
         dmasound.volume_right);
 if (len >= space) {
  printk(KERN_ERR "dmasound_atari: overflowed state buffer alloc.\n") ;
  len = space ;
 }
 return len;
}


/*** Machine definitions *****************************************************/

static SETTINGS def_hard_falcon = {
 .format  = AFMT_S8,
 .stereo  = 0,
 .size  = 8,
 .speed  = 8195
} ;

static SETTINGS def_hard_tt = {
 .format = AFMT_S8,
 .stereo = 0,
 .size = 8,
 .speed = 12517
} ;

static SETTINGS def_soft = {
 .format = AFMT_U8,
 .stereo = 0,
 .size = 8,
 .speed = 8000
} ;

static __initdata MACHINE machTT = {
 .name  = "Atari",
 .name2  = "TT",
 .owner  = THIS_MODULE,
 .dma_alloc = AtaAlloc,
 .dma_free = AtaFree,
 .irqinit = AtaIrqInit,
#ifdef MODULE
 .irqcleanup = AtaIrqCleanUp,
#endif /* MODULE */
 .init  = TTInit,
 .silence = TTSilence,
 .setFormat = TTSetFormat,
 .setVolume = TTSetVolume,
 .setBass = AtaSetBass,
 .setTreble = AtaSetTreble,
 .setGain = TTSetGain,
 .play  = AtaPlay,
 .mixer_init = TTMixerInit,
 .mixer_ioctl = TTMixerIoctl,
 .write_sq_setup = AtaWriteSqSetup,
 .sq_open = AtaSqOpen,
 .state_info = TTStateInfo,
 .min_dsp_speed = 6258,
 .version = ((DMASOUND_ATARI_REVISION<<8) | DMASOUND_ATARI_EDITION),
 .hardware_afmts = AFMT_S8,  /* h'ware-supported formats *only* here */
 .capabilities =  DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */
};

static __initdata MACHINE machFalcon = {
 .name  = "Atari",
 .name2  = "FALCON",
 .dma_alloc = AtaAlloc,
 .dma_free = AtaFree,
 .irqinit = AtaIrqInit,
#ifdef MODULE
 .irqcleanup = AtaIrqCleanUp,
#endif /* MODULE */
 .init  = FalconInit,
 .silence = FalconSilence,
 .setFormat = FalconSetFormat,
 .setVolume = FalconSetVolume,
 .setBass = AtaSetBass,
 .setTreble = AtaSetTreble,
 .play  = AtaPlay,
 .mixer_init = FalconMixerInit,
 .mixer_ioctl = FalconMixerIoctl,
 .write_sq_setup = AtaWriteSqSetup,
 .sq_open = AtaSqOpen,
 .state_info = FalconStateInfo,
 .min_dsp_speed = 8195,
 .version = ((DMASOUND_ATARI_REVISION<<8) | DMASOUND_ATARI_EDITION),
 .hardware_afmts = (AFMT_S8 | AFMT_S16_BE), /* h'ware-supported formats *only* here */
 .capabilities =  DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */
};


/*** Config & Setup **********************************************************/


static int __init dmasound_atari_init(void)
{
 if (MACH_IS_ATARI && ATARIHW_PRESENT(PCM_8BIT)) {
     if (ATARIHW_PRESENT(CODEC)) {
  dmasound.mach = machFalcon;
  dmasound.mach.default_soft = def_soft ;
  dmasound.mach.default_hard = def_hard_falcon ;
  is_falcon = 1;
     } else if (ATARIHW_PRESENT(MICROWIRE)) {
  dmasound.mach = machTT;
  dmasound.mach.default_soft = def_soft ;
  dmasound.mach.default_hard = def_hard_tt ;
  is_falcon = 0;
     } else
  return -ENODEV;
     if ((st_mfp.int_en_a & st_mfp.int_mk_a & 0x20) == 0)
  return dmasound_init();
     else {
  printk("DMA sound driver: Timer A interrupt already in use\n");
  return -EBUSY;
     }
 }
 return -ENODEV;
}

static void __exit dmasound_atari_cleanup(void)
{
 dmasound_deinit();
}

module_init(dmasound_atari_init);
module_exit(dmasound_atari_cleanup);

MODULE_DESCRIPTION("Atari TT and Falcon DMA Sound Driver");
MODULE_LICENSE("GPL");