// SPDX-License-Identifier: GPL-2.0-only
// Copyright (c) 2025 Šerif Rami <ramiserifpersia@gmail.com>

#include "us144mkii.h"

/**
 * tascam_playback_open() - Opens the PCM playback substream.
 * @substream: The ALSA PCM substream to open.
 *
 * This function sets the hardware parameters for the playback substream
 * and stores a reference to the substream in the driver's private data.
 *
 * Return: 0 on success.
 */
static int tascam_playback_open(struct snd_pcm_substream *substream) {
  struct tascam_card *tascam = snd_pcm_substream_chip(substream);

  substream->runtime->hw = tascam_pcm_hw;
  tascam->playback_substream = substream;
  atomic_set(&tascam->playback_active, 0);

  return 0;
}

/**
 * tascam_playback_close() - Closes the PCM playback substream.
 * @substream: The ALSA PCM substream to close.
 *
 * This function clears the reference to the playback substream in the
 * driver's private data.
 *
 * Return: 0 on success.
 */
static int tascam_playback_close(struct snd_pcm_substream *substream) {
  struct tascam_card *tascam = snd_pcm_substream_chip(substream);

  tascam->playback_substream = NULL;

  return 0;
}

/**
 * tascam_playback_prepare() - Prepares the PCM playback substream for use.
 * @substream: The ALSA PCM substream to prepare.
 *
 * This function initializes playback-related counters and flags, and configures
 * the playback URBs with appropriate packet sizes based on the nominal frame
 * rate and feedback accumulator.
 *
 * Return: 0 on success.
 */
static int tascam_playback_prepare(struct snd_pcm_substream *substream) {
  struct tascam_card *tascam = snd_pcm_substream_chip(substream);
  struct snd_pcm_runtime *runtime = substream->runtime;
  int i, u;
  size_t nominal_frames_per_packet, nominal_bytes_per_packet;
  size_t total_bytes_in_urb;
  unsigned int feedback_packets;

  tascam->driver_playback_pos = 0;
  tascam->playback_frames_consumed = 0;
  tascam->last_period_pos = 0;
  tascam->feedback_pattern_in_idx = 0;
  tascam->feedback_pattern_out_idx = 0;
  tascam->feedback_synced = false;
  tascam->feedback_consecutive_errors = 0;
  tascam->feedback_urb_skip_count = NUM_FEEDBACK_URBS;

<<<<<<< HEAD
  nominal_frames_per_packet = runtime->rate / 8000;
  for (i = 0; i < FEEDBACK_ACCUMULATOR_SIZE; i++)
    tascam->feedback_accumulator_pattern[i] = nominal_frames_per_packet;
=======
	nominal_frames_per_packet = runtime->rate / 8000;
	for (i = 0; i < FEEDBACK_ACCUMULATOR_SIZE; i++)
		tascam->feedback_accumulator_pattern[i] =
			nominal_frames_per_packet;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  feedback_packets = 1;

  for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
    struct urb *f_urb = tascam->feedback_urbs[i];
    int j;

<<<<<<< HEAD
    f_urb->number_of_packets = feedback_packets;
    f_urb->transfer_buffer_length = feedback_packets * FEEDBACK_PACKET_SIZE;
    for (j = 0; j < feedback_packets; j++) {
      f_urb->iso_frame_desc[j].offset = j * FEEDBACK_PACKET_SIZE;
      f_urb->iso_frame_desc[j].length = FEEDBACK_PACKET_SIZE;
    }
  }
=======
		f_urb->number_of_packets = feedback_packets;
		f_urb->transfer_buffer_length =
			feedback_packets * FEEDBACK_PACKET_SIZE;
		for (j = 0; j < feedback_packets; j++) {
			f_urb->iso_frame_desc[j].offset =
				j * FEEDBACK_PACKET_SIZE;
			f_urb->iso_frame_desc[j].length = FEEDBACK_PACKET_SIZE;
		}
	}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  nominal_bytes_per_packet = nominal_frames_per_packet * BYTES_PER_FRAME;
  total_bytes_in_urb = nominal_bytes_per_packet * PLAYBACK_URB_PACKETS;

  for (u = 0; u < NUM_PLAYBACK_URBS; u++) {
    struct urb *urb = tascam->playback_urbs[u];

<<<<<<< HEAD
    memset(urb->transfer_buffer, 0, tascam->playback_urb_alloc_size);
    urb->transfer_buffer_length = total_bytes_in_urb;
    urb->number_of_packets = PLAYBACK_URB_PACKETS;
    for (i = 0; i < PLAYBACK_URB_PACKETS; i++) {
      urb->iso_frame_desc[i].offset = i * nominal_bytes_per_packet;
      urb->iso_frame_desc[i].length = nominal_bytes_per_packet;
    }
  }
