Commit 89e1e66d authored by Clemens Ladisch's avatar Clemens Ladisch Committed by Takashi Iwai

ALSA: usb-audio: automatically detect feedback format

There are two USB Audio Class specifications (v1 and v2), but neither of
them clearly defines the feedback format for high-speed UAC v1 devices.
Add to this whatever the Creative and M-Audio firmware writers have been
smoking, and it becomes impossible to predict the exact feedback format
used by a particular device.

Therefore, automatically detect the feedback format by looking at the
magnitude of the first received feedback value.

Also, this allows us to get rid of some special cases for E-Mu devices.
Signed-off-by: default avatarClemens Ladisch <clemens@ladisch.de>
Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent 0d040df9
...@@ -62,12 +62,14 @@ struct snd_usb_substream { ...@@ -62,12 +62,14 @@ struct snd_usb_substream {
unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */ unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */
unsigned int freqn; /* nominal sampling rate in fs/fps in Q16.16 format */ unsigned int freqn; /* nominal sampling rate in fs/fps in Q16.16 format */
unsigned int freqm; /* momentary sampling rate in fs/fps in Q16.16 format */ unsigned int freqm; /* momentary sampling rate in fs/fps in Q16.16 format */
int freqshift; /* how much to shift the feedback value to get Q16.16 */
unsigned int freqmax; /* maximum sampling rate, used for buffer management */ unsigned int freqmax; /* maximum sampling rate, used for buffer management */
unsigned int phase; /* phase accumulator */ unsigned int phase; /* phase accumulator */
unsigned int maxpacksize; /* max packet size in bytes */ unsigned int maxpacksize; /* max packet size in bytes */
unsigned int maxframesize; /* max packet size in frames */ unsigned int maxframesize; /* max packet size in frames */
unsigned int curpacksize; /* current packet size in bytes (for capture) */ unsigned int curpacksize; /* current packet size in bytes (for capture) */
unsigned int curframesize; /* current packet size in frames (for capture) */ unsigned int curframesize; /* current packet size in frames (for capture) */
unsigned int syncmaxsize; /* sync endpoint packet size */
unsigned int fill_max: 1; /* fill max packet size always */ unsigned int fill_max: 1; /* fill max packet size always */
unsigned int txfr_quirk:1; /* allow sub-frame alignment */ unsigned int txfr_quirk:1; /* allow sub-frame alignment */
unsigned int fmt_type; /* USB audio format type (1-3) */ unsigned int fmt_type; /* USB audio format type (1-3) */
......
...@@ -237,6 +237,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt) ...@@ -237,6 +237,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
subs->datainterval = fmt->datainterval; subs->datainterval = fmt->datainterval;
subs->syncpipe = subs->syncinterval = 0; subs->syncpipe = subs->syncinterval = 0;
subs->maxpacksize = fmt->maxpacksize; subs->maxpacksize = fmt->maxpacksize;
subs->syncmaxsize = 0;
subs->fill_max = 0; subs->fill_max = 0;
/* we need a sync pipe in async OUT or adaptive IN mode */ /* we need a sync pipe in async OUT or adaptive IN mode */
...@@ -283,6 +284,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt) ...@@ -283,6 +284,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1; subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
else else
subs->syncinterval = 3; subs->syncinterval = 3;
subs->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize);
} }
/* always fill max packet size */ /* always fill max packet size */
......
...@@ -132,6 +132,11 @@ static void proc_dump_substream_status(struct snd_usb_substream *subs, struct sn ...@@ -132,6 +132,11 @@ static void proc_dump_substream_status(struct snd_usb_substream *subs, struct sn
? get_full_speed_hz(subs->freqm) ? get_full_speed_hz(subs->freqm)
: get_high_speed_hz(subs->freqm), : get_high_speed_hz(subs->freqm),
subs->freqm >> 16, subs->freqm & 0xffff); subs->freqm >> 16, subs->freqm & 0xffff);
if (subs->freqshift != INT_MIN)
snd_iprintf(buffer, " Feedback Format = %d.%d\n",
(subs->syncmaxsize > 3 ? 32 : 24)
- (16 - subs->freqshift),
16 - subs->freqshift);
} else { } else {
snd_iprintf(buffer, " Status: Stop\n"); snd_iprintf(buffer, " Status: Stop\n");
} }
......
...@@ -225,6 +225,7 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs, ...@@ -225,6 +225,7 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
else else
subs->freqn = get_usb_high_speed_rate(rate); subs->freqn = get_usb_high_speed_rate(rate);
subs->freqm = subs->freqn; subs->freqm = subs->freqn;
subs->freqshift = INT_MIN;
/* calculate max. frequency */ /* calculate max. frequency */
if (subs->maxpacksize) { if (subs->maxpacksize) {
/* whatever fits into a max. size packet */ /* whatever fits into a max. size packet */
...@@ -513,11 +514,10 @@ static int retire_paused_capture_urb(struct snd_usb_substream *subs, ...@@ -513,11 +514,10 @@ static int retire_paused_capture_urb(struct snd_usb_substream *subs,
/* /*
* prepare urb for full speed playback sync pipe * prepare urb for playback sync pipe
* *
* set up the offset and length to receive the current frequency. * set up the offset and length to receive the current frequency.
*/ */
static int prepare_playback_sync_urb(struct snd_usb_substream *subs, static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
struct snd_pcm_runtime *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
...@@ -525,103 +525,78 @@ static int prepare_playback_sync_urb(struct snd_usb_substream *subs, ...@@ -525,103 +525,78 @@ static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
struct snd_urb_ctx *ctx = urb->context; struct snd_urb_ctx *ctx = urb->context;
urb->dev = ctx->subs->dev; /* we need to set this at each time */ urb->dev = ctx->subs->dev; /* we need to set this at each time */
urb->iso_frame_desc[0].length = 3; urb->iso_frame_desc[0].length = min(4u, ctx->subs->syncmaxsize);
urb->iso_frame_desc[0].offset = 0; urb->iso_frame_desc[0].offset = 0;
return 0; return 0;
} }
/* /*
* prepare urb for high speed playback sync pipe * process after playback sync complete
* *
* set up the offset and length to receive the current frequency. * Full speed devices report feedback values in 10.14 format as samples per
*/ * frame, high speed devices in 16.16 format as samples per microframe.
* Because the Audio Class 1 spec was written before USB 2.0, many high speed
static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs, * devices use a wrong interpretation, some others use an entirely different
struct snd_pcm_runtime *runtime, * format. Therefore, we cannot predict what format any particular device uses
struct urb *urb) * and must detect it automatically.
{
struct snd_urb_ctx *ctx = urb->context;
urb->dev = ctx->subs->dev; /* we need to set this at each time */
urb->iso_frame_desc[0].length = 4;
urb->iso_frame_desc[0].offset = 0;
return 0;
}
/*
* process after full speed playback sync complete
*
* retrieve the current 10.14 frequency from pipe, and set it.
* the value is referred in prepare_playback_urb().
*/ */
static int retire_playback_sync_urb(struct snd_usb_substream *subs, static int retire_playback_sync_urb(struct snd_usb_substream *subs,
struct snd_pcm_runtime *runtime, struct snd_pcm_runtime *runtime,
struct urb *urb) struct urb *urb)
{ {
unsigned int f; unsigned int f;
int shift;
unsigned long flags; unsigned long flags;
if (urb->iso_frame_desc[0].status == 0 && if (urb->iso_frame_desc[0].status != 0 ||
urb->iso_frame_desc[0].actual_length == 3) { urb->iso_frame_desc[0].actual_length < 3)
f = combine_triple((u8*)urb->transfer_buffer) << 2; return 0;
if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
spin_lock_irqsave(&subs->lock, flags);
subs->freqm = f;
spin_unlock_irqrestore(&subs->lock, flags);
}
}
return 0;
}
/* f = le32_to_cpup(urb->transfer_buffer);
* process after high speed playback sync complete if (urb->iso_frame_desc[0].actual_length == 3)
* f &= 0x00ffffff;
* retrieve the current 12.13 frequency from pipe, and set it. else
* the value is referred in prepare_playback_urb(). f &= 0x0fffffff;
*/ if (f == 0)
static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs, return 0;
struct snd_pcm_runtime *runtime,
struct urb *urb)
{
unsigned int f;
unsigned long flags;
if (urb->iso_frame_desc[0].status == 0 && if (unlikely(subs->freqshift == INT_MIN)) {
urb->iso_frame_desc[0].actual_length == 4) { /*
f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff; * The first time we see a feedback value, determine its format
if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) { * by shifting it left or right until it matches the nominal
spin_lock_irqsave(&subs->lock, flags); * frequency value. This assumes that the feedback does not
subs->freqm = f; * differ from the nominal value more than +50% or -25%.
spin_unlock_irqrestore(&subs->lock, flags); */
shift = 0;
while (f < subs->freqn - subs->freqn / 4) {
f <<= 1;
shift++;
}
while (f > subs->freqn + subs->freqn / 2) {
f >>= 1;
shift--;
} }
subs->freqshift = shift;
} }
else if (subs->freqshift >= 0)
f <<= subs->freqshift;
else
f >>= -subs->freqshift;
return 0; if (likely(f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax)) {
} /*
* If the frequency looks valid, set it.
/* * This value is referred to in prepare_playback_urb().
* process after E-Mu 0202/0404/Tracker Pre high speed playback sync complete */
* spin_lock_irqsave(&subs->lock, flags);
* These devices return the number of samples per packet instead of the number subs->freqm = f;
* of samples per microframe. spin_unlock_irqrestore(&subs->lock, flags);
*/ } else {
static int retire_playback_sync_urb_hs_emu(struct snd_usb_substream *subs, /*
struct snd_pcm_runtime *runtime, * Out of range; maybe the shift value is wrong.
struct urb *urb) * Reset it so that we autodetect again the next time.
{ */
unsigned int f; subs->freqshift = INT_MIN;
unsigned long flags;
if (urb->iso_frame_desc[0].status == 0 &&
urb->iso_frame_desc[0].actual_length == 4) {
f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff;
f >>= subs->datainterval;
if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) {
spin_lock_irqsave(&subs->lock, flags);
subs->freqm = f;
spin_unlock_irqrestore(&subs->lock, flags);
}
} }
return 0; return 0;
...@@ -878,21 +853,6 @@ static struct snd_urb_ops audio_urb_ops[2] = { ...@@ -878,21 +853,6 @@ static struct snd_urb_ops audio_urb_ops[2] = {
}, },
}; };
static struct snd_urb_ops audio_urb_ops_high_speed[2] = {
{
.prepare = prepare_nodata_playback_urb,
.retire = retire_playback_urb,
.prepare_sync = prepare_playback_sync_urb_hs,
.retire_sync = retire_playback_sync_urb_hs,
},
{
.prepare = prepare_capture_urb,
.retire = retire_capture_urb,
.prepare_sync = prepare_capture_sync_urb_hs,
.retire_sync = retire_capture_sync_urb,
},
};
/* /*
* initialize the substream instance. * initialize the substream instance.
*/ */
...@@ -909,23 +869,9 @@ void snd_usb_init_substream(struct snd_usb_stream *as, ...@@ -909,23 +869,9 @@ void snd_usb_init_substream(struct snd_usb_stream *as,
subs->direction = stream; subs->direction = stream;
subs->dev = as->chip->dev; subs->dev = as->chip->dev;
subs->txfr_quirk = as->chip->txfr_quirk; subs->txfr_quirk = as->chip->txfr_quirk;
if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) { subs->ops = audio_urb_ops[stream];
subs->ops = audio_urb_ops[stream]; if (snd_usb_get_speed(subs->dev) >= USB_SPEED_HIGH)
} else { subs->ops.prepare_sync = prepare_capture_sync_urb_hs;
subs->ops = audio_urb_ops_high_speed[stream];
switch (as->chip->usb_id) {
case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
subs->ops.retire_sync = retire_playback_sync_urb_hs_emu;
break;
case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra 8 */
case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
subs->ops.prepare_sync = prepare_playback_sync_urb;
subs->ops.retire_sync = retire_playback_sync_urb;
break;
}
}
snd_usb_set_pcm_ops(as->pcm, stream); snd_usb_set_pcm_ops(as->pcm, stream);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment