include/asm-sparc64/audioio.h

/*
 * include/asm-sparc/audioio.h
 *
 * Sparc Audio Midlayer
 * Copyright (C) 1996 Thomas K. Dyas (tdyas@noc.rutgers.edu)
 */

#ifndef _AUDIOIO_H_
#define _AUDIOIO_H_

/*
 *	SunOS/Solaris /dev/audio interface
 */

#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
#include <linux/types.h>
#include <linux/time.h>
#include <linux/ioctl.h>
#endif

/*
 * This structure contains state information for audio device IO streams.
 */
typedef struct audio_prinfo {
	/*
	 * The following values describe the audio data encoding.
	 */
	unsigned int sample_rate;	/* samples per second */
	unsigned int channels;	/* number of interleaved channels */
	unsigned int precision;	/* bit-width of each sample */
	unsigned int encoding;	/* data encoding method */

	/*
	 * The following values control audio device configuration
	 */
	unsigned int gain;		/* gain level: 0 - 255 */
	unsigned int port;		/* selected I/O port (see below) */
	unsigned int avail_ports;	/* available I/O ports (see below) */
	unsigned int _xxx[2];		/* Reserved for future use */

	unsigned int buffer_size;	/* I/O buffer size */

	/*
	 * The following values describe driver state
	 */
	unsigned int samples;		/* number of samples converted */
	unsigned int eof;		/* End Of File counter (play only) */

	unsigned char	pause;		/* non-zero for pause, zero to resume */
	unsigned char	error;		/* non-zero if overflow/underflow */
	unsigned char	waiting;	/* non-zero if a process wants access */
	unsigned char balance;	/* stereo channel balance */

	unsigned short minordev;

	/*
	 * The following values are read-only state flags
	 */
	unsigned char open;		/* non-zero if open access permitted */
	unsigned char active;		/* non-zero if I/O is active */
} audio_prinfo_t;


/*
 * This structure describes the current state of the audio device.
 */
typedef struct audio_info {
	/*
	 * Per-stream information
	 */
	audio_prinfo_t play;	/* output status information */
	audio_prinfo_t record;	/* input status information */

	/*
	 * Per-unit/channel information
	 */
	unsigned int monitor_gain;	/* input to output mix: 0 - 255 */
	unsigned char output_muted;	/* non-zero if output is muted */
	unsigned char _xxx[3];	/* Reserved for future use */
	unsigned int _yyy[3];		/* Reserved for future use */
} audio_info_t;


/*
 * Audio encoding types
 */
#define	AUDIO_ENCODING_NONE	(0)	/* no encoding assigned	  */
#define	AUDIO_ENCODING_ULAW	(1)	/* u-law encoding	  */
#define	AUDIO_ENCODING_ALAW	(2)	/* A-law encoding	  */
#define	AUDIO_ENCODING_LINEAR	(3)	/* Linear PCM encoding	  */
#define AUDIO_ENCODING_FLOAT    (4)     /* IEEE float (-1. <-> +1.) */
#define	AUDIO_ENCODING_DVI	(104)	/* DVI ADPCM		  */
#define	AUDIO_ENCODING_LINEAR8	(105)	/* 8 bit UNSIGNED	  */
#define	AUDIO_ENCODING_LINEARLE	(106)	/* Linear PCM LE encoding */

/*
 * These ranges apply to record, play, and monitor gain values
 */
#define	AUDIO_MIN_GAIN	(0)	/* minimum gain value */
#define	AUDIO_MAX_GAIN	(255)	/* maximum gain value */

/*
 * These values apply to the balance field to adjust channel gain values
 */
#define	AUDIO_LEFT_BALANCE	(0)	/* left channel only	*/
#define	AUDIO_MID_BALANCE	(32)	/* equal left/right channel */
#define	AUDIO_RIGHT_BALANCE	(64)	/* right channel only	*/
#define	AUDIO_BALANCE_SHIFT	(3)

/*
 * Generic minimum/maximum limits for number of channels, both modes
 */
#define	AUDIO_MIN_PLAY_CHANNELS	(1)
#define	AUDIO_MAX_PLAY_CHANNELS	(4)
#define	AUDIO_MIN_REC_CHANNELS	(1)
#define	AUDIO_MAX_REC_CHANNELS	(4)

/*
 * Generic minimum/maximum limits for sample precision
 */
#define	AUDIO_MIN_PLAY_PRECISION	(8)
#define	AUDIO_MAX_PLAY_PRECISION	(32)
#define	AUDIO_MIN_REC_PRECISION		(8)
#define	AUDIO_MAX_REC_PRECISION		(32)

/*
 * Define some convenient names for typical audio ports
 */
/*
 * output ports (several may be enabled simultaneously)
 */
#define	AUDIO_SPEAKER		0x01	/* output to built-in speaker */
#define	AUDIO_HEADPHONE		0x02	/* output to headphone jack */
#define	AUDIO_LINE_OUT		0x04	/* output to line out	 */

/*
 * input ports (usually only one at a time)
 */
#define	AUDIO_MICROPHONE	0x01	/* input from microphone */
#define	AUDIO_LINE_IN		0x02	/* input from line in	 */
#define	AUDIO_CD		0x04	/* input from on-board CD inputs */
#define	AUDIO_INTERNAL_CD_IN	AUDIO_CD	/* input from internal CDROM */
#define AUDIO_ANALOG_LOOPBACK   0x40    /* input from output */


/*
 * This macro initializes an audio_info structure to 'harmless' values.
 * Note that (~0) might not be a harmless value for a flag that was
 * a signed int.
 */
#define	AUDIO_INITINFO(i)	{					\
	unsigned int	*__x__;						\
	for (__x__ = (unsigned int *)(i);				\
	    (char *) __x__ < (((char *)(i)) + sizeof (audio_info_t));	\
	    *__x__++ = ~0);						\
}

/*
 * These allow testing for what the user wants to set 
 */
#define AUD_INITVALUE   (~0)
#define Modify(X)       ((unsigned int)(X) != AUD_INITVALUE)
#define Modifys(X)      ((X) != (unsigned short)AUD_INITVALUE)
#define Modifyc(X)      ((X) != (unsigned char)AUD_INITVALUE)

/*
 * Parameter for the AUDIO_GETDEV ioctl to determine current
 * audio devices.
 */
#define	MAX_AUDIO_DEV_LEN	(16)
typedef struct audio_device {
	char name[MAX_AUDIO_DEV_LEN];
	char version[MAX_AUDIO_DEV_LEN];
	char config[MAX_AUDIO_DEV_LEN];
} audio_device_t;


/*
 * Ioctl calls for the audio device.
 */

/*
 * AUDIO_GETINFO retrieves the current state of the audio device.
 *
 * AUDIO_SETINFO copies all fields of the audio_info structure whose
 * values are not set to the initialized value (-1) to the device state.
 * It performs an implicit AUDIO_GETINFO to return the new state of the
 * device.  Note that the record.samples and play.samples fields are set
 * to the last value before the AUDIO_SETINFO took effect.  This allows
 * an application to reset the counters while atomically retrieving the
 * last value.
 *
 * AUDIO_DRAIN suspends the calling process until the write buffers are
 * empty.
 *
 * AUDIO_GETDEV returns a structure of type audio_device_t which contains
 * three strings.  The string "name" is a short identifying string (for
 * example, the SBus Fcode name string), the string "version" identifies
 * the current version of the device, and the "config" string identifies
 * the specific configuration of the audio stream.  All fields are
 * device-dependent -- see the device specific manual pages for details.
 *
 * AUDIO_GETDEV_SUNOS returns a number which is an audio device defined 
 * herein (making it not too portable)
 *
 * AUDIO_FLUSH stops all playback and recording, clears all queued buffers, 
 * resets error counters, and restarts recording and playback as appropriate
 * for the current sampling mode.
 */