=======
		memset(urb->transfer_buffer, 0,
		       tascam->playback_urb_alloc_size);
		urb->transfer_buffer_length = total_bytes_in_urb;
		urb->number_of_packets = PLAYBACK_URB_PACKETS;
		for (i = 0; i < PLAYBACK_URB_PACKETS; i++) {
			urb->iso_frame_desc[i].offset =
				i * nominal_bytes_per_packet;
			urb->iso_frame_desc[i].length =
				nominal_bytes_per_packet;
		}
	}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  return 0;
}

/**
 * tascam_playback_pointer() - Returns the current playback pointer position.
 * @substream: The ALSA PCM substream.
 *
 * This function returns the current position of the playback pointer within
 * the ALSA ring buffer, in frames.
 *
 * Return: The current playback pointer position in frames.
 */
static snd_pcm_uframes_t
<<<<<<< HEAD
tascam_playback_pointer(struct snd_pcm_substream *substream) {
  struct tascam_card *tascam = snd_pcm_substream_chip(substream);
  struct snd_pcm_runtime *runtime = substream->runtime;
  u64 pos;
  unsigned long flags;
=======
tascam_playback_pointer(struct snd_pcm_substream *substream)
{
	struct tascam_card *tascam = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	u64 pos;
	unsigned long flags;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  if (!atomic_read(&tascam->playback_active))
    return 0;

  spin_lock_irqsave(&tascam->lock, flags);
  pos = tascam->playback_frames_consumed;
  spin_unlock_irqrestore(&tascam->lock, flags);

  u64 remainder = do_div(pos, runtime->buffer_size);
  return runtime ? remainder : 0;
}

/**
 * tascam_playback_ops - ALSA PCM operations for playback.
 *
 * This structure defines the callback functions for playback stream operations,
 * including open, close, ioctl, hardware parameters, hardware free, prepare,
 * trigger, and pointer.
 */
const struct snd_pcm_ops tascam_playback_ops = {
    .open = tascam_playback_open,
    .close = tascam_playback_close,
    .ioctl = snd_pcm_lib_ioctl,
    .hw_params = tascam_pcm_hw_params,
    .hw_free = tascam_pcm_hw_free,
    .prepare = tascam_playback_prepare,
    .trigger = tascam_pcm_trigger,
    .pointer = tascam_playback_pointer,
};

/**
 * playback_urb_complete() - Completion handler for playback isochronous URBs.
 * @urb: the completed URB
 *
 * This function runs in interrupt context. It calculates the number of bytes
 * to send in the next set of packets based on the feedback-driven clock,
 * copies the audio data from the ALSA ring buffer (applying routing), and
 * resubmits the URB.
 */
void playback_urb_complete(struct urb *urb) {
  struct tascam_card *tascam = urb->context;
  struct snd_pcm_substream *substream;
  struct snd_pcm_runtime *runtime;
  unsigned long flags;
  u8 *src_buf, *dst_buf;
  size_t total_bytes_for_urb = 0;
  snd_pcm_uframes_t offset_frames;
  snd_pcm_uframes_t frames_to_copy;
  int ret, i;

<<<<<<< HEAD
  if (urb->status) {
    if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
        urb->status != -ESHUTDOWN && urb->status != -ENODEV)
      dev_err_ratelimited(tascam->card->dev, "Playback URB failed: %d\n",
                          urb->status);
    goto out;
  }
  if (!tascam || !atomic_read(&tascam->playback_active))
    goto out;
=======
	if (urb->status) {
		if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
		    urb->status != -ESHUTDOWN && urb->status != -ENODEV)
			dev_err_ratelimited(tascam->card->dev,
					    "Playback URB failed: %d\n",
					    urb->status);
		goto out;
	}
	if (!tascam || !atomic_read(&tascam->playback_active))
		goto out;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  substream = tascam->playback_substream;
  if (!substream || !substream->runtime)
    goto out;
  runtime = substream->runtime;

  spin_lock_irqsave(&tascam->lock, flags);

  for (i = 0; i < urb->number_of_packets; i++) {
    unsigned int frames_for_packet;
    size_t bytes_for_packet;

<<<<<<< HEAD
    if (tascam->feedback_synced) {
      frames_for_packet =
          tascam
              ->feedback_accumulator_pattern[tascam->feedback_pattern_out_idx];
      tascam->feedback_pattern_out_idx =
          (tascam->feedback_pattern_out_idx + 1) % FEEDBACK_ACCUMULATOR_SIZE;
    } else {
      frames_for_packet = runtime->rate / 8000;
    }
    bytes_for_packet = frames_for_packet * BYTES_PER_FRAME;
=======
		if (tascam->feedback_synced) {
			frames_for_packet =
				tascam->feedback_accumulator_pattern
					[tascam->feedback_pattern_out_idx];
			tascam->feedback_pattern_out_idx =
				(tascam->feedback_pattern_out_idx + 1) %
				FEEDBACK_ACCUMULATOR_SIZE;
		} else {
			frames_for_packet = runtime->rate / 8000;
		}
		bytes_for_packet = frames_for_packet * BYTES_PER_FRAME;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

    urb->iso_frame_desc[i].offset = total_bytes_for_urb;
    urb->iso_frame_desc[i].length = bytes_for_packet;
    total_bytes_for_urb += bytes_for_packet;
  }
  urb->transfer_buffer_length = total_bytes_for_urb;

