?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: usb-audio: process pending stop at PCM hw_free and close
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / sound / usb / pcm.c
blobbc3c9acc68b76000f50c0a50a2e00ce9a3a1ad85
1 /*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17 #include <linux/init.h>
18 #include <linux/slab.h>
19 #include <linux/ratelimit.h>
20 #include <linux/usb.h>
21 #include <linux/usb/audio.h>
22 #include <linux/usb/audio-v2.h>
23
24 #include <sound/core.h>
25 #include <sound/pcm.h>
26 #include <sound/pcm_params.h>
27
28 #include "usbaudio.h"
29 #include "card.h"
30 #include "quirks.h"
31 #include "debug.h"
32 #include "endpoint.h"
33 #include "helper.h"
34 #include "pcm.h"
35 #include "clock.h"
36 #include "power.h"
37
38 #define SUBSTREAM_FLAG_DATA_EP_STARTED 0
39 #define SUBSTREAM_FLAG_SYNC_EP_STARTED 1
40
41 /* return the estimated delay based on USB frame counters */
42 snd_pcm_uframes_t snd_usb_pcm_delay(struct snd_usb_substream *subs,
43 unsigned int rate)
44 {
45 int current_frame_number;
46 int frame_diff;
47 int est_delay;
48
49 current_frame_number = usb_get_current_frame_number(subs->dev);
50 /*
51 * HCD implementations use different widths, use lower 8 bits.
52 * The delay will be managed up to 256ms, which is more than
53 * enough
54 */
55 frame_diff = (current_frame_number - subs->last_frame_number) & 0xff;
56
57 /* Approximation based on number of samples per USB frame (ms),
58 some truncation for 44.1 but the estimate is good enough */
59 est_delay = subs->last_delay - (frame_diff * rate / 1000);
60 if (est_delay < 0)
61 est_delay = 0;
62 return est_delay;
63 }
64
65 /*
66 * return the current pcm pointer. just based on the hwptr_done value.
67 */
68 static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
69 {
70 struct snd_usb_substream *subs;
71 unsigned int hwptr_done;
72
73 subs = (struct snd_usb_substream *)substream->runtime->private_data;
74 if (subs->stream->chip->shutdown)
75 return SNDRV_PCM_POS_XRUN;
76 spin_lock(&subs->lock);
77 hwptr_done = subs->hwptr_done;
78 substream->runtime->delay = snd_usb_pcm_delay(subs,
79 substream->runtime->rate);
80 spin_unlock(&subs->lock);
81 return hwptr_done / (substream->runtime->frame_bits >> 3);
82 }
83
84 /*
85 * find a matching audio format
86 */
87 static struct audioformat *find_format(struct snd_usb_substream *subs)
88 {
89 struct list_head *p;
90 struct audioformat *found = NULL;
91 int cur_attr = 0, attr;
92
93 list_for_each(p, &subs->fmt_list) {
94 struct audioformat *fp;
95 fp = list_entry(p, struct audioformat, list);
96 if (!(fp->formats & (1uLL << subs->pcm_format)))
97 continue;
98 if (fp->channels != subs->channels)
99 continue;
100 if (subs->cur_rate < fp->rate_min ||
101 subs->cur_rate > fp->rate_max)
102 continue;
103 if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
104 unsigned int i;
105 for (i = 0; i < fp->nr_rates; i++)
106 if (fp->rate_table[i] == subs->cur_rate)
107 break;
108 if (i >= fp->nr_rates)
109 continue;
110 }
111 attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE;
112 if (! found) {
113 found = fp;
114 cur_attr = attr;
115 continue;
116 }
117 /* avoid async out and adaptive in if the other method
118 * supports the same format.
119 * this is a workaround for the case like
120 * M-audio audiophile USB.
121 */
122 if (attr != cur_attr) {
123 if ((attr == USB_ENDPOINT_SYNC_ASYNC &&
124 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
125 (attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
126 subs->direction == SNDRV_PCM_STREAM_CAPTURE))
127 continue;
128 if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC &&
129 subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
130 (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
131 subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
132 found = fp;
133 cur_attr = attr;
134 continue;
135 }
136 }
137 /* find the format with the largest max. packet size */
138 if (fp->maxpacksize > found->maxpacksize) {
139 found = fp;
140 cur_attr = attr;
141 }
142 }
143 return found;
144 }
145
146 static int init_pitch_v1(struct snd_usb_audio *chip, int iface,
147 struct usb_host_interface *alts,
148 struct audioformat *fmt)
149 {
150 struct usb_device *dev = chip->dev;
151 unsigned int ep;
152 unsigned char data[1];
153 int err;
154
155 ep = get_endpoint(alts, 0)->bEndpointAddress;
156
157 data[0] = 1;
158 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
159 USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
160 UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep,
161 data, sizeof(data))) < 0) {
162 snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
163 dev->devnum, iface, ep);
164 return err;
165 }
166
167 return 0;
168 }
169
170 static int init_pitch_v2(struct snd_usb_audio *chip, int iface,
171 struct usb_host_interface *alts,
172 struct audioformat *fmt)
173 {
174 struct usb_device *dev = chip->dev;
175 unsigned char data[1];
176 int err;
177
178 data[0] = 1;
179 if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
180 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
181 UAC2_EP_CS_PITCH << 8, 0,
182 data, sizeof(data))) < 0) {
183 snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH (v2)\n",
184 dev->devnum, iface, fmt->altsetting);
185 return err;
186 }
187
188 return 0;
189 }
190
191 /*
192 * initialize the pitch control and sample rate
193 */
194 int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
195 struct usb_host_interface *alts,
196 struct audioformat *fmt)
197 {
198 struct usb_interface_descriptor *altsd = get_iface_desc(alts);
199
200 /* if endpoint doesn't have pitch control, bail out */
201 if (!(fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL))
202 return 0;
203
204 switch (altsd->bInterfaceProtocol) {
205 case UAC_VERSION_1:
206 default:
207 return init_pitch_v1(chip, iface, alts, fmt);
208
209 case UAC_VERSION_2:
210 return init_pitch_v2(chip, iface, alts, fmt);
211 }
212 }
213
214 static int start_endpoints(struct snd_usb_substream *subs, bool can_sleep)
215 {
216 int err;
217
218 if (!subs->data_endpoint)
219 return -EINVAL;
220
221 if (!test_and_set_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) {
222 struct snd_usb_endpoint *ep = subs->data_endpoint;
223
224 snd_printdd(KERN_DEBUG "Starting data EP @%p\n", ep);
225
226 ep->data_subs = subs;
227 err = snd_usb_endpoint_start(ep, can_sleep);
228 if (err < 0) {
229 clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags);
230 return err;
231 }
232 }
233
234 if (subs->sync_endpoint &&
235 !test_and_set_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) {
236 struct snd_usb_endpoint *ep = subs->sync_endpoint;
237
238 if (subs->data_endpoint->iface != subs->sync_endpoint->iface ||
239 subs->data_endpoint->alt_idx != subs->sync_endpoint->alt_idx) {
240 err = usb_set_interface(subs->dev,
241 subs->sync_endpoint->iface,
242 subs->sync_endpoint->alt_idx);
243 if (err < 0) {
244 snd_printk(KERN_ERR
245 "%d:%d:%d: cannot set interface (%d)\n",
246 subs->dev->devnum,
247 subs->sync_endpoint->iface,
248 subs->sync_endpoint->alt_idx, err);
249 return -EIO;
250 }
251 }
252
253 snd_printdd(KERN_DEBUG "Starting sync EP @%p\n", ep);
254
255 ep->sync_slave = subs->data_endpoint;
256 err = snd_usb_endpoint_start(ep, can_sleep);
257 if (err < 0) {
258 clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags);
259 return err;
260 }
261 }
262
263 return 0;
264 }
265
266 static void stop_endpoints(struct snd_usb_substream *subs, bool wait)
267 {
268 if (test_and_clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags))
269 snd_usb_endpoint_stop(subs->sync_endpoint);
270
271 if (test_and_clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags))
272 snd_usb_endpoint_stop(subs->data_endpoint);
273
274 if (wait) {
275 snd_usb_endpoint_sync_pending_stop(subs->sync_endpoint);
276 snd_usb_endpoint_sync_pending_stop(subs->data_endpoint);
277 }
278 }
279
280 static int deactivate_endpoints(struct snd_usb_substream *subs)
281 {
282 int reta, retb;
283
284 reta = snd_usb_endpoint_deactivate(subs->sync_endpoint);
285 retb = snd_usb_endpoint_deactivate(subs->data_endpoint);
286
287 if (reta < 0)
288 return reta;
289
290 if (retb < 0)
291 return retb;
292
293 return 0;
294 }
295
296 /*
297 * find a matching format and set up the interface
298 */
299 static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
300 {
301 struct usb_device *dev = subs->dev;
302 struct usb_host_interface *alts;
303 struct usb_interface_descriptor *altsd;
304 struct usb_interface *iface;
305 unsigned int ep, attr;
306 int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
307 int err, implicit_fb = 0;
308
309 iface = usb_ifnum_to_if(dev, fmt->iface);
310 if (WARN_ON(!iface))
311 return -EINVAL;
312 alts = &iface->altsetting[fmt->altset_idx];
313 altsd = get_iface_desc(alts);
314 if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
315 return -EINVAL;
316
317 if (fmt == subs->cur_audiofmt)
318 return 0;
319
320 /* close the old interface */
321 if (subs->interface >= 0 && subs->interface != fmt->iface) {
322 err = usb_set_interface(subs->dev, subs->interface, 0);
323 if (err < 0) {
324 snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed (%d)\n",
325 dev->devnum, fmt->iface, fmt->altsetting, err);
326 return -EIO;
327 }
328 subs->interface = -1;
329 subs->altset_idx = 0;
330 }
331
332 /* set interface */
333 if (subs->interface != fmt->iface ||
334 subs->altset_idx != fmt->altset_idx) {
335 err = usb_set_interface(dev, fmt->iface, fmt->altsetting);
336 if (err < 0) {
337 snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed (%d)\n",
338 dev->devnum, fmt->iface, fmt->altsetting, err);
339 return -EIO;
340 }
341 snd_printdd(KERN_INFO "setting usb interface %d:%d\n",
342 fmt->iface, fmt->altsetting);
343 subs->interface = fmt->iface;
344 subs->altset_idx = fmt->altset_idx;
345 }
346
347 subs->data_endpoint = snd_usb_add_endpoint(subs->stream->chip,
348 alts, fmt->endpoint, subs->direction,
349 SND_USB_ENDPOINT_TYPE_DATA);
350 if (!subs->data_endpoint)
351 return -EINVAL;
352
353 /* we need a sync pipe in async OUT or adaptive IN mode */
354 /* check the number of EP, since some devices have broken
355 * descriptors which fool us. if it has only one EP,
356 * assume it as adaptive-out or sync-in.
357 */
358 attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
359
360 switch (subs->stream->chip->usb_id) {
361 case USB_ID(0x0763, 0x2080): /* M-Audio FastTrack Ultra */
362 case USB_ID(0x0763, 0x2081):
363 if (is_playback) {
364 implicit_fb = 1;
365 ep = 0x81;
366 iface = usb_ifnum_to_if(dev, 2);
367
368 if (!iface || iface->num_altsetting == 0)
369 return -EINVAL;
370
371 alts = &iface->altsetting[1];
372 goto add_sync_ep;
373 }
374 }
375
376 if (((is_playback && attr == USB_ENDPOINT_SYNC_ASYNC) ||
377 (!is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) &&
378 altsd->bNumEndpoints >= 2) {
379 /* check sync-pipe endpoint */
380 /* ... and check descriptor size before accessing bSynchAddress
381 because there is a version of the SB Audigy 2 NX firmware lacking
382 the audio fields in the endpoint descriptors */
383 if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
384 (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
385 get_endpoint(alts, 1)->bSynchAddress != 0 &&
386 !implicit_fb)) {
387 snd_printk(KERN_ERR "%d:%d:%d : invalid sync pipe. bmAttributes %02x, bLength %d, bSynchAddress %02x\n",
388 dev->devnum, fmt->iface, fmt->altsetting,
389 get_endpoint(alts, 1)->bmAttributes,
390 get_endpoint(alts, 1)->bLength,
391 get_endpoint(alts, 1)->bSynchAddress);
392 return -EINVAL;
393 }
394 ep = get_endpoint(alts, 1)->bEndpointAddress;
395 if (!implicit_fb &&
396 get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
397 (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
398 (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
399 snd_printk(KERN_ERR "%d:%d:%d : invalid sync pipe. is_playback %d, ep %02x, bSynchAddress %02x\n",
400 dev->devnum, fmt->iface, fmt->altsetting,
401 is_playback, ep, get_endpoint(alts, 0)->bSynchAddress);
402 return -EINVAL;
403 }
404
405 implicit_fb = (get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_USAGE_MASK)
406 == USB_ENDPOINT_USAGE_IMPLICIT_FB;
407
408 add_sync_ep:
409 subs->sync_endpoint = snd_usb_add_endpoint(subs->stream->chip,
410 alts, ep, !subs->direction,
411 implicit_fb ?
412 SND_USB_ENDPOINT_TYPE_DATA :
413 SND_USB_ENDPOINT_TYPE_SYNC);
414 if (!subs->sync_endpoint)
415 return -EINVAL;
416
417 subs->data_endpoint->sync_master = subs->sync_endpoint;
418 }
419
420 if ((err = snd_usb_init_pitch(subs->stream->chip, fmt->iface, alts, fmt)) < 0)
421 return err;
422
423 subs->cur_audiofmt = fmt;
424
425 snd_usb_set_format_quirk(subs, fmt);
426
427 #if 0
428 printk(KERN_DEBUG
429 "setting done: format = %d, rate = %d..%d, channels = %d\n",
430 fmt->format, fmt->rate_min, fmt->rate_max, fmt->channels);
431 printk(KERN_DEBUG
432 " datapipe = 0x%0x, syncpipe = 0x%0x\n",
433 subs->datapipe, subs->syncpipe);
434 #endif
435
436 return 0;
437 }
438
439 /*
440 * configure endpoint params
441 *
442 * called during initial setup and upon resume
443 */
444 static int configure_endpoint(struct snd_usb_substream *subs)
445 {
446 int ret;
447
448 /* format changed */
449 stop_endpoints(subs, true);
450 ret = snd_usb_endpoint_set_params(subs->data_endpoint,
451 subs->pcm_format,
452 subs->channels,
453 subs->period_bytes,
454 subs->cur_rate,
455 subs->cur_audiofmt,
456 subs->sync_endpoint);
457 if (ret < 0)
458 return ret;
459
460 if (subs->sync_endpoint)
461 ret = snd_usb_endpoint_set_params(subs->data_endpoint,
462 subs->pcm_format,
463 subs->channels,
464 subs->period_bytes,
465 subs->cur_rate,
466 subs->cur_audiofmt,
467 NULL);
468 return ret;
469 }
470
471 /*
472 * hw_params callback
473 *
474 * allocate a buffer and set the given audio format.
475 *
476 * so far we use a physically linear buffer although packetize transfer
477 * doesn't need a continuous area.
478 * if sg buffer is supported on the later version of alsa, we'll follow
479 * that.
480 */
481 static int snd_usb_hw_params(struct snd_pcm_substream *substream,
482 struct snd_pcm_hw_params *hw_params)
483 {
484 struct snd_usb_substream *subs = substream->runtime->private_data;
485 struct audioformat *fmt;
486 int ret;
487
488 ret = snd_pcm_lib_alloc_vmalloc_buffer(substream,
489 params_buffer_bytes(hw_params));
490 if (ret < 0)
491 return ret;
492
493 subs->pcm_format = params_format(hw_params);
494 subs->period_bytes = params_period_bytes(hw_params);
495 subs->channels = params_channels(hw_params);
496 subs->cur_rate = params_rate(hw_params);
497
498 fmt = find_format(subs);
499 if (!fmt) {
500 snd_printd(KERN_DEBUG "cannot set format: format = %#x, rate = %d, channels = %d\n",
501 subs->pcm_format, subs->cur_rate, subs->channels);
502 return -EINVAL;
503 }
504
505 down_read(&subs->stream->chip->shutdown_rwsem);
506 if (subs->stream->chip->shutdown)
507 ret = -ENODEV;
508 else
509 ret = set_format(subs, fmt);
510 up_read(&subs->stream->chip->shutdown_rwsem);
511 if (ret < 0)
512 return ret;
513
514 subs->interface = fmt->iface;
515 subs->altset_idx = fmt->altset_idx;
516 subs->need_setup_ep = true;
517
518 return 0;
519 }
520
521 /*
522 * hw_free callback
523 *
524 * reset the audio format and release the buffer
525 */
526 static int snd_usb_hw_free(struct snd_pcm_substream *substream)
527 {
528 struct snd_usb_substream *subs = substream->runtime->private_data;
529
530 subs->cur_audiofmt = NULL;
531 subs->cur_rate = 0;
532 subs->period_bytes = 0;
533 down_read(&subs->stream->chip->shutdown_rwsem);
534 if (!subs->stream->chip->shutdown) {
535 stop_endpoints(subs, true);
536 deactivate_endpoints(subs);
537 }
538 up_read(&subs->stream->chip->shutdown_rwsem);
539 return snd_pcm_lib_free_vmalloc_buffer(substream);
540 }
541
542 /*
543 * prepare callback
544 *
545 * only a few subtle things...
546 */
547 static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
548 {
549 struct snd_pcm_runtime *runtime = substream->runtime;
550 struct snd_usb_substream *subs = runtime->private_data;
551 struct usb_host_interface *alts;
552 struct usb_interface *iface;
553 int ret;
554
555 if (! subs->cur_audiofmt) {
556 snd_printk(KERN_ERR "usbaudio: no format is specified!\n");
557 return -ENXIO;
558 }
559
560 down_read(&subs->stream->chip->shutdown_rwsem);
561 if (subs->stream->chip->shutdown) {
562 ret = -ENODEV;
563 goto unlock;
564 }
565 if (snd_BUG_ON(!subs->data_endpoint)) {
566 ret = -EIO;
567 goto unlock;
568 }
569
570 snd_usb_endpoint_sync_pending_stop(subs->sync_endpoint);
571 snd_usb_endpoint_sync_pending_stop(subs->data_endpoint);
572
573 ret = set_format(subs, subs->cur_audiofmt);
574 if (ret < 0)
575 goto unlock;
576
577 iface = usb_ifnum_to_if(subs->dev, subs->cur_audiofmt->iface);
578 alts = &iface->altsetting[subs->cur_audiofmt->altset_idx];
579 ret = snd_usb_init_sample_rate(subs->stream->chip,
580 subs->cur_audiofmt->iface,
581 alts,
582 subs->cur_audiofmt,
583 subs->cur_rate);
584 if (ret < 0)
585 goto unlock;
586
587 if (subs->need_setup_ep) {
588 ret = configure_endpoint(subs);
589 if (ret < 0)
590 goto unlock;
591 subs->need_setup_ep = false;
592 }
593
594 /* some unit conversions in runtime */
595 subs->data_endpoint->maxframesize =
596 bytes_to_frames(runtime, subs->data_endpoint->maxpacksize);
597 subs->data_endpoint->curframesize =
598 bytes_to_frames(runtime, subs->data_endpoint->curpacksize);
599
600 /* reset the pointer */
601 subs->hwptr_done = 0;
602 subs->transfer_done = 0;
603 subs->last_delay = 0;
604 subs->last_frame_number = 0;
605 runtime->delay = 0;
606
607 /* for playback, submit the URBs now; otherwise, the first hwptr_done
608 * updates for all URBs would happen at the same time when starting */
609 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK)
610 ret = start_endpoints(subs, true);
611
612 unlock:
613 up_read(&subs->stream->chip->shutdown_rwsem);
614 return ret;
615 }
616
617 static struct snd_pcm_hardware snd_usb_hardware =
618 {
619 .info = SNDRV_PCM_INFO_MMAP |
620 SNDRV_PCM_INFO_MMAP_VALID |
621 SNDRV_PCM_INFO_BATCH |
622 SNDRV_PCM_INFO_INTERLEAVED |
623 SNDRV_PCM_INFO_BLOCK_TRANSFER |
624 SNDRV_PCM_INFO_PAUSE,
625 .buffer_bytes_max = 1024 * 1024,
626 .period_bytes_min = 64,
627 .period_bytes_max = 512 * 1024,
628 .periods_min = 2,
629 .periods_max = 1024,
630 };
631
632 static int hw_check_valid_format(struct snd_usb_substream *subs,
633 struct snd_pcm_hw_params *params,
634 struct audioformat *fp)
635 {
636 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
637 struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
638 struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
639 struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
640 struct snd_mask check_fmts;
641 unsigned int ptime;
642
643 /* check the format */
644 snd_mask_none(&check_fmts);
645 check_fmts.bits[0] = (u32)fp->formats;
646 check_fmts.bits[1] = (u32)(fp->formats >> 32);
647 snd_mask_intersect(&check_fmts, fmts);
648 if (snd_mask_empty(&check_fmts)) {
649 hwc_debug(" > check: no supported format %d\n", fp->format);
650 return 0;
651 }
652 /* check the channels */
653 if (fp->channels < ct->min || fp->channels > ct->max) {
654 hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
655 return 0;
656 }
657 /* check the rate is within the range */
658 if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
659 hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max);
660 return 0;
661 }
662 if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
663 hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min);
664 return 0;
665 }
666 /* check whether the period time is >= the data packet interval */
667 if (subs->speed != USB_SPEED_FULL) {
668 ptime = 125 * (1 << fp->datainterval);
669 if (ptime > pt->max || (ptime == pt->max && pt->openmax)) {
670 hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max);
671 return 0;
672 }
673 }
674 return 1;
675 }
676
677 static int hw_rule_rate(struct snd_pcm_hw_params *params,
678 struct snd_pcm_hw_rule *rule)
679 {
680 struct snd_usb_substream *subs = rule->private;
681 struct list_head *p;
682 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
683 unsigned int rmin, rmax;
684 int changed;
685
686 hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
687 changed = 0;
688 rmin = rmax = 0;
689 list_for_each(p, &subs->fmt_list) {
690 struct audioformat *fp;
691 fp = list_entry(p, struct audioformat, list);
692 if (!hw_check_valid_format(subs, params, fp))
693 continue;
694 if (changed++) {
695 if (rmin > fp->rate_min)
696 rmin = fp->rate_min;
697 if (rmax < fp->rate_max)
698 rmax = fp->rate_max;
699 } else {
700 rmin = fp->rate_min;
701 rmax = fp->rate_max;
702 }
703 }
704
705 if (!changed) {
706 hwc_debug(" --> get empty\n");
707 it->empty = 1;
708 return -EINVAL;
709 }
710
711 changed = 0;
712 if (it->min < rmin) {
713 it->min = rmin;
714 it->openmin = 0;
715 changed = 1;
716 }
717 if (it->max > rmax) {
718 it->max = rmax;
719 it->openmax = 0;
720 changed = 1;
721 }
722 if (snd_interval_checkempty(it)) {
723 it->empty = 1;
724 return -EINVAL;
725 }
726 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
727 return changed;
728 }
729
730
731 static int hw_rule_channels(struct snd_pcm_hw_params *params,
732 struct snd_pcm_hw_rule *rule)
733 {
734 struct snd_usb_substream *subs = rule->private;
735 struct list_head *p;
736 struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
737 unsigned int rmin, rmax;
738 int changed;
739
740 hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
741 changed = 0;
742 rmin = rmax = 0;
743 list_for_each(p, &subs->fmt_list) {
744 struct audioformat *fp;
745 fp = list_entry(p, struct audioformat, list);
746 if (!hw_check_valid_format(subs, params, fp))
747 continue;
748 if (changed++) {
749 if (rmin > fp->channels)
750 rmin = fp->channels;
751 if (rmax < fp->channels)
752 rmax = fp->channels;
753 } else {
754 rmin = fp->channels;
755 rmax = fp->channels;
756 }
757 }
758
759 if (!changed) {
760 hwc_debug(" --> get empty\n");
761 it->empty = 1;
762 return -EINVAL;
763 }
764
765 changed = 0;
766 if (it->min < rmin) {
767 it->min = rmin;
768 it->openmin = 0;
769 changed = 1;
770 }
771 if (it->max > rmax) {
772 it->max = rmax;
773 it->openmax = 0;
774 changed = 1;
775 }
776 if (snd_interval_checkempty(it)) {
777 it->empty = 1;
778 return -EINVAL;
779 }
780 hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
781 return changed;
782 }
783
784 static int hw_rule_format(struct snd_pcm_hw_params *params,
785 struct snd_pcm_hw_rule *rule)
786 {
787 struct snd_usb_substream *subs = rule->private;
788 struct list_head *p;
789 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
790 u64 fbits;
791 u32 oldbits[2];
792 int changed;
793
794 hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
795 fbits = 0;
796 list_for_each(p, &subs->fmt_list) {
797 struct audioformat *fp;
798 fp = list_entry(p, struct audioformat, list);
799 if (!hw_check_valid_format(subs, params, fp))
800 continue;
801 fbits |= fp->formats;
802 }
803
804 oldbits[0] = fmt->bits[0];
805 oldbits[1] = fmt->bits[1];
806 fmt->bits[0] &= (u32)fbits;
807 fmt->bits[1] &= (u32)(fbits >> 32);
808 if (!fmt->bits[0] && !fmt->bits[1]) {
809 hwc_debug(" --> get empty\n");
810 return -EINVAL;
811 }
812 changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
813 hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
814 return changed;
815 }
816
817 static int hw_rule_period_time(struct snd_pcm_hw_params *params,
818 struct snd_pcm_hw_rule *rule)
819 {
820 struct snd_usb_substream *subs = rule->private;
821 struct audioformat *fp;
822 struct snd_interval *it;
823 unsigned char min_datainterval;
824 unsigned int pmin;
825 int changed;
826
827 it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
828 hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max);
829 min_datainterval = 0xff;
830 list_for_each_entry(fp, &subs->fmt_list, list) {
831 if (!hw_check_valid_format(subs, params, fp))
832 continue;
833 min_datainterval = min(min_datainterval, fp->datainterval);
834 }
835 if (min_datainterval == 0xff) {
836 hwc_debug(" --> get empty\n");
837 it->empty = 1;
838 return -EINVAL;
839 }
840 pmin = 125 * (1 << min_datainterval);
841 changed = 0;
842 if (it->min < pmin) {
843 it->min = pmin;
844 it->openmin = 0;
845 changed = 1;
846 }
847 if (snd_interval_checkempty(it)) {
848 it->empty = 1;
849 return -EINVAL;
850 }
851 hwc_debug(" --> (%u,%u) (changed = %d)\n", it->min, it->max, changed);
852 return changed;
853 }
854
855 /*
856 * If the device supports unusual bit rates, does the request meet these?
857 */
858 static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
859 struct snd_usb_substream *subs)
860 {
861 struct audioformat *fp;
862 int *rate_list;
863 int count = 0, needs_knot = 0;
864 int err;
865
866 kfree(subs->rate_list.list);
867 subs->rate_list.list = NULL;
868
869 list_for_each_entry(fp, &subs->fmt_list, list) {
870 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
871 return 0;
872 count += fp->nr_rates;
873 if (fp->rates & SNDRV_PCM_RATE_KNOT)
874 needs_knot = 1;
875 }
876 if (!needs_knot)
877 return 0;
878
879 subs->rate_list.list = rate_list =
880 kmalloc(sizeof(int) * count, GFP_KERNEL);
881 if (!subs->rate_list.list)
882 return -ENOMEM;
883 subs->rate_list.count = count;
884 subs->rate_list.mask = 0;
885 count = 0;
886 list_for_each_entry(fp, &subs->fmt_list, list) {
887 int i;
888 for (i = 0; i < fp->nr_rates; i++)
889 rate_list[count++] = fp->rate_table[i];
890 }
891 err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
892 &subs->rate_list);
893 if (err < 0)
894 return err;
895
896 return 0;
897 }
898
899
900 /*
901 * set up the runtime hardware information.
902 */
903
904 static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
905 {
906 struct list_head *p;
907 unsigned int pt, ptmin;
908 int param_period_time_if_needed;
909 int err;
910
911 runtime->hw.formats = subs->formats;
912
913 runtime->hw.rate_min = 0x7fffffff;
914 runtime->hw.rate_max = 0;
915 runtime->hw.channels_min = 256;
916 runtime->hw.channels_max = 0;
917 runtime->hw.rates = 0;
918 ptmin = UINT_MAX;
919 /* check min/max rates and channels */
920 list_for_each(p, &subs->fmt_list) {
921 struct audioformat *fp;
922 fp = list_entry(p, struct audioformat, list);
923 runtime->hw.rates |= fp->rates;
924 if (runtime->hw.rate_min > fp->rate_min)
925 runtime->hw.rate_min = fp->rate_min;
926 if (runtime->hw.rate_max < fp->rate_max)
927 runtime->hw.rate_max = fp->rate_max;
928 if (runtime->hw.channels_min > fp->channels)
929 runtime->hw.channels_min = fp->channels;
930 if (runtime->hw.channels_max < fp->channels)
931 runtime->hw.channels_max = fp->channels;
932 if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) {
933 /* FIXME: there might be more than one audio formats... */
934 runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
935 fp->frame_size;
936 }
937 pt = 125 * (1 << fp->datainterval);
938 ptmin = min(ptmin, pt);
939 }
940 err = snd_usb_autoresume(subs->stream->chip);
941 if (err < 0)
942 return err;
943
944 param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME;
945 if (subs->speed == USB_SPEED_FULL)
946 /* full speed devices have fixed data packet interval */
947 ptmin = 1000;
948 if (ptmin == 1000)
949 /* if period time doesn't go below 1 ms, no rules needed */
950 param_period_time_if_needed = -1;
951 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME,
952 ptmin, UINT_MAX);
953
954 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
955 hw_rule_rate, subs,
956 SNDRV_PCM_HW_PARAM_FORMAT,
957 SNDRV_PCM_HW_PARAM_CHANNELS,
958 param_period_time_if_needed,
959 -1)) < 0)
960 goto rep_err;
961 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
962 hw_rule_channels, subs,
963 SNDRV_PCM_HW_PARAM_FORMAT,
964 SNDRV_PCM_HW_PARAM_RATE,
965 param_period_time_if_needed,
966 -1)) < 0)
967 goto rep_err;
968 if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
969 hw_rule_format, subs,
970 SNDRV_PCM_HW_PARAM_RATE,
971 SNDRV_PCM_HW_PARAM_CHANNELS,
972 param_period_time_if_needed,
973 -1)) < 0)
974 goto rep_err;
975 if (param_period_time_if_needed >= 0) {
976 err = snd_pcm_hw_rule_add(runtime, 0,
977 SNDRV_PCM_HW_PARAM_PERIOD_TIME,
978 hw_rule_period_time, subs,
979 SNDRV_PCM_HW_PARAM_FORMAT,
980 SNDRV_PCM_HW_PARAM_CHANNELS,
981 SNDRV_PCM_HW_PARAM_RATE,
982 -1);
983 if (err < 0)
984 goto rep_err;
985 }
986 if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0)
987 goto rep_err;
988 return 0;
989
990 rep_err:
991 snd_usb_autosuspend(subs->stream->chip);
992 return err;
993 }
994
995 static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction)
996 {
997 struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
998 struct snd_pcm_runtime *runtime = substream->runtime;
999 struct snd_usb_substream *subs = &as->substream[direction];
1000
1001 subs->interface = -1;
1002 subs->altset_idx = 0;
1003 runtime->hw = snd_usb_hardware;
1004 runtime->private_data = subs;
1005 subs->pcm_substream = substream;
1006 /* runtime PM is also done there */
1007 return setup_hw_info(runtime, subs);
1008 }
1009
1010 static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
1011 {
1012 struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
1013 struct snd_usb_substream *subs = &as->substream[direction];
1014
1015 stop_endpoints(subs, true);
1016
1017 if (!as->chip->shutdown && subs->interface >= 0) {
1018 usb_set_interface(subs->dev, subs->interface, 0);
1019 subs->interface = -1;
1020 }
1021
1022 subs->pcm_substream = NULL;
1023 snd_usb_autosuspend(subs->stream->chip);
1024
1025 return 0;
1026 }
1027
1028 /* Since a URB can handle only a single linear buffer, we must use double
1029 * buffering when the data to be transferred overflows the buffer boundary.
1030 * To avoid inconsistencies when updating hwptr_done, we use double buffering
1031 * for all URBs.
1032 */
1033 static void retire_capture_urb(struct snd_usb_substream *subs,
1034 struct urb *urb)
1035 {
1036 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1037 unsigned int stride, frames, bytes, oldptr;
1038 int i, period_elapsed = 0;
1039 unsigned long flags;
1040 unsigned char *cp;
1041
1042 stride = runtime->frame_bits >> 3;
1043
1044 for (i = 0; i < urb->number_of_packets; i++) {
1045 cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
1046 if (urb->iso_frame_desc[i].status && printk_ratelimit()) {
1047 snd_printdd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
1048 // continue;
1049 }
1050 bytes = urb->iso_frame_desc[i].actual_length;
1051 frames = bytes / stride;
1052 if (!subs->txfr_quirk)
1053 bytes = frames * stride;
1054 if (bytes % (runtime->sample_bits >> 3) != 0) {
1055 #ifdef CONFIG_SND_DEBUG_VERBOSE
1056 int oldbytes = bytes;
1057 #endif
1058 bytes = frames * stride;
1059 snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
1060 oldbytes, bytes);
1061 }
1062 /* update the current pointer */
1063 spin_lock_irqsave(&subs->lock, flags);
1064 oldptr = subs->hwptr_done;
1065 subs->hwptr_done += bytes;
1066 if (subs->hwptr_done >= runtime->buffer_size * stride)
1067 subs->hwptr_done -= runtime->buffer_size * stride;
1068 frames = (bytes + (oldptr % stride)) / stride;
1069 subs->transfer_done += frames;
1070 if (subs->transfer_done >= runtime->period_size) {
1071 subs->transfer_done -= runtime->period_size;
1072 period_elapsed = 1;
1073 }
1074 spin_unlock_irqrestore(&subs->lock, flags);
1075 /* copy a data chunk */
1076 if (oldptr + bytes > runtime->buffer_size * stride) {
1077 unsigned int bytes1 =
1078 runtime->buffer_size * stride - oldptr;
1079 memcpy(runtime->dma_area + oldptr, cp, bytes1);
1080 memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
1081 } else {
1082 memcpy(runtime->dma_area + oldptr, cp, bytes);
1083 }
1084 }
1085
1086 if (period_elapsed)
1087 snd_pcm_period_elapsed(subs->pcm_substream);
1088 }
1089
1090 static void prepare_playback_urb(struct snd_usb_substream *subs,
1091 struct urb *urb)
1092 {
1093 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1094 struct snd_usb_endpoint *ep = subs->data_endpoint;
1095 struct snd_urb_ctx *ctx = urb->context;
1096 unsigned int counts, frames, bytes;
1097 int i, stride, period_elapsed = 0;
1098 unsigned long flags;
1099
1100 stride = runtime->frame_bits >> 3;
1101
1102 frames = 0;
1103 urb->number_of_packets = 0;
1104 spin_lock_irqsave(&subs->lock, flags);
1105 for (i = 0; i < ctx->packets; i++) {
1106 if (ctx->packet_size[i])
1107 counts = ctx->packet_size[i];
1108 else
1109 counts = snd_usb_endpoint_next_packet_size(ep);
1110
1111 /* set up descriptor */
1112 urb->iso_frame_desc[i].offset = frames * stride;
1113 urb->iso_frame_desc[i].length = counts * stride;
1114 frames += counts;
1115 urb->number_of_packets++;
1116 subs->transfer_done += counts;
1117 if (subs->transfer_done >= runtime->period_size) {
1118 subs->transfer_done -= runtime->period_size;
1119 period_elapsed = 1;
1120 if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
1121 if (subs->transfer_done > 0) {
1122 /* FIXME: fill-max mode is not
1123 * supported yet */
1124 frames -= subs->transfer_done;
1125 counts -= subs->transfer_done;
1126 urb->iso_frame_desc[i].length =
1127 counts * stride;
1128 subs->transfer_done = 0;
1129 }
1130 i++;
1131 if (i < ctx->packets) {
1132 /* add a transfer delimiter */
1133 urb->iso_frame_desc[i].offset =
1134 frames * stride;
1135 urb->iso_frame_desc[i].length = 0;
1136 urb->number_of_packets++;
1137 }
1138 break;
1139 }
1140 }
1141 if (period_elapsed &&
1142 !snd_usb_endpoint_implict_feedback_sink(subs->data_endpoint)) /* finish at the period boundary */
1143 break;
1144 }
1145 bytes = frames * stride;
1146 if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
1147 /* err, the transferred area goes over buffer boundary. */
1148 unsigned int bytes1 =
1149 runtime->buffer_size * stride - subs->hwptr_done;
1150 memcpy(urb->transfer_buffer,
1151 runtime->dma_area + subs->hwptr_done, bytes1);
1152 memcpy(urb->transfer_buffer + bytes1,
1153 runtime->dma_area, bytes - bytes1);
1154 } else {
1155 memcpy(urb->transfer_buffer,
1156 runtime->dma_area + subs->hwptr_done, bytes);
1157 }
1158 subs->hwptr_done += bytes;
1159 if (subs->hwptr_done >= runtime->buffer_size * stride)
1160 subs->hwptr_done -= runtime->buffer_size * stride;
1161
1162 /* update delay with exact number of samples queued */
1163 runtime->delay = subs->last_delay;
1164 runtime->delay += frames;
1165 subs->last_delay = runtime->delay;
1166
1167 /* realign last_frame_number */
1168 subs->last_frame_number = usb_get_current_frame_number(subs->dev);
1169 subs->last_frame_number &= 0xFF; /* keep 8 LSBs */
1170
1171 spin_unlock_irqrestore(&subs->lock, flags);
1172 urb->transfer_buffer_length = bytes;
1173 if (period_elapsed)
1174 snd_pcm_period_elapsed(subs->pcm_substream);
1175 }
1176
1177 /*
1178 * process after playback data complete
1179 * - decrease the delay count again
1180 */
1181 static void retire_playback_urb(struct snd_usb_substream *subs,
1182 struct urb *urb)
1183 {
1184 unsigned long flags;
1185 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
1186 int stride = runtime->frame_bits >> 3;
1187 int processed = urb->transfer_buffer_length / stride;
1188 int est_delay;
1189
1190 /* ignore the delay accounting when procssed=0 is given, i.e.
1191 * silent payloads are procssed before handling the actual data
1192 */
1193 if (!processed)
1194 return;
1195
1196 spin_lock_irqsave(&subs->lock, flags);
1197 est_delay = snd_usb_pcm_delay(subs, runtime->rate);
1198 /* update delay with exact number of samples played */
1199 if (processed > subs->last_delay)
1200 subs->last_delay = 0;
1201 else
1202 subs->last_delay -= processed;
1203 runtime->delay = subs->last_delay;
1204
1205 /*
1206 * Report when delay estimate is off by more than 2ms.
1207 * The error should be lower than 2ms since the estimate relies
1208 * on two reads of a counter updated every ms.
1209 */
1210 if (abs(est_delay - subs->last_delay) * 1000 > runtime->rate * 2)
1211 snd_printk(KERN_DEBUG "delay: estimated %d, actual %d\n",
1212 est_delay, subs->last_delay);
1213
1214 spin_unlock_irqrestore(&subs->lock, flags);
1215 }
1216
1217 static int snd_usb_playback_open(struct snd_pcm_substream *substream)
1218 {
1219 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK);
1220 }
1221
1222 static int snd_usb_playback_close(struct snd_pcm_substream *substream)
1223 {
1224 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK);
1225 }
1226
1227 static int snd_usb_capture_open(struct snd_pcm_substream *substream)
1228 {
1229 return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE);
1230 }
1231
1232 static int snd_usb_capture_close(struct snd_pcm_substream *substream)
1233 {
1234 return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
1235 }
1236
1237 static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream,
1238 int cmd)
1239 {
1240 struct snd_usb_substream *subs = substream->runtime->private_data;
1241
1242 switch (cmd) {
1243 case SNDRV_PCM_TRIGGER_START:
1244 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1245 subs->data_endpoint->prepare_data_urb = prepare_playback_urb;
1246 subs->data_endpoint->retire_data_urb = retire_playback_urb;
1247 subs->running = 1;
1248 return 0;
1249 case SNDRV_PCM_TRIGGER_STOP:
1250 stop_endpoints(subs, false);
1251 subs->running = 0;
1252 return 0;
1253 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1254 subs->data_endpoint->prepare_data_urb = NULL;
1255 subs->data_endpoint->retire_data_urb = NULL;
1256 subs->running = 0;
1257 return 0;
1258 }
1259
1260 return -EINVAL;
1261 }
1262
1263 static int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream,
1264 int cmd)
1265 {
1266 int err;
1267 struct snd_usb_substream *subs = substream->runtime->private_data;
1268
1269 switch (cmd) {
1270 case SNDRV_PCM_TRIGGER_START:
1271 err = start_endpoints(subs, false);
1272 if (err < 0)
1273 return err;
1274
1275 subs->data_endpoint->retire_data_urb = retire_capture_urb;
1276 subs->running = 1;
1277 return 0;
1278 case SNDRV_PCM_TRIGGER_STOP:
1279 stop_endpoints(subs, false);
1280 subs->running = 0;
1281 return 0;
1282 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1283 subs->data_endpoint->retire_data_urb = NULL;
1284 subs->running = 0;
1285 return 0;
1286 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1287 subs->data_endpoint->retire_data_urb = retire_capture_urb;
1288 subs->running = 1;
1289 return 0;
1290 }
1291
1292 return -EINVAL;
1293 }
1294
1295 static struct snd_pcm_ops snd_usb_playback_ops = {
1296 .open = snd_usb_playback_open,
1297 .close = snd_usb_playback_close,
1298 .ioctl = snd_pcm_lib_ioctl,
1299 .hw_params = snd_usb_hw_params,
1300 .hw_free = snd_usb_hw_free,
1301 .prepare = snd_usb_pcm_prepare,
1302 .trigger = snd_usb_substream_playback_trigger,
1303 .pointer = snd_usb_pcm_pointer,
1304 .page = snd_pcm_lib_get_vmalloc_page,
1305 .mmap = snd_pcm_lib_mmap_vmalloc,
1306 };
1307
1308 static struct snd_pcm_ops snd_usb_capture_ops = {
1309 .open = snd_usb_capture_open,
1310 .close = snd_usb_capture_close,
1311 .ioctl = snd_pcm_lib_ioctl,
1312 .hw_params = snd_usb_hw_params,
1313 .hw_free = snd_usb_hw_free,
1314 .prepare = snd_usb_pcm_prepare,
1315 .trigger = snd_usb_substream_capture_trigger,
1316 .pointer = snd_usb_pcm_pointer,
1317 .page = snd_pcm_lib_get_vmalloc_page,
1318 .mmap = snd_pcm_lib_mmap_vmalloc,
1319 };
1320
1321 void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream)
1322 {
1323 snd_pcm_set_ops(pcm, stream,
1324 stream == SNDRV_PCM_STREAM_PLAYBACK ?
1325 &snd_usb_playback_ops : &snd_usb_capture_ops);
1326 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree