![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or at your option any later version this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details you should have received a copy of the gnu general public license along with this program if not write to the free software foundation inc 59 temple place suite 330 boston ma 02111 1307 usa extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 1334 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Richard Fontana <rfontana@redhat.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070033.113240726@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
1266 lines
35 KiB
C
1266 lines
35 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Loopback soundcard
|
|
*
|
|
* Original code:
|
|
* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
|
|
*
|
|
* More accurate positioning and full-duplex support:
|
|
* Copyright (c) Ahmet İnan <ainan at mathematik.uni-freiburg.de>
|
|
*
|
|
* Major (almost complete) rewrite:
|
|
* Copyright (c) by Takashi Iwai <tiwai@suse.de>
|
|
*
|
|
* A next major update in 2010 (separate timers for playback and capture):
|
|
* Copyright (c) Jaroslav Kysela <perex@perex.cz>
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/time.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <sound/core.h>
|
|
#include <sound/control.h>
|
|
#include <sound/pcm.h>
|
|
#include <sound/pcm_params.h>
|
|
#include <sound/info.h>
|
|
#include <sound/initval.h>
|
|
|
|
MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
|
|
MODULE_DESCRIPTION("A loopback soundcard");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_SUPPORTED_DEVICE("{{ALSA,Loopback soundcard}}");
|
|
|
|
#define MAX_PCM_SUBSTREAMS 8
|
|
|
|
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
|
|
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
|
|
static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
|
|
static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8};
|
|
static int pcm_notify[SNDRV_CARDS];
|
|
|
|
module_param_array(index, int, NULL, 0444);
|
|
MODULE_PARM_DESC(index, "Index value for loopback soundcard.");
|
|
module_param_array(id, charp, NULL, 0444);
|
|
MODULE_PARM_DESC(id, "ID string for loopback soundcard.");
|
|
module_param_array(enable, bool, NULL, 0444);
|
|
MODULE_PARM_DESC(enable, "Enable this loopback soundcard.");
|
|
module_param_array(pcm_substreams, int, NULL, 0444);
|
|
MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-8) for loopback driver.");
|
|
module_param_array(pcm_notify, int, NULL, 0444);
|
|
MODULE_PARM_DESC(pcm_notify, "Break capture when PCM format/rate/channels changes.");
|
|
|
|
#define NO_PITCH 100000
|
|
|
|
struct loopback_pcm;
|
|
|
|
struct loopback_cable {
|
|
spinlock_t lock;
|
|
struct loopback_pcm *streams[2];
|
|
struct snd_pcm_hardware hw;
|
|
/* flags */
|
|
unsigned int valid;
|
|
unsigned int running;
|
|
unsigned int pause;
|
|
};
|
|
|
|
struct loopback_setup {
|
|
unsigned int notify: 1;
|
|
unsigned int rate_shift;
|
|
unsigned int format;
|
|
unsigned int rate;
|
|
unsigned int channels;
|
|
struct snd_ctl_elem_id active_id;
|
|
struct snd_ctl_elem_id format_id;
|
|
struct snd_ctl_elem_id rate_id;
|
|
struct snd_ctl_elem_id channels_id;
|
|
};
|
|
|
|
struct loopback {
|
|
struct snd_card *card;
|
|
struct mutex cable_lock;
|
|
struct loopback_cable *cables[MAX_PCM_SUBSTREAMS][2];
|
|
struct snd_pcm *pcm[2];
|
|
struct loopback_setup setup[MAX_PCM_SUBSTREAMS][2];
|
|
};
|
|
|
|
struct loopback_pcm {
|
|
struct loopback *loopback;
|
|
struct snd_pcm_substream *substream;
|
|
struct loopback_cable *cable;
|
|
unsigned int pcm_buffer_size;
|
|
unsigned int buf_pos; /* position in buffer */
|
|
unsigned int silent_size;
|
|
/* PCM parameters */
|
|
unsigned int pcm_period_size;
|
|
unsigned int pcm_bps; /* bytes per second */
|
|
unsigned int pcm_salign; /* bytes per sample * channels */
|
|
unsigned int pcm_rate_shift; /* rate shift value */
|
|
/* flags */
|
|
unsigned int period_update_pending :1;
|
|
/* timer stuff */
|
|
unsigned int irq_pos; /* fractional IRQ position */
|
|
unsigned int period_size_frac;
|
|
unsigned int last_drift;
|
|
unsigned long last_jiffies;
|
|
struct timer_list timer;
|
|
};
|
|
|
|
static struct platform_device *devices[SNDRV_CARDS];
|
|
|
|
static inline unsigned int byte_pos(struct loopback_pcm *dpcm, unsigned int x)
|
|
{
|
|
if (dpcm->pcm_rate_shift == NO_PITCH) {
|
|
x /= HZ;
|
|
} else {
|
|
x = div_u64(NO_PITCH * (unsigned long long)x,
|
|
HZ * (unsigned long long)dpcm->pcm_rate_shift);
|
|
}
|
|
return x - (x % dpcm->pcm_salign);
|
|
}
|
|
|
|
static inline unsigned int frac_pos(struct loopback_pcm *dpcm, unsigned int x)
|
|
{
|
|
if (dpcm->pcm_rate_shift == NO_PITCH) { /* no pitch */
|
|
return x * HZ;
|
|
} else {
|
|
x = div_u64(dpcm->pcm_rate_shift * (unsigned long long)x * HZ,
|
|
NO_PITCH);
|
|
}
|
|
return x;
|
|
}
|
|
|
|
static inline struct loopback_setup *get_setup(struct loopback_pcm *dpcm)
|
|
{
|
|
int device = dpcm->substream->pstr->pcm->device;
|
|
|
|
if (dpcm->substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
|
|
device ^= 1;
|
|
return &dpcm->loopback->setup[dpcm->substream->number][device];
|
|
}
|
|
|
|
static inline unsigned int get_notify(struct loopback_pcm *dpcm)
|
|
{
|
|
return get_setup(dpcm)->notify;
|
|
}
|
|
|
|
static inline unsigned int get_rate_shift(struct loopback_pcm *dpcm)
|
|
{
|
|
return get_setup(dpcm)->rate_shift;
|
|
}
|
|
|
|
/* call in cable->lock */
|
|
static void loopback_timer_start(struct loopback_pcm *dpcm)
|
|
{
|
|
unsigned long tick;
|
|
unsigned int rate_shift = get_rate_shift(dpcm);
|
|
|
|
if (rate_shift != dpcm->pcm_rate_shift) {
|
|
dpcm->pcm_rate_shift = rate_shift;
|
|
dpcm->period_size_frac = frac_pos(dpcm, dpcm->pcm_period_size);
|
|
}
|
|
if (dpcm->period_size_frac <= dpcm->irq_pos) {
|
|
dpcm->irq_pos %= dpcm->period_size_frac;
|
|
dpcm->period_update_pending = 1;
|
|
}
|
|
tick = dpcm->period_size_frac - dpcm->irq_pos;
|
|
tick = (tick + dpcm->pcm_bps - 1) / dpcm->pcm_bps;
|
|
mod_timer(&dpcm->timer, jiffies + tick);
|
|
}
|
|
|
|
/* call in cable->lock */
|
|
static inline void loopback_timer_stop(struct loopback_pcm *dpcm)
|
|
{
|
|
del_timer(&dpcm->timer);
|
|
dpcm->timer.expires = 0;
|
|
}
|
|
|
|
static inline void loopback_timer_stop_sync(struct loopback_pcm *dpcm)
|
|
{
|
|
del_timer_sync(&dpcm->timer);
|
|
}
|
|
|
|
#define CABLE_VALID_PLAYBACK (1 << SNDRV_PCM_STREAM_PLAYBACK)
|
|
#define CABLE_VALID_CAPTURE (1 << SNDRV_PCM_STREAM_CAPTURE)
|
|
#define CABLE_VALID_BOTH (CABLE_VALID_PLAYBACK|CABLE_VALID_CAPTURE)
|
|
|
|
static int loopback_check_format(struct loopback_cable *cable, int stream)
|
|
{
|
|
struct snd_pcm_runtime *runtime, *cruntime;
|
|
struct loopback_setup *setup;
|
|
struct snd_card *card;
|
|
int check;
|
|
|
|
if (cable->valid != CABLE_VALID_BOTH) {
|
|
if (stream == SNDRV_PCM_STREAM_PLAYBACK)
|
|
goto __notify;
|
|
return 0;
|
|
}
|
|
runtime = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]->
|
|
substream->runtime;
|
|
cruntime = cable->streams[SNDRV_PCM_STREAM_CAPTURE]->
|
|
substream->runtime;
|
|
check = runtime->format != cruntime->format ||
|
|
runtime->rate != cruntime->rate ||
|
|
runtime->channels != cruntime->channels;
|
|
if (!check)
|
|
return 0;
|
|
if (stream == SNDRV_PCM_STREAM_CAPTURE) {
|
|
return -EIO;
|
|
} else {
|
|
snd_pcm_stop(cable->streams[SNDRV_PCM_STREAM_CAPTURE]->
|
|
substream, SNDRV_PCM_STATE_DRAINING);
|
|
__notify:
|
|
runtime = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]->
|
|
substream->runtime;
|
|
setup = get_setup(cable->streams[SNDRV_PCM_STREAM_PLAYBACK]);
|
|
card = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]->loopback->card;
|
|
if (setup->format != runtime->format) {
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
|
&setup->format_id);
|
|
setup->format = runtime->format;
|
|
}
|
|
if (setup->rate != runtime->rate) {
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
|
&setup->rate_id);
|
|
setup->rate = runtime->rate;
|
|
}
|
|
if (setup->channels != runtime->channels) {
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
|
&setup->channels_id);
|
|
setup->channels = runtime->channels;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void loopback_active_notify(struct loopback_pcm *dpcm)
|
|
{
|
|
snd_ctl_notify(dpcm->loopback->card,
|
|
SNDRV_CTL_EVENT_MASK_VALUE,
|
|
&get_setup(dpcm)->active_id);
|
|
}
|
|
|
|
static int loopback_trigger(struct snd_pcm_substream *substream, int cmd)
|
|
{
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
struct loopback_pcm *dpcm = runtime->private_data;
|
|
struct loopback_cable *cable = dpcm->cable;
|
|
int err, stream = 1 << substream->stream;
|
|
|
|
switch (cmd) {
|
|
case SNDRV_PCM_TRIGGER_START:
|
|
err = loopback_check_format(cable, substream->stream);
|
|
if (err < 0)
|
|
return err;
|
|
dpcm->last_jiffies = jiffies;
|
|
dpcm->pcm_rate_shift = 0;
|
|
dpcm->last_drift = 0;
|
|
spin_lock(&cable->lock);
|
|
cable->running |= stream;
|
|
cable->pause &= ~stream;
|
|
loopback_timer_start(dpcm);
|
|
spin_unlock(&cable->lock);
|
|
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
|
|
loopback_active_notify(dpcm);
|
|
break;
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
spin_lock(&cable->lock);
|
|
cable->running &= ~stream;
|
|
cable->pause &= ~stream;
|
|
loopback_timer_stop(dpcm);
|
|
spin_unlock(&cable->lock);
|
|
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
|
|
loopback_active_notify(dpcm);
|
|
break;
|
|
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
|
|
case SNDRV_PCM_TRIGGER_SUSPEND:
|
|
spin_lock(&cable->lock);
|
|
cable->pause |= stream;
|
|
loopback_timer_stop(dpcm);
|
|
spin_unlock(&cable->lock);
|
|
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
|
|
loopback_active_notify(dpcm);
|
|
break;
|
|
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
|
|
case SNDRV_PCM_TRIGGER_RESUME:
|
|
spin_lock(&cable->lock);
|
|
dpcm->last_jiffies = jiffies;
|
|
cable->pause &= ~stream;
|
|
loopback_timer_start(dpcm);
|
|
spin_unlock(&cable->lock);
|
|
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
|
|
loopback_active_notify(dpcm);
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void params_change(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
struct loopback_pcm *dpcm = runtime->private_data;
|
|
struct loopback_cable *cable = dpcm->cable;
|
|
|
|
cable->hw.formats = pcm_format_to_bits(runtime->format);
|
|
cable->hw.rate_min = runtime->rate;
|
|
cable->hw.rate_max = runtime->rate;
|
|
cable->hw.channels_min = runtime->channels;
|
|
cable->hw.channels_max = runtime->channels;
|
|
}
|
|
|
|
static int loopback_prepare(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
struct loopback_pcm *dpcm = runtime->private_data;
|
|
struct loopback_cable *cable = dpcm->cable;
|
|
int bps, salign;
|
|
|
|
loopback_timer_stop_sync(dpcm);
|
|
|
|
salign = (snd_pcm_format_physical_width(runtime->format) *
|
|
runtime->channels) / 8;
|
|
bps = salign * runtime->rate;
|
|
if (bps <= 0 || salign <= 0)
|
|
return -EINVAL;
|
|
|
|
dpcm->buf_pos = 0;
|
|
dpcm->pcm_buffer_size = frames_to_bytes(runtime, runtime->buffer_size);
|
|
if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
|
|
/* clear capture buffer */
|
|
dpcm->silent_size = dpcm->pcm_buffer_size;
|
|
snd_pcm_format_set_silence(runtime->format, runtime->dma_area,
|
|
runtime->buffer_size * runtime->channels);
|
|
}
|
|
|
|
dpcm->irq_pos = 0;
|
|
dpcm->period_update_pending = 0;
|
|
dpcm->pcm_bps = bps;
|
|
dpcm->pcm_salign = salign;
|
|
dpcm->pcm_period_size = frames_to_bytes(runtime, runtime->period_size);
|
|
|
|
mutex_lock(&dpcm->loopback->cable_lock);
|
|
if (!(cable->valid & ~(1 << substream->stream)) ||
|
|
(get_setup(dpcm)->notify &&
|
|
substream->stream == SNDRV_PCM_STREAM_PLAYBACK))
|
|
params_change(substream);
|
|
cable->valid |= 1 << substream->stream;
|
|
mutex_unlock(&dpcm->loopback->cable_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void clear_capture_buf(struct loopback_pcm *dpcm, unsigned int bytes)
|
|
{
|
|
struct snd_pcm_runtime *runtime = dpcm->substream->runtime;
|
|
char *dst = runtime->dma_area;
|
|
unsigned int dst_off = dpcm->buf_pos;
|
|
|
|
if (dpcm->silent_size >= dpcm->pcm_buffer_size)
|
|
return;
|
|
if (dpcm->silent_size + bytes > dpcm->pcm_buffer_size)
|
|
bytes = dpcm->pcm_buffer_size - dpcm->silent_size;
|
|
|
|
for (;;) {
|
|
unsigned int size = bytes;
|
|
if (dst_off + size > dpcm->pcm_buffer_size)
|
|
size = dpcm->pcm_buffer_size - dst_off;
|
|
snd_pcm_format_set_silence(runtime->format, dst + dst_off,
|
|
bytes_to_frames(runtime, size) *
|
|
runtime->channels);
|
|
dpcm->silent_size += size;
|
|
bytes -= size;
|
|
if (!bytes)
|
|
break;
|
|
dst_off = 0;
|
|
}
|
|
}
|
|
|
|
static void copy_play_buf(struct loopback_pcm *play,
|
|
struct loopback_pcm *capt,
|
|
unsigned int bytes)
|
|
{
|
|
struct snd_pcm_runtime *runtime = play->substream->runtime;
|
|
char *src = runtime->dma_area;
|
|
char *dst = capt->substream->runtime->dma_area;
|
|
unsigned int src_off = play->buf_pos;
|
|
unsigned int dst_off = capt->buf_pos;
|
|
unsigned int clear_bytes = 0;
|
|
|
|
/* check if playback is draining, trim the capture copy size
|
|
* when our pointer is at the end of playback ring buffer */
|
|
if (runtime->status->state == SNDRV_PCM_STATE_DRAINING &&
|
|
snd_pcm_playback_hw_avail(runtime) < runtime->buffer_size) {
|
|
snd_pcm_uframes_t appl_ptr, appl_ptr1, diff;
|
|
appl_ptr = appl_ptr1 = runtime->control->appl_ptr;
|
|
appl_ptr1 -= appl_ptr1 % runtime->buffer_size;
|
|
appl_ptr1 += play->buf_pos / play->pcm_salign;
|
|
if (appl_ptr < appl_ptr1)
|
|
appl_ptr1 -= runtime->buffer_size;
|
|
diff = (appl_ptr - appl_ptr1) * play->pcm_salign;
|
|
if (diff < bytes) {
|
|
clear_bytes = bytes - diff;
|
|
bytes = diff;
|
|
}
|
|
}
|
|
|
|
for (;;) {
|
|
unsigned int size = bytes;
|
|
if (src_off + size > play->pcm_buffer_size)
|
|
size = play->pcm_buffer_size - src_off;
|
|
if (dst_off + size > capt->pcm_buffer_size)
|
|
size = capt->pcm_buffer_size - dst_off;
|
|
memcpy(dst + dst_off, src + src_off, size);
|
|
capt->silent_size = 0;
|
|
bytes -= size;
|
|
if (!bytes)
|
|
break;
|
|
src_off = (src_off + size) % play->pcm_buffer_size;
|
|
dst_off = (dst_off + size) % capt->pcm_buffer_size;
|
|
}
|
|
|
|
if (clear_bytes > 0) {
|
|
clear_capture_buf(capt, clear_bytes);
|
|
capt->silent_size = 0;
|
|
}
|
|
}
|
|
|
|
static inline unsigned int bytepos_delta(struct loopback_pcm *dpcm,
|
|
unsigned int jiffies_delta)
|
|
{
|
|
unsigned long last_pos;
|
|
unsigned int delta;
|
|
|
|
last_pos = byte_pos(dpcm, dpcm->irq_pos);
|
|
dpcm->irq_pos += jiffies_delta * dpcm->pcm_bps;
|
|
delta = byte_pos(dpcm, dpcm->irq_pos) - last_pos;
|
|
if (delta >= dpcm->last_drift)
|
|
delta -= dpcm->last_drift;
|
|
dpcm->last_drift = 0;
|
|
if (dpcm->irq_pos >= dpcm->period_size_frac) {
|
|
dpcm->irq_pos %= dpcm->period_size_frac;
|
|
dpcm->period_update_pending = 1;
|
|
}
|
|
return delta;
|
|
}
|
|
|
|
static inline void bytepos_finish(struct loopback_pcm *dpcm,
|
|
unsigned int delta)
|
|
{
|
|
dpcm->buf_pos += delta;
|
|
dpcm->buf_pos %= dpcm->pcm_buffer_size;
|
|
}
|
|
|
|
/* call in cable->lock */
|
|
static unsigned int loopback_pos_update(struct loopback_cable *cable)
|
|
{
|
|
struct loopback_pcm *dpcm_play =
|
|
cable->streams[SNDRV_PCM_STREAM_PLAYBACK];
|
|
struct loopback_pcm *dpcm_capt =
|
|
cable->streams[SNDRV_PCM_STREAM_CAPTURE];
|
|
unsigned long delta_play = 0, delta_capt = 0;
|
|
unsigned int running, count1, count2;
|
|
|
|
running = cable->running ^ cable->pause;
|
|
if (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) {
|
|
delta_play = jiffies - dpcm_play->last_jiffies;
|
|
dpcm_play->last_jiffies += delta_play;
|
|
}
|
|
|
|
if (running & (1 << SNDRV_PCM_STREAM_CAPTURE)) {
|
|
delta_capt = jiffies - dpcm_capt->last_jiffies;
|
|
dpcm_capt->last_jiffies += delta_capt;
|
|
}
|
|
|
|
if (delta_play == 0 && delta_capt == 0)
|
|
goto unlock;
|
|
|
|
if (delta_play > delta_capt) {
|
|
count1 = bytepos_delta(dpcm_play, delta_play - delta_capt);
|
|
bytepos_finish(dpcm_play, count1);
|
|
delta_play = delta_capt;
|
|
} else if (delta_play < delta_capt) {
|
|
count1 = bytepos_delta(dpcm_capt, delta_capt - delta_play);
|
|
clear_capture_buf(dpcm_capt, count1);
|
|
bytepos_finish(dpcm_capt, count1);
|
|
delta_capt = delta_play;
|
|
}
|
|
|
|
if (delta_play == 0 && delta_capt == 0)
|
|
goto unlock;
|
|
|
|
/* note delta_capt == delta_play at this moment */
|
|
count1 = bytepos_delta(dpcm_play, delta_play);
|
|
count2 = bytepos_delta(dpcm_capt, delta_capt);
|
|
if (count1 < count2) {
|
|
dpcm_capt->last_drift = count2 - count1;
|
|
count1 = count2;
|
|
} else if (count1 > count2) {
|
|
dpcm_play->last_drift = count1 - count2;
|
|
}
|
|
copy_play_buf(dpcm_play, dpcm_capt, count1);
|
|
bytepos_finish(dpcm_play, count1);
|
|
bytepos_finish(dpcm_capt, count1);
|
|
unlock:
|
|
return running;
|
|
}
|
|
|
|
static void loopback_timer_function(struct timer_list *t)
|
|
{
|
|
struct loopback_pcm *dpcm = from_timer(dpcm, t, timer);
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&dpcm->cable->lock, flags);
|
|
if (loopback_pos_update(dpcm->cable) & (1 << dpcm->substream->stream)) {
|
|
loopback_timer_start(dpcm);
|
|
if (dpcm->period_update_pending) {
|
|
dpcm->period_update_pending = 0;
|
|
spin_unlock_irqrestore(&dpcm->cable->lock, flags);
|
|
/* need to unlock before calling below */
|
|
snd_pcm_period_elapsed(dpcm->substream);
|
|
return;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&dpcm->cable->lock, flags);
|
|
}
|
|
|
|
static snd_pcm_uframes_t loopback_pointer(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
struct loopback_pcm *dpcm = runtime->private_data;
|
|
snd_pcm_uframes_t pos;
|
|
|
|
spin_lock(&dpcm->cable->lock);
|
|
loopback_pos_update(dpcm->cable);
|
|
pos = dpcm->buf_pos;
|
|
spin_unlock(&dpcm->cable->lock);
|
|
return bytes_to_frames(runtime, pos);
|
|
}
|
|
|
|
static const struct snd_pcm_hardware loopback_pcm_hardware =
|
|
{
|
|
.info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP |
|
|
SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE |
|
|
SNDRV_PCM_INFO_RESUME),
|
|
.formats = (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |
|
|
SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE |
|
|
SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE |
|
|
SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE |
|
|
SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE),
|
|
.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_192000,
|
|
.rate_min = 8000,
|
|
.rate_max = 192000,
|
|
.channels_min = 1,
|
|
.channels_max = 32,
|
|
.buffer_bytes_max = 2 * 1024 * 1024,
|
|
.period_bytes_min = 64,
|
|
/* note check overflow in frac_pos() using pcm_rate_shift before
|
|
changing period_bytes_max value */
|
|
.period_bytes_max = 1024 * 1024,
|
|
.periods_min = 1,
|
|
.periods_max = 1024,
|
|
.fifo_size = 0,
|
|
};
|
|
|
|
static void loopback_runtime_free(struct snd_pcm_runtime *runtime)
|
|
{
|
|
struct loopback_pcm *dpcm = runtime->private_data;
|
|
kfree(dpcm);
|
|
}
|
|
|
|
static int loopback_hw_params(struct snd_pcm_substream *substream,
|
|
struct snd_pcm_hw_params *params)
|
|
{
|
|
return snd_pcm_lib_alloc_vmalloc_buffer(substream,
|
|
params_buffer_bytes(params));
|
|
}
|
|
|
|
static int loopback_hw_free(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
struct loopback_pcm *dpcm = runtime->private_data;
|
|
struct loopback_cable *cable = dpcm->cable;
|
|
|
|
mutex_lock(&dpcm->loopback->cable_lock);
|
|
cable->valid &= ~(1 << substream->stream);
|
|
mutex_unlock(&dpcm->loopback->cable_lock);
|
|
return snd_pcm_lib_free_vmalloc_buffer(substream);
|
|
}
|
|
|
|
static unsigned int get_cable_index(struct snd_pcm_substream *substream)
|
|
{
|
|
if (!substream->pcm->device)
|
|
return substream->stream;
|
|
else
|
|
return !substream->stream;
|
|
}
|
|
|
|
static int rule_format(struct snd_pcm_hw_params *params,
|
|
struct snd_pcm_hw_rule *rule)
|
|
{
|
|
struct loopback_pcm *dpcm = rule->private;
|
|
struct loopback_cable *cable = dpcm->cable;
|
|
struct snd_mask m;
|
|
|
|
snd_mask_none(&m);
|
|
mutex_lock(&dpcm->loopback->cable_lock);
|
|
m.bits[0] = (u_int32_t)cable->hw.formats;
|
|
m.bits[1] = (u_int32_t)(cable->hw.formats >> 32);
|
|
mutex_unlock(&dpcm->loopback->cable_lock);
|
|
return snd_mask_refine(hw_param_mask(params, rule->var), &m);
|
|
}
|
|
|
|
static int rule_rate(struct snd_pcm_hw_params *params,
|
|
struct snd_pcm_hw_rule *rule)
|
|
{
|
|
struct loopback_pcm *dpcm = rule->private;
|
|
struct loopback_cable *cable = dpcm->cable;
|
|
struct snd_interval t;
|
|
|
|
mutex_lock(&dpcm->loopback->cable_lock);
|
|
t.min = cable->hw.rate_min;
|
|
t.max = cable->hw.rate_max;
|
|
mutex_unlock(&dpcm->loopback->cable_lock);
|
|
t.openmin = t.openmax = 0;
|
|
t.integer = 0;
|
|
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
|
|
}
|
|
|
|
static int rule_channels(struct snd_pcm_hw_params *params,
|
|
struct snd_pcm_hw_rule *rule)
|
|
{
|
|
struct loopback_pcm *dpcm = rule->private;
|
|
struct loopback_cable *cable = dpcm->cable;
|
|
struct snd_interval t;
|
|
|
|
mutex_lock(&dpcm->loopback->cable_lock);
|
|
t.min = cable->hw.channels_min;
|
|
t.max = cable->hw.channels_max;
|
|
mutex_unlock(&dpcm->loopback->cable_lock);
|
|
t.openmin = t.openmax = 0;
|
|
t.integer = 0;
|
|
return snd_interval_refine(hw_param_interval(params, rule->var), &t);
|
|
}
|
|
|
|
static void free_cable(struct snd_pcm_substream *substream)
|
|
{
|
|
struct loopback *loopback = substream->private_data;
|
|
int dev = get_cable_index(substream);
|
|
struct loopback_cable *cable;
|
|
|
|
cable = loopback->cables[substream->number][dev];
|
|
if (!cable)
|
|
return;
|
|
if (cable->streams[!substream->stream]) {
|
|
/* other stream is still alive */
|
|
spin_lock_irq(&cable->lock);
|
|
cable->streams[substream->stream] = NULL;
|
|
spin_unlock_irq(&cable->lock);
|
|
} else {
|
|
/* free the cable */
|
|
loopback->cables[substream->number][dev] = NULL;
|
|
kfree(cable);
|
|
}
|
|
}
|
|
|
|
static int loopback_open(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_pcm_runtime *runtime = substream->runtime;
|
|
struct loopback *loopback = substream->private_data;
|
|
struct loopback_pcm *dpcm;
|
|
struct loopback_cable *cable = NULL;
|
|
int err = 0;
|
|
int dev = get_cable_index(substream);
|
|
|
|
mutex_lock(&loopback->cable_lock);
|
|
dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
|
|
if (!dpcm) {
|
|
err = -ENOMEM;
|
|
goto unlock;
|
|
}
|
|
dpcm->loopback = loopback;
|
|
dpcm->substream = substream;
|
|
timer_setup(&dpcm->timer, loopback_timer_function, 0);
|
|
|
|
cable = loopback->cables[substream->number][dev];
|
|
if (!cable) {
|
|
cable = kzalloc(sizeof(*cable), GFP_KERNEL);
|
|
if (!cable) {
|
|
err = -ENOMEM;
|
|
goto unlock;
|
|
}
|
|
spin_lock_init(&cable->lock);
|
|
cable->hw = loopback_pcm_hardware;
|
|
loopback->cables[substream->number][dev] = cable;
|
|
}
|
|
dpcm->cable = cable;
|
|
|
|
snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
|
|
|
|
/* use dynamic rules based on actual runtime->hw values */
|
|
/* note that the default rules created in the PCM midlevel code */
|
|
/* are cached -> they do not reflect the actual state */
|
|
err = snd_pcm_hw_rule_add(runtime, 0,
|
|
SNDRV_PCM_HW_PARAM_FORMAT,
|
|
rule_format, dpcm,
|
|
SNDRV_PCM_HW_PARAM_FORMAT, -1);
|
|
if (err < 0)
|
|
goto unlock;
|
|
err = snd_pcm_hw_rule_add(runtime, 0,
|
|
SNDRV_PCM_HW_PARAM_RATE,
|
|
rule_rate, dpcm,
|
|
SNDRV_PCM_HW_PARAM_RATE, -1);
|
|
if (err < 0)
|
|
goto unlock;
|
|
err = snd_pcm_hw_rule_add(runtime, 0,
|
|
SNDRV_PCM_HW_PARAM_CHANNELS,
|
|
rule_channels, dpcm,
|
|
SNDRV_PCM_HW_PARAM_CHANNELS, -1);
|
|
if (err < 0)
|
|
goto unlock;
|
|
|
|
runtime->private_data = dpcm;
|
|
runtime->private_free = loopback_runtime_free;
|
|
if (get_notify(dpcm))
|
|
runtime->hw = loopback_pcm_hardware;
|
|
else
|
|
runtime->hw = cable->hw;
|
|
|
|
spin_lock_irq(&cable->lock);
|
|
cable->streams[substream->stream] = dpcm;
|
|
spin_unlock_irq(&cable->lock);
|
|
|
|
unlock:
|
|
if (err < 0) {
|
|
free_cable(substream);
|
|
kfree(dpcm);
|
|
}
|
|
mutex_unlock(&loopback->cable_lock);
|
|
return err;
|
|
}
|
|
|
|
static int loopback_close(struct snd_pcm_substream *substream)
|
|
{
|
|
struct loopback *loopback = substream->private_data;
|
|
struct loopback_pcm *dpcm = substream->runtime->private_data;
|
|
|
|
loopback_timer_stop_sync(dpcm);
|
|
mutex_lock(&loopback->cable_lock);
|
|
free_cable(substream);
|
|
mutex_unlock(&loopback->cable_lock);
|
|
return 0;
|
|
}
|
|
|
|
static const struct snd_pcm_ops loopback_pcm_ops = {
|
|
.open = loopback_open,
|
|
.close = loopback_close,
|
|
.ioctl = snd_pcm_lib_ioctl,
|
|
.hw_params = loopback_hw_params,
|
|
.hw_free = loopback_hw_free,
|
|
.prepare = loopback_prepare,
|
|
.trigger = loopback_trigger,
|
|
.pointer = loopback_pointer,
|
|
.page = snd_pcm_lib_get_vmalloc_page,
|
|
};
|
|
|
|
static int loopback_pcm_new(struct loopback *loopback,
|
|
int device, int substreams)
|
|
{
|
|
struct snd_pcm *pcm;
|
|
int err;
|
|
|
|
err = snd_pcm_new(loopback->card, "Loopback PCM", device,
|
|
substreams, substreams, &pcm);
|
|
if (err < 0)
|
|
return err;
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &loopback_pcm_ops);
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &loopback_pcm_ops);
|
|
|
|
pcm->private_data = loopback;
|
|
pcm->info_flags = 0;
|
|
strcpy(pcm->name, "Loopback PCM");
|
|
|
|
loopback->pcm[device] = pcm;
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_rate_shift_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 1;
|
|
uinfo->value.integer.min = 80000;
|
|
uinfo->value.integer.max = 120000;
|
|
uinfo->value.integer.step = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_rate_shift_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct loopback *loopback = snd_kcontrol_chip(kcontrol);
|
|
|
|
mutex_lock(&loopback->cable_lock);
|
|
ucontrol->value.integer.value[0] =
|
|
loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].rate_shift;
|
|
mutex_unlock(&loopback->cable_lock);
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_rate_shift_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct loopback *loopback = snd_kcontrol_chip(kcontrol);
|
|
unsigned int val;
|
|
int change = 0;
|
|
|
|
val = ucontrol->value.integer.value[0];
|
|
if (val < 80000)
|
|
val = 80000;
|
|
if (val > 120000)
|
|
val = 120000;
|
|
mutex_lock(&loopback->cable_lock);
|
|
if (val != loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].rate_shift) {
|
|
loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].rate_shift = val;
|
|
change = 1;
|
|
}
|
|
mutex_unlock(&loopback->cable_lock);
|
|
return change;
|
|
}
|
|
|
|
static int loopback_notify_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct loopback *loopback = snd_kcontrol_chip(kcontrol);
|
|
|
|
mutex_lock(&loopback->cable_lock);
|
|
ucontrol->value.integer.value[0] =
|
|
loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].notify;
|
|
mutex_unlock(&loopback->cable_lock);
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_notify_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct loopback *loopback = snd_kcontrol_chip(kcontrol);
|
|
unsigned int val;
|
|
int change = 0;
|
|
|
|
val = ucontrol->value.integer.value[0] ? 1 : 0;
|
|
mutex_lock(&loopback->cable_lock);
|
|
if (val != loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].notify) {
|
|
loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].notify = val;
|
|
change = 1;
|
|
}
|
|
mutex_unlock(&loopback->cable_lock);
|
|
return change;
|
|
}
|
|
|
|
static int loopback_active_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct loopback *loopback = snd_kcontrol_chip(kcontrol);
|
|
struct loopback_cable *cable;
|
|
|
|
unsigned int val = 0;
|
|
|
|
mutex_lock(&loopback->cable_lock);
|
|
cable = loopback->cables[kcontrol->id.subdevice][kcontrol->id.device ^ 1];
|
|
if (cable != NULL) {
|
|
unsigned int running = cable->running ^ cable->pause;
|
|
|
|
val = (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ? 1 : 0;
|
|
}
|
|
mutex_unlock(&loopback->cable_lock);
|
|
ucontrol->value.integer.value[0] = val;
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_format_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 1;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = SNDRV_PCM_FORMAT_LAST;
|
|
uinfo->value.integer.step = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_format_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct loopback *loopback = snd_kcontrol_chip(kcontrol);
|
|
|
|
ucontrol->value.integer.value[0] =
|
|
loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].format;
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_rate_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 1;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = 192000;
|
|
uinfo->value.integer.step = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_rate_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct loopback *loopback = snd_kcontrol_chip(kcontrol);
|
|
|
|
mutex_lock(&loopback->cable_lock);
|
|
ucontrol->value.integer.value[0] =
|
|
loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].rate;
|
|
mutex_unlock(&loopback->cable_lock);
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_channels_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 1;
|
|
uinfo->value.integer.min = 1;
|
|
uinfo->value.integer.max = 1024;
|
|
uinfo->value.integer.step = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_channels_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct loopback *loopback = snd_kcontrol_chip(kcontrol);
|
|
|
|
mutex_lock(&loopback->cable_lock);
|
|
ucontrol->value.integer.value[0] =
|
|
loopback->setup[kcontrol->id.subdevice]
|
|
[kcontrol->id.device].channels;
|
|
mutex_unlock(&loopback->cable_lock);
|
|
return 0;
|
|
}
|
|
|
|
static struct snd_kcontrol_new loopback_controls[] = {
|
|
{
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
.name = "PCM Rate Shift 100000",
|
|
.info = loopback_rate_shift_info,
|
|
.get = loopback_rate_shift_get,
|
|
.put = loopback_rate_shift_put,
|
|
},
|
|
{
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
.name = "PCM Notify",
|
|
.info = snd_ctl_boolean_mono_info,
|
|
.get = loopback_notify_get,
|
|
.put = loopback_notify_put,
|
|
},
|
|
#define ACTIVE_IDX 2
|
|
{
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
.name = "PCM Slave Active",
|
|
.info = snd_ctl_boolean_mono_info,
|
|
.get = loopback_active_get,
|
|
},
|
|
#define FORMAT_IDX 3
|
|
{
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
.name = "PCM Slave Format",
|
|
.info = loopback_format_info,
|
|
.get = loopback_format_get
|
|
},
|
|
#define RATE_IDX 4
|
|
{
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
.name = "PCM Slave Rate",
|
|
.info = loopback_rate_info,
|
|
.get = loopback_rate_get
|
|
},
|
|
#define CHANNELS_IDX 5
|
|
{
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
|
.name = "PCM Slave Channels",
|
|
.info = loopback_channels_info,
|
|
.get = loopback_channels_get
|
|
}
|
|
};
|
|
|
|
static int loopback_mixer_new(struct loopback *loopback, int notify)
|
|
{
|
|
struct snd_card *card = loopback->card;
|
|
struct snd_pcm *pcm;
|
|
struct snd_kcontrol *kctl;
|
|
struct loopback_setup *setup;
|
|
int err, dev, substr, substr_count, idx;
|
|
|
|
strcpy(card->mixername, "Loopback Mixer");
|
|
for (dev = 0; dev < 2; dev++) {
|
|
pcm = loopback->pcm[dev];
|
|
substr_count =
|
|
pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count;
|
|
for (substr = 0; substr < substr_count; substr++) {
|
|
setup = &loopback->setup[substr][dev];
|
|
setup->notify = notify;
|
|
setup->rate_shift = NO_PITCH;
|
|
setup->format = SNDRV_PCM_FORMAT_S16_LE;
|
|
setup->rate = 48000;
|
|
setup->channels = 2;
|
|
for (idx = 0; idx < ARRAY_SIZE(loopback_controls);
|
|
idx++) {
|
|
kctl = snd_ctl_new1(&loopback_controls[idx],
|
|
loopback);
|
|
if (!kctl)
|
|
return -ENOMEM;
|
|
kctl->id.device = dev;
|
|
kctl->id.subdevice = substr;
|
|
switch (idx) {
|
|
case ACTIVE_IDX:
|
|
setup->active_id = kctl->id;
|
|
break;
|
|
case FORMAT_IDX:
|
|
setup->format_id = kctl->id;
|
|
break;
|
|
case RATE_IDX:
|
|
setup->rate_id = kctl->id;
|
|
break;
|
|
case CHANNELS_IDX:
|
|
setup->channels_id = kctl->id;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
err = snd_ctl_add(card, kctl);
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void print_dpcm_info(struct snd_info_buffer *buffer,
|
|
struct loopback_pcm *dpcm,
|
|
const char *id)
|
|
{
|
|
snd_iprintf(buffer, " %s\n", id);
|
|
if (dpcm == NULL) {
|
|
snd_iprintf(buffer, " inactive\n");
|
|
return;
|
|
}
|
|
snd_iprintf(buffer, " buffer_size:\t%u\n", dpcm->pcm_buffer_size);
|
|
snd_iprintf(buffer, " buffer_pos:\t\t%u\n", dpcm->buf_pos);
|
|
snd_iprintf(buffer, " silent_size:\t%u\n", dpcm->silent_size);
|
|
snd_iprintf(buffer, " period_size:\t%u\n", dpcm->pcm_period_size);
|
|
snd_iprintf(buffer, " bytes_per_sec:\t%u\n", dpcm->pcm_bps);
|
|
snd_iprintf(buffer, " sample_align:\t%u\n", dpcm->pcm_salign);
|
|
snd_iprintf(buffer, " rate_shift:\t\t%u\n", dpcm->pcm_rate_shift);
|
|
snd_iprintf(buffer, " update_pending:\t%u\n",
|
|
dpcm->period_update_pending);
|
|
snd_iprintf(buffer, " irq_pos:\t\t%u\n", dpcm->irq_pos);
|
|
snd_iprintf(buffer, " period_frac:\t%u\n", dpcm->period_size_frac);
|
|
snd_iprintf(buffer, " last_jiffies:\t%lu (%lu)\n",
|
|
dpcm->last_jiffies, jiffies);
|
|
snd_iprintf(buffer, " timer_expires:\t%lu\n", dpcm->timer.expires);
|
|
}
|
|
|
|
static void print_substream_info(struct snd_info_buffer *buffer,
|
|
struct loopback *loopback,
|
|
int sub,
|
|
int num)
|
|
{
|
|
struct loopback_cable *cable = loopback->cables[sub][num];
|
|
|
|
snd_iprintf(buffer, "Cable %i substream %i:\n", num, sub);
|
|
if (cable == NULL) {
|
|
snd_iprintf(buffer, " inactive\n");
|
|
return;
|
|
}
|
|
snd_iprintf(buffer, " valid: %u\n", cable->valid);
|
|
snd_iprintf(buffer, " running: %u\n", cable->running);
|
|
snd_iprintf(buffer, " pause: %u\n", cable->pause);
|
|
print_dpcm_info(buffer, cable->streams[0], "Playback");
|
|
print_dpcm_info(buffer, cable->streams[1], "Capture");
|
|
}
|
|
|
|
static void print_cable_info(struct snd_info_entry *entry,
|
|
struct snd_info_buffer *buffer)
|
|
{
|
|
struct loopback *loopback = entry->private_data;
|
|
int sub, num;
|
|
|
|
mutex_lock(&loopback->cable_lock);
|
|
num = entry->name[strlen(entry->name)-1];
|
|
num = num == '0' ? 0 : 1;
|
|
for (sub = 0; sub < MAX_PCM_SUBSTREAMS; sub++)
|
|
print_substream_info(buffer, loopback, sub, num);
|
|
mutex_unlock(&loopback->cable_lock);
|
|
}
|
|
|
|
static int loopback_proc_new(struct loopback *loopback, int cidx)
|
|
{
|
|
char name[32];
|
|
|
|
snprintf(name, sizeof(name), "cable#%d", cidx);
|
|
return snd_card_ro_proc_new(loopback->card, name, loopback,
|
|
print_cable_info);
|
|
}
|
|
|
|
static int loopback_probe(struct platform_device *devptr)
|
|
{
|
|
struct snd_card *card;
|
|
struct loopback *loopback;
|
|
int dev = devptr->id;
|
|
int err;
|
|
|
|
err = snd_card_new(&devptr->dev, index[dev], id[dev], THIS_MODULE,
|
|
sizeof(struct loopback), &card);
|
|
if (err < 0)
|
|
return err;
|
|
loopback = card->private_data;
|
|
|
|
if (pcm_substreams[dev] < 1)
|
|
pcm_substreams[dev] = 1;
|
|
if (pcm_substreams[dev] > MAX_PCM_SUBSTREAMS)
|
|
pcm_substreams[dev] = MAX_PCM_SUBSTREAMS;
|
|
|
|
loopback->card = card;
|
|
mutex_init(&loopback->cable_lock);
|
|
|
|
err = loopback_pcm_new(loopback, 0, pcm_substreams[dev]);
|
|
if (err < 0)
|
|
goto __nodev;
|
|
err = loopback_pcm_new(loopback, 1, pcm_substreams[dev]);
|
|
if (err < 0)
|
|
goto __nodev;
|
|
err = loopback_mixer_new(loopback, pcm_notify[dev] ? 1 : 0);
|
|
if (err < 0)
|
|
goto __nodev;
|
|
loopback_proc_new(loopback, 0);
|
|
loopback_proc_new(loopback, 1);
|
|
strcpy(card->driver, "Loopback");
|
|
strcpy(card->shortname, "Loopback");
|
|
sprintf(card->longname, "Loopback %i", dev + 1);
|
|
err = snd_card_register(card);
|
|
if (!err) {
|
|
platform_set_drvdata(devptr, card);
|
|
return 0;
|
|
}
|
|
__nodev:
|
|
snd_card_free(card);
|
|
return err;
|
|
}
|
|
|
|
static int loopback_remove(struct platform_device *devptr)
|
|
{
|
|
snd_card_free(platform_get_drvdata(devptr));
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
static int loopback_suspend(struct device *pdev)
|
|
{
|
|
struct snd_card *card = dev_get_drvdata(pdev);
|
|
|
|
snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
|
|
return 0;
|
|
}
|
|
|
|
static int loopback_resume(struct device *pdev)
|
|
{
|
|
struct snd_card *card = dev_get_drvdata(pdev);
|
|
|
|
snd_power_change_state(card, SNDRV_CTL_POWER_D0);
|
|
return 0;
|
|
}
|
|
|
|
static SIMPLE_DEV_PM_OPS(loopback_pm, loopback_suspend, loopback_resume);
|
|
#define LOOPBACK_PM_OPS &loopback_pm
|
|
#else
|
|
#define LOOPBACK_PM_OPS NULL
|
|
#endif
|
|
|
|
#define SND_LOOPBACK_DRIVER "snd_aloop"
|
|
|
|
static struct platform_driver loopback_driver = {
|
|
.probe = loopback_probe,
|
|
.remove = loopback_remove,
|
|
.driver = {
|
|
.name = SND_LOOPBACK_DRIVER,
|
|
.pm = LOOPBACK_PM_OPS,
|
|
},
|
|
};
|
|
|
|
static void loopback_unregister_all(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(devices); ++i)
|
|
platform_device_unregister(devices[i]);
|
|
platform_driver_unregister(&loopback_driver);
|
|
}
|
|
|
|
static int __init alsa_card_loopback_init(void)
|
|
{
|
|
int i, err, cards;
|
|
|
|
err = platform_driver_register(&loopback_driver);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
|
|
cards = 0;
|
|
for (i = 0; i < SNDRV_CARDS; i++) {
|
|
struct platform_device *device;
|
|
if (!enable[i])
|
|
continue;
|
|
device = platform_device_register_simple(SND_LOOPBACK_DRIVER,
|
|
i, NULL, 0);
|
|
if (IS_ERR(device))
|
|
continue;
|
|
if (!platform_get_drvdata(device)) {
|
|
platform_device_unregister(device);
|
|
continue;
|
|
}
|
|
devices[i] = device;
|
|
cards++;
|
|
}
|
|
if (!cards) {
|
|
#ifdef MODULE
|
|
printk(KERN_ERR "aloop: No loopback enabled\n");
|
|
#endif
|
|
loopback_unregister_all();
|
|
return -ENODEV;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void __exit alsa_card_loopback_exit(void)
|
|
{
|
|
loopback_unregister_all();
|
|
}
|
|
|
|
module_init(alsa_card_loopback_init)
|
|
module_exit(alsa_card_loopback_exit)
|