xref: /openbmc/linux/sound/usb/pcm.c (revision 8ba61c9f)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  */
4 
5 #include <linux/init.h>
6 #include <linux/slab.h>
7 #include <linux/bitrev.h>
8 #include <linux/ratelimit.h>
9 #include <linux/usb.h>
10 #include <linux/usb/audio.h>
11 #include <linux/usb/audio-v2.h>
12 
13 #include <sound/core.h>
14 #include <sound/pcm.h>
15 #include <sound/pcm_params.h>
16 
17 #include "usbaudio.h"
18 #include "card.h"
19 #include "quirks.h"
20 #include "endpoint.h"
21 #include "helper.h"
22 #include "pcm.h"
23 #include "clock.h"
24 #include "power.h"
25 #include "media.h"
26 #include "implicit.h"
27 
28 #define SUBSTREAM_FLAG_DATA_EP_STARTED	0
29 #define SUBSTREAM_FLAG_SYNC_EP_STARTED	1
30 
31 /* return the estimated delay based on USB frame counters */
snd_usb_pcm_delay(struct snd_usb_substream * subs,struct snd_pcm_runtime * runtime)32 static snd_pcm_uframes_t snd_usb_pcm_delay(struct snd_usb_substream *subs,
33 					   struct snd_pcm_runtime *runtime)
34 {
35 	unsigned int current_frame_number;
36 	unsigned int frame_diff;
37 	int est_delay;
38 	int queued;
39 
40 	if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
41 		queued = bytes_to_frames(runtime, subs->inflight_bytes);
42 		if (!queued)
43 			return 0;
44 	} else if (!subs->running) {
45 		return 0;
46 	}
47 
48 	current_frame_number = usb_get_current_frame_number(subs->dev);
49 	/*
50 	 * HCD implementations use different widths, use lower 8 bits.
51 	 * The delay will be managed up to 256ms, which is more than
52 	 * enough
53 	 */
54 	frame_diff = (current_frame_number - subs->last_frame_number) & 0xff;
55 
56 	/* Approximation based on number of samples per USB frame (ms),
57 	   some truncation for 44.1 but the estimate is good enough */
58 	est_delay = frame_diff * runtime->rate / 1000;
59 
60 	if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
61 		est_delay = queued - est_delay;
62 		if (est_delay < 0)
63 			est_delay = 0;
64 	}
65 
66 	return est_delay;
67 }
68 
69 /*
70  * return the current pcm pointer.  just based on the hwptr_done value.
71  */
snd_usb_pcm_pointer(struct snd_pcm_substream * substream)72 static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
73 {
74 	struct snd_pcm_runtime *runtime = substream->runtime;
75 	struct snd_usb_substream *subs = runtime->private_data;
76 	unsigned int hwptr_done;
77 
78 	if (atomic_read(&subs->stream->chip->shutdown))
79 		return SNDRV_PCM_POS_XRUN;
80 	spin_lock(&subs->lock);
81 	hwptr_done = subs->hwptr_done;
82 	runtime->delay = snd_usb_pcm_delay(subs, runtime);
83 	spin_unlock(&subs->lock);
84 	return bytes_to_frames(runtime, hwptr_done);
85 }
86 
87 /*
88  * find a matching audio format
89  */
90 static const struct audioformat *
find_format(struct list_head * fmt_list_head,snd_pcm_format_t format,unsigned int rate,unsigned int channels,bool strict_match,struct snd_usb_substream * subs)91 find_format(struct list_head *fmt_list_head, snd_pcm_format_t format,
92 	    unsigned int rate, unsigned int channels, bool strict_match,
93 	    struct snd_usb_substream *subs)
94 {
95 	const struct audioformat *fp;
96 	const struct audioformat *found = NULL;
97 	int cur_attr = 0, attr;
98 
99 	list_for_each_entry(fp, fmt_list_head, list) {
100 		if (strict_match) {
101 			if (!(fp->formats & pcm_format_to_bits(format)))
102 				continue;
103 			if (fp->channels != channels)
104 				continue;
105 		}
106 		if (rate < fp->rate_min || rate > fp->rate_max)
107 			continue;
108 		if (!(fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
109 			unsigned int i;
110 			for (i = 0; i < fp->nr_rates; i++)
111 				if (fp->rate_table[i] == rate)
112 					break;
113 			if (i >= fp->nr_rates)
114 				continue;
115 		}
116 		attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE;
117 		if (!found) {
118 			found = fp;
119 			cur_attr = attr;
120 			continue;
121 		}
122 		/* avoid async out and adaptive in if the other method
123 		 * supports the same format.
124 		 * this is a workaround for the case like
125 		 * M-audio audiophile USB.
126 		 */
127 		if (subs && attr != cur_attr) {
128 			if ((attr == USB_ENDPOINT_SYNC_ASYNC &&
129 			     subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
130 			    (attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
131 			     subs->direction == SNDRV_PCM_STREAM_CAPTURE))
132 				continue;
133 			if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC &&
134 			     subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
135 			    (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
136 			     subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
137 				found = fp;
138 				cur_attr = attr;
139 				continue;
140 			}
141 		}
142 		/* find the format with the largest max. packet size */
143 		if (fp->maxpacksize > found->maxpacksize) {
144 			found = fp;
145 			cur_attr = attr;
146 		}
147 	}
148 	return found;
149 }
150 
151 static const struct audioformat *
find_substream_format(struct snd_usb_substream * subs,const struct snd_pcm_hw_params * params)152 find_substream_format(struct snd_usb_substream *subs,
153 		      const struct snd_pcm_hw_params *params)
154 {
155 	return find_format(&subs->fmt_list, params_format(params),
156 			   params_rate(params), params_channels(params),
157 			   true, subs);
158 }
159 
snd_usb_pcm_has_fixed_rate(struct snd_usb_substream * subs)160 bool snd_usb_pcm_has_fixed_rate(struct snd_usb_substream *subs)
161 {
162 	const struct audioformat *fp;
163 	struct snd_usb_audio *chip;
164 	int rate = -1;
165 
166 	if (!subs)
167 		return false;
168 	chip = subs->stream->chip;
169 	if (!(chip->quirk_flags & QUIRK_FLAG_FIXED_RATE))
170 		return false;
171 	list_for_each_entry(fp, &subs->fmt_list, list) {
172 		if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
173 			return false;
174 		if (fp->nr_rates < 1)
175 			continue;
176 		if (fp->nr_rates > 1)
177 			return false;
178 		if (rate < 0) {
179 			rate = fp->rate_table[0];
180 			continue;
181 		}
182 		if (rate != fp->rate_table[0])
183 			return false;
184 	}
185 	return true;
186 }
187 
init_pitch_v1(struct snd_usb_audio * chip,int ep)188 static int init_pitch_v1(struct snd_usb_audio *chip, int ep)
189 {
190 	struct usb_device *dev = chip->dev;
191 	unsigned char data[1];
192 	int err;
193 
194 	data[0] = 1;
195 	err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
196 			      USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
197 			      UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep,
198 			      data, sizeof(data));
199 	return err;
200 }
201 
init_pitch_v2(struct snd_usb_audio * chip,int ep)202 static int init_pitch_v2(struct snd_usb_audio *chip, int ep)
203 {
204 	struct usb_device *dev = chip->dev;
205 	unsigned char data[1];
206 	int err;
207 
208 	data[0] = 1;
209 	err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
210 			      USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
211 			      UAC2_EP_CS_PITCH << 8, 0,
212 			      data, sizeof(data));
213 	return err;
214 }
215 
216 /*
217  * initialize the pitch control and sample rate
218  */
snd_usb_init_pitch(struct snd_usb_audio * chip,const struct audioformat * fmt)219 int snd_usb_init_pitch(struct snd_usb_audio *chip,
220 		       const struct audioformat *fmt)
221 {
222 	int err;
223 
224 	/* if endpoint doesn't have pitch control, bail out */
225 	if (!(fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL))
226 		return 0;
227 
228 	usb_audio_dbg(chip, "enable PITCH for EP 0x%x\n", fmt->endpoint);
229 
230 	switch (fmt->protocol) {
231 	case UAC_VERSION_1:
232 		err = init_pitch_v1(chip, fmt->endpoint);
233 		break;
234 	case UAC_VERSION_2:
235 		err = init_pitch_v2(chip, fmt->endpoint);
236 		break;
237 	default:
238 		return 0;
239 	}
240 
241 	if (err < 0) {
242 		usb_audio_err(chip, "failed to enable PITCH for EP 0x%x\n",
243 			      fmt->endpoint);
244 		return err;
245 	}
246 
247 	return 0;
248 }
249 
stop_endpoints(struct snd_usb_substream * subs,bool keep_pending)250 static bool stop_endpoints(struct snd_usb_substream *subs, bool keep_pending)
251 {
252 	bool stopped = 0;
253 
254 	if (test_and_clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) {
255 		snd_usb_endpoint_stop(subs->sync_endpoint, keep_pending);
256 		stopped = true;
257 	}
258 	if (test_and_clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) {
259 		snd_usb_endpoint_stop(subs->data_endpoint, keep_pending);
260 		stopped = true;
261 	}
262 	return stopped;
263 }
264 
start_endpoints(struct snd_usb_substream * subs)265 static int start_endpoints(struct snd_usb_substream *subs)
266 {
267 	int err;
268 
269 	if (!subs->data_endpoint)
270 		return -EINVAL;
271 
272 	if (!test_and_set_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) {
273 		err = snd_usb_endpoint_start(subs->data_endpoint);
274 		if (err < 0) {
275 			clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags);
276 			goto error;
277 		}
278 	}
279 
280 	if (subs->sync_endpoint &&
281 	    !test_and_set_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) {
282 		err = snd_usb_endpoint_start(subs->sync_endpoint);
283 		if (err < 0) {
284 			clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags);
285 			goto error;
286 		}
287 	}
288 
289 	return 0;
290 
291  error:
292 	stop_endpoints(subs, false);
293 	return err;
294 }
295 
sync_pending_stops(struct snd_usb_substream * subs)296 static void sync_pending_stops(struct snd_usb_substream *subs)
297 {
298 	snd_usb_endpoint_sync_pending_stop(subs->sync_endpoint);
299 	snd_usb_endpoint_sync_pending_stop(subs->data_endpoint);
300 }
301 
302 /* PCM sync_stop callback */
snd_usb_pcm_sync_stop(struct snd_pcm_substream * substream)303 static int snd_usb_pcm_sync_stop(struct snd_pcm_substream *substream)
304 {
305 	struct snd_usb_substream *subs = substream->runtime->private_data;
306 
307 	sync_pending_stops(subs);
308 	return 0;
309 }
310 
311 /* Set up sync endpoint */
snd_usb_audioformat_set_sync_ep(struct snd_usb_audio * chip,struct audioformat * fmt)312 int snd_usb_audioformat_set_sync_ep(struct snd_usb_audio *chip,
313 				    struct audioformat *fmt)
314 {
315 	struct usb_device *dev = chip->dev;
316 	struct usb_host_interface *alts;
317 	struct usb_interface_descriptor *altsd;
318 	unsigned int ep, attr, sync_attr;
319 	bool is_playback;
320 	int err;
321 
322 	if (fmt->sync_ep)
323 		return 0; /* already set up */
324 
325 	alts = snd_usb_get_host_interface(chip, fmt->iface, fmt->altsetting);
326 	if (!alts)
327 		return 0;
328 	altsd = get_iface_desc(alts);
329 
330 	err = snd_usb_parse_implicit_fb_quirk(chip, fmt, alts);
331 	if (err > 0)
332 		return 0; /* matched */
333 
334 	/*
335 	 * Generic sync EP handling
336 	 */
337 
338 	if (fmt->ep_idx > 0 || altsd->bNumEndpoints < 2)
339 		return 0;
340 
341 	is_playback = !(get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN);
342 	attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
343 	if ((is_playback && (attr == USB_ENDPOINT_SYNC_SYNC ||
344 			     attr == USB_ENDPOINT_SYNC_ADAPTIVE)) ||
345 	    (!is_playback && attr != USB_ENDPOINT_SYNC_ADAPTIVE))
346 		return 0;
347 
348 	sync_attr = get_endpoint(alts, 1)->bmAttributes;
349 
350 	/*
351 	 * In case of illegal SYNC_NONE for OUT endpoint, we keep going to see
352 	 * if we don't find a sync endpoint, as on M-Audio Transit. In case of
353 	 * error fall back to SYNC mode and don't create sync endpoint
354 	 */
355 
356 	/* check sync-pipe endpoint */
357 	/* ... and check descriptor size before accessing bSynchAddress
358 	   because there is a version of the SB Audigy 2 NX firmware lacking
359 	   the audio fields in the endpoint descriptors */
360 	if ((sync_attr & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_ISOC ||
361 	    (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
362 	     get_endpoint(alts, 1)->bSynchAddress != 0)) {
363 		dev_err(&dev->dev,
364 			"%d:%d : invalid sync pipe. bmAttributes %02x, bLength %d, bSynchAddress %02x\n",
365 			   fmt->iface, fmt->altsetting,
366 			   get_endpoint(alts, 1)->bmAttributes,
367 			   get_endpoint(alts, 1)->bLength,
368 			   get_endpoint(alts, 1)->bSynchAddress);
369 		if (is_playback && attr == USB_ENDPOINT_SYNC_NONE)
370 			return 0;
371 		return -EINVAL;
372 	}
373 	ep = get_endpoint(alts, 1)->bEndpointAddress;
374 	if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
375 	    get_endpoint(alts, 0)->bSynchAddress != 0 &&
376 	    ((is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
377 	     (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
378 		dev_err(&dev->dev,
379 			"%d:%d : invalid sync pipe. is_playback %d, ep %02x, bSynchAddress %02x\n",
380 			   fmt->iface, fmt->altsetting,
381 			   is_playback, ep, get_endpoint(alts, 0)->bSynchAddress);
382 		if (is_playback && attr == USB_ENDPOINT_SYNC_NONE)
383 			return 0;
384 		return -EINVAL;
385 	}
386 
387 	fmt->sync_ep = ep;
388 	fmt->sync_iface = altsd->bInterfaceNumber;
389 	fmt->sync_altsetting = altsd->bAlternateSetting;
390 	fmt->sync_ep_idx = 1;
391 	if ((sync_attr & USB_ENDPOINT_USAGE_MASK) == USB_ENDPOINT_USAGE_IMPLICIT_FB)
392 		fmt->implicit_fb = 1;
393 
394 	dev_dbg(&dev->dev, "%d:%d: found sync_ep=0x%x, iface=%d, alt=%d, implicit_fb=%d\n",
395 		fmt->iface, fmt->altsetting, fmt->sync_ep, fmt->sync_iface,
396 		fmt->sync_altsetting, fmt->implicit_fb);
397 
398 	return 0;
399 }
400 
snd_usb_pcm_change_state(struct snd_usb_substream * subs,int state)401 static int snd_usb_pcm_change_state(struct snd_usb_substream *subs, int state)
402 {
403 	int ret;
404 
405 	if (!subs->str_pd)
406 		return 0;
407 
408 	ret = snd_usb_power_domain_set(subs->stream->chip, subs->str_pd, state);
409 	if (ret < 0) {
410 		dev_err(&subs->dev->dev,
411 			"Cannot change Power Domain ID: %d to state: %d. Err: %d\n",
412 			subs->str_pd->pd_id, state, ret);
413 		return ret;
414 	}
415 
416 	return 0;
417 }
418 
snd_usb_pcm_suspend(struct snd_usb_stream * as)419 int snd_usb_pcm_suspend(struct snd_usb_stream *as)
420 {
421 	int ret;
422 
423 	ret = snd_usb_pcm_change_state(&as->substream[0], UAC3_PD_STATE_D2);
424 	if (ret < 0)
425 		return ret;
426 
427 	ret = snd_usb_pcm_change_state(&as->substream[1], UAC3_PD_STATE_D2);
428 	if (ret < 0)
429 		return ret;
430 
431 	return 0;
432 }
433 
snd_usb_pcm_resume(struct snd_usb_stream * as)434 int snd_usb_pcm_resume(struct snd_usb_stream *as)
435 {
436 	int ret;
437 
438 	ret = snd_usb_pcm_change_state(&as->substream[0], UAC3_PD_STATE_D1);
439 	if (ret < 0)
440 		return ret;
441 
442 	ret = snd_usb_pcm_change_state(&as->substream[1], UAC3_PD_STATE_D1);
443 	if (ret < 0)
444 		return ret;
445 
446 	return 0;
447 }
448 
close_endpoints(struct snd_usb_audio * chip,struct snd_usb_substream * subs)449 static void close_endpoints(struct snd_usb_audio *chip,
450 			    struct snd_usb_substream *subs)
451 {
452 	if (subs->data_endpoint) {
453 		snd_usb_endpoint_set_sync(chip, subs->data_endpoint, NULL);
454 		snd_usb_endpoint_close(chip, subs->data_endpoint);
455 		subs->data_endpoint = NULL;
456 	}
457 
458 	if (subs->sync_endpoint) {
459 		snd_usb_endpoint_close(chip, subs->sync_endpoint);
460 		subs->sync_endpoint = NULL;
461 	}
462 }
463 
464 /*
465  * hw_params callback
466  *
467  * allocate a buffer and set the given audio format.
468  *
469  * so far we use a physically linear buffer although packetize transfer
470  * doesn't need a continuous area.
471  * if sg buffer is supported on the later version of alsa, we'll follow
472  * that.
473  */
snd_usb_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hw_params)474 static int snd_usb_hw_params(struct snd_pcm_substream *substream,
475 			     struct snd_pcm_hw_params *hw_params)
476 {
477 	struct snd_usb_substream *subs = substream->runtime->private_data;
478 	struct snd_usb_audio *chip = subs->stream->chip;
479 	const struct audioformat *fmt;
480 	const struct audioformat *sync_fmt;
481 	bool fixed_rate, sync_fixed_rate;
482 	int ret;
483 
484 	ret = snd_media_start_pipeline(subs);
485 	if (ret)
486 		return ret;
487 
488 	fixed_rate = snd_usb_pcm_has_fixed_rate(subs);
489 	fmt = find_substream_format(subs, hw_params);
490 	if (!fmt) {
491 		usb_audio_dbg(chip,
492 			      "cannot find format: format=%s, rate=%d, channels=%d\n",
493 			      snd_pcm_format_name(params_format(hw_params)),
494 			      params_rate(hw_params), params_channels(hw_params));
495 		ret = -EINVAL;
496 		goto stop_pipeline;
497 	}
498 
499 	if (fmt->implicit_fb) {
500 		sync_fmt = snd_usb_find_implicit_fb_sync_format(chip, fmt,
501 								hw_params,
502 								!substream->stream,
503 								&sync_fixed_rate);
504 		if (!sync_fmt) {
505 			usb_audio_dbg(chip,
506 				      "cannot find sync format: ep=0x%x, iface=%d:%d, format=%s, rate=%d, channels=%d\n",
507 				      fmt->sync_ep, fmt->sync_iface,
508 				      fmt->sync_altsetting,
509 				      snd_pcm_format_name(params_format(hw_params)),
510 				      params_rate(hw_params), params_channels(hw_params));
511 			ret = -EINVAL;
512 			goto stop_pipeline;
513 		}
514 	} else {
515 		sync_fmt = fmt;
516 		sync_fixed_rate = fixed_rate;
517 	}
518 
519 	ret = snd_usb_lock_shutdown(chip);
520 	if (ret < 0)
521 		goto stop_pipeline;
522 
523 	ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0);
524 	if (ret < 0)
525 		goto unlock;
526 
527 	if (subs->data_endpoint) {
528 		if (snd_usb_endpoint_compatible(chip, subs->data_endpoint,
529 						fmt, hw_params))
530 			goto unlock;
531 		if (stop_endpoints(subs, false))
532 			sync_pending_stops(subs);
533 		close_endpoints(chip, subs);
534 	}
535 
536 	subs->data_endpoint = snd_usb_endpoint_open(chip, fmt, hw_params, false, fixed_rate);
537 	if (!subs->data_endpoint) {
538 		ret = -EINVAL;
539 		goto unlock;
540 	}
541 
542 	if (fmt->sync_ep) {
543 		subs->sync_endpoint = snd_usb_endpoint_open(chip, sync_fmt,
544 							    hw_params,
545 							    fmt == sync_fmt,
546 							    sync_fixed_rate);
547 		if (!subs->sync_endpoint) {
548 			ret = -EINVAL;
549 			goto unlock;
550 		}
551 
552 		snd_usb_endpoint_set_sync(chip, subs->data_endpoint,
553 					  subs->sync_endpoint);
554 	}
555 
556 	mutex_lock(&chip->mutex);
557 	subs->cur_audiofmt = fmt;
558 	mutex_unlock(&chip->mutex);
559 
560 	if (!subs->data_endpoint->need_setup)
561 		goto unlock;
562 
563 	if (subs->sync_endpoint) {
564 		ret = snd_usb_endpoint_set_params(chip, subs->sync_endpoint);
565 		if (ret < 0)
566 			goto unlock;
567 	}
568 
569 	ret = snd_usb_endpoint_set_params(chip, subs->data_endpoint);
570 
571  unlock:
572 	if (ret < 0)
573 		close_endpoints(chip, subs);
574 
575 	snd_usb_unlock_shutdown(chip);
576  stop_pipeline:
577 	if (ret < 0)
578 		snd_media_stop_pipeline(subs);
579 
580 	return ret;
581 }
582 
583 /*
584  * hw_free callback
585  *
586  * reset the audio format and release the buffer
587  */
snd_usb_hw_free(struct snd_pcm_substream * substream)588 static int snd_usb_hw_free(struct snd_pcm_substream *substream)
589 {
590 	struct snd_usb_substream *subs = substream->runtime->private_data;
591 	struct snd_usb_audio *chip = subs->stream->chip;
592 
593 	snd_media_stop_pipeline(subs);
594 	mutex_lock(&chip->mutex);
595 	subs->cur_audiofmt = NULL;
596 	mutex_unlock(&chip->mutex);
597 	if (!snd_usb_lock_shutdown(chip)) {
598 		if (stop_endpoints(subs, false))
599 			sync_pending_stops(subs);
600 		close_endpoints(chip, subs);
601 		snd_usb_unlock_shutdown(chip);
602 	}
603 
604 	return 0;
605 }
606 
607 /* free-wheeling mode? (e.g. dmix) */
in_free_wheeling_mode(struct snd_pcm_runtime * runtime)608 static int in_free_wheeling_mode(struct snd_pcm_runtime *runtime)
609 {
610 	return runtime->stop_threshold > runtime->buffer_size;
611 }
612 
613 /* check whether early start is needed for playback stream */
lowlatency_playback_available(struct snd_pcm_runtime * runtime,struct snd_usb_substream * subs)614 static int lowlatency_playback_available(struct snd_pcm_runtime *runtime,
615 					 struct snd_usb_substream *subs)
616 {
617 	struct snd_usb_audio *chip = subs->stream->chip;
618 
619 	if (subs->direction == SNDRV_PCM_STREAM_CAPTURE)
620 		return false;
621 	/* disabled via module option? */
622 	if (!chip->lowlatency)
623 		return false;
624 	if (in_free_wheeling_mode(runtime))
625 		return false;
626 	/* implicit feedback mode has own operation mode */
627 	if (snd_usb_endpoint_implicit_feedback_sink(subs->data_endpoint))
628 		return false;
629 	return true;
630 }
631 
632 /*
633  * prepare callback
634  *
635  * only a few subtle things...
636  */
snd_usb_pcm_prepare(struct snd_pcm_substream * substream)637 static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
638 {
639 	struct snd_pcm_runtime *runtime = substream->runtime;
640 	struct snd_usb_substream *subs = runtime->private_data;
641 	struct snd_usb_audio *chip = subs->stream->chip;
642 	int retry = 0;
643 	int ret;
644 
645 	ret = snd_usb_lock_shutdown(chip);
646 	if (ret < 0)
647 		return ret;
648 	if (snd_BUG_ON(!subs->data_endpoint)) {
649 		ret = -EIO;
650 		goto unlock;
651 	}
652 
653 	ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0);
654 	if (ret < 0)
655 		goto unlock;
656 
657  again:
658 	if (subs->sync_endpoint) {
659 		ret = snd_usb_endpoint_prepare(chip, subs->sync_endpoint);
660 		if (ret < 0)
661 			goto unlock;
662 	}
663 
664 	ret = snd_usb_endpoint_prepare(chip, subs->data_endpoint);
665 	if (ret < 0)
666 		goto unlock;
667 	else if (ret > 0)
668 		snd_usb_set_format_quirk(subs, subs->cur_audiofmt);
669 	ret = 0;
670 
671 	/* reset the pointer */
672 	subs->buffer_bytes = frames_to_bytes(runtime, runtime->buffer_size);
673 	subs->inflight_bytes = 0;
674 	subs->hwptr_done = 0;
675 	subs->transfer_done = 0;
676 	subs->last_frame_number = 0;
677 	subs->period_elapsed_pending = 0;
678 	runtime->delay = 0;
679 
680 	subs->lowlatency_playback = lowlatency_playback_available(runtime, subs);
681 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
682 	    !subs->lowlatency_playback) {
683 		ret = start_endpoints(subs);
684 		/* if XRUN happens at starting streams (possibly with implicit
685 		 * fb case), restart again, but only try once.
686 		 */
687 		if (ret == -EPIPE && !retry++) {
688 			sync_pending_stops(subs);
689 			goto again;
690 		}
691 	}
692  unlock:
693 	snd_usb_unlock_shutdown(chip);
694 	return ret;
695 }
696 
697 /*
698  * h/w constraints
699  */
700 
701 #ifdef HW_CONST_DEBUG
702 #define hwc_debug(fmt, args...) pr_debug(fmt, ##args)
703 #else
704 #define hwc_debug(fmt, args...) do { } while(0)
705 #endif
706 
707 static const struct snd_pcm_hardware snd_usb_hardware =
708 {
709 	.info =			SNDRV_PCM_INFO_MMAP |
710 				SNDRV_PCM_INFO_MMAP_VALID |
711 				SNDRV_PCM_INFO_BATCH |
712 				SNDRV_PCM_INFO_INTERLEAVED |
713 				SNDRV_PCM_INFO_BLOCK_TRANSFER |
714 				SNDRV_PCM_INFO_PAUSE,
715 	.channels_min =		1,
716 	.channels_max =		256,
717 	.buffer_bytes_max =	INT_MAX, /* limited by BUFFER_TIME later */
718 	.period_bytes_min =	64,
719 	.period_bytes_max =	INT_MAX, /* limited by PERIOD_TIME later */
720 	.periods_min =		2,
721 	.periods_max =		1024,
722 };
723 
hw_check_valid_format(struct snd_usb_substream * subs,struct snd_pcm_hw_params * params,const struct audioformat * fp)724 static int hw_check_valid_format(struct snd_usb_substream *subs,
725 				 struct snd_pcm_hw_params *params,
726 				 const struct audioformat *fp)
727 {
728 	struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
729 	struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
730 	struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
731 	struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
732 	struct snd_mask check_fmts;
733 	unsigned int ptime;
734 
735 	/* check the format */
736 	snd_mask_none(&check_fmts);
737 	check_fmts.bits[0] = (u32)fp->formats;
738 	check_fmts.bits[1] = (u32)(fp->formats >> 32);
739 	snd_mask_intersect(&check_fmts, fmts);
740 	if (snd_mask_empty(&check_fmts)) {
741 		hwc_debug("   > check: no supported format 0x%llx\n", fp->formats);
742 		return 0;
743 	}
744 	/* check the channels */
745 	if (fp->channels < ct->min || fp->channels > ct->max) {
746 		hwc_debug("   > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
747 		return 0;
748 	}
749 	/* check the rate is within the range */
750 	if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
751 		hwc_debug("   > check: rate_min %d > max %d\n", fp->rate_min, it->max);
752 		return 0;
753 	}
754 	if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
755 		hwc_debug("   > check: rate_max %d < min %d\n", fp->rate_max, it->min);
756 		return 0;
757 	}
758 	/* check whether the period time is >= the data packet interval */
759 	if (subs->speed != USB_SPEED_FULL) {
760 		ptime = 125 * (1 << fp->datainterval);
761 		if (ptime > pt->max || (ptime == pt->max && pt->openmax)) {
762 			hwc_debug("   > check: ptime %u > max %u\n", ptime, pt->max);
763 			return 0;
764 		}
765 	}
766 	return 1;
767 }
768 
apply_hw_params_minmax(struct snd_interval * it,unsigned int rmin,unsigned int rmax)769 static int apply_hw_params_minmax(struct snd_interval *it, unsigned int rmin,
770 				  unsigned int rmax)
771 {
772 	int changed;
773 
774 	if (rmin > rmax) {
775 		hwc_debug("  --> get empty\n");
776 		it->empty = 1;
777 		return -EINVAL;
778 	}
779 
780 	changed = 0;
781 	if (it->min < rmin) {
782 		it->min = rmin;
783 		it->openmin = 0;
784 		changed = 1;
785 	}
786 	if (it->max > rmax) {
787 		it->max = rmax;
788 		it->openmax = 0;
789 		changed = 1;
790 	}
791 	if (snd_interval_checkempty(it)) {
792 		it->empty = 1;
793 		return -EINVAL;
794 	}
795 	hwc_debug("  --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
796 	return changed;
797 }
798 
799 /* get the specified endpoint object that is being used by other streams
800  * (i.e. the parameter is locked)
801  */
802 static const struct snd_usb_endpoint *
get_endpoint_in_use(struct snd_usb_audio * chip,int endpoint,const struct snd_usb_endpoint * ref_ep)803 get_endpoint_in_use(struct snd_usb_audio *chip, int endpoint,
804 		    const struct snd_usb_endpoint *ref_ep)
805 {
806 	const struct snd_usb_endpoint *ep;
807 
808 	ep = snd_usb_get_endpoint(chip, endpoint);
809 	if (ep && ep->cur_audiofmt && (ep != ref_ep || ep->opened > 1))
810 		return ep;
811 	return NULL;
812 }
813 
hw_rule_rate(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)814 static int hw_rule_rate(struct snd_pcm_hw_params *params,
815 			struct snd_pcm_hw_rule *rule)
816 {
817 	struct snd_usb_substream *subs = rule->private;
818 	struct snd_usb_audio *chip = subs->stream->chip;
819 	const struct snd_usb_endpoint *ep;
820 	const struct audioformat *fp;
821 	struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
822 	unsigned int rmin, rmax, r;
823 	int i;
824 
825 	hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
826 	rmin = UINT_MAX;
827 	rmax = 0;
828 	list_for_each_entry(fp, &subs->fmt_list, list) {
829 		if (!hw_check_valid_format(subs, params, fp))
830 			continue;
831 
832 		ep = get_endpoint_in_use(chip, fp->endpoint,
833 					 subs->data_endpoint);
834 		if (ep) {
835 			hwc_debug("rate limit %d for ep#%x\n",
836 				  ep->cur_rate, fp->endpoint);
837 			rmin = min(rmin, ep->cur_rate);
838 			rmax = max(rmax, ep->cur_rate);
839 			continue;
840 		}
841 
842 		if (fp->implicit_fb) {
843 			ep = get_endpoint_in_use(chip, fp->sync_ep,
844 						 subs->sync_endpoint);
845 			if (ep) {
846 				hwc_debug("rate limit %d for sync_ep#%x\n",
847 					  ep->cur_rate, fp->sync_ep);
848 				rmin = min(rmin, ep->cur_rate);
849 				rmax = max(rmax, ep->cur_rate);
850 				continue;
851 			}
852 		}
853 
854 		r = snd_usb_endpoint_get_clock_rate(chip, fp->clock);
855 		if (r > 0) {
856 			if (!snd_interval_test(it, r))
857 				continue;
858 			rmin = min(rmin, r);
859 			rmax = max(rmax, r);
860 			continue;
861 		}
862 		if (fp->rate_table && fp->nr_rates) {
863 			for (i = 0; i < fp->nr_rates; i++) {
864 				r = fp->rate_table[i];
865 				if (!snd_interval_test(it, r))
866 					continue;
867 				rmin = min(rmin, r);
868 				rmax = max(rmax, r);
869 			}
870 		} else {
871 			rmin = min(rmin, fp->rate_min);
872 			rmax = max(rmax, fp->rate_max);
873 		}
874 	}
875 
876 	return apply_hw_params_minmax(it, rmin, rmax);
877 }
878 
879 
hw_rule_channels(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)880 static int hw_rule_channels(struct snd_pcm_hw_params *params,
881 			    struct snd_pcm_hw_rule *rule)
882 {
883 	struct snd_usb_substream *subs = rule->private;
884 	const struct audioformat *fp;
885 	struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
886 	unsigned int rmin, rmax;
887 
888 	hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
889 	rmin = UINT_MAX;
890 	rmax = 0;
891 	list_for_each_entry(fp, &subs->fmt_list, list) {
892 		if (!hw_check_valid_format(subs, params, fp))
893 			continue;
894 		rmin = min(rmin, fp->channels);
895 		rmax = max(rmax, fp->channels);
896 	}
897 
898 	return apply_hw_params_minmax(it, rmin, rmax);
899 }
900 
apply_hw_params_format_bits(struct snd_mask * fmt,u64 fbits)901 static int apply_hw_params_format_bits(struct snd_mask *fmt, u64 fbits)
902 {
903 	u32 oldbits[2];
904 	int changed;
905 
906 	oldbits[0] = fmt->bits[0];
907 	oldbits[1] = fmt->bits[1];
908 	fmt->bits[0] &= (u32)fbits;
909 	fmt->bits[1] &= (u32)(fbits >> 32);
910 	if (!fmt->bits[0] && !fmt->bits[1]) {
911 		hwc_debug("  --> get empty\n");
912 		return -EINVAL;
913 	}
914 	changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
915 	hwc_debug("  --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
916 	return changed;
917 }
918 
hw_rule_format(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)919 static int hw_rule_format(struct snd_pcm_hw_params *params,
920 			  struct snd_pcm_hw_rule *rule)
921 {
922 	struct snd_usb_substream *subs = rule->private;
923 	struct snd_usb_audio *chip = subs->stream->chip;
924 	const struct snd_usb_endpoint *ep;
925 	const struct audioformat *fp;
926 	struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
927 	u64 fbits;
928 
929 	hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
930 	fbits = 0;
931 	list_for_each_entry(fp, &subs->fmt_list, list) {
932 		if (!hw_check_valid_format(subs, params, fp))
933 			continue;
934 
935 		ep = get_endpoint_in_use(chip, fp->endpoint,
936 					 subs->data_endpoint);
937 		if (ep) {
938 			hwc_debug("format limit %d for ep#%x\n",
939 				  ep->cur_format, fp->endpoint);
940 			fbits |= pcm_format_to_bits(ep->cur_format);
941 			continue;
942 		}
943 
944 		if (fp->implicit_fb) {
945 			ep = get_endpoint_in_use(chip, fp->sync_ep,
946 						 subs->sync_endpoint);
947 			if (ep) {
948 				hwc_debug("format limit %d for sync_ep#%x\n",
949 					  ep->cur_format, fp->sync_ep);
950 				fbits |= pcm_format_to_bits(ep->cur_format);
951 				continue;
952 			}
953 		}
954 
955 		fbits |= fp->formats;
956 	}
957 	return apply_hw_params_format_bits(fmt, fbits);
958 }
959 
hw_rule_period_time(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)960 static int hw_rule_period_time(struct snd_pcm_hw_params *params,
961 			       struct snd_pcm_hw_rule *rule)
962 {
963 	struct snd_usb_substream *subs = rule->private;
964 	const struct audioformat *fp;
965 	struct snd_interval *it;
966 	unsigned char min_datainterval;
967 	unsigned int pmin;
968 
969 	it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
970 	hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max);
971 	min_datainterval = 0xff;
972 	list_for_each_entry(fp, &subs->fmt_list, list) {
973 		if (!hw_check_valid_format(subs, params, fp))
974 			continue;
975 		min_datainterval = min(min_datainterval, fp->datainterval);
976 	}
977 	if (min_datainterval == 0xff) {
978 		hwc_debug("  --> get empty\n");
979 		it->empty = 1;
980 		return -EINVAL;
981 	}
982 	pmin = 125 * (1 << min_datainterval);
983 
984 	return apply_hw_params_minmax(it, pmin, UINT_MAX);
985 }
986 
987 /* additional hw constraints for implicit feedback mode */
hw_rule_period_size_implicit_fb(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)988 static int hw_rule_period_size_implicit_fb(struct snd_pcm_hw_params *params,
989 					   struct snd_pcm_hw_rule *rule)
990 {
991 	struct snd_usb_substream *subs = rule->private;
992 	struct snd_usb_audio *chip = subs->stream->chip;
993 	const struct audioformat *fp;
994 	const struct snd_usb_endpoint *ep;
995 	struct snd_interval *it;
996 	unsigned int rmin, rmax;
997 
998 	it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
999 	hwc_debug("hw_rule_period_size: (%u,%u)\n", it->min, it->max);
1000 	rmin = UINT_MAX;
1001 	rmax = 0;
1002 	list_for_each_entry(fp, &subs->fmt_list, list) {
1003 		if (!hw_check_valid_format(subs, params, fp))
1004 			continue;
1005 		ep = get_endpoint_in_use(chip, fp->endpoint,
1006 					 subs->data_endpoint);
1007 		if (ep) {
1008 			hwc_debug("period size limit %d for ep#%x\n",
1009 				  ep->cur_period_frames, fp->endpoint);
1010 			rmin = min(rmin, ep->cur_period_frames);
1011 			rmax = max(rmax, ep->cur_period_frames);
1012 			continue;
1013 		}
1014 
1015 		if (fp->implicit_fb) {
1016 			ep = get_endpoint_in_use(chip, fp->sync_ep,
1017 						 subs->sync_endpoint);
1018 			if (ep) {
1019 				hwc_debug("period size limit %d for sync_ep#%x\n",
1020 					  ep->cur_period_frames, fp->sync_ep);
1021 				rmin = min(rmin, ep->cur_period_frames);
1022 				rmax = max(rmax, ep->cur_period_frames);
1023 				continue;
1024 			}
1025 		}
1026 	}
1027 
1028 	if (!rmax)
1029 		return 0; /* no limit by implicit fb */
1030 	return apply_hw_params_minmax(it, rmin, rmax);
1031 }
1032 
hw_rule_periods_implicit_fb(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)1033 static int hw_rule_periods_implicit_fb(struct snd_pcm_hw_params *params,
1034 				       struct snd_pcm_hw_rule *rule)
1035 {
1036 	struct snd_usb_substream *subs = rule->private;
1037 	struct snd_usb_audio *chip = subs->stream->chip;
1038 	const struct audioformat *fp;
1039 	const struct snd_usb_endpoint *ep;
1040 	struct snd_interval *it;
1041 	unsigned int rmin, rmax;
1042 
1043 	it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIODS);
1044 	hwc_debug("hw_rule_periods: (%u,%u)\n", it->min, it->max);
1045 	rmin = UINT_MAX;
1046 	rmax = 0;
1047 	list_for_each_entry(fp, &subs->fmt_list, list) {
1048 		if (!hw_check_valid_format(subs, params, fp))
1049 			continue;
1050 		ep = get_endpoint_in_use(chip, fp->endpoint,
1051 					 subs->data_endpoint);
1052 		if (ep) {
1053 			hwc_debug("periods limit %d for ep#%x\n",
1054 				  ep->cur_buffer_periods, fp->endpoint);
1055 			rmin = min(rmin, ep->cur_buffer_periods);
1056 			rmax = max(rmax, ep->cur_buffer_periods);
1057 			continue;
1058 		}
1059 
1060 		if (fp->implicit_fb) {
1061 			ep = get_endpoint_in_use(chip, fp->sync_ep,
1062 						 subs->sync_endpoint);
1063 			if (ep) {
1064 				hwc_debug("periods limit %d for sync_ep#%x\n",
1065 					  ep->cur_buffer_periods, fp->sync_ep);
1066 				rmin = min(rmin, ep->cur_buffer_periods);
1067 				rmax = max(rmax, ep->cur_buffer_periods);
1068 				continue;
1069 			}
1070 		}
1071 	}
1072 
1073 	if (!rmax)
1074 		return 0; /* no limit by implicit fb */
1075 	return apply_hw_params_minmax(it, rmin, rmax);
1076 }
1077 
1078 /*
1079  * set up the runtime hardware information.
1080  */
1081 
setup_hw_info(struct snd_pcm_runtime * runtime,struct snd_usb_substream * subs)1082 static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
1083 {
1084 	const struct audioformat *fp;
1085 	unsigned int pt, ptmin;
1086 	int param_period_time_if_needed = -1;
1087 	int err;
1088 
1089 	runtime->hw.formats = subs->formats;
1090 
1091 	runtime->hw.rate_min = 0x7fffffff;
1092 	runtime->hw.rate_max = 0;
1093 	runtime->hw.channels_min = 256;
1094 	runtime->hw.channels_max = 0;
1095 	runtime->hw.rates = 0;
1096 	ptmin = UINT_MAX;
1097 	/* check min/max rates and channels */
1098 	list_for_each_entry(fp, &subs->fmt_list, list) {
1099 		runtime->hw.rates |= fp->rates;
1100 		if (runtime->hw.rate_min > fp->rate_min)
1101 			runtime->hw.rate_min = fp->rate_min;
1102 		if (runtime->hw.rate_max < fp->rate_max)
1103 			runtime->hw.rate_max = fp->rate_max;
1104 		if (runtime->hw.channels_min > fp->channels)
1105 			runtime->hw.channels_min = fp->channels;
1106 		if (runtime->hw.channels_max < fp->channels)
1107 			runtime->hw.channels_max = fp->channels;
1108 		if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) {
1109 			/* FIXME: there might be more than one audio formats... */
1110 			runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
1111 				fp->frame_size;
1112 		}
1113 		pt = 125 * (1 << fp->datainterval);
1114 		ptmin = min(ptmin, pt);
1115 	}
1116 
1117 	param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME;
1118 	if (subs->speed == USB_SPEED_FULL)
1119 		/* full speed devices have fixed data packet interval */
1120 		ptmin = 1000;
1121 	if (ptmin == 1000)
1122 		/* if period time doesn't go below 1 ms, no rules needed */
1123 		param_period_time_if_needed = -1;
1124 
1125 	err = snd_pcm_hw_constraint_minmax(runtime,
1126 					   SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1127 					   ptmin, UINT_MAX);
1128 	if (err < 0)
1129 		return err;
1130 
1131 	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
1132 				  hw_rule_rate, subs,
1133 				  SNDRV_PCM_HW_PARAM_RATE,
1134 				  SNDRV_PCM_HW_PARAM_FORMAT,
1135 				  SNDRV_PCM_HW_PARAM_CHANNELS,
1136 				  param_period_time_if_needed,
1137 				  -1);
1138 	if (err < 0)
1139 		return err;
1140 
1141 	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
1142 				  hw_rule_channels, subs,
1143 				  SNDRV_PCM_HW_PARAM_CHANNELS,
1144 				  SNDRV_PCM_HW_PARAM_FORMAT,
1145 				  SNDRV_PCM_HW_PARAM_RATE,
1146 				  param_period_time_if_needed,
1147 				  -1);
1148 	if (err < 0)
1149 		return err;
1150 	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
1151 				  hw_rule_format, subs,
1152 				  SNDRV_PCM_HW_PARAM_FORMAT,
1153 				  SNDRV_PCM_HW_PARAM_RATE,
1154 				  SNDRV_PCM_HW_PARAM_CHANNELS,
1155 				  param_period_time_if_needed,
1156 				  -1);
1157 	if (err < 0)
1158 		return err;
1159 	if (param_period_time_if_needed >= 0) {
1160 		err = snd_pcm_hw_rule_add(runtime, 0,
1161 					  SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1162 					  hw_rule_period_time, subs,
1163 					  SNDRV_PCM_HW_PARAM_FORMAT,
1164 					  SNDRV_PCM_HW_PARAM_CHANNELS,
1165 					  SNDRV_PCM_HW_PARAM_RATE,
1166 					  -1);
1167 		if (err < 0)
1168 			return err;
1169 	}
1170 
1171 	/* set max period and buffer sizes for 1 and 2 seconds, respectively */
1172 	err = snd_pcm_hw_constraint_minmax(runtime,
1173 					   SNDRV_PCM_HW_PARAM_PERIOD_TIME,
1174 					   0, 1000000);
1175 	if (err < 0)
1176 		return err;
1177 	err = snd_pcm_hw_constraint_minmax(runtime,
1178 					   SNDRV_PCM_HW_PARAM_BUFFER_TIME,
1179 					   0, 2000000);
1180 	if (err < 0)
1181 		return err;
1182 
1183 	/* additional hw constraints for implicit fb */
1184 	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1185 				  hw_rule_period_size_implicit_fb, subs,
1186 				  SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);
1187 	if (err < 0)
1188 		return err;
1189 	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS,
1190 				  hw_rule_periods_implicit_fb, subs,
1191 				  SNDRV_PCM_HW_PARAM_PERIODS, -1);
1192 	if (err < 0)
1193 		return err;
1194 
1195 	list_for_each_entry(fp, &subs->fmt_list, list) {
1196 		if (fp->implicit_fb) {
1197 			runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
1198 			break;
1199 		}
1200 	}
1201 
1202 	return 0;
1203 }
1204 
snd_usb_pcm_open(struct snd_pcm_substream * substream)1205 static int snd_usb_pcm_open(struct snd_pcm_substream *substream)
1206 {
1207 	int direction = substream->stream;
1208 	struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1209 	struct snd_pcm_runtime *runtime = substream->runtime;
1210 	struct snd_usb_substream *subs = &as->substream[direction];
1211 	int ret;
1212 
1213 	runtime->hw = snd_usb_hardware;
1214 	/* need an explicit sync to catch applptr update in low-latency mode */
1215 	if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
1216 	    as->chip->lowlatency)
1217 		runtime->hw.info |= SNDRV_PCM_INFO_SYNC_APPLPTR;
1218 	runtime->private_data = subs;
1219 	subs->pcm_substream = substream;
1220 	/* runtime PM is also done there */
1221 
1222 	/* initialize DSD/DOP context */
1223 	subs->dsd_dop.byte_idx = 0;
1224 	subs->dsd_dop.channel = 0;
1225 	subs->dsd_dop.marker = 1;
1226 
1227 	ret = setup_hw_info(runtime, subs);
1228 	if (ret < 0)
1229 		return ret;
1230 	ret = snd_usb_autoresume(subs->stream->chip);
1231 	if (ret < 0)
1232 		return ret;
1233 	ret = snd_media_stream_init(subs, as->pcm, direction);
1234 	if (ret < 0)
1235 		snd_usb_autosuspend(subs->stream->chip);
1236 	return ret;
1237 }
1238 
snd_usb_pcm_close(struct snd_pcm_substream * substream)1239 static int snd_usb_pcm_close(struct snd_pcm_substream *substream)
1240 {
1241 	int direction = substream->stream;
1242 	struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1243 	struct snd_usb_substream *subs = &as->substream[direction];
1244 	int ret;
1245 
1246 	snd_media_stop_pipeline(subs);
1247 
1248 	if (!snd_usb_lock_shutdown(subs->stream->chip)) {
1249 		ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D1);
1250 		snd_usb_unlock_shutdown(subs->stream->chip);
1251 		if (ret < 0)
1252 			return ret;
1253 	}
1254 
1255 	subs->pcm_substream = NULL;
1256 	snd_usb_autosuspend(subs->stream->chip);
1257 
1258 	return 0;
1259 }
1260 
1261 /* Since a URB can handle only a single linear buffer, we must use double
1262  * buffering when the data to be transferred overflows the buffer boundary.
1263  * To avoid inconsistencies when updating hwptr_done, we use double buffering
1264  * for all URBs.
1265  */
retire_capture_urb(struct snd_usb_substream * subs,struct urb * urb)1266 static void retire_capture_urb(struct snd_usb_substream *subs,
1267 			       struct urb *urb)
1268 {
1269 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1270 	unsigned int stride, frames, bytes, oldptr;
1271 	int i, period_elapsed = 0;
1272 	unsigned long flags;
1273 	unsigned char *cp;
1274 	int current_frame_number;
1275 
1276 	/* read frame number here, update pointer in critical section */
1277 	current_frame_number = usb_get_current_frame_number(subs->dev);
1278 
1279 	stride = runtime->frame_bits >> 3;
1280 
1281 	for (i = 0; i < urb->number_of_packets; i++) {
1282 		cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset + subs->pkt_offset_adj;
1283 		if (urb->iso_frame_desc[i].status && printk_ratelimit()) {
1284 			dev_dbg(&subs->dev->dev, "frame %d active: %d\n",
1285 				i, urb->iso_frame_desc[i].status);
1286 			// continue;
1287 		}
1288 		bytes = urb->iso_frame_desc[i].actual_length;
1289 		if (subs->stream_offset_adj > 0) {
1290 			unsigned int adj = min(subs->stream_offset_adj, bytes);
1291 			cp += adj;
1292 			bytes -= adj;
1293 			subs->stream_offset_adj -= adj;
1294 		}
1295 		frames = bytes / stride;
1296 		if (!subs->txfr_quirk)
1297 			bytes = frames * stride;
1298 		if (bytes % (runtime->sample_bits >> 3) != 0) {
1299 			int oldbytes = bytes;
1300 			bytes = frames * stride;
1301 			dev_warn_ratelimited(&subs->dev->dev,
1302 				 "Corrected urb data len. %d->%d\n",
1303 							oldbytes, bytes);
1304 		}
1305 		/* update the current pointer */
1306 		spin_lock_irqsave(&subs->lock, flags);
1307 		oldptr = subs->hwptr_done;
1308 		subs->hwptr_done += bytes;
1309 		if (subs->hwptr_done >= subs->buffer_bytes)
1310 			subs->hwptr_done -= subs->buffer_bytes;
1311 		frames = (bytes + (oldptr % stride)) / stride;
1312 		subs->transfer_done += frames;
1313 		if (subs->transfer_done >= runtime->period_size) {
1314 			subs->transfer_done -= runtime->period_size;
1315 			period_elapsed = 1;
1316 		}
1317 
1318 		/* realign last_frame_number */
1319 		subs->last_frame_number = current_frame_number;
1320 
1321 		spin_unlock_irqrestore(&subs->lock, flags);
1322 		/* copy a data chunk */
1323 		if (oldptr + bytes > subs->buffer_bytes) {
1324 			unsigned int bytes1 = subs->buffer_bytes - oldptr;
1325 
1326 			memcpy(runtime->dma_area + oldptr, cp, bytes1);
1327 			memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
1328 		} else {
1329 			memcpy(runtime->dma_area + oldptr, cp, bytes);
1330 		}
1331 	}
1332 
1333 	if (period_elapsed)
1334 		snd_pcm_period_elapsed(subs->pcm_substream);
1335 }
1336 
urb_ctx_queue_advance(struct snd_usb_substream * subs,struct urb * urb,unsigned int bytes)1337 static void urb_ctx_queue_advance(struct snd_usb_substream *subs,
1338 				  struct urb *urb, unsigned int bytes)
1339 {
1340 	struct snd_urb_ctx *ctx = urb->context;
1341 
1342 	ctx->queued += bytes;
1343 	subs->inflight_bytes += bytes;
1344 	subs->hwptr_done += bytes;
1345 	if (subs->hwptr_done >= subs->buffer_bytes)
1346 		subs->hwptr_done -= subs->buffer_bytes;
1347 }
1348 
fill_playback_urb_dsd_dop(struct snd_usb_substream * subs,struct urb * urb,unsigned int bytes)1349 static inline void fill_playback_urb_dsd_dop(struct snd_usb_substream *subs,
1350 					     struct urb *urb, unsigned int bytes)
1351 {
1352 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1353 	unsigned int dst_idx = 0;
1354 	unsigned int src_idx = subs->hwptr_done;
1355 	unsigned int wrap = subs->buffer_bytes;
1356 	u8 *dst = urb->transfer_buffer;
1357 	u8 *src = runtime->dma_area;
1358 	static const u8 marker[] = { 0x05, 0xfa };
1359 	unsigned int queued = 0;
1360 
1361 	/*
1362 	 * The DSP DOP format defines a way to transport DSD samples over
1363 	 * normal PCM data endpoints. It requires stuffing of marker bytes
1364 	 * (0x05 and 0xfa, alternating per sample frame), and then expects
1365 	 * 2 additional bytes of actual payload. The whole frame is stored
1366 	 * LSB.
1367 	 *
1368 	 * Hence, for a stereo transport, the buffer layout looks like this,
1369 	 * where L refers to left channel samples and R to right.
1370 	 *
1371 	 *   L1 L2 0x05   R1 R2 0x05   L3 L4 0xfa  R3 R4 0xfa
1372 	 *   L5 L6 0x05   R5 R6 0x05   L7 L8 0xfa  R7 R8 0xfa
1373 	 *   .....
1374 	 *
1375 	 */
1376 
1377 	while (bytes--) {
1378 		if (++subs->dsd_dop.byte_idx == 3) {
1379 			/* frame boundary? */
1380 			dst[dst_idx++] = marker[subs->dsd_dop.marker];
1381 			src_idx += 2;
1382 			subs->dsd_dop.byte_idx = 0;
1383 
1384 			if (++subs->dsd_dop.channel % runtime->channels == 0) {
1385 				/* alternate the marker */
1386 				subs->dsd_dop.marker++;
1387 				subs->dsd_dop.marker %= ARRAY_SIZE(marker);
1388 				subs->dsd_dop.channel = 0;
1389 			}
1390 		} else {
1391 			/* stuff the DSD payload */
1392 			int idx = (src_idx + subs->dsd_dop.byte_idx - 1) % wrap;
1393 
1394 			if (subs->cur_audiofmt->dsd_bitrev)
1395 				dst[dst_idx++] = bitrev8(src[idx]);
1396 			else
1397 				dst[dst_idx++] = src[idx];
1398 			queued++;
1399 		}
1400 	}
1401 
1402 	urb_ctx_queue_advance(subs, urb, queued);
1403 }
1404 
1405 /* copy bit-reversed bytes onto transfer buffer */
fill_playback_urb_dsd_bitrev(struct snd_usb_substream * subs,struct urb * urb,unsigned int bytes)1406 static void fill_playback_urb_dsd_bitrev(struct snd_usb_substream *subs,
1407 					 struct urb *urb, unsigned int bytes)
1408 {
1409 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1410 	const u8 *src = runtime->dma_area;
1411 	u8 *buf = urb->transfer_buffer;
1412 	int i, ofs = subs->hwptr_done;
1413 
1414 	for (i = 0; i < bytes; i++) {
1415 		*buf++ = bitrev8(src[ofs]);
1416 		if (++ofs >= subs->buffer_bytes)
1417 			ofs = 0;
1418 	}
1419 
1420 	urb_ctx_queue_advance(subs, urb, bytes);
1421 }
1422 
copy_to_urb(struct snd_usb_substream * subs,struct urb * urb,int offset,int stride,unsigned int bytes)1423 static void copy_to_urb(struct snd_usb_substream *subs, struct urb *urb,
1424 			int offset, int stride, unsigned int bytes)
1425 {
1426 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1427 
1428 	if (subs->hwptr_done + bytes > subs->buffer_bytes) {
1429 		/* err, the transferred area goes over buffer boundary. */
1430 		unsigned int bytes1 = subs->buffer_bytes - subs->hwptr_done;
1431 
1432 		memcpy(urb->transfer_buffer + offset,
1433 		       runtime->dma_area + subs->hwptr_done, bytes1);
1434 		memcpy(urb->transfer_buffer + offset + bytes1,
1435 		       runtime->dma_area, bytes - bytes1);
1436 	} else {
1437 		memcpy(urb->transfer_buffer + offset,
1438 		       runtime->dma_area + subs->hwptr_done, bytes);
1439 	}
1440 
1441 	urb_ctx_queue_advance(subs, urb, bytes);
1442 }
1443 
copy_to_urb_quirk(struct snd_usb_substream * subs,struct urb * urb,int stride,unsigned int bytes)1444 static unsigned int copy_to_urb_quirk(struct snd_usb_substream *subs,
1445 				      struct urb *urb, int stride,
1446 				      unsigned int bytes)
1447 {
1448 	__le32 packet_length;
1449 	int i;
1450 
1451 	/* Put __le32 length descriptor at start of each packet. */
1452 	for (i = 0; i < urb->number_of_packets; i++) {
1453 		unsigned int length = urb->iso_frame_desc[i].length;
1454 		unsigned int offset = urb->iso_frame_desc[i].offset;
1455 
1456 		packet_length = cpu_to_le32(length);
1457 		offset += i * sizeof(packet_length);
1458 		urb->iso_frame_desc[i].offset = offset;
1459 		urb->iso_frame_desc[i].length += sizeof(packet_length);
1460 		memcpy(urb->transfer_buffer + offset,
1461 		       &packet_length, sizeof(packet_length));
1462 		copy_to_urb(subs, urb, offset + sizeof(packet_length),
1463 			    stride, length);
1464 	}
1465 	/* Adjust transfer size accordingly. */
1466 	bytes += urb->number_of_packets * sizeof(packet_length);
1467 	return bytes;
1468 }
1469 
prepare_playback_urb(struct snd_usb_substream * subs,struct urb * urb,bool in_stream_lock)1470 static int prepare_playback_urb(struct snd_usb_substream *subs,
1471 				struct urb *urb,
1472 				bool in_stream_lock)
1473 {
1474 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1475 	struct snd_usb_endpoint *ep = subs->data_endpoint;
1476 	struct snd_urb_ctx *ctx = urb->context;
1477 	unsigned int frames, bytes;
1478 	int counts;
1479 	unsigned int transfer_done, frame_limit, avail = 0;
1480 	int i, stride, period_elapsed = 0;
1481 	unsigned long flags;
1482 	int err = 0;
1483 
1484 	stride = ep->stride;
1485 
1486 	frames = 0;
1487 	ctx->queued = 0;
1488 	urb->number_of_packets = 0;
1489 
1490 	spin_lock_irqsave(&subs->lock, flags);
1491 	frame_limit = subs->frame_limit + ep->max_urb_frames;
1492 	transfer_done = subs->transfer_done;
1493 
1494 	if (subs->lowlatency_playback &&
1495 	    runtime->state != SNDRV_PCM_STATE_DRAINING) {
1496 		unsigned int hwptr = subs->hwptr_done / stride;
1497 
1498 		/* calculate the byte offset-in-buffer of the appl_ptr */
1499 		avail = (runtime->control->appl_ptr - runtime->hw_ptr_base)
1500 			% runtime->buffer_size;
1501 		if (avail <= hwptr)
1502 			avail += runtime->buffer_size;
1503 		avail -= hwptr;
1504 	}
1505 
1506 	for (i = 0; i < ctx->packets; i++) {
1507 		counts = snd_usb_endpoint_next_packet_size(ep, ctx, i, avail);
1508 		if (counts < 0)
1509 			break;
1510 		/* set up descriptor */
1511 		urb->iso_frame_desc[i].offset = frames * stride;
1512 		urb->iso_frame_desc[i].length = counts * stride;
1513 		frames += counts;
1514 		avail -= counts;
1515 		urb->number_of_packets++;
1516 		transfer_done += counts;
1517 		if (transfer_done >= runtime->period_size) {
1518 			transfer_done -= runtime->period_size;
1519 			frame_limit = 0;
1520 			period_elapsed = 1;
1521 			if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
1522 				if (transfer_done > 0) {
1523 					/* FIXME: fill-max mode is not
1524 					 * supported yet */
1525 					frames -= transfer_done;
1526 					counts -= transfer_done;
1527 					urb->iso_frame_desc[i].length =
1528 						counts * stride;
1529 					transfer_done = 0;
1530 				}
1531 				i++;
1532 				if (i < ctx->packets) {
1533 					/* add a transfer delimiter */
1534 					urb->iso_frame_desc[i].offset =
1535 						frames * stride;
1536 					urb->iso_frame_desc[i].length = 0;
1537 					urb->number_of_packets++;
1538 				}
1539 				break;
1540 			}
1541 		}
1542 		/* finish at the period boundary or after enough frames */
1543 		if ((period_elapsed || transfer_done >= frame_limit) &&
1544 		    !snd_usb_endpoint_implicit_feedback_sink(ep))
1545 			break;
1546 	}
1547 
1548 	if (!frames) {
1549 		err = -EAGAIN;
1550 		goto unlock;
1551 	}
1552 
1553 	bytes = frames * stride;
1554 	subs->transfer_done = transfer_done;
1555 	subs->frame_limit = frame_limit;
1556 	if (unlikely(ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE &&
1557 		     subs->cur_audiofmt->dsd_dop)) {
1558 		fill_playback_urb_dsd_dop(subs, urb, bytes);
1559 	} else if (unlikely(ep->cur_format == SNDRV_PCM_FORMAT_DSD_U8 &&
1560 			   subs->cur_audiofmt->dsd_bitrev)) {
1561 		fill_playback_urb_dsd_bitrev(subs, urb, bytes);
1562 	} else {
1563 		/* usual PCM */
1564 		if (!subs->tx_length_quirk)
1565 			copy_to_urb(subs, urb, 0, stride, bytes);
1566 		else
1567 			bytes = copy_to_urb_quirk(subs, urb, stride, bytes);
1568 			/* bytes is now amount of outgoing data */
1569 	}
1570 
1571 	subs->last_frame_number = usb_get_current_frame_number(subs->dev);
1572 
1573 	if (subs->trigger_tstamp_pending_update) {
1574 		/* this is the first actual URB submitted,
1575 		 * update trigger timestamp to reflect actual start time
1576 		 */
1577 		snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
1578 		subs->trigger_tstamp_pending_update = false;
1579 	}
1580 
1581 	if (period_elapsed && !subs->running && subs->lowlatency_playback) {
1582 		subs->period_elapsed_pending = 1;
1583 		period_elapsed = 0;
1584 	}
1585 
1586  unlock:
1587 	spin_unlock_irqrestore(&subs->lock, flags);
1588 	if (err < 0)
1589 		return err;
1590 	urb->transfer_buffer_length = bytes;
1591 	if (period_elapsed) {
1592 		if (in_stream_lock)
1593 			snd_pcm_period_elapsed_under_stream_lock(subs->pcm_substream);
1594 		else
1595 			snd_pcm_period_elapsed(subs->pcm_substream);
1596 	}
1597 	return 0;
1598 }
1599 
1600 /*
1601  * process after playback data complete
1602  * - decrease the delay count again
1603  */
retire_playback_urb(struct snd_usb_substream * subs,struct urb * urb)1604 static void retire_playback_urb(struct snd_usb_substream *subs,
1605 			       struct urb *urb)
1606 {
1607 	unsigned long flags;
1608 	struct snd_urb_ctx *ctx = urb->context;
1609 	bool period_elapsed = false;
1610 
1611 	spin_lock_irqsave(&subs->lock, flags);
1612 	if (ctx->queued) {
1613 		if (subs->inflight_bytes >= ctx->queued)
1614 			subs->inflight_bytes -= ctx->queued;
1615 		else
1616 			subs->inflight_bytes = 0;
1617 	}
1618 
1619 	subs->last_frame_number = usb_get_current_frame_number(subs->dev);
1620 	if (subs->running) {
1621 		period_elapsed = subs->period_elapsed_pending;
1622 		subs->period_elapsed_pending = 0;
1623 	}
1624 	spin_unlock_irqrestore(&subs->lock, flags);
1625 	if (period_elapsed)
1626 		snd_pcm_period_elapsed(subs->pcm_substream);
1627 }
1628 
1629 /* PCM ack callback for the playback stream;
1630  * this plays a role only when the stream is running in low-latency mode.
1631  */
snd_usb_pcm_playback_ack(struct snd_pcm_substream * substream)1632 static int snd_usb_pcm_playback_ack(struct snd_pcm_substream *substream)
1633 {
1634 	struct snd_usb_substream *subs = substream->runtime->private_data;
1635 	struct snd_usb_endpoint *ep;
1636 
1637 	if (!subs->lowlatency_playback || !subs->running)
1638 		return 0;
1639 	ep = subs->data_endpoint;
1640 	if (!ep)
1641 		return 0;
1642 	/* When no more in-flight URBs available, try to process the pending
1643 	 * outputs here
1644 	 */
1645 	if (!ep->active_mask)
1646 		return snd_usb_queue_pending_output_urbs(ep, true);
1647 	return 0;
1648 }
1649 
snd_usb_substream_playback_trigger(struct snd_pcm_substream * substream,int cmd)1650 static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream,
1651 					      int cmd)
1652 {
1653 	struct snd_usb_substream *subs = substream->runtime->private_data;
1654 	int err;
1655 
1656 	switch (cmd) {
1657 	case SNDRV_PCM_TRIGGER_START:
1658 		subs->trigger_tstamp_pending_update = true;
1659 		fallthrough;
1660 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1661 		snd_usb_endpoint_set_callback(subs->data_endpoint,
1662 					      prepare_playback_urb,
1663 					      retire_playback_urb,
1664 					      subs);
1665 		if (subs->lowlatency_playback &&
1666 		    cmd == SNDRV_PCM_TRIGGER_START) {
1667 			if (in_free_wheeling_mode(substream->runtime))
1668 				subs->lowlatency_playback = false;
1669 			err = start_endpoints(subs);
1670 			if (err < 0) {
1671 				snd_usb_endpoint_set_callback(subs->data_endpoint,
1672 							      NULL, NULL, NULL);
1673 				return err;
1674 			}
1675 		}
1676 		subs->running = 1;
1677 		dev_dbg(&subs->dev->dev, "%d:%d Start Playback PCM\n",
1678 			subs->cur_audiofmt->iface,
1679 			subs->cur_audiofmt->altsetting);
1680 		return 0;
1681 	case SNDRV_PCM_TRIGGER_SUSPEND:
1682 	case SNDRV_PCM_TRIGGER_STOP:
1683 		stop_endpoints(subs, substream->runtime->state == SNDRV_PCM_STATE_DRAINING);
1684 		snd_usb_endpoint_set_callback(subs->data_endpoint,
1685 					      NULL, NULL, NULL);
1686 		subs->running = 0;
1687 		dev_dbg(&subs->dev->dev, "%d:%d Stop Playback PCM\n",
1688 			subs->cur_audiofmt->iface,
1689 			subs->cur_audiofmt->altsetting);
1690 		return 0;
1691 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1692 		/* keep retire_data_urb for delay calculation */
1693 		snd_usb_endpoint_set_callback(subs->data_endpoint,
1694 					      NULL,
1695 					      retire_playback_urb,
1696 					      subs);
1697 		subs->running = 0;
1698 		dev_dbg(&subs->dev->dev, "%d:%d Pause Playback PCM\n",
1699 			subs->cur_audiofmt->iface,
1700 			subs->cur_audiofmt->altsetting);
1701 		return 0;
1702 	}
1703 
1704 	return -EINVAL;
1705 }
1706 
snd_usb_substream_capture_trigger(struct snd_pcm_substream * substream,int cmd)1707 static int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream,
1708 					     int cmd)
1709 {
1710 	int err;
1711 	struct snd_usb_substream *subs = substream->runtime->private_data;
1712 
1713 	switch (cmd) {
1714 	case SNDRV_PCM_TRIGGER_START:
1715 		err = start_endpoints(subs);
1716 		if (err < 0)
1717 			return err;
1718 		fallthrough;
1719 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1720 		snd_usb_endpoint_set_callback(subs->data_endpoint,
1721 					      NULL, retire_capture_urb,
1722 					      subs);
1723 		subs->last_frame_number = usb_get_current_frame_number(subs->dev);
1724 		subs->running = 1;
1725 		dev_dbg(&subs->dev->dev, "%d:%d Start Capture PCM\n",
1726 			subs->cur_audiofmt->iface,
1727 			subs->cur_audiofmt->altsetting);
1728 		return 0;
1729 	case SNDRV_PCM_TRIGGER_SUSPEND:
1730 	case SNDRV_PCM_TRIGGER_STOP:
1731 		stop_endpoints(subs, false);
1732 		fallthrough;
1733 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1734 		snd_usb_endpoint_set_callback(subs->data_endpoint,
1735 					      NULL, NULL, NULL);
1736 		subs->running = 0;
1737 		dev_dbg(&subs->dev->dev, "%d:%d Stop Capture PCM\n",
1738 			subs->cur_audiofmt->iface,
1739 			subs->cur_audiofmt->altsetting);
1740 		return 0;
1741 	}
1742 
1743 	return -EINVAL;
1744 }
1745 
1746 static const struct snd_pcm_ops snd_usb_playback_ops = {
1747 	.open =		snd_usb_pcm_open,
1748 	.close =	snd_usb_pcm_close,
1749 	.hw_params =	snd_usb_hw_params,
1750 	.hw_free =	snd_usb_hw_free,
1751 	.prepare =	snd_usb_pcm_prepare,
1752 	.trigger =	snd_usb_substream_playback_trigger,
1753 	.sync_stop =	snd_usb_pcm_sync_stop,
1754 	.pointer =	snd_usb_pcm_pointer,
1755 	.ack =		snd_usb_pcm_playback_ack,
1756 };
1757 
1758 static const struct snd_pcm_ops snd_usb_capture_ops = {
1759 	.open =		snd_usb_pcm_open,
1760 	.close =	snd_usb_pcm_close,
1761 	.hw_params =	snd_usb_hw_params,
1762 	.hw_free =	snd_usb_hw_free,
1763 	.prepare =	snd_usb_pcm_prepare,
1764 	.trigger =	snd_usb_substream_capture_trigger,
1765 	.sync_stop =	snd_usb_pcm_sync_stop,
1766 	.pointer =	snd_usb_pcm_pointer,
1767 };
1768 
snd_usb_set_pcm_ops(struct snd_pcm * pcm,int stream)1769 void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream)
1770 {
1771 	const struct snd_pcm_ops *ops;
1772 
1773 	ops = stream == SNDRV_PCM_STREAM_PLAYBACK ?
1774 			&snd_usb_playback_ops : &snd_usb_capture_ops;
1775 	snd_pcm_set_ops(pcm, stream, ops);
1776 }
1777 
snd_usb_preallocate_buffer(struct snd_usb_substream * subs)1778 void snd_usb_preallocate_buffer(struct snd_usb_substream *subs)
1779 {
1780 	struct snd_pcm *pcm = subs->stream->pcm;
1781 	struct snd_pcm_substream *s = pcm->streams[subs->direction].substream;
1782 	struct device *dev = subs->dev->bus->sysdev;
1783 
1784 	if (snd_usb_use_vmalloc)
1785 		snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_VMALLOC,
1786 					   NULL, 0, 0);
1787 	else
1788 		snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_DEV_SG,
1789 					   dev, 64*1024, 512*1024);
1790 }
1791