static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream)
{
unsigned int i;
for (i = 0; i < stream->queue_length; ++i) {
int err = usb_submit_urb(&stream->urbs[i]->urb, GFP_KERNEL);
if (err < 0) {
dev_err(&ua->dev->dev, "USB request error %d: %s\n",
err, usb_error_string(err));
return err;
}
}
return 0;
}
static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index)
{
struct usb_host_interface *alts;
alts = ua->intf[intf_index]->cur_altsetting;
if (alts->desc.bAlternateSetting != 0) {
int err = usb_set_interface(ua->dev,
alts->desc.bInterfaceNumber, 0);
if (err < 0 && !test_bit(DISCONNECTED, &ua->states))
dev_warn(&ua->dev->dev,
"interface reset failed; error %d: %s\n",
err, usb_error_string(err));
}
}
static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index)
{
struct usb_host_interface *alts;
alts = ua->intf[intf_index]->cur_altsetting;
if (alts->desc.bAlternateSetting != 1) {
int err = usb_set_interface(ua->dev,
alts->desc.bInterfaceNumber, 1);
if (err < 0) {
dev_err(&ua->dev->dev,
"cannot initialize interface; error %d: %s\n",
err, usb_error_string(err));
return err;
}
}
return 0;
}
static void capture_urb_complete(struct urb *urb)
{
struct ua101 *ua = urb->context;
struct ua101_stream *stream = &ua->capture;
unsigned long flags;
unsigned int frames, write_ptr;
bool do_period_elapsed;
int err;
if (unlikely(urb->status == -ENOENT || /* unlinked */
urb->status == -ENODEV || /* device removed */
urb->status == -ECONNRESET || /* unlinked */
urb->status == -ESHUTDOWN)) /* device disabled */
goto stream_stopped;
if (urb->status >= 0 && urb->iso_frame_desc[0].status >= 0)
frames = urb->iso_frame_desc[0].actual_length /
stream->frame_bytes;
else
frames = 0;
spin_lock_irqsave(&ua->lock, flags);
if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
do_period_elapsed = copy_capture_data(stream, urb, frames);
else
do_period_elapsed = false;
if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
err = usb_submit_urb(urb, GFP_ATOMIC);
if (unlikely(err < 0)) {
spin_unlock_irqrestore(&ua->lock, flags);
dev_err(&ua->dev->dev, "USB request error %d: %s\n",
err, usb_error_string(err));
goto stream_stopped;
}
/* append packet size to FIFO */
write_ptr = ua->rate_feedback_start;
add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count);
ua->rate_feedback[write_ptr] = frames;
if (ua->rate_feedback_count < ua->playback.queue_length) {
ua->rate_feedback_count++;
if (ua->rate_feedback_count ==
ua->playback.queue_length)
wake_up(&ua->rate_feedback_wait);
} else {
/*
* Ring buffer overflow; this happens when the playback
* stream is not running. Throw away the oldest entry,
* so that the playback stream, when it starts, sees
* the most recent packet sizes.
*/
add_with_wraparound(ua, &ua->rate_feedback_start, 1);
}
if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) &&
!list_empty(&ua->ready_playback_urbs))
tasklet_schedule(&ua->playback_tasklet);
}
spin_unlock_irqrestore(&ua->lock, flags);
if (do_period_elapsed)
snd_pcm_period_elapsed(stream->substream);
return;
stream_stopped:
abort_usb_playback(ua);
abort_usb_capture(ua);
abort_alsa_playback(ua);
abort_alsa_capture(ua);
}
static void playback_tasklet(unsigned long data)
{
struct ua101 *ua = (void *)data;
unsigned long flags;
unsigned int frames;
struct ua101_urb *urb;
bool do_period_elapsed = false;
int err;
if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states)))
return;
/*
* Synchronizing the playback rate to the capture rate is done by using
* the same sequence of packet sizes for both streams.
* Submitting a playback URB therefore requires both a ready URB and
* the size of the corresponding capture packet, i.e., both playback
* and capture URBs must have been completed. Since the USB core does
* not guarantee that playback and capture complete callbacks are
* called alternately, we use two FIFOs for packet sizes and read URBs;
* submitting playback URBs is possible as long as both FIFOs are
* nonempty.
*/
spin_lock_irqsave(&ua->lock, flags);
while (ua->rate_feedback_count > 0 &&
!list_empty(&ua->ready_playback_urbs)) {
/* take packet size out of FIFO */
frames = ua->rate_feedback[ua->rate_feedback_start];
add_with_wraparound(ua, &ua->rate_feedback_start, 1);
ua->rate_feedback_count--;
/* take URB out of FIFO */
urb = list_first_entry(&ua->ready_playback_urbs,
struct ua101_urb, ready_list);
list_del(&urb->ready_list);
/* fill packet with data or silence */
urb->urb.iso_frame_desc[0].length =
frames * ua->playback.frame_bytes;
if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
do_period_elapsed |= copy_playback_data(&ua->playback,
&urb->urb,
frames);
else
memset(urb->urb.transfer_buffer, 0,
urb->urb.iso_frame_desc[0].length);
/* and off you go ... */
err = usb_submit_urb(&urb->urb, GFP_ATOMIC);
if (unlikely(err < 0)) {
spin_unlock_irqrestore(&ua->lock, flags);
abort_usb_playback(ua);
abort_alsa_playback(ua);
dev_err(&ua->dev->dev, "USB request error %d: %s\n",
err, usb_error_string(err));
return;
}
ua->playback.substream->runtime->delay += frames;
}
spin_unlock_irqrestore(&ua->lock, flags);
if (do_period_elapsed)
snd_pcm_period_elapsed(ua->playback.substream);
}