<<<<<<< HEAD
  offset_frames = tascam->driver_playback_pos;
  frames_to_copy = bytes_to_frames(runtime, total_bytes_for_urb);
  tascam->driver_playback_pos =
      (offset_frames + frames_to_copy) % runtime->buffer_size;
=======
	offset_frames = tascam->driver_playback_pos;
	frames_to_copy = bytes_to_frames(runtime, total_bytes_for_urb);
	tascam->driver_playback_pos =
		(offset_frames + frames_to_copy) % runtime->buffer_size;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  spin_unlock_irqrestore(&tascam->lock, flags);

<<<<<<< HEAD
  if (total_bytes_for_urb > 0) {
    src_buf = runtime->dma_area + frames_to_bytes(runtime, offset_frames);
    dst_buf = tascam->playback_routing_buffer;

    /* Handle ring buffer wrap-around */
    if (offset_frames + frames_to_copy > runtime->buffer_size) {
      size_t first_chunk_bytes =
          frames_to_bytes(runtime, runtime->buffer_size - offset_frames);
      size_t second_chunk_bytes = total_bytes_for_urb - first_chunk_bytes;

      memcpy(dst_buf, src_buf, first_chunk_bytes);
      memcpy(dst_buf + first_chunk_bytes, runtime->dma_area,
             second_chunk_bytes);
    } else {
      memcpy(dst_buf, src_buf, total_bytes_for_urb);
    }

    /* Apply routing to the contiguous data in our routing buffer */
    process_playback_routing_us144mkii(tascam, dst_buf, dst_buf,
                                       frames_to_copy);
    memcpy(urb->transfer_buffer, dst_buf, total_bytes_for_urb);
  }

  urb->dev = tascam->dev;
  usb_get_urb(urb);
  usb_anchor_urb(urb, &tascam->playback_anchor);
  ret = usb_submit_urb(urb, GFP_ATOMIC);
  if (ret < 0) {
    dev_err_ratelimited(tascam->card->dev,
                        "Failed to resubmit playback URB: %d\n", ret);
    usb_unanchor_urb(urb);
    usb_put_urb(urb);
  }
