Lines Matching refs:ua
129 static void abort_alsa_playback(struct ua101 *ua);
130 static void abort_alsa_capture(struct ua101 *ua);
157 static void abort_usb_capture(struct ua101 *ua)
159 if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) {
160 wake_up(&ua->alsa_capture_wait);
161 wake_up(&ua->rate_feedback_wait);
165 static void abort_usb_playback(struct ua101 *ua)
167 if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states))
168 wake_up(&ua->alsa_playback_wait);
174 struct ua101 *ua = urb->urb.context;
181 abort_usb_playback(ua);
182 abort_alsa_playback(ua);
186 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) {
188 spin_lock_irqsave(&ua->lock, flags);
189 list_add_tail(&urb->ready_list, &ua->ready_playback_urbs);
190 if (ua->rate_feedback_count > 0)
191 queue_work(system_highpri_wq, &ua->playback_work);
192 ua->playback.substream->runtime->delay -=
194 ua->playback.frame_bytes;
195 spin_unlock_irqrestore(&ua->lock, flags);
201 struct ua101 *ua = urb->context;
206 set_bit(PLAYBACK_URB_COMPLETED, &ua->states);
207 wake_up(&ua->alsa_playback_wait);
242 static inline void add_with_wraparound(struct ua101 *ua,
246 if (*value >= ua->playback.queue_length)
247 *value -= ua->playback.queue_length;
252 struct ua101 *ua = container_of(work, struct ua101, playback_work);
259 if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states)))
273 spin_lock_irqsave(&ua->lock, flags);
274 while (ua->rate_feedback_count > 0 &&
275 !list_empty(&ua->ready_playback_urbs)) {
277 frames = ua->rate_feedback[ua->rate_feedback_start];
278 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
279 ua->rate_feedback_count--;
282 urb = list_first_entry(&ua->ready_playback_urbs,
288 frames * ua->playback.frame_bytes;
289 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
290 do_period_elapsed |= copy_playback_data(&ua->playback,
300 spin_unlock_irqrestore(&ua->lock, flags);
301 abort_usb_playback(ua);
302 abort_alsa_playback(ua);
303 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
307 ua->playback.substream->runtime->delay += frames;
309 spin_unlock_irqrestore(&ua->lock, flags);
311 snd_pcm_period_elapsed(ua->playback.substream);
349 struct ua101 *ua = urb->context;
350 struct ua101_stream *stream = &ua->capture;
368 spin_lock_irqsave(&ua->lock, flags);
370 if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
375 if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
378 spin_unlock_irqrestore(&ua->lock, flags);
379 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
385 write_ptr = ua->rate_feedback_start;
386 add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count);
387 ua->rate_feedback[write_ptr] = frames;
388 if (ua->rate_feedback_count < ua->playback.queue_length) {
389 ua->rate_feedback_count++;
390 if (ua->rate_feedback_count ==
391 ua->playback.queue_length)
392 wake_up(&ua->rate_feedback_wait);
400 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
402 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) &&
403 !list_empty(&ua->ready_playback_urbs))
404 queue_work(system_highpri_wq, &ua->playback_work);
407 spin_unlock_irqrestore(&ua->lock, flags);
415 abort_usb_playback(ua);
416 abort_usb_capture(ua);
417 abort_alsa_playback(ua);
418 abort_alsa_capture(ua);
423 struct ua101 *ua = urb->context;
428 set_bit(CAPTURE_URB_COMPLETED, &ua->states);
429 wake_up(&ua->alsa_capture_wait);
432 static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream)
439 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
456 static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index)
460 alts = ua->intf[intf_index]->cur_altsetting;
462 int err = usb_set_interface(ua->dev,
465 dev_err(&ua->dev->dev,
474 static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index)
478 if (!ua->intf[intf_index])
481 alts = ua->intf[intf_index]->cur_altsetting;
483 int err = usb_set_interface(ua->dev,
485 if (err < 0 && !test_bit(DISCONNECTED, &ua->states))
486 dev_warn(&ua->dev->dev,
492 static void stop_usb_capture(struct ua101 *ua)
494 clear_bit(USB_CAPTURE_RUNNING, &ua->states);
496 kill_stream_urbs(&ua->capture);
498 disable_iso_interface(ua, INTF_CAPTURE);
501 static int start_usb_capture(struct ua101 *ua)
505 if (test_bit(DISCONNECTED, &ua->states))
508 if (test_bit(USB_CAPTURE_RUNNING, &ua->states))
511 kill_stream_urbs(&ua->capture);
513 err = enable_iso_interface(ua, INTF_CAPTURE);
517 clear_bit(CAPTURE_URB_COMPLETED, &ua->states);
518 ua->capture.urbs[0]->urb.complete = first_capture_urb_complete;
519 ua->rate_feedback_start = 0;
520 ua->rate_feedback_count = 0;
522 set_bit(USB_CAPTURE_RUNNING, &ua->states);
523 err = submit_stream_urbs(ua, &ua->capture);
525 stop_usb_capture(ua);
529 static void stop_usb_playback(struct ua101 *ua)
531 clear_bit(USB_PLAYBACK_RUNNING, &ua->states);
533 kill_stream_urbs(&ua->playback);
535 cancel_work_sync(&ua->playback_work);
537 disable_iso_interface(ua, INTF_PLAYBACK);
540 static int start_usb_playback(struct ua101 *ua)
546 if (test_bit(DISCONNECTED, &ua->states))
549 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states))
552 kill_stream_urbs(&ua->playback);
553 cancel_work_sync(&ua->playback_work);
555 err = enable_iso_interface(ua, INTF_PLAYBACK);
559 clear_bit(PLAYBACK_URB_COMPLETED, &ua->states);
560 ua->playback.urbs[0]->urb.complete =
562 spin_lock_irq(&ua->lock);
563 INIT_LIST_HEAD(&ua->ready_playback_urbs);
564 spin_unlock_irq(&ua->lock);
570 wait_event(ua->rate_feedback_wait,
571 ua->rate_feedback_count >= ua->playback.queue_length ||
572 !test_bit(USB_CAPTURE_RUNNING, &ua->states) ||
573 test_bit(DISCONNECTED, &ua->states));
574 if (test_bit(DISCONNECTED, &ua->states)) {
575 stop_usb_playback(ua);
578 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
579 stop_usb_playback(ua);
583 for (i = 0; i < ua->playback.queue_length; ++i) {
585 spin_lock_irq(&ua->lock);
586 frames = ua->rate_feedback[ua->rate_feedback_start];
587 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
588 ua->rate_feedback_count--;
589 spin_unlock_irq(&ua->lock);
590 urb = &ua->playback.urbs[i]->urb;
592 frames * ua->playback.frame_bytes;
597 set_bit(USB_PLAYBACK_RUNNING, &ua->states);
598 err = submit_stream_urbs(ua, &ua->playback);
600 stop_usb_playback(ua);
604 static void abort_alsa_capture(struct ua101 *ua)
606 if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
607 snd_pcm_stop_xrun(ua->capture.substream);
610 static void abort_alsa_playback(struct ua101 *ua)
612 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
613 snd_pcm_stop_xrun(ua->playback.substream);
616 static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream,
628 substream->runtime->hw.formats = ua->format_bit;
629 substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate);
630 substream->runtime->hw.rate_min = ua->rate;
631 substream->runtime->hw.rate_max = ua->rate;
641 1500000 / ua->packets_per_second,
651 struct ua101 *ua = substream->private_data;
654 ua->capture.substream = substream;
655 err = set_stream_hw(ua, substream, ua->capture.channels);
659 DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second);
662 mutex_lock(&ua->mutex);
663 err = start_usb_capture(ua);
665 set_bit(ALSA_CAPTURE_OPEN, &ua->states);
666 mutex_unlock(&ua->mutex);
672 struct ua101 *ua = substream->private_data;
675 ua->playback.substream = substream;
676 err = set_stream_hw(ua, substream, ua->playback.channels);
680 DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length,
681 ua->packets_per_second);
683 mutex_lock(&ua->mutex);
684 err = start_usb_capture(ua);
687 err = start_usb_playback(ua);
689 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
690 stop_usb_capture(ua);
693 set_bit(ALSA_PLAYBACK_OPEN, &ua->states);
695 mutex_unlock(&ua->mutex);
701 struct ua101 *ua = substream->private_data;
703 mutex_lock(&ua->mutex);
704 clear_bit(ALSA_CAPTURE_OPEN, &ua->states);
705 if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states))
706 stop_usb_capture(ua);
707 mutex_unlock(&ua->mutex);
713 struct ua101 *ua = substream->private_data;
715 mutex_lock(&ua->mutex);
716 stop_usb_playback(ua);
717 clear_bit(ALSA_PLAYBACK_OPEN, &ua->states);
718 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
719 stop_usb_capture(ua);
720 mutex_unlock(&ua->mutex);
727 struct ua101 *ua = substream->private_data;
730 mutex_lock(&ua->mutex);
731 err = start_usb_capture(ua);
732 mutex_unlock(&ua->mutex);
739 struct ua101 *ua = substream->private_data;
742 mutex_lock(&ua->mutex);
743 err = start_usb_capture(ua);
745 err = start_usb_playback(ua);
746 mutex_unlock(&ua->mutex);
752 struct ua101 *ua = substream->private_data;
755 mutex_lock(&ua->mutex);
756 err = start_usb_capture(ua);
757 mutex_unlock(&ua->mutex);
767 wait_event(ua->alsa_capture_wait,
768 test_bit(CAPTURE_URB_COMPLETED, &ua->states) ||
769 !test_bit(USB_CAPTURE_RUNNING, &ua->states));
770 if (test_bit(DISCONNECTED, &ua->states))
772 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
775 ua->capture.period_pos = 0;
776 ua->capture.buffer_pos = 0;
782 struct ua101 *ua = substream->private_data;
785 mutex_lock(&ua->mutex);
786 err = start_usb_capture(ua);
788 err = start_usb_playback(ua);
789 mutex_unlock(&ua->mutex);
794 wait_event(ua->alsa_playback_wait,
795 test_bit(PLAYBACK_URB_COMPLETED, &ua->states) ||
796 !test_bit(USB_PLAYBACK_RUNNING, &ua->states));
797 if (test_bit(DISCONNECTED, &ua->states))
799 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
803 ua->playback.period_pos = 0;
804 ua->playback.buffer_pos = 0;
810 struct ua101 *ua = substream->private_data;
814 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
816 set_bit(ALSA_CAPTURE_RUNNING, &ua->states);
819 clear_bit(ALSA_CAPTURE_RUNNING, &ua->states);
828 struct ua101 *ua = substream->private_data;
832 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
834 set_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
837 clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
844 static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua,
850 spin_lock_irqsave(&ua->lock, flags);
852 spin_unlock_irqrestore(&ua->lock, flags);
858 struct ua101 *ua = subs->private_data;
860 return ua101_pcm_pointer(ua, &ua->capture);
865 struct ua101 *ua = subs->private_data;
867 return ua101_pcm_pointer(ua, &ua->playback);
940 static int detect_usb_format(struct ua101 *ua)
947 fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]);
948 fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]);
954 ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE;
957 ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE;
960 dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n");
964 dev_err(&ua->dev->dev,
971 dev_err(&ua->dev->dev, "sample width is not 24 bits\n");
975 ua->rate = combine_triple(fmt_capture->tSamFreq[0]);
977 if (ua->rate != rate2) {
978 dev_err(&ua->dev->dev,
980 rate2, ua->rate);
984 switch (ua->dev->speed) {
986 ua->packets_per_second = 1000;
989 ua->packets_per_second = 8000;
992 dev_err(&ua->dev->dev, "unknown device speed\n");
996 ua->capture.channels = fmt_capture->bNrChannels;
997 ua->playback.channels = fmt_playback->bNrChannels;
998 ua->capture.frame_bytes =
999 fmt_capture->bSubframeSize * ua->capture.channels;
1000 ua->playback.frame_bytes =
1001 fmt_playback->bSubframeSize * ua->playback.channels;
1003 epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc;
1005 dev_err(&ua->dev->dev, "invalid capture endpoint\n");
1008 ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd));
1009 ua->capture.max_packet_bytes = usb_endpoint_maxp(epd);
1011 epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc;
1013 dev_err(&ua->dev->dev, "invalid playback endpoint\n");
1016 ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd));
1017 ua->playback.max_packet_bytes = usb_endpoint_maxp(epd);
1021 static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1044 usb_alloc_coherent(ua->dev, size, GFP_KERNEL,
1054 dev_err(&ua->dev->dev, "too many packets\n");
1060 static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1065 usb_free_coherent(ua->dev,
1071 static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream,
1090 urb->urb.dev = ua->dev;
1098 urb->urb.context = ua;
1111 dev_err(&ua->dev->dev, "internal buffer size error\n");
1125 static void free_usb_related_resources(struct ua101 *ua,
1131 mutex_lock(&ua->mutex);
1132 free_stream_urbs(&ua->capture);
1133 free_stream_urbs(&ua->playback);
1134 mutex_unlock(&ua->mutex);
1135 free_stream_buffers(ua, &ua->capture);
1136 free_stream_buffers(ua, &ua->playback);
1138 for (i = 0; i < ARRAY_SIZE(ua->intf); ++i) {
1139 mutex_lock(&ua->mutex);
1140 intf = ua->intf[i];
1141 ua->intf[i] = NULL;
1142 mutex_unlock(&ua->mutex);
1154 struct ua101 *ua = card->private_data;
1156 mutex_destroy(&ua->mutex);
1183 struct ua101 *ua;
1207 sizeof(*ua), &card);
1213 ua = card->private_data;
1214 ua->dev = interface_to_usbdev(interface);
1215 ua->card = card;
1216 ua->card_index = card_index;
1217 INIT_LIST_HEAD(&ua->midi_list);
1218 spin_lock_init(&ua->lock);
1219 mutex_init(&ua->mutex);
1220 INIT_LIST_HEAD(&ua->ready_playback_urbs);
1221 INIT_WORK(&ua->playback_work, playback_work);
1222 init_waitqueue_head(&ua->alsa_capture_wait);
1223 init_waitqueue_head(&ua->rate_feedback_wait);
1224 init_waitqueue_head(&ua->alsa_playback_wait);
1226 ua->intf[0] = interface;
1227 for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) {
1228 ua->intf[i] = usb_ifnum_to_if(ua->dev,
1230 if (!ua->intf[i]) {
1231 dev_err(&ua->dev->dev, "interface %u not found\n",
1237 ua->intf[i], ua);
1239 ua->intf[i] = NULL;
1245 err = detect_usb_format(ua);
1252 usb_make_path(ua->dev, usb_path, sizeof(usb_path));
1253 snprintf(ua->card->longname, sizeof(ua->card->longname),
1255 ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path,
1256 ua->dev->speed == USB_SPEED_HIGH ? "high" : "full");
1258 err = alloc_stream_buffers(ua, &ua->capture);
1261 err = alloc_stream_buffers(ua, &ua->playback);
1265 err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete);
1268 err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete);
1272 err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm);
1275 ua->pcm->private_data = ua;
1276 strcpy(ua->pcm->name, name);
1277 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops);
1278 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops);
1279 snd_pcm_set_managed_buffer_all(ua->pcm, SNDRV_DMA_TYPE_VMALLOC,
1282 err = snd_usbmidi_create(card, ua->intf[INTF_MIDI],
1283 &ua->midi_list, &midi_quirk);
1291 usb_set_intfdata(interface, ua);
1298 free_usb_related_resources(ua, interface);
1306 struct ua101 *ua = usb_get_intfdata(interface);
1309 if (!ua)
1314 set_bit(DISCONNECTED, &ua->states);
1315 wake_up(&ua->rate_feedback_wait);
1318 snd_card_disconnect(ua->card);
1321 list_for_each(midi, &ua->midi_list)
1323 abort_alsa_playback(ua);
1324 abort_alsa_capture(ua);
1325 mutex_lock(&ua->mutex);
1326 stop_usb_playback(ua);
1327 stop_usb_capture(ua);
1328 mutex_unlock(&ua->mutex);
1330 free_usb_related_resources(ua, interface);
1332 devices_used &= ~(1 << ua->card_index);
1334 snd_card_free_when_closed(ua->card);