#define	AUDIO_GETINFO	_IOR('A', 1, audio_info_t)
#define	AUDIO_SETINFO	_IOWR('A', 2, audio_info_t)
#define	AUDIO_DRAIN	_IO('A', 3)
#define	AUDIO_GETDEV	_IOR('A', 4, audio_device_t)
#define	AUDIO_GETDEV_SUNOS	_IOR('A', 4, int)
#define AUDIO_FLUSH     _IO('A', 5)

/* Define possible audio hardware configurations for 
 * old SunOS-style AUDIO_GETDEV ioctl */
#define AUDIO_DEV_UNKNOWN       (0)     /* not defined */
#define AUDIO_DEV_AMD           (1)     /* audioamd device */
#define AUDIO_DEV_SPEAKERBOX    (2)     /* dbri device with speakerbox */
#define AUDIO_DEV_CODEC         (3)     /* dbri device (internal speaker) */
#define AUDIO_DEV_CS4231        (5)     /* cs4231 device */

/*
 * The following ioctl sets the audio device into an internal loopback mode,
 * if the hardware supports this.  The argument is TRUE to set loopback,
 * FALSE to reset to normal operation.  If the hardware does not support
 * internal loopback, the ioctl should fail with EINVAL.
 * Causes ADC data to be digitally mixed in and sent to the DAC.
 */
#define	AUDIO_DIAG_LOOPBACK	_IOW('A', 101, int)

/*
 *	Linux kernel internal implementation.
 */

#ifdef __KERNEL__

#include <linux/fs.h>
#include <linux/tqueue.h>
#include <linux/wait.h>

#define	SDF_OPEN_WRITE	0x00000001
#define	SDF_OPEN_READ	0x00000002

struct sparcaudio_ringbuffer
{
  __u8 *rb_start, *rb_end;		/* start, end of this memory buffer */
  __u8 *rb_in, *rb_out;			/* input, output pointers */

  int rb_fragsize;			/* size of an audio frag */
  int rb_numfrags;			/* number of frags */

  int rb_count, rb_hiwat, rb_lowat;	/* bytes in use, hi/lo wat points */

  int rb_bufsize;			/* total size of buffer */
};

struct sparcaudio_driver
{
	const char * name;
	struct sparcaudio_operations *ops;
	void *private;
	unsigned long flags;
        struct strevent *sd_siglist;
        /* duplex: 0=simplex, 1=duplex, 2=loop */
        int sd_sigflags, duplex;

        /* Which audio device are we? */
        int index; 

        /* This device */
        struct sbus_dev *dev;

	/* Processes blocked on open() sit here. */
	wait_queue_head_t open_wait;

	/* Task queue for this driver's bottom half. */
	struct tq_struct tqueue;

        /* Start of ring buffer support */
        __u8 *input_buffer, *output_buffer;

	/* Support for a circular queue of output buffers. */
	__u8 **output_buffers;
	size_t *output_sizes, output_size, output_buffer_size;
	int num_output_buffers, output_front, output_rear, output_offset;
	int output_count, output_active, playing_count, output_eof;
	wait_queue_head_t output_write_wait, output_drain_wait;
        char *output_notify;

        /* Support for a circular queue of input buffers. */
        __u8 **input_buffers;
	size_t *input_sizes, input_size, input_buffer_size;
        int num_input_buffers, input_front, input_rear, input_offset;
        int input_count, input_active, recording_count;
        wait_queue_head_t input_read_wait;

        /* Hack to make it look like we support variable size buffers. */
        int buffer_size;

        int mixer_modify_counter;
};