=======
	if (total_bytes_for_urb > 0) {
		src_buf = runtime->dma_area +
			  frames_to_bytes(runtime, offset_frames);
		dst_buf = tascam->playback_routing_buffer;

		/* Handle ring buffer wrap-around */
		if (offset_frames + frames_to_copy > runtime->buffer_size) {
			size_t first_chunk_bytes = frames_to_bytes(
				runtime, runtime->buffer_size - offset_frames);
			size_t second_chunk_bytes =
				total_bytes_for_urb - first_chunk_bytes;

			memcpy(dst_buf, src_buf, first_chunk_bytes);
			memcpy(dst_buf + first_chunk_bytes, runtime->dma_area,
			       second_chunk_bytes);
		} else {
			memcpy(dst_buf, src_buf, total_bytes_for_urb);
		}

		/* Apply routing to the contiguous data in our routing buffer */
		process_playback_routing_us144mkii(tascam, dst_buf, dst_buf,
						   frames_to_copy);
		memcpy(urb->transfer_buffer, dst_buf, total_bytes_for_urb);
	}

	urb->dev = tascam->dev;
	usb_get_urb(urb);
	usb_anchor_urb(urb, &tascam->playback_anchor);
	ret = usb_submit_urb(urb, GFP_ATOMIC);
	if (ret < 0) {
		dev_err_ratelimited(tascam->card->dev,
				    "Failed to resubmit playback URB: %d\n",
				    ret);
		usb_unanchor_urb(urb);
		usb_put_urb(urb);
	}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
out:
  usb_put_urb(urb);
}

/**
 * feedback_urb_complete() - Completion handler for feedback isochronous URBs.
 * @urb: the completed URB
 *
 * This is the master clock for the driver. It runs in interrupt context.
 * It reads the feedback value from the device, which indicates how many
 * samples the device has consumed. This information is used to adjust the
 * playback rate and to advance the capture stream pointer, keeping both
 * streams in sync. It then calls snd_pcm_period_elapsed if necessary and
 * resubmits itself.
 */
void feedback_urb_complete(struct urb *urb) {
  struct tascam_card *tascam = urb->context;
  struct snd_pcm_substream *playback_ss, *capture_ss;
  struct snd_pcm_runtime *playback_rt, *capture_rt;
  unsigned long flags;
  u64 total_frames_in_urb = 0;
  int ret, p;
  unsigned int old_in_idx, new_in_idx;
  bool playback_period_elapsed = false;
  bool capture_period_elapsed = false;

<<<<<<< HEAD
  if (urb->status) {
    if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
        urb->status != -ESHUTDOWN && urb->status != -ENODEV)
      dev_err_ratelimited(tascam->card->dev, "Feedback URB failed: %d\n",
                          urb->status);
    goto out;
  }
  if (!tascam || !atomic_read(&tascam->playback_active))
    goto out;
=======
	if (urb->status) {
		if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
		    urb->status != -ESHUTDOWN && urb->status != -ENODEV)
			dev_err_ratelimited(tascam->card->dev,
					    "Feedback URB failed: %d\n",
					    urb->status);
		goto out;
	}
	if (!tascam || !atomic_read(&tascam->playback_active))
		goto out;
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  playback_ss = tascam->playback_substream;
  if (!playback_ss || !playback_ss->runtime)
    goto out;
  playback_rt = playback_ss->runtime;

  capture_ss = tascam->capture_substream;
  capture_rt = capture_ss ? capture_ss->runtime : NULL;

  spin_lock_irqsave(&tascam->lock, flags);

  if (tascam->feedback_urb_skip_count > 0) {
    tascam->feedback_urb_skip_count--;
    goto unlock_and_continue;
  }

  old_in_idx = tascam->feedback_pattern_in_idx;

  for (p = 0; p < urb->number_of_packets; p++) {
    u8 feedback_value = 0;
    const unsigned int *pattern;
    bool packet_ok = (urb->iso_frame_desc[p].status == 0 &&
                      urb->iso_frame_desc[p].actual_length >= 1);

<<<<<<< HEAD
    if (packet_ok)
      feedback_value =
          *((u8 *)urb->transfer_buffer + urb->iso_frame_desc[p].offset);

    if (packet_ok && feedback_value >= tascam->feedback_base_value &&
        feedback_value <= tascam->feedback_max_value) {
      pattern =
          tascam
              ->feedback_patterns[feedback_value - tascam->feedback_base_value];
      tascam->feedback_consecutive_errors = 0;
      int i;

      for (i = 0; i < 8; i++) {
        unsigned int in_idx =
            (tascam->feedback_pattern_in_idx + i) % FEEDBACK_ACCUMULATOR_SIZE;

        tascam->feedback_accumulator_pattern[in_idx] = pattern[i];
        total_frames_in_urb += pattern[i];
      }
    } else {
      unsigned int nominal_frames = playback_rt->rate / 8000;
      int i;

      if (tascam->feedback_synced) {
        tascam->feedback_consecutive_errors++;
        if (tascam->feedback_consecutive_errors >
            FEEDBACK_SYNC_LOSS_THRESHOLD) {
          dev_err(tascam->card->dev,
                  "Fatal: Feedback sync lost. Stopping stream.\n");
          if (playback_ss)
            snd_pcm_stop(playback_ss, SNDRV_PCM_STATE_XRUN);
          if (capture_ss)
            snd_pcm_stop(capture_ss, SNDRV_PCM_STATE_XRUN);
          tascam->feedback_synced = false;
          goto unlock_and_continue;
        }
      }
      for (i = 0; i < 8; i++) {
        unsigned int in_idx =
            (tascam->feedback_pattern_in_idx + i) % FEEDBACK_ACCUMULATOR_SIZE;

        tascam->feedback_accumulator_pattern[in_idx] = nominal_frames;
        total_frames_in_urb += nominal_frames;
      }
    }
    tascam->feedback_pattern_in_idx =
        (tascam->feedback_pattern_in_idx + 8) % FEEDBACK_ACCUMULATOR_SIZE;
  }
=======
		if (packet_ok)
			feedback_value = *((u8 *)urb->transfer_buffer +
					   urb->iso_frame_desc[p].offset);

		if (packet_ok &&
		    feedback_value >= tascam->feedback_base_value &&
		    feedback_value <= tascam->feedback_max_value) {
			pattern = tascam->feedback_patterns
					  [feedback_value -
					   tascam->feedback_base_value];
			tascam->feedback_consecutive_errors = 0;
			int i;

			for (i = 0; i < 8; i++) {
				unsigned int in_idx =
					(tascam->feedback_pattern_in_idx + i) %
					FEEDBACK_ACCUMULATOR_SIZE;

				tascam->feedback_accumulator_pattern[in_idx] =
					pattern[i];
				total_frames_in_urb += pattern[i];
			}
		} else {
			unsigned int nominal_frames = playback_rt->rate / 8000;
			int i;

			if (tascam->feedback_synced) {
				tascam->feedback_consecutive_errors++;
				if (tascam->feedback_consecutive_errors >
				    FEEDBACK_SYNC_LOSS_THRESHOLD) {
					dev_err(tascam->card->dev,
						"Fatal: Feedback sync lost. Stopping stream.\n");
					if (playback_ss)
						snd_pcm_stop(
							playback_ss,
							SNDRV_PCM_STATE_XRUN);
					if (capture_ss)
						snd_pcm_stop(
							capture_ss,
							SNDRV_PCM_STATE_XRUN);
					tascam->feedback_synced = false;
					goto unlock_and_continue;
				}
			}
			for (i = 0; i < 8; i++) {
				unsigned int in_idx =
					(tascam->feedback_pattern_in_idx + i) %
					FEEDBACK_ACCUMULATOR_SIZE;

				tascam->feedback_accumulator_pattern[in_idx] =
					nominal_frames;
				total_frames_in_urb += nominal_frames;
			}
		}
		tascam->feedback_pattern_in_idx =
			(tascam->feedback_pattern_in_idx + 8) %
			FEEDBACK_ACCUMULATOR_SIZE;
	}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  new_in_idx = tascam->feedback_pattern_in_idx;

