| | Open Sound System |
| Do you have problems with sound/audio application development? Don't panic! Click here for help! |
This file is part of Open Sound System.
Copyright (C) 4Front Technologies 1996-2008.
This this source file is released under GPL v2 license (no other versions). See the COPYING file included in the main directory of this source distribution for the license terms and conditions.
#define MAX_IMUX_INSTANCES 16
#define MAX_IMUX_DEV 48
#define SUPPORTED_FORMATS (AFMT_S16_NE|AFMT_S16_OE)
#include "oss_imux_cfg.h"
static unsigned long long used_masterdevs = 0LL;
typedef struct
{
int audio_dev;
int port_number;
int is_opened, is_prepared, is_triggered;
int speed, channels, fmt;
int ch_index;
int left_igain, right_igain;
oss_peaks_t peaks;
}
imux_portc;
typedef struct
{
oss_device_t *osdev;
oss_device_t *master_osdev;
oss_mutex_t mutex;
int installed_ok;
int hw_dev;
int hw_speed, hw_channels, hw_fmt, sw_fmt;
int hw_fragsize;
int device_started;
struct fileinfo finfo;
int nr_devices, open_count;
imux_portc portc[MAX_IMUX_DEV];
int fragsize;
int prev_fragment;
Mixer
int mixer_dev; int autoreset; /* Autoreset igain sliders to 100 during open */
Startup info
int imux_devices;
int imux_rate;
int imux_masterdev;
int instance_no;
}
imux_devc;
static imux_devc imux_info[MAX_IMUX_INSTANCES] = { {0} };
static int nimuxdevs = 0;
/*ARGSUSED*/
static int
imux_set_rate (int dev, int arg)
{
imux_devc *devc = audio_engines[dev]->devc;
return devc->hw_speed;
}
/*ARGSUSED*/
static short
imux_set_channels (int dev, short arg)
{
imux_portc *portc = audio_engines[dev]->portc;
return portc->channels = 2;
}
/*ARGSUSED*/
static unsigned int
imux_set_format (int dev, unsigned int arg)
{
imux_devc *devc = audio_engines[dev]->devc;
return devc->sw_fmt;
}
static int
imux_igain (int dev, int ctrl, unsigned int cmd, int value)
{
Access function for IMUX input gain
int left, right;
imux_devc *devc = mixer_devs[dev]->devc;
imux_portc *portc;
if (ctrl != 100 && (ctrl < 0 || ctrl >= devc->imux_devices))
return OSS_EINVAL;
portc = &devc->portc[ctrl];
if (cmd == SNDCTL_MIX_READ)
{
if (ctrl == 100)
return devc->autoreset;
return (portc->left_igain & 0x00ff) |
((portc->right_igain & 0x00ff) << 8);
}
if (cmd == SNDCTL_MIX_WRITE)
{
if (ctrl == 100)
return devc->autoreset = !!value;
left = value & 0x00ff;
right = (value >> 8) & 0x00ff;
if (left < 0)
left = 0;
if (left > 100)
left = 100;
if (right < 0)
right = 0;
if (right > 100)
right = 100;
portc->left_igain = left;
portc->right_igain = right;
return left | (right << 8);
}
return OSS_EINVAL;
}
static int
imux_ioctl (int dev, unsigned int cmd, ioctl_arg arg)
{
imux_devc *devc = audio_engines[dev]->devc;
imux_portc *portc = audio_engines[dev]->portc;
int value, i, n, p;
switch (cmd)
{
case SNDCTL_DSP_SET_RECSRC:
{
value = *arg;
if (value <= 0 || value >= devc->hw_channels - 1)
return OSS_EINVAL;
portc->ch_index = value;
}
case SNDCTL_DSP_GET_RECSRC:
return *arg = portc->ch_index;
break;
case SNDCTL_DSP_GET_RECSRC_NAMES:
{
oss_mixer_enuminfo *ei = (oss_mixer_enuminfo *) arg;
memset (ei, 0, sizeof (*ei));
n = ei->nvalues = devc->hw_channels - 1;
p = 0;
if (n <= 1) /* Only one alternative */
{
ei->nvalues = 1;
ei->strindex[0] = 0;
sprintf (ei->strings, "default");
}
else
/* Multiple alternatives */
for (i = 0; i < n; i++)
{
ei->strindex[i] = p;
sprintf (&ei->strings[p], "CH%d/%d", i + 1, i + 2);
p += strlen (&ei->strings[p]) + 1;
}
return 0;
}
break;
case SNDCTL_DSP_SETRECVOL:
value = *arg;
return *arg = imux_igain (audio_engines[dev]->mixer_dev,
portc->ch_index, SNDCTL_MIX_WRITE, value);
break;
case SNDCTL_DSP_GETRECVOL:
return *arg = imux_igain (audio_engines[dev]->mixer_dev,
portc->ch_index, SNDCTL_MIX_READ, 0);
break;
case SNDCTL_DSP_GETIPEAKS:
memset (arg, 0, sizeof (oss_peaks_t));
memcpy (arg, portc->peaks, sizeof (portc->peaks));
memset (portc->peaks, 0, sizeof (portc->peaks));
return 0;
break;
}
return OSS_EINVAL;
}
static void imux_trigger (int dev, int state);
static void
imux_reset (int dev)
{
imux_trigger (dev, 0);
}
/*ARGSUSED*/
static void
bufcpy16ne (imux_devc * devc, imux_portc * portc, unsigned char *tbuf,
unsigned char *buf, int nbytes, int frame_size, int hw_framesize)
{
int ns, i, hw_channels;
short *p1, *p2;
ns = nbytes / frame_size;
hw_channels = hw_framesize / sizeof (*p2);
p1 = (short *) tbuf;
p2 = (short *) (buf + portc->ch_index * frame_size / 2);
for (i = 0; i < ns; i++)
{
int v;
/* Left channel */
v = *p2++;
v = v * portc->left_igain / 100;
*p1++ = v;
if (v < 0)
v = -v;
if (v > portc->peaks[0])
portc->peaks[0] = v;
/* Right channel */
v = *p2++;
v = v * portc->right_igain / 100;
*p1++ = v;
if (v < 0)
v = -v;
if (v > portc->peaks[1])
portc->peaks[1] = v;
if (hw_channels > 2)
p2 += hw_channels - 2;
}
}
/*ARGSUSED*/
static void
bufcpy16oe (imux_devc * devc, imux_portc * portc, unsigned char *tbuf,
unsigned char *buf, int nbytes, int frame_size, int hw_framesize)
{
int ns, i, hw_channels;
short *p1, *p2;
ns = nbytes / frame_size;
hw_channels = hw_framesize / sizeof (*p2);
p1 = (short *) tbuf;
p2 = (short *) (buf + portc->ch_index * frame_size / 2);
for (i = 0; i < ns; i++)
{
int v;
/* Left channel */
v = *p2++;
v = ((v >> 8) & 0xff) | ((v & 0xff) << 8);
v = v * portc->left_igain / 100;
*p1++ = v;
if (v < 0)
v = -v;
if (v > portc->peaks[0])
portc->peaks[0] = v;
/* Right channel */
v = *p2++;
v = ((v >> 8) & 0xff) | ((v & 0xff) << 8);
v = v * portc->right_igain / 100;
*p1++ = v;
if (v < 0)
v = -v;
if (v > portc->peaks[1])
portc->peaks[1] = v;
if (hw_channels > 2)
p2 += hw_channels - 2;
}
}
/*ARGSUSED*/
static void
imux_callback (int dev, int parm)
{
dmap_t *dmap;
unsigned char *buf, *tbuf;
int i, len, frag, tail, next, n;
imux_devc *devc = NULL;
for (i = 0; i < nimuxdevs && devc == NULL; i++)
{
if (imux_info[i].hw_dev == dev)
devc = &imux_info[i];
}
if (devc == NULL)
{
cmn_err (CE_WARN, "IMUX error\n");
return;
}
dmap = audio_engines[dev]->dmap_in;
frag = dmap_get_qhead (dmap);
tail = dmap_get_qtail (dmap);
next = (frag + 1) % dmap->nfrags;
n = 0;
while (n++ < 2 && frag != tail && next != tail
&& devc->prev_fragment != frag)
{
devc->prev_fragment = frag;
buf = &dmap->dmabuf[frag * dmap->fragment_size];
len = dmap->fragment_size;
dmap->user_counter += dmap->fragment_size;
for (i = 0; i < devc->nr_devices; i++)
{
dmap_t *client_dmap;
imux_portc *portc = &devc->portc[i];
client_dmap = audio_engines[portc->audio_dev]->dmap_in;
if (!portc->is_opened || !portc->is_triggered)
continue;
if (client_dmap->fragment_size != (2 * len) / devc->hw_channels)
{
DDB (cmn_err (CE_WARN, "Fragment warning (%d, %d, %d-%d)\n",
client_dmap->fragment_size, len,
audio_engines[portc->audio_dev]->min_block,
audio_engines[portc->audio_dev]->max_block));
#if 1
/* Make automatic adjustments */
client_dmap->fragment_size = (2 * len) / devc->hw_channels;
client_dmap->nfrags =
client_dmap->buffsize / client_dmap->fragment_size;
client_dmap->bytes_in_use =
client_dmap->nfrags * client_dmap->fragment_size;
#else
continue;
#endif
}
tbuf =
&client_dmap->dmabuf[dmap_get_qtail (client_dmap) *
client_dmap->fragment_size];
if (devc->hw_fmt == AFMT_S16_NE) /* Native 16 bits */
{
bufcpy16ne (devc, portc, tbuf, buf,
client_dmap->fragment_size,
client_dmap->frame_size, dmap->frame_size);
}
else if (devc->hw_fmt == AFMT_S16_OE) /* Native 16 bits */
{
bufcpy16oe (devc, portc, tbuf, buf,
client_dmap->fragment_size,
client_dmap->frame_size, dmap->frame_size);
}
else
memcpy (tbuf, buf, len);
#ifdef DO_TIMINGS
oss_timing_printf ("Imux: copy f=%d/%d to ch=%d t=%d/%d", frag, tail,
i, dmap_get_qtail (client_dmap),
dmap_get_qhead (client_dmap));
#endif
oss_audio_inputintr (portc->audio_dev, 0);
}
frag = dmap_get_qhead (dmap);
tail = dmap_get_qtail (dmap);
next = (frag + 1) % dmap->nfrags;
}
}
static int
start_device (imux_devc * devc)
{
int i, err, dev, trig, nc;
/* int frags = 0x7fff0008; fragment size of 256 bytes */
if (devc->hw_dev < 0 || devc->hw_dev >= num_audio_engines)
{
devc->hw_dev = 0;
}
if (devc->hw_dev < 0 || devc->hw_dev >= num_audio_engines)
{
cmn_err (CE_WARN, "No audio hardware available\n");
return OSS_ENXIO;
}
if (devc->device_started)
{
return 1;
}
devc->finfo.mode = OPEN_READ;
devc->finfo.acc_flags = 0;
devc->prev_fragment = -1;
DDB (cmn_err (CE_NOTE,
"Instance %d: Will use audio device %d as the master\n",
devc->instance_no, devc->hw_dev));
if (devc->hw_dev >= devc->portc[0].audio_dev
&& devc->hw_dev <= devc->portc[devc->imux_devices - 1].audio_dev)
{
cmn_err (CE_WARN, "Bad master device %d\n", devc->hw_dev);
return OSS_ENXIO;
}
if (!(audio_engines[devc->hw_dev]->iformat_mask & SUPPORTED_FORMATS))
{
cmn_err (CE_CONT,
"Audio device %d doesn't support compatible sample formats.\n",
devc->hw_dev);
return OSS_EIO;
}
if ((err =
oss_audio_open_engine (devc->hw_dev, OSS_DEV_DSP, &devc->finfo, 1, 0,
NULL)) < 0)
{
return err;
}
audio_engines[devc->hw_dev]->cooked_enable = 0;
strcpy (audio_engines[devc->hw_dev]->cmd, "IMUX");
audio_engines[devc->hw_dev]->pid = 0;
devc->hw_fmt =
oss_audio_set_format (devc->hw_dev, devc->hw_fmt,
audio_engines[devc->hw_dev]->iformat_mask);
devc->device_started = 1;
devc->hw_channels = 2;
devc->hw_channels = devc->hw_channels =
oss_audio_set_channels (devc->hw_dev, devc->hw_channels);
TODO: Turn off OPT_SHADOW flag from the virtual devices if the master device works in multi channel mode.
devc->hw_speed = oss_audio_set_rate (devc->hw_dev, devc->hw_speed);
#if 0
oss_audio_ioctl (devc->hw_dev, NULL, SNDCTL_DSP_SETFRAGMENT,
(ioctl_arg) & frags);
#endif
oss_audio_ioctl (devc->hw_dev, NULL, SNDCTL_DSP_GETBLKSIZE,
(ioctl_arg) & devc->fragsize);
if (!(devc->hw_fmt & SUPPORTED_FORMATS))
{
oss_audio_release (devc->hw_dev, &devc->finfo);
cmn_err (CE_WARN,
"This device doesn't support any known sample formats (%x)\n",
devc->hw_fmt);
return OSS_EIO;
}
switch (devc->hw_fmt)
{
case AFMT_S16_NE:
devc->sw_fmt = AFMT_S16_NE;
break;
case AFMT_S16_OE:
devc->sw_fmt = AFMT_S16_NE;
break;
default:
cmn_err (CE_WARN, "Bad sample format %x\n", devc->hw_fmt);
}
nc = devc->hw_channels;
if (nc < 2)
{
oss_audio_release (devc->hw_dev, &devc->finfo);
cmn_err (CE_WARN, "A 2 channel soundcard (or better) is required\n");
return OSS_EIO;
}
DDB (cmn_err (CE_CONT, "Started audio device %d, s=%d, c=%d, bits=%d\n",
devc->hw_dev, devc->hw_speed, devc->hw_channels,
devc->hw_fmt));
trig = 0;
oss_audio_ioctl (devc->hw_dev, NULL, SNDCTL_DSP_SETTRIGGER,
(ioctl_arg) & trig);
trig = PCM_ENABLE_INPUT;
oss_audio_ioctl (devc->hw_dev, NULL, SNDCTL_DSP_SETTRIGGER,
(ioctl_arg) & trig);
devc->hw_fragsize = audio_engines[devc->hw_dev]->dmap_out->fragment_size;
for (i = 0; i < devc->nr_devices; i++)
{
int bz = (2 * devc->hw_fragsize) / devc->hw_channels;
dev = devc->portc[i].audio_dev;
audio_engines[dev]->fixed_rate = devc->hw_speed;
audio_engines[dev]->min_block = bz;
audio_engines[dev]->max_block = bz;
}
audio_engines[devc->hw_dev]->dmap_in->audio_callback = imux_callback;
return 1;
}
static void
stop_device (imux_devc * devc)
{
if (!devc->device_started)
return;
oss_audio_ioctl (devc->hw_dev, NULL, SNDCTL_DSP_HALT, 0);
oss_audio_release (devc->hw_dev, &devc->finfo);
audio_engines[devc->hw_dev]->pid = -1;
memset (audio_engines[devc->hw_dev]->cmd, 0,
sizeof (audio_engines[devc->hw_dev]->cmd));
audio_engines[devc->hw_dev]->flags &= ~ADEV_NOSRC;
devc->device_started = 0;
}
/*ARGSUSED*/
static int
imux_open (int dev, int mode, int open_flags)
{
imux_portc *portc = audio_engines[dev]->portc;
imux_devc *devc = audio_engines[dev]->devc;
oss_native_word flags;
int bz, err;
if (devc->hw_dev < 0)
{
cmn_err (CE_NOTE, "No master device allocated\n");
return OSS_EIO;
}
MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
if (portc->is_opened)
{
MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
return OSS_EBUSY;
}
portc->is_opened = 1;
portc->is_prepared = 0;
portc->is_triggered = 0;
portc->channels = 2;
portc->ch_index = 0;
memset (portc->peaks, 0, sizeof (portc->peaks));
portc->fmt = AFMT_S16_NE;
audio_engines[dev]->rate_source = audio_engines[devc->hw_dev]->rate_source;
MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
if (!devc->device_started)
if ((err = start_device (devc)) < 0)
{
portc->is_opened = 0;
return err;
}
bz = (2 * devc->hw_fragsize) / devc->hw_channels;
audio_engines[dev]->min_block = audio_engines[dev]->max_block = bz;
portc->ch_index = portc->port_number % (devc->hw_channels / 2);
portc->speed = devc->hw_speed;
if (devc->autoreset)
{
portc->left_igain = 100;
portc->right_igain = 100;
mixer_devs[devc->mixer_dev]->modify_counter++;
}
MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
devc->open_count++;
MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
return 0;
}
/*ARGSUSED*/
static void
imux_close (int dev, int mode)
{
imux_portc *portc = audio_engines[dev]->portc;
imux_devc *devc = audio_engines[dev]->devc;
oss_native_word flags;
int count;
MUTEX_ENTER_IRQDISABLE (devc->mutex, flags);
portc->is_triggered = 0;
count = --devc->open_count;
/* MUTEX_EXIT_IRQRESTORE (devc->mutex, flags); */
if (count == 0) /* Last one? */
stop_device (devc);
/* MUTEX_ENTER_IRQDISABLE (devc->mutex, flags); */
portc->is_opened = 0;
MUTEX_EXIT_IRQRESTORE (devc->mutex, flags);
}
/*ARGSUSED*/
static void
imux_output_block (int dev, oss_native_word buf, int count, int fragsize,
int intrflag)
{
}
/*ARGSUSED*/
static void
imux_start_input (int dev, oss_native_word buf, int count, int fragsize,
int intrflag)
{
}
static void
imux_trigger (int dev, int state)
{
imux_portc *portc = audio_engines[dev]->portc;
if (state & PCM_ENABLE_INPUT)
portc->is_triggered = 1;
else
portc->is_triggered = 0;
}
/*ARGSUSED*/
static int
imux_prepare_for_input (int dev, int bsize, int bcount)
{
return 0;
}
/*ARGSUSED*/
static int
imux_prepare_for_output (int dev, int bsize, int bcount)
{
return OSS_EIO;
}
/*ARGSUSED*/
static int
imux_alloc_buffer (int dev, dmap_t * dmap, int direction)
{
#define MY_BUFFSIZE (64*1024)
if (dmap->dmabuf != NULL)
return 0;
dmap->dmabuf_phys = 0; /* Not mmap() capable */
dmap->dmabuf = KERNEL_MALLOC (MY_BUFFSIZE);
if (dmap->dmabuf == NULL)
return OSS_ENOSPC;
dmap->buffsize = MY_BUFFSIZE;
return 0;
}
/*ARGSUSED*/
static int
imux_free_buffer (int dev, dmap_t * dmap, int direction)
{
if (dmap->dmabuf == NULL)
return 0;
KERNEL_FREE (dmap->dmabuf);
dmap->dmabuf = NULL;
return 0;
}
#if 0
static int
imux_get_buffer_pointer (int dev, dmap_t * dmap, int direction)
{
}
#endif
static audiodrv_t imux_driver = {
imux_open,
imux_close,
imux_output_block,
imux_start_input,
imux_ioctl,
imux_prepare_for_input,
imux_prepare_for_output,
imux_reset,
NULL,
NULL,
NULL,
NULL,
imux_trigger,
imux_set_rate,
imux_set_format,
imux_set_channels,
NULL,
NULL,
NULL,
NULL,
imux_alloc_buffer,
imux_free_buffer,
NULL,
NULL,
NULL /* imux_get_buffer_pointer */
};
/*ARGSUSED*/
static int
imux_mixer_ioctl (int dev, int audiodev, unsigned int cmd, ioctl_arg arg)
{
return OSS_EINVAL;
}
static mixer_driver_t imux_mixer_driver = {
imux_mixer_ioctl
};
static const unsigned char peak_cnv[256] = {
0, 18, 29, 36, 42, 47, 51, 54, 57, 60, 62, 65, 67, 69, 71, 72,
74, 75, 77, 78, 79, 81, 82, 83, 84, 85, 86, 87, 88, 89, 89, 90,
91, 92, 93, 93, 94, 95, 95, 96, 97, 97, 98, 99, 99, 100, 100, 101,
101, 102, 102, 103, 103, 104, 104, 105, 105, 106, 106, 107, 107, 108, 108,
108,
109, 109, 110, 110, 110, 111, 111, 111, 112, 112, 113, 113, 113, 114, 114,
114,
115, 115, 115, 115, 116, 116, 116, 117, 117, 117, 118, 118, 118, 118, 119,
119,
119, 119, 120, 120, 120, 121, 121, 121, 121, 122, 122, 122, 122, 122, 123,
123,
123, 123, 124, 124, 124, 124, 125, 125, 125, 125, 125, 126, 126, 126, 126,
126,
127, 127, 127, 127, 127, 128, 128, 128, 128, 128, 129, 129, 129, 129, 129,
130,
130, 130, 130, 130, 130, 131, 131, 131, 131, 131, 131, 132, 132, 132, 132,
132,
132, 133, 133, 133, 133, 133, 133, 134, 134, 134, 134, 134, 134, 134, 135,
135,
135, 135, 135, 135, 135, 136, 136, 136, 136, 136, 136, 136, 137, 137, 137,
137,
137, 137, 137, 138, 138, 138, 138, 138, 138, 138, 138, 139, 139, 139, 139,
139,
139, 139, 139, 140, 140, 140, 140, 140, 140, 140, 140, 141, 141, 141, 141,
141,
141, 141, 141, 141, 142, 142, 142, 142, 142, 142, 142, 142, 142, 143, 143,
143,
143, 143, 143, 143, 143, 143, 144, 144, 144, 144, 144, 144, 144, 144, 144,
144,
};
/*ARGSUSED*/
static int
imux_vu (int dev, int ctrl, unsigned int cmd, int value)
{
Access function for PCM VU meters
int left, right;
imux_devc *devc = mixer_devs[dev]->devc;
if (ctrl < 0 || ctrl >= devc->imux_devices)
return OSS_EINVAL;
if (cmd == SNDCTL_MIX_READ)
{
imux_portc *portc = &devc->portc[ctrl];
left = peak_cnv[(portc->peaks[0] * 144) / 32768];
right = peak_cnv[(portc->peaks[1] * 144) / 32768];
memset (portc->peaks, 0, sizeof (portc->peaks));
return left | (right << 8);
}
return OSS_EINVAL;
}
static int
imux_mix_init (int dev)
{
int group;
imux_devc *devc = mixer_devs[dev]->devc;
int i;
int err;
if ((group = mixer_ext_create_group (dev, 0, "CLIENT")) < 0)
return group;
for (i = 0; i < devc->imux_devices; i++)
{
char tmp[32];
sprintf (tmp, "@pcm%d", devc->portc[i].audio_dev);
if ((err = mixer_ext_create_control (dev, group, i, imux_igain,
MIXT_STEREOSLIDER,
tmp, 100,
MIXF_READABLE | MIXF_WRITEABLE)) <
0)
return err;
if ((err = mixer_ext_create_control (dev, group, i, imux_vu,
MIXT_STEREOPEAK,
"-", 144, MIXF_READABLE)) < 0)
return err;
}
if ((err = mixer_ext_create_control (dev, group, 100, imux_igain,
MIXT_ONOFF,
"autoreset", 2,
MIXF_READABLE | MIXF_WRITEABLE)) < 0)
return err;
return 0;
}
static int
find_master_device (imux_devc * devc)
{
Find a suitable master device.
Return 1 if found and 0 if not.
int dev;
adev_p adev;
if (num_audio_devfiles < 1)
return 0;
if (devc->imux_masterdev >= 0)
{
imux_masterdev property was given. Use the given /dev/dsp# number as the master device.
if (devc->imux_masterdev >= num_audio_devfiles)
return 0; /* Device not attached yet */
devc->hw_dev = audio_devfiles[devc->imux_masterdev]->engine_num;
adev = audio_engines[devc->hw_dev];
if (adev->flags & (ADEV_NOINPUT))
{
cmn_err (CE_NOTE,
"Audio device %d cannot be used as an IMUX master device\n",
devc->imux_masterdev);
devc->hw_dev = -1;
return 0;
}
devc->hw_dev = adev->engine_num;
/* TODO: Prevent the other virtual drivers from picking this one */
}
else
{
Try to find if some of the devices currently available is suitable master device.
devc->hw_dev = -1;
for (dev = 0; dev < num_audio_engines; dev++)
{
adev = audio_engines[dev];
if (adev->flags & ADEV_NOINPUT)
continue;
if (used_masterdevs & (1LL << dev))
continue;
devc->hw_dev = adev->engine_num;
break;
}
}
return (devc->hw_dev >= 0);
}
static int
try_to_start (void *dc)
{
int n, adev, opts;
char tmp[32];
imux_devc *devc = dc;
int my_mixer;
if (!find_master_device (devc))
return 0;
If the situation is hopeless then just tell the caller to stop trying this operation.
if (devc->hw_dev < 0)
return 1;
if (used_masterdevs & (1LL << devc->hw_dev))
{
devc->hw_dev = -1;
cmn_err (CE_WARN,
"Selected master device % for IMUX instance %d already used for some other instance\n",
devc->osdev->instance, devc->hw_dev);
return 1;
}
used_masterdevs |= (1LL << devc->hw_dev);
opts =
ADEV_STEREOONLY | ADEV_16BITONLY | ADEV_VIRTUAL | ADEV_NOOUTPUT |
ADEV_FIXEDRATE | ADEV_NOMMAP;
devc->nr_devices = 0;
devc->open_count = 0;
devc->hw_speed = devc->imux_rate;
devc->master_osdev = audio_engines[devc->hw_dev]->osdev;
devc->installed_ok = 1;
devc->autoreset = 1;
MUTEX_INIT (devc->master_osdev, devc->mutex, MH_DRV + 4);
if ((my_mixer = oss_install_mixer (OSS_MIXER_DRIVER_VERSION,
devc->osdev,
devc->master_osdev,
"IMUX Control panel",
&imux_mixer_driver,
sizeof (mixer_driver_t), devc)) >= 0)
{
mixer_ext_set_init_fn (my_mixer, imux_mix_init, 32);
}
else
my_mixer = -1;
devc->mixer_dev = my_mixer;
for (n = 0; n < devc->imux_devices; n++)
{
imux_portc *portc;
if (n > 0)
opts |= ADEV_SHADOW;
sprintf (tmp, "IMux%d audio record", devc->instance_no);
if ((adev = oss_install_audiodev (OSS_AUDIO_DRIVER_VERSION,
devc->osdev,
devc->master_osdev,
tmp,
&imux_driver,
sizeof (audiodrv_t),
opts, AFMT_S16_NE, devc, -1)) < 0)
{
return 1;
}
portc = &devc->portc[n];
audio_engines[adev]->portc = portc;
audio_engines[adev]->mixer_dev = my_mixer;
audio_engines[adev]->min_rate = 5000;
audio_engines[adev]->max_rate = 192000;
portc->left_igain = 100;
portc->right_igain = 100;
portc->audio_dev = adev;
portc->is_opened = 0;
portc->is_prepared = 0;
portc->is_triggered = 0;
portc->speed = 48000;
portc->channels = 2;
portc->fmt = AFMT_S16_NE;
portc->port_number = n;
devc->nr_devices = n + 1;
}
return 1;
}
int
oss_imux_attach (oss_device_t * osdev)
{
extern int imux_devices;
extern int imux_masterdev;
extern int imux_rate;
imux_devc *devc;
if (imux_devices < 2)
imux_devices = 2;
if (imux_devices > MAX_IMUX_DEV)
imux_devices = MAX_IMUX_DEV;
if (nimuxdevs >= MAX_IMUX_INSTANCES)
{
cmn_err (CE_NOTE, "Only %d instances permitted\n", MAX_IMUX_INSTANCES);
return 0;
}
devc = &imux_info[nimuxdevs++];
devc->osdev = osdev;
osdev->devc = devc;
devc->master_osdev = NULL;
devc->instance_no = osdev->instance;
devc->imux_devices = imux_devices;
devc->imux_rate = imux_rate;
devc->imux_masterdev = imux_masterdev;
imux_masterdev = -1;
devc->hw_dev = -1;
devc->sw_fmt = AFMT_S16_NE;
oss_register_device (osdev, "OSS IMUX driver");
if (!try_to_start (devc))
{
oss_audio_register_client (try_to_start, devc, devc->osdev);
}
return 1;
}
int
oss_imux_detach (oss_device_t * osdev)
{
imux_devc *devc = osdev->devc;
if (oss_disable_device (osdev) < 0)
return 0;
if (devc->installed_ok)
{
MUTEX_CLEANUP (devc->mutex);
}
oss_unregister_device (devc->osdev);
return 1;
}