struct sparcaudio_operations
{
	int (*open)(struct inode *, struct file *, struct sparcaudio_driver *);
	void (*release)(struct inode *, struct file *, struct sparcaudio_driver *);
	int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long,
		     struct sparcaudio_driver *);

	/* Ask driver to begin playing a buffer. */
	void (*start_output)(struct sparcaudio_driver *, __u8 *, unsigned long);

	/* Ask driver to stop playing a buffer. */
	void (*stop_output)(struct sparcaudio_driver *);

	/* Ask driver to begin recording into a buffer. */
	void (*start_input)(struct sparcaudio_driver *, __u8 *, unsigned long);

	/* Ask driver to stop recording. */
	void (*stop_input)(struct sparcaudio_driver *);

	/* Return driver name/version to caller. (/dev/audio specific) */
	void (*sunaudio_getdev)(struct sparcaudio_driver *, audio_device_t *);

        /* Get and set the output volume. (0-255) */
        int (*set_output_volume)(struct sparcaudio_driver *, int);
        int (*get_output_volume)(struct sparcaudio_driver *);

        /* Get and set the input volume. (0-255) */
        int (*set_input_volume)(struct sparcaudio_driver *, int);
        int (*get_input_volume)(struct sparcaudio_driver *);

        /* Get and set the monitor volume. (0-255) */
        int (*set_monitor_volume)(struct sparcaudio_driver *, int);
        int (*get_monitor_volume)(struct sparcaudio_driver *);

        /* Get and set the output balance. (0-64) */
        int (*set_output_balance)(struct sparcaudio_driver *, int);
        int (*get_output_balance)(struct sparcaudio_driver *);

        /* Get and set the input balance. (0-64) */
        int (*set_input_balance)(struct sparcaudio_driver *, int);
        int (*get_input_balance)(struct sparcaudio_driver *);

        /* Get and set the output channels. (1-4) */
        int (*set_output_channels)(struct sparcaudio_driver *, int);
        int (*get_output_channels)(struct sparcaudio_driver *);

        /* Get and set the input channels. (1-4) */
        int (*set_input_channels)(struct sparcaudio_driver *, int);
        int (*get_input_channels)(struct sparcaudio_driver *);

        /* Get and set the output precision. (8-32) */
        int (*set_output_precision)(struct sparcaudio_driver *, int);
        int (*get_output_precision)(struct sparcaudio_driver *);

        /* Get and set the input precision. (8-32) */
        int (*set_input_precision)(struct sparcaudio_driver *, int);
        int (*get_input_precision)(struct sparcaudio_driver *);

        /* Get and set the output port. () */
        int (*set_output_port)(struct sparcaudio_driver *, int);
        int (*get_output_port)(struct sparcaudio_driver *);

        /* Get and set the input port. () */
        int (*set_input_port)(struct sparcaudio_driver *, int);
        int (*get_input_port)(struct sparcaudio_driver *);

        /* Get and set the output encoding. () */
        int (*set_output_encoding)(struct sparcaudio_driver *, int);
        int (*get_output_encoding)(struct sparcaudio_driver *);

        /* Get and set the input encoding. () */
        int (*set_input_encoding)(struct sparcaudio_driver *, int);
        int (*get_input_encoding)(struct sparcaudio_driver *);

        /* Get and set the output rate. () */
        int (*set_output_rate)(struct sparcaudio_driver *, int);
        int (*get_output_rate)(struct sparcaudio_driver *);

        /* Get and set the input rate. () */
        int (*set_input_rate)(struct sparcaudio_driver *, int);
        int (*get_input_rate)(struct sparcaudio_driver *);

	/* Return driver number to caller. (SunOS /dev/audio specific) */
	int (*sunaudio_getdev_sunos)(struct sparcaudio_driver *);

        /* Get available ports */
        int (*get_output_ports)(struct sparcaudio_driver *);
        int (*get_input_ports)(struct sparcaudio_driver *);

        /* Get and set output mute */
        int (*set_output_muted)(struct sparcaudio_driver *, int);
        int (*get_output_muted)(struct sparcaudio_driver *);

        /* Get and set output pause */
        int (*set_output_pause)(struct sparcaudio_driver *, int);
        int (*get_output_pause)(struct sparcaudio_driver *);

        /* Get and set input pause */
        int (*set_input_pause)(struct sparcaudio_driver *, int);
        int (*get_input_pause)(struct sparcaudio_driver *);

        /* Get and set output samples */
        int (*set_output_samples)(struct sparcaudio_driver *, int);
        int (*get_output_samples)(struct sparcaudio_driver *);

        /* Get and set input samples */
        int (*set_input_samples)(struct sparcaudio_driver *, int);
        int (*get_input_samples)(struct sparcaudio_driver *);

        /* Get and set output error */
        int (*set_output_error)(struct sparcaudio_driver *, int);
        int (*get_output_error)(struct sparcaudio_driver *);

        /* Get and set input error */
        int (*set_input_error)(struct sparcaudio_driver *, int);
        int (*get_input_error)(struct sparcaudio_driver *);

        /* Get supported encodings */
        int (*get_formats)(struct sparcaudio_driver *);
};

extern int register_sparcaudio_driver(struct sparcaudio_driver *, int);
extern int unregister_sparcaudio_driver(struct sparcaudio_driver *, int);
extern void sparcaudio_output_done(struct sparcaudio_driver *, int);
extern void sparcaudio_input_done(struct sparcaudio_driver *, int);

#endif

/* Device minor numbers */

#define SPARCAUDIO_MIXER_MINOR 0
/* No sequencer (1) */
/* No midi (2) */
#define SPARCAUDIO_DSP_MINOR   3
#define SPARCAUDIO_AUDIO_MINOR 4
#define SPARCAUDIO_DSP16_MINOR 5
#define SPARCAUDIO_STATUS_MINOR 6
#define SPARCAUDIO_AUDIOCTL_MINOR 7
/* No sequencer l2 (8) */
/* No sound processor (9) */

/* allocate 2^SPARCAUDIO_DEVICE_SHIFT minors per audio device */
#define SPARCAUDIO_DEVICE_SHIFT 4

/* With the coming of dummy devices this should perhaps be as high as 5? */
#define SPARCAUDIO_MAX_DEVICES 3

/* Streams crap for realaudio */

typedef
struct strevent {
    struct strevent *se_next;   /* next event for this stream or NULL*/
    struct strevent *se_prev;   /* previous event for this stream or last
                                 * event if this is the first one*/
    pid_t se_pid;               /* process to be signaled */
    short se_evs;               /* events wanted */
} strevent_t;

typedef
struct stdata
{
        struct stdata    *sd_next ;     /* all stdatas are linked together */
        struct stdata    *sd_prev ;
        struct strevent   *sd_siglist;  /* processes to be sent SIGPOLL */
        int  sd_sigflags;               /* logical OR of all siglist events */
} stdata_t;

#define I_NREAD _IOR('S',01, int)
#define I_NREAD_SOLARIS (('S'<<8)|1)

#define I_FLUSH _IO('S',05)
#define I_FLUSH_SOLARIS (('S'<<8)|5)
#define FLUSHR  1                       /* flush read queue */
#define FLUSHW  2                       /* flush write queue */
#define FLUSHRW 3                       /* flush both queues */

#define I_SETSIG _IO('S',011)
#define I_SETSIG_SOLARIS (('S'<<8)|11)
#define S_INPUT         0x01
#define S_HIPRI         0x02           
#define S_OUTPUT        0x04           
#define S_MSG           0x08           
#define S_ERROR         0x0010         
#define S_HANGUP        0x0020         
#define S_RDNORM        0x0040         
#define S_WRNORM        S_OUTPUT
#define S_RDBAND        0x0080         
#define S_WRBAND        0x0100         
#define S_BANDURG       0x0200         
#define S_ALL           0x03FF

#define I_GETSIG _IOR('S',012,int)
#define I_GETSIG_SOLARIS (('S'<<8)|12)

/* Conversion between Sun and OSS volume settings */
static __inline__ 
int OSS_LEFT(int value)
{
  return ((value & 0xff) % 101);
}

static __inline__ 
int OSS_RIGHT(int value)
{
  return  (((value >> 8) & 0xff) % 101);
}

static __inline__ 
int O_TO_S(int value)
{
  return value * 255 / 100;
}

static __inline__ 
int S_TO_O(int value)
{
  return value * 100 / 255;
}

static __inline__ 
int OSS_TO_GAIN(int value)
{
  int l = O_TO_S(OSS_LEFT(value));
  int r = O_TO_S(OSS_RIGHT(value));
  return ((l > r) ? l : r);
}

static __inline__ 
int OSS_TO_LGAIN(int value)
{
  int l = O_TO_S(OSS_LEFT(value));
  int r = O_TO_S(OSS_RIGHT(value));
  return ((l < r) ? l : r);
}

static __inline__ 
int OSS_TO_BAL(int value) 
{
  if (!OSS_TO_GAIN(value))
    return AUDIO_MID_BALANCE;
  if (!OSS_TO_LGAIN(value)) {
    if (OSS_TO_GAIN(value) == OSS_TO_GAIN(OSS_RIGHT(value)))
      return AUDIO_RIGHT_BALANCE;
    else
      return AUDIO_LEFT_BALANCE;
  }
  if (OSS_TO_GAIN(value) == OSS_TO_GAIN(OSS_RIGHT(value)))
    return ((OSS_TO_GAIN(value) - OSS_TO_LGAIN(value)) >> AUDIO_BALANCE_SHIFT)
      + AUDIO_MID_BALANCE;
  else
    return AUDIO_MID_BALANCE - ((OSS_TO_GAIN(value) - OSS_TO_LGAIN(value)) 
				>> AUDIO_BALANCE_SHIFT);
}

static __inline__ 
int BAL_TO_OSS(int value, unsigned char balance)
{
  int l, r, adj;
  if (balance > 63) balance = 63;
  if (balance < AUDIO_MID_BALANCE) {
    l = (int)value * 100 / 255 + ((value * 100 % 255) > 0);
    adj = ((AUDIO_MID_BALANCE - balance) << AUDIO_BALANCE_SHIFT);
    if (adj < value)
      r = (int)(value - adj)
	* 100 / 255;
    else r = 0;
  } else if (balance > AUDIO_MID_BALANCE) {
    r = (int)value * 100 / 255 + ((value * 100 % 255) > 0);
    adj = ((balance - AUDIO_MID_BALANCE) << AUDIO_BALANCE_SHIFT);
    if (adj < value)
      l = (int)(value - adj)
	* 100 / 255;
    else l = 0;
  } else {
    l = r = (int)value * 100 / 255 + ((value * 100 % 255) > 0);
  }

  return ((r << 8) + l);
}

#ifdef __KERNEL__
/* OSS mixer ioctl port handling */
static __inline__
int OSS_PORT_AUDIO(struct sparcaudio_driver *drv, unsigned int set) 
{
  int p;
  if (drv->ops->get_output_port) {
    p = drv->ops->get_output_port(drv);
    if (p & set)
      return 0x6464;
  }  
  return 0;
}

static __inline__
int OSS_IPORT_AUDIO(struct sparcaudio_driver *drv, unsigned int set) 
{
  int p;
  if (drv->ops->get_input_port) {
    p = drv->ops->get_input_port(drv);
    if (p & set)
      return 0x6464;
  }  
  return 0;
}

static __inline__ 
void OSS_TWIDDLE_PORT(struct sparcaudio_driver *drv, unsigned int ioctl, 
		      unsigned int port, unsigned int set, unsigned int value) 
{
  if (ioctl == port) {
    int p;
    if (drv->ops->get_output_port && drv->ops->set_output_port) {
      p = drv->ops->get_output_port(drv);
      if ((value == 0) || ((p & set) && (OSS_LEFT(value) < 100)))
	drv->ops->set_output_port(drv, p & ~(set));
      else
	drv->ops->set_output_port(drv, p | set);
    }
  }
}

static __inline__ 
void OSS_TWIDDLE_IPORT(struct sparcaudio_driver *drv, unsigned int ioctl, 
		      unsigned int port, unsigned int set, unsigned int value) 
{
  if (ioctl == port) {
    int p;
    if (drv->ops->get_input_port && drv->ops->set_input_port) {
      p = drv->ops->get_input_port(drv);
      if ((value == 0) || ((p & set) && (OSS_LEFT(value) < 100)))
	drv->ops->set_input_port(drv, p & ~(set));
      else
	drv->ops->set_input_port(drv, p | set);
    }
  }
}
#endif /* __KERNEL__ */
#endif /* _AUDIOIO_H_ */