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 */
tascam_playback_open(struct snd_pcm_substream * substream)15 static 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 */
tascam_playback_close(struct snd_pcm_substream * substream)35 static 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 */
tascam_playback_prepare(struct snd_pcm_substream * substream)54 static 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 */
120 static snd_pcm_uframes_t
tascam_playback_pointer(struct snd_pcm_substream * substream)121 tascam_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 */
147 const 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
playback_urb_complete(struct urb * urb)158 void 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 }
253 out:
254 usb_put_urb(urb);
255 }
256
feedback_urb_complete(struct urb * urb)257 void 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 }
443 out:
444 usb_put_urb(urb);
445 }
446
tascam_stop_pcm_work_handler(struct work_struct * work)447 void 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 }
457