<<<<<<< HEAD
  if (!tascam->feedback_synced) {
    unsigned int out_idx = tascam->feedback_pattern_out_idx;
    bool is_ahead = (new_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE <
                    (FEEDBACK_ACCUMULATOR_SIZE / 2);
    bool was_behind = (old_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE >=
                      (FEEDBACK_ACCUMULATOR_SIZE / 2);

    if (is_ahead && was_behind) {
      dev_dbg(tascam->card->dev, "Sync Acquired! (in: %u, out: %u)\n",
              new_in_idx, out_idx);
      tascam->feedback_synced = true;
      tascam->feedback_consecutive_errors = 0;
    }
  }
=======
	if (!tascam->feedback_synced) {
		unsigned int out_idx = tascam->feedback_pattern_out_idx;
		bool is_ahead =
			(new_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE <
			(FEEDBACK_ACCUMULATOR_SIZE / 2);
		bool was_behind =
			(old_in_idx - out_idx) % FEEDBACK_ACCUMULATOR_SIZE >=
			(FEEDBACK_ACCUMULATOR_SIZE / 2);

		if (is_ahead && was_behind) {
			dev_dbg(tascam->card->dev,
				"Sync Acquired! (in: %u, out: %u)\n",
				new_in_idx, out_idx);
			tascam->feedback_synced = true;
			tascam->feedback_consecutive_errors = 0;
		}
	}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

  if (total_frames_in_urb > 0) {
    tascam->playback_frames_consumed += total_frames_in_urb;
    if (atomic_read(&tascam->capture_active))
      tascam->capture_frames_processed += total_frames_in_urb;
  }

<<<<<<< HEAD
  if (playback_rt->period_size > 0) {
    u64 current_period =
        div_u64(tascam->playback_frames_consumed, playback_rt->period_size);
=======
	if (playback_rt->period_size > 0) {
		u64 current_period = div_u64(tascam->playback_frames_consumed,
					     playback_rt->period_size);
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

    if (current_period > tascam->last_period_pos) {
      tascam->last_period_pos = current_period;
      playback_period_elapsed = true;
    }
  }

<<<<<<< HEAD
  if (atomic_read(&tascam->capture_active) && capture_rt &&
      capture_rt->period_size > 0) {
    u64 current_capture_period =
        div_u64(tascam->capture_frames_processed, capture_rt->period_size);

    if (current_capture_period > tascam->last_capture_period_pos) {
      tascam->last_capture_period_pos = current_capture_period;
      capture_period_elapsed = true;
    }
  }
=======
	if (atomic_read(&tascam->capture_active) && capture_rt &&
	    capture_rt->period_size > 0) {
		u64 current_capture_period =
			div_u64(tascam->capture_frames_processed,
				capture_rt->period_size);

		if (current_capture_period > tascam->last_capture_period_pos) {
			tascam->last_capture_period_pos =
				current_capture_period;
			capture_period_elapsed = true;
		}
	}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b

unlock_and_continue:
  spin_unlock_irqrestore(&tascam->lock, flags);

  if (playback_period_elapsed)
    snd_pcm_period_elapsed(playback_ss);
  if (capture_period_elapsed)
    snd_pcm_period_elapsed(capture_ss);

<<<<<<< HEAD
  urb->dev = tascam->dev;
  usb_get_urb(urb);
  usb_anchor_urb(urb, &tascam->feedback_anchor);
  ret = usb_submit_urb(urb, GFP_ATOMIC);
  if (ret < 0) {
    dev_err_ratelimited(tascam->card->dev,
                        "Failed to resubmit feedback URB: %d\n", ret);
    usb_unanchor_urb(urb);
    usb_put_urb(urb);
  }
=======
	urb->dev = tascam->dev;
	usb_get_urb(urb);
	usb_anchor_urb(urb, &tascam->feedback_anchor);
	ret = usb_submit_urb(urb, GFP_ATOMIC);
	if (ret < 0) {
		dev_err_ratelimited(tascam->card->dev,
				    "Failed to resubmit feedback URB: %d\n",
				    ret);
		usb_unanchor_urb(urb);
		usb_put_urb(urb);
	}
>>>>>>> f44b75094c078b0354fac280d769bc9a1bb6133b
out:
  usb_put_urb(urb);
}
