us144mkii_playback.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2// Copyright (c) 2025 Šerif Rami <ramiserifpersia@gmail.com>
  3
  4#include "us144mkii.h"
  5
  6/**
  7 * tascam_playback_open() - Opens the PCM playback substream.
  8 * @substream: The ALSA PCM substream to open.
  9 *
 10 * This function sets the hardware parameters for the playback substream
 11 * and stores a reference to the substream in the driver's private data.
 12 *
 13 * Return: 0 on success.
 14 */
 15static int tascam_playback_open(struct snd_pcm_substream *substream)
 16{
 17	struct tascam_card *tascam = snd_pcm_substream_chip(substream);
 18
 19	substream->runtime->hw = tascam_pcm_hw;
 20	tascam->playback_substream = substream;
 21	atomic_set(&tascam->playback_active, 0);
 22
 23	return 0;
 24}
 25
 26/**
 27 * tascam_playback_close() - Closes the PCM playback substream.
 28 * @substream: The ALSA PCM substream to close.
 29 *
 30 * This function clears the reference to the playback substream in the
 31 * driver's private data.
 32 *
 33 * Return: 0 on success.
 34 */
 35static int tascam_playback_close(struct snd_pcm_substream *substream)
 36{
 37	struct tascam_card *tascam = snd_pcm_substream_chip(substream);
 38
 39	tascam->playback_substream = NULL;
 40
 41	return 0;
 42}
 43
 44/**
 45 * tascam_playback_prepare() - Prepares the PCM playback substream for use.
 46 * @substream: The ALSA PCM substream to prepare.
 47 *
 48 * This function initializes playback-related counters and flags, and configures
 49 * the playback URBs with appropriate packet sizes based on the nominal frame
 50 * rate.
 51 *
 52 * Return: 0 on success.
 53 */
 54static int tascam_playback_prepare(struct snd_pcm_substream *substream)
 55{
 56	struct tascam_card *tascam = snd_pcm_substream_chip(substream);
 57	struct snd_pcm_runtime *runtime = substream->runtime;
 58	int i, u;
 59	size_t nominal_frames_per_packet, nominal_bytes_per_packet;
 60	size_t total_bytes_in_urb;
 61
 62	tascam->driver_playback_pos = 0;
 63	tascam->playback_frames_consumed = 0;
 64	tascam->last_period_pos = 0;
 65	tascam->feedback_pattern_in_idx = 0;
 66	tascam->feedback_pattern_out_idx = 0;
 67	tascam->feedback_synced = false;
 68	tascam->feedback_consecutive_errors = 0;
 69	tascam->feedback_urb_skip_count = NUM_FEEDBACK_URBS;
 70
 71	nominal_frames_per_packet = runtime->rate / 8000;
 72	for (i = 0; i < FEEDBACK_ACCUMULATOR_SIZE; i++)
 73		tascam->feedback_accumulator_pattern[i] =
 74			nominal_frames_per_packet;
 75
 76	for (i = 0; i < NUM_FEEDBACK_URBS; i++) {
 77		struct urb *f_urb = tascam->feedback_urbs[i];
 78		int j;
 79
 80		f_urb->number_of_packets = FEEDBACK_URB_PACKETS;
 81		f_urb->transfer_buffer_length =
 82			FEEDBACK_URB_PACKETS * FEEDBACK_PACKET_SIZE;
 83		for (j = 0; j < FEEDBACK_URB_PACKETS; j++) {
 84			f_urb->iso_frame_desc[j].offset =
 85				j * FEEDBACK_PACKET_SIZE;
 86			f_urb->iso_frame_desc[j].length = FEEDBACK_PACKET_SIZE;
 87		}
 88	}
 89
 90	nominal_bytes_per_packet = nominal_frames_per_packet * BYTES_PER_FRAME;
 91	total_bytes_in_urb = nominal_bytes_per_packet * PLAYBACK_URB_PACKETS;
 92
 93	for (u = 0; u < NUM_PLAYBACK_URBS; u++) {
 94		struct urb *urb = tascam->playback_urbs[u];
 95
 96		memset(urb->transfer_buffer, 0,
 97		       tascam->playback_urb_alloc_size);
 98		urb->transfer_buffer_length = total_bytes_in_urb;
 99		urb->number_of_packets = PLAYBACK_URB_PACKETS;
100		for (i = 0; i < PLAYBACK_URB_PACKETS; i++) {
101			urb->iso_frame_desc[i].offset =
102				i * nominal_bytes_per_packet;
103			urb->iso_frame_desc[i].length =
104				nominal_bytes_per_packet;
105		}
106	}
107
108	return 0;
109}
110
111/**
112 * tascam_playback_pointer() - Returns the current playback pointer position.
113 * @substream: The ALSA PCM substream.
114 *
115 * This function returns the current position of the playback pointer within
116 * the ALSA ring buffer, in frames.
117 *
118 * Return: The current playback pointer position in frames.
119 */
120static snd_pcm_uframes_t
121tascam_playback_pointer(struct snd_pcm_substream *substream)
122{
123	struct tascam_card *tascam = snd_pcm_substream_chip(substream);
124	struct snd_pcm_runtime *runtime = substream->runtime;
125	u64 pos;
126
127	if (!atomic_read(&tascam->playback_active))
128		return 0;
129
130	scoped_guard(spinlock_irqsave, &tascam->lock) {
131		pos = tascam->playback_frames_consumed;
132	}
133
134	if (runtime->buffer_size == 0)
135		return 0;
136
137	return do_div(pos, runtime->buffer_size);
138}
139
140/**
141 * tascam_playback_ops - ALSA PCM operations for playback.
142 *
143 * This structure defines the callback functions for playback stream operations,
144 * including open, close, ioctl, hardware parameters, hardware free, prepare,
145 * trigger, and pointer.
146 */
147const struct snd_pcm_ops tascam_playback_ops = {
148	.open = tascam_playback_open,
149	.close = tascam_playback_close,
150	.ioctl = snd_pcm_lib_ioctl,
151	.hw_params = tascam_pcm_hw_params,
152	.hw_free = tascam_pcm_hw_free,
153	.prepare = tascam_playback_prepare,
154	.trigger = tascam_pcm_trigger,
155	.pointer = tascam_playback_pointer,
156};
157
158void playback_urb_complete(struct urb *urb)
159{
160	struct tascam_card *tascam = urb->context;
161	struct snd_pcm_substream *substream;
162	struct snd_pcm_runtime *runtime;
163	size_t total_bytes_for_urb = 0;
164	snd_pcm_uframes_t offset_frames;
165	snd_pcm_uframes_t frames_to_copy;
166	int ret, i;
167
168	if (urb->status) {
169		if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
170		    urb->status != -ESHUTDOWN && urb->status != -ENODEV)
171			dev_err_ratelimited(tascam->card->dev,
172					    "Playback URB failed: %d\n",
173					    urb->status);
174		goto out;
175	}
176	if (!tascam || !atomic_read(&tascam->playback_active))
177		goto out;
178
179	substream = tascam->playback_substream;
180	if (!substream || !substream->runtime)
181		goto out;
182	runtime = substream->runtime;
183
184	scoped_guard(spinlock_irqsave, &tascam->lock) {
185		for (i = 0; i < urb->number_of_packets; i++) {
186			unsigned int frames_for_packet;
187			size_t bytes_for_packet;
188
189			if (tascam->feedback_synced) {
190				frames_for_packet =
191					tascam->feedback_accumulator_pattern
192						[tascam->feedback_pattern_out_idx];
193				tascam->feedback_pattern_out_idx =
194					(tascam->feedback_pattern_out_idx + 1) %
195					FEEDBACK_ACCUMULATOR_SIZE;
196			} else {
197				frames_for_packet = runtime->rate / 8000;
198			}
199			bytes_for_packet = frames_for_packet * BYTES_PER_FRAME;
200
201			urb->iso_frame_desc[i].offset = total_bytes_for_urb;
202			urb->iso_frame_desc[i].length = bytes_for_packet;
203			total_bytes_for_urb += bytes_for_packet;
204		}
205		urb->transfer_buffer_length = total_bytes_for_urb;
206
207		offset_frames = tascam->driver_playback_pos;
208		frames_to_copy = bytes_to_frames(runtime, total_bytes_for_urb);
209		tascam->driver_playback_pos =
210			(offset_frames + frames_to_copy) % runtime->buffer_size;
211	}
212
213	if (total_bytes_for_urb > 0) {
214		u8 *dst_buf = urb->transfer_buffer;
215
216		/* Handle ring buffer wrap-around */
217		if (offset_frames + frames_to_copy > runtime->buffer_size) {
218			size_t first_chunk_bytes = frames_to_bytes(
219				runtime, runtime->buffer_size - offset_frames);
220			size_t second_chunk_bytes =
221				total_bytes_for_urb - first_chunk_bytes;
222
223			memcpy(dst_buf,
224			       runtime->dma_area +
225				       frames_to_bytes(runtime, offset_frames),
226			       first_chunk_bytes);
227			memcpy(dst_buf + first_chunk_bytes, runtime->dma_area,
228			       second_chunk_bytes);
229		} else {
230			memcpy(dst_buf,
231			       runtime->dma_area +
232				       frames_to_bytes(runtime, offset_frames),
233			       total_bytes_for_urb);
234		}
235
236		process_playback_routing_us144mkii(tascam, dst_buf, dst_buf,
237						   frames_to_copy);
238	}
239
240	urb->dev = tascam->dev;
241	usb_get_urb(urb);
242	usb_anchor_urb(urb, &tascam->playback_anchor);
243	ret = usb_submit_urb(urb, GFP_ATOMIC);
244	if (ret < 0) {
245		dev_err_ratelimited(tascam->card->dev,
246				    "Failed to resubmit playback URB: %d\n",
247				    ret);
248		usb_unanchor_urb(urb);
249		usb_put_urb(urb);
250		atomic_dec(
251			&tascam->active_urbs); /* Decrement on failed resubmission */
252	}
253out:
254	usb_put_urb(urb);
255}
256
257void feedback_urb_complete(struct urb *urb)
258{
259	struct tascam_card *tascam = urb->context;
260	struct snd_pcm_substream *playback_ss, *capture_ss;
261	struct snd_pcm_runtime *playback_rt, *capture_rt;
262	u64 total_frames_in_urb = 0;
263	int ret, p;
264	unsigned int old_in_idx, new_in_idx;
265	bool playback_period_elapsed = false;
266	bool capture_period_elapsed = false;
267
268	if (urb->status) {
269		if (urb->status != -ENOENT && urb->status != -ECONNRESET &&
270		    urb->status != -ESHUTDOWN && urb->status != -ENODEV) {
271			dev_err_ratelimited(tascam->card->dev,
272					    "Feedback URB failed: %d\n",
273					    urb->status);
274			atomic_dec(
275				&tascam->active_urbs); /* Decrement on failed resubmission */
276		}
277		goto out;
278	}
279	if (!tascam || !atomic_read(&tascam->playback_active))
280		goto out;
281
282	playback_ss = tascam->playback_substream;
283	if (!playback_ss || !playback_ss->runtime)
284		goto out;
285	playback_rt = playback_ss->runtime;
286
287	capture_ss = tascam->capture_substream;
288	capture_rt = capture_ss ? capture_ss->runtime : NULL;
289
290	scoped_guard(spinlock_irqsave, &tascam->lock) {
291		if (tascam->feedback_urb_skip_count > 0) {
292			tascam->feedback_urb_skip_count--;
293			break;
294		}
295
296		old_in_idx = tascam->feedback_pattern_in_idx;
297
298		for (p = 0; p < urb->number_of_packets; p++) {
299			u8 feedback_value = 0;
300			const unsigned int *pattern;
301			bool packet_ok =
302				(urb->iso_frame_desc[p].status == 0 &&
303				 urb->iso_frame_desc[p].actual_length >= 1);
304
305			if (packet_ok)
306				feedback_value =
307					*((u8 *)urb->transfer_buffer +
308					  urb->iso_frame_desc[p].offset);
309
310			if (packet_ok) {
311				int delta = feedback_value -
312						    tascam->fpo.base_feedback_value +
313						    tascam->fpo.feedback_offset;
314				int pattern_idx;
315
316				if (delta < 0) {
317					pattern_idx =
318						0; // Clamp to the lowest pattern
319				} else if (delta >= 5) {
320					pattern_idx =
321						4; // Clamp to the highest pattern
322				} else {
323					pattern_idx = delta;
324				}
325
326				pattern =
327					tascam->fpo
328						.full_frame_patterns[pattern_idx];
329				tascam->feedback_consecutive_errors = 0;
330				int i;
331
332				for (i = 0; i < 8; i++) {
333					unsigned int in_idx =
334						(tascam->feedback_pattern_in_idx +
335						 i) %
336						FEEDBACK_ACCUMULATOR_SIZE;
337
338					tascam->feedback_accumulator_pattern
339						[in_idx] = pattern[i];
340					total_frames_in_urb += pattern[i];
341				}
342			} else {
343				unsigned int nominal_frames =
344					playback_rt->rate / 8000;
345				int i;
346
347				if (tascam->feedback_synced) {
348					tascam->feedback_consecutive_errors++;
349					if (tascam->feedback_consecutive_errors >
350					    FEEDBACK_SYNC_LOSS_THRESHOLD) {
351						dev_err(tascam->card->dev,
352							"Fatal: Feedback sync lost. Stopping stream.\n");
353						schedule_work(
354								&tascam->stop_pcm_work);
355						tascam->feedback_synced = false;
356						break;
357					}
358				}
359				for (i = 0; i < 8; i++) {
360					unsigned int in_idx =
361						(tascam->feedback_pattern_in_idx +
362						 i) %
363						FEEDBACK_ACCUMULATOR_SIZE;
364
365					tascam->feedback_accumulator_pattern
366						[in_idx] = nominal_frames;
367					total_frames_in_urb += nominal_frames;
368				}
369			}
370			tascam->feedback_pattern_in_idx =
371				(tascam->feedback_pattern_in_idx + 8) %
372				FEEDBACK_ACCUMULATOR_SIZE;
373		}
374
375		new_in_idx = tascam->feedback_pattern_in_idx;
376
377		if (!tascam->feedback_synced) {
378			unsigned int out_idx = tascam->feedback_pattern_out_idx;
379			bool is_ahead = (new_in_idx - out_idx) %
380						FEEDBACK_ACCUMULATOR_SIZE <
381					(FEEDBACK_ACCUMULATOR_SIZE / 2);
382			bool was_behind = (old_in_idx - out_idx) %
383						FEEDBACK_ACCUMULATOR_SIZE >=
384					(FEEDBACK_ACCUMULATOR_SIZE / 2);
385
386			if (is_ahead && was_behind) {
387				dev_dbg(tascam->card->dev,
388					"Sync Acquired! (in: %u, out: %u)\n",
389					new_in_idx, out_idx);
390				tascam->feedback_synced = true;
391				tascam->feedback_consecutive_errors = 0;
392			}
393		}
394
395		if (total_frames_in_urb > 0) {
396			tascam->playback_frames_consumed += total_frames_in_urb;
397			if (atomic_read(&tascam->capture_active))
398				tascam->capture_frames_processed +=
399					total_frames_in_urb;
400		}
401
402		if (playback_rt->period_size > 0) {
403			u64 current_period =
404				div_u64(tascam->playback_frames_consumed,
405						playback_rt->period_size);
406
407			if (current_period > tascam->last_period_pos) {
408				tascam->last_period_pos = current_period;
409				playback_period_elapsed = true;
410			}
411		}
412
413		if (atomic_read(&tascam->capture_active) && capture_rt &&
414		    capture_rt->period_size > 0) {
415			u64 current_capture_period =
416				div_u64(tascam->capture_frames_processed,
417						capture_rt->period_size);
418
419			if (current_capture_period >
420			    tascam->last_capture_period_pos) {
421				tascam->last_capture_period_pos =
422					current_capture_period;
423				capture_period_elapsed = true;
424			}
425		}
426	}
427	if (playback_period_elapsed)
428		snd_pcm_period_elapsed(playback_ss);
429	if (capture_period_elapsed)
430		snd_pcm_period_elapsed(capture_ss);
431
432	urb->dev = tascam->dev;
433	usb_get_urb(urb);
434	usb_anchor_urb(urb, &tascam->feedback_anchor);
435	ret = usb_submit_urb(urb, GFP_ATOMIC);
436	if (ret < 0) {
437		dev_err_ratelimited(tascam->card->dev,
438				    "Failed to resubmit feedback URB: %d\n",
439				    ret);
440		usb_unanchor_urb(urb);
441		usb_put_urb(urb);
442	}
443out:
444	usb_put_urb(urb);
445}
446
447void tascam_stop_pcm_work_handler(struct work_struct *work)
448{
449	struct tascam_card *tascam =
450		container_of(work, struct tascam_card, stop_pcm_work);
451
452	if (tascam->playback_substream)
453		snd_pcm_stop(tascam->playback_substream, SNDRV_PCM_STATE_XRUN);
454	if (tascam->capture_substream)
455		snd_pcm_stop(tascam->capture_substream, SNDRV_PCM_STATE_XRUN);
456}