/* * 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 #include #include #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 #include #include #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); extern int amd7930_init(void); extern int cs4231_init(void); #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_ */