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 */ |
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, size: 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(usb_dev: 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 | */ |
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(v: &subs->stream->chip->shutdown)) |
79 | return SNDRV_PCM_POS_XRUN; |
80 | spin_lock(lock: &subs->lock); |
81 | hwptr_done = subs->hwptr_done; |
82 | runtime->delay = snd_usb_pcm_delay(subs, runtime); |
83 | spin_unlock(lock: &subs->lock); |
84 | return bytes_to_frames(runtime, size: hwptr_done); |
85 | } |
86 | |
87 | /* |
88 | * find a matching audio format |
89 | */ |
90 | static const struct audioformat * |
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(pcm_format: 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 * |
152 | find_substream_format(struct snd_usb_substream *subs, |
153 | const struct snd_pcm_hw_params *params) |
154 | { |
155 | return find_format(fmt_list_head: &subs->fmt_list, format: params_format(p: params), |
156 | rate: params_rate(p: params), channels: params_channels(p: params), |
157 | strict_match: true, subs); |
158 | } |
159 | |
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 | |
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, index: ep, |
198 | data, size: sizeof(data)); |
199 | return err; |
200 | } |
201 | |
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, index: 0, |
212 | data, size: sizeof(data)); |
213 | return err; |
214 | } |
215 | |
216 | /* |
217 | * initialize the pitch control and sample rate |
218 | */ |
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, ep: fmt->endpoint); |
233 | break; |
234 | case UAC_VERSION_2: |
235 | err = init_pitch_v2(chip, ep: 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 | |
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, addr: &subs->flags)) { |
255 | snd_usb_endpoint_stop(ep: subs->sync_endpoint, keep_pending); |
256 | stopped = true; |
257 | } |
258 | if (test_and_clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, addr: &subs->flags)) { |
259 | snd_usb_endpoint_stop(ep: subs->data_endpoint, keep_pending); |
260 | stopped = true; |
261 | } |
262 | return stopped; |
263 | } |
264 | |
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, addr: &subs->flags)) { |
273 | err = snd_usb_endpoint_start(ep: subs->data_endpoint); |
274 | if (err < 0) { |
275 | clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, addr: &subs->flags); |
276 | goto error; |
277 | } |
278 | } |
279 | |
280 | if (subs->sync_endpoint && |
281 | !test_and_set_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, addr: &subs->flags)) { |
282 | err = snd_usb_endpoint_start(ep: subs->sync_endpoint); |
283 | if (err < 0) { |
284 | clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, addr: &subs->flags); |
285 | goto error; |
286 | } |
287 | } |
288 | |
289 | return 0; |
290 | |
291 | error: |
292 | stop_endpoints(subs, keep_pending: false); |
293 | return err; |
294 | } |
295 | |
296 | static void sync_pending_stops(struct snd_usb_substream *subs) |
297 | { |
298 | snd_usb_endpoint_sync_pending_stop(ep: subs->sync_endpoint); |
299 | snd_usb_endpoint_sync_pending_stop(ep: subs->data_endpoint); |
300 | } |
301 | |
302 | /* PCM sync_stop callback */ |
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 */ |
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, ifnum: fmt->iface, altsetting: 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 | |
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(chip: subs->stream->chip, pd: 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 | |
419 | int snd_usb_pcm_suspend(struct snd_usb_stream *as) |
420 | { |
421 | int ret; |
422 | |
423 | ret = snd_usb_pcm_change_state(subs: &as->substream[0], state: UAC3_PD_STATE_D2); |
424 | if (ret < 0) |
425 | return ret; |
426 | |
427 | ret = snd_usb_pcm_change_state(subs: &as->substream[1], state: UAC3_PD_STATE_D2); |
428 | if (ret < 0) |
429 | return ret; |
430 | |
431 | return 0; |
432 | } |
433 | |
434 | int snd_usb_pcm_resume(struct snd_usb_stream *as) |
435 | { |
436 | int ret; |
437 | |
438 | ret = snd_usb_pcm_change_state(subs: &as->substream[0], state: UAC3_PD_STATE_D1); |
439 | if (ret < 0) |
440 | return ret; |
441 | |
442 | ret = snd_usb_pcm_change_state(subs: &as->substream[1], state: UAC3_PD_STATE_D1); |
443 | if (ret < 0) |
444 | return ret; |
445 | |
446 | return 0; |
447 | } |
448 | |
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, data_ep: subs->data_endpoint, NULL); |
454 | snd_usb_endpoint_close(chip, ep: subs->data_endpoint); |
455 | subs->data_endpoint = NULL; |
456 | } |
457 | |
458 | if (subs->sync_endpoint) { |
459 | snd_usb_endpoint_close(chip, ep: 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 | */ |
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, params: 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, target: fmt, |
501 | params: hw_params, |
502 | stream: !substream->stream, |
503 | fixed_rate: &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, state: UAC3_PD_STATE_D0); |
524 | if (ret < 0) |
525 | goto unlock; |
526 | |
527 | if (subs->data_endpoint) { |
528 | if (snd_usb_endpoint_compatible(chip, ep: subs->data_endpoint, |
529 | fp: fmt, params: hw_params)) |
530 | goto unlock; |
531 | if (stop_endpoints(subs, keep_pending: false)) |
532 | sync_pending_stops(subs); |
533 | close_endpoints(chip, subs); |
534 | } |
535 | |
536 | subs->data_endpoint = snd_usb_endpoint_open(chip, fp: fmt, params: hw_params, is_sync_ep: 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, fp: sync_fmt, |
544 | params: hw_params, |
545 | is_sync_ep: fmt == sync_fmt, |
546 | fixed_rate: sync_fixed_rate); |
547 | if (!subs->sync_endpoint) { |
548 | ret = -EINVAL; |
549 | goto unlock; |
550 | } |
551 | |
552 | snd_usb_endpoint_set_sync(chip, data_ep: subs->data_endpoint, |
553 | sync_ep: subs->sync_endpoint); |
554 | } |
555 | |
556 | mutex_lock(&chip->mutex); |
557 | subs->cur_audiofmt = fmt; |
558 | mutex_unlock(lock: &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, ep: subs->sync_endpoint); |
565 | if (ret < 0) |
566 | goto unlock; |
567 | } |
568 | |
569 | ret = snd_usb_endpoint_set_params(chip, ep: 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 | */ |
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(lock: &chip->mutex); |
597 | if (!snd_usb_lock_shutdown(chip)) { |
598 | if (stop_endpoints(subs, keep_pending: 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) */ |
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 */ |
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(ep: subs->data_endpoint)) |
628 | return false; |
629 | return true; |
630 | } |
631 | |
632 | /* |
633 | * prepare callback |
634 | * |
635 | * only a few subtle things... |
636 | */ |
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, state: 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, ep: subs->sync_endpoint); |
660 | if (ret < 0) |
661 | goto unlock; |
662 | } |
663 | |
664 | ret = snd_usb_endpoint_prepare(chip, ep: subs->data_endpoint); |
665 | if (ret < 0) |
666 | goto unlock; |
667 | else if (ret > 0) |
668 | snd_usb_set_format_quirk(subs, fmt: subs->cur_audiofmt); |
669 | ret = 0; |
670 | |
671 | /* reset the pointer */ |
672 | subs->buffer_bytes = frames_to_bytes(runtime, size: 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 | |
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(mask: &check_fmts); |
737 | check_fmts.bits[0] = (u32)fp->formats; |
738 | check_fmts.bits[1] = (u32)(fp->formats >> 32); |
739 | snd_mask_intersect(mask: &check_fmts, v: fmts); |
740 | if (snd_mask_empty(mask: &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 | |
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(i: 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 * |
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, ep_num: endpoint); |
809 | if (ep && ep->cur_audiofmt && (ep != ref_ep || ep->opened > 1)) |
810 | return ep; |
811 | return NULL; |
812 | } |
813 | |
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, endpoint: fp->endpoint, |
833 | ref_ep: 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, endpoint: fp->sync_ep, |
844 | ref_ep: 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, clock: fp->clock); |
855 | if (r > 0) { |
856 | if (!snd_interval_test(i: it, val: 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(i: it, val: 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 | |
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 | |
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 | |
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, endpoint: fp->endpoint, |
936 | ref_ep: 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(pcm_format: ep->cur_format); |
941 | continue; |
942 | } |
943 | |
944 | if (fp->implicit_fb) { |
945 | ep = get_endpoint_in_use(chip, endpoint: fp->sync_ep, |
946 | ref_ep: 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(pcm_format: ep->cur_format); |
951 | continue; |
952 | } |
953 | } |
954 | |
955 | fbits |= fp->formats; |
956 | } |
957 | return apply_hw_params_format_bits(fmt, fbits); |
958 | } |
959 | |
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, rmin: pmin, UINT_MAX); |
985 | } |
986 | |
987 | /* additional hw constraints for implicit feedback mode */ |
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, endpoint: fp->endpoint, |
1006 | ref_ep: 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, endpoint: fp->sync_ep, |
1017 | ref_ep: 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 | |
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, endpoint: fp->endpoint, |
1051 | ref_ep: 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, endpoint: fp->sync_ep, |
1062 | ref_ep: 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 | |
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 | min: ptmin, UINT_MAX); |
1128 | if (err < 0) |
1129 | return err; |
1130 | |
1131 | err = snd_pcm_hw_rule_add(runtime, cond: 0, SNDRV_PCM_HW_PARAM_RATE, |
1132 | func: hw_rule_rate, private: 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, cond: 0, SNDRV_PCM_HW_PARAM_CHANNELS, |
1142 | func: hw_rule_channels, private: 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, cond: 0, SNDRV_PCM_HW_PARAM_FORMAT, |
1151 | func: hw_rule_format, private: 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, cond: 0, |
1161 | SNDRV_PCM_HW_PARAM_PERIOD_TIME, |
1162 | func: hw_rule_period_time, private: 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 | min: 0, max: 1000000); |
1175 | if (err < 0) |
1176 | return err; |
1177 | err = snd_pcm_hw_constraint_minmax(runtime, |
1178 | SNDRV_PCM_HW_PARAM_BUFFER_TIME, |
1179 | min: 0, max: 2000000); |
1180 | if (err < 0) |
1181 | return err; |
1182 | |
1183 | /* additional hw constraints for implicit fb */ |
1184 | err = snd_pcm_hw_rule_add(runtime, cond: 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, |
1185 | func: hw_rule_period_size_implicit_fb, private: subs, |
1186 | SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1); |
1187 | if (err < 0) |
1188 | return err; |
1189 | err = snd_pcm_hw_rule_add(runtime, cond: 0, SNDRV_PCM_HW_PARAM_PERIODS, |
1190 | func: hw_rule_periods_implicit_fb, private: 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 | |
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(chip: subs->stream->chip); |
1231 | if (ret < 0) |
1232 | return ret; |
1233 | ret = snd_media_stream_init(subs, pcm: as->pcm, stream: direction); |
1234 | if (ret < 0) |
1235 | snd_usb_autosuspend(chip: subs->stream->chip); |
1236 | return ret; |
1237 | } |
1238 | |
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(chip: subs->stream->chip)) { |
1249 | ret = snd_usb_pcm_change_state(subs, state: UAC3_PD_STATE_D1); |
1250 | snd_usb_unlock_shutdown(chip: subs->stream->chip); |
1251 | if (ret < 0) |
1252 | return ret; |
1253 | } |
1254 | |
1255 | subs->pcm_substream = NULL; |
1256 | snd_usb_autosuspend(chip: 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 | */ |
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(usb_dev: 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(lock: &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(substream: subs->pcm_substream); |
1335 | } |
1336 | |
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 | |
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, bytes: queued); |
1403 | } |
1404 | |
1405 | /* copy bit-reversed bytes onto transfer buffer */ |
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 | |
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 | |
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: offset + sizeof(packet_length), |
1463 | stride, bytes: length); |
1464 | } |
1465 | /* Adjust transfer size accordingly. */ |
1466 | bytes += urb->number_of_packets * sizeof(packet_length); |
1467 | return bytes; |
1468 | } |
1469 | |
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, idx: 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, offset: 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(usb_dev: 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, tv: &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(lock: &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(substream: subs->pcm_substream); |
1594 | else |
1595 | snd_pcm_period_elapsed(substream: subs->pcm_substream); |
1596 | } |
1597 | return 0; |
1598 | } |
1599 | |
1600 | /* |
1601 | * process after playback data complete |
1602 | * - decrease the delay count again |
1603 | */ |
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(usb_dev: subs->dev); |
1620 | if (subs->running) { |
1621 | period_elapsed = subs->period_elapsed_pending; |
1622 | subs->period_elapsed_pending = 0; |
1623 | } |
1624 | spin_unlock_irqrestore(lock: &subs->lock, flags); |
1625 | if (period_elapsed) |
1626 | snd_pcm_period_elapsed(substream: 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 | */ |
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, in_stream_lock: true); |
1647 | return 0; |
1648 | } |
1649 | |
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(ep: subs->data_endpoint, |
1662 | prepare: prepare_playback_urb, |
1663 | retire: retire_playback_urb, |
1664 | data_subs: subs); |
1665 | if (subs->lowlatency_playback && |
1666 | cmd == SNDRV_PCM_TRIGGER_START) { |
1667 | if (in_free_wheeling_mode(runtime: substream->runtime)) |
1668 | subs->lowlatency_playback = false; |
1669 | err = start_endpoints(subs); |
1670 | if (err < 0) { |
1671 | snd_usb_endpoint_set_callback(ep: 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, keep_pending: substream->runtime->state == SNDRV_PCM_STATE_DRAINING); |
1684 | snd_usb_endpoint_set_callback(ep: 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(ep: subs->data_endpoint, |
1694 | NULL, |
1695 | retire: retire_playback_urb, |
1696 | data_subs: 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 | |
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(ep: subs->data_endpoint, |
1721 | NULL, retire: retire_capture_urb, |
1722 | data_subs: subs); |
1723 | subs->last_frame_number = usb_get_current_frame_number(usb_dev: 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, keep_pending: false); |
1732 | fallthrough; |
1733 | case SNDRV_PCM_TRIGGER_PAUSE_PUSH: |
1734 | snd_usb_endpoint_set_callback(ep: 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 | |
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, direction: stream, ops); |
1776 | } |
1777 | |
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(substream: s, SNDRV_DMA_TYPE_VMALLOC, |
1786 | NULL, size: 0, max: 0); |
1787 | else |
1788 | snd_pcm_set_managed_buffer(substream: s, SNDRV_DMA_TYPE_DEV_SG, |
1789 | data: dev, size: 64*1024, max: 512*1024); |
1790 | } |
1791 | |