Lines Matching refs:ua
139 static void abort_alsa_playback(struct ua101 *ua);
140 static void abort_alsa_capture(struct ua101 *ua);
167 static void abort_usb_capture(struct ua101 *ua)
169 if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) {
170 wake_up(&ua->alsa_capture_wait);
171 wake_up(&ua->rate_feedback_wait);
175 static void abort_usb_playback(struct ua101 *ua)
177 if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states))
178 wake_up(&ua->alsa_playback_wait);
184 struct ua101 *ua = urb->urb.context;
191 abort_usb_playback(ua);
192 abort_alsa_playback(ua);
196 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) {
198 spin_lock_irqsave(&ua->lock, flags);
199 list_add_tail(&urb->ready_list, &ua->ready_playback_urbs);
200 if (ua->rate_feedback_count > 0)
201 tasklet_schedule(&ua->playback_tasklet);
202 ua->playback.substream->runtime->delay -=
204 ua->playback.frame_bytes;
205 spin_unlock_irqrestore(&ua->lock, flags);
211 struct ua101 *ua = urb->context;
216 set_bit(PLAYBACK_URB_COMPLETED, &ua->states);
217 wake_up(&ua->alsa_playback_wait);
252 static inline void add_with_wraparound(struct ua101 *ua,
256 if (*value >= ua->playback.queue_length)
257 *value -= ua->playback.queue_length;
262 struct ua101 *ua = (void *)data;
269 if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states)))
283 spin_lock_irqsave(&ua->lock, flags);
284 while (ua->rate_feedback_count > 0 &&
285 !list_empty(&ua->ready_playback_urbs)) {
287 frames = ua->rate_feedback[ua->rate_feedback_start];
288 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
289 ua->rate_feedback_count--;
292 urb = list_first_entry(&ua->ready_playback_urbs,
298 frames * ua->playback.frame_bytes;
299 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
300 do_period_elapsed |= copy_playback_data(&ua->playback,
310 spin_unlock_irqrestore(&ua->lock, flags);
311 abort_usb_playback(ua);
312 abort_alsa_playback(ua);
313 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
317 ua->playback.substream->runtime->delay += frames;
319 spin_unlock_irqrestore(&ua->lock, flags);
321 snd_pcm_period_elapsed(ua->playback.substream);
359 struct ua101 *ua = urb->context;
360 struct ua101_stream *stream = &ua->capture;
378 spin_lock_irqsave(&ua->lock, flags);
380 if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
385 if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
388 spin_unlock_irqrestore(&ua->lock, flags);
389 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
395 write_ptr = ua->rate_feedback_start;
396 add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count);
397 ua->rate_feedback[write_ptr] = frames;
398 if (ua->rate_feedback_count < ua->playback.queue_length) {
399 ua->rate_feedback_count++;
400 if (ua->rate_feedback_count ==
401 ua->playback.queue_length)
402 wake_up(&ua->rate_feedback_wait);
410 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
412 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) &&
413 !list_empty(&ua->ready_playback_urbs))
414 tasklet_schedule(&ua->playback_tasklet);
417 spin_unlock_irqrestore(&ua->lock, flags);
425 abort_usb_playback(ua);
426 abort_usb_capture(ua);
427 abort_alsa_playback(ua);
428 abort_alsa_capture(ua);
433 struct ua101 *ua = urb->context;
438 set_bit(CAPTURE_URB_COMPLETED, &ua->states);
439 wake_up(&ua->alsa_capture_wait);
442 static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream)
449 dev_err(&ua->dev->dev, "USB request error %d: %s\n",
465 static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index)
469 alts = ua->intf[intf_index]->cur_altsetting;
471 int err = usb_set_interface(ua->dev,
474 dev_err(&ua->dev->dev,
483 static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index)
487 alts = ua->intf[intf_index]->cur_altsetting;
489 int err = usb_set_interface(ua->dev,
491 if (err < 0 && !test_bit(DISCONNECTED, &ua->states))
492 dev_warn(&ua->dev->dev,
498 static void stop_usb_capture(struct ua101 *ua)
500 clear_bit(USB_CAPTURE_RUNNING, &ua->states);
502 kill_stream_urbs(&ua->capture);
504 disable_iso_interface(ua, INTF_CAPTURE);
507 static int start_usb_capture(struct ua101 *ua)
511 if (test_bit(DISCONNECTED, &ua->states))
514 if (test_bit(USB_CAPTURE_RUNNING, &ua->states))
517 kill_stream_urbs(&ua->capture);
519 err = enable_iso_interface(ua, INTF_CAPTURE);
523 clear_bit(CAPTURE_URB_COMPLETED, &ua->states);
524 ua->capture.urbs[0]->urb.complete = first_capture_urb_complete;
525 ua->rate_feedback_start = 0;
526 ua->rate_feedback_count = 0;
528 set_bit(USB_CAPTURE_RUNNING, &ua->states);
529 err = submit_stream_urbs(ua, &ua->capture);
531 stop_usb_capture(ua);
535 static void stop_usb_playback(struct ua101 *ua)
537 clear_bit(USB_PLAYBACK_RUNNING, &ua->states);
539 kill_stream_urbs(&ua->playback);
541 tasklet_kill(&ua->playback_tasklet);
543 disable_iso_interface(ua, INTF_PLAYBACK);
546 static int start_usb_playback(struct ua101 *ua)
552 if (test_bit(DISCONNECTED, &ua->states))
555 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states))
558 kill_stream_urbs(&ua->playback);
559 tasklet_kill(&ua->playback_tasklet);
561 err = enable_iso_interface(ua, INTF_PLAYBACK);
565 clear_bit(PLAYBACK_URB_COMPLETED, &ua->states);
566 ua->playback.urbs[0]->urb.complete =
568 spin_lock_irq(&ua->lock);
569 INIT_LIST_HEAD(&ua->ready_playback_urbs);
570 spin_unlock_irq(&ua->lock);
576 wait_event(ua->rate_feedback_wait,
577 ua->rate_feedback_count >= ua->playback.queue_length ||
578 !test_bit(USB_CAPTURE_RUNNING, &ua->states) ||
579 test_bit(DISCONNECTED, &ua->states));
580 if (test_bit(DISCONNECTED, &ua->states)) {
581 stop_usb_playback(ua);
584 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
585 stop_usb_playback(ua);
589 for (i = 0; i < ua->playback.queue_length; ++i) {
591 spin_lock_irq(&ua->lock);
592 frames = ua->rate_feedback[ua->rate_feedback_start];
593 add_with_wraparound(ua, &ua->rate_feedback_start, 1);
594 ua->rate_feedback_count--;
595 spin_unlock_irq(&ua->lock);
596 urb = &ua->playback.urbs[i]->urb;
598 frames * ua->playback.frame_bytes;
603 set_bit(USB_PLAYBACK_RUNNING, &ua->states);
604 err = submit_stream_urbs(ua, &ua->playback);
606 stop_usb_playback(ua);
610 static void abort_alsa_capture(struct ua101 *ua)
612 if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
613 snd_pcm_stop(ua->capture.substream, SNDRV_PCM_STATE_XRUN);
616 static void abort_alsa_playback(struct ua101 *ua)
618 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
619 snd_pcm_stop(ua->playback.substream, SNDRV_PCM_STATE_XRUN);
622 static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream,
634 substream->runtime->hw.formats = ua->format_bit;
635 substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate);
636 substream->runtime->hw.rate_min = ua->rate;
637 substream->runtime->hw.rate_max = ua->rate;
647 1500000 / ua->packets_per_second,
657 struct ua101 *ua = substream->private_data;
660 ua->capture.substream = substream;
661 err = set_stream_hw(ua, substream, ua->capture.channels);
665 DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second);
668 mutex_lock(&ua->mutex);
669 err = start_usb_capture(ua);
671 set_bit(ALSA_CAPTURE_OPEN, &ua->states);
672 mutex_unlock(&ua->mutex);
678 struct ua101 *ua = substream->private_data;
681 ua->playback.substream = substream;
682 err = set_stream_hw(ua, substream, ua->playback.channels);
686 DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length,
687 ua->packets_per_second);
689 mutex_lock(&ua->mutex);
690 err = start_usb_capture(ua);
693 err = start_usb_playback(ua);
695 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
696 stop_usb_capture(ua);
699 set_bit(ALSA_PLAYBACK_OPEN, &ua->states);
701 mutex_unlock(&ua->mutex);
707 struct ua101 *ua = substream->private_data;
709 mutex_lock(&ua->mutex);
710 clear_bit(ALSA_CAPTURE_OPEN, &ua->states);
711 if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states))
712 stop_usb_capture(ua);
713 mutex_unlock(&ua->mutex);
719 struct ua101 *ua = substream->private_data;
721 mutex_lock(&ua->mutex);
722 stop_usb_playback(ua);
723 clear_bit(ALSA_PLAYBACK_OPEN, &ua->states);
724 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
725 stop_usb_capture(ua);
726 mutex_unlock(&ua->mutex);
733 struct ua101 *ua = substream->private_data;
736 mutex_lock(&ua->mutex);
737 err = start_usb_capture(ua);
738 mutex_unlock(&ua->mutex);
749 struct ua101 *ua = substream->private_data;
752 mutex_lock(&ua->mutex);
753 err = start_usb_capture(ua);
755 err = start_usb_playback(ua);
756 mutex_unlock(&ua->mutex);
771 struct ua101 *ua = substream->private_data;
774 mutex_lock(&ua->mutex);
775 err = start_usb_capture(ua);
776 mutex_unlock(&ua->mutex);
786 wait_event(ua->alsa_capture_wait,
787 test_bit(CAPTURE_URB_COMPLETED, &ua->states) ||
788 !test_bit(USB_CAPTURE_RUNNING, &ua->states));
789 if (test_bit(DISCONNECTED, &ua->states))
791 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
794 ua->capture.period_pos = 0;
795 ua->capture.buffer_pos = 0;
801 struct ua101 *ua = substream->private_data;
804 mutex_lock(&ua->mutex);
805 err = start_usb_capture(ua);
807 err = start_usb_playback(ua);
808 mutex_unlock(&ua->mutex);
813 wait_event(ua->alsa_playback_wait,
814 test_bit(PLAYBACK_URB_COMPLETED, &ua->states) ||
815 !test_bit(USB_PLAYBACK_RUNNING, &ua->states));
816 if (test_bit(DISCONNECTED, &ua->states))
818 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
822 ua->playback.period_pos = 0;
823 ua->playback.buffer_pos = 0;
829 struct ua101 *ua = substream->private_data;
833 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
835 set_bit(ALSA_CAPTURE_RUNNING, &ua->states);
838 clear_bit(ALSA_CAPTURE_RUNNING, &ua->states);
847 struct ua101 *ua = substream->private_data;
851 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
853 set_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
856 clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
863 static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua,
869 spin_lock_irqsave(&ua->lock, flags);
871 spin_unlock_irqrestore(&ua->lock, flags);
877 struct ua101 *ua = subs->private_data;
879 return ua101_pcm_pointer(ua, &ua->capture);
884 struct ua101 *ua = subs->private_data;
886 return ua101_pcm_pointer(ua, &ua->playback);
967 static int detect_usb_format(struct ua101 *ua)
974 fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]);
975 fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]);
981 ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE;
984 ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE;
987 dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n");
991 dev_err(&ua->dev->dev,
998 dev_err(&ua->dev->dev, "sample width is not 24 bits\n");
1002 ua->rate = combine_triple(fmt_capture->tSamFreq[0]);
1004 if (ua->rate != rate2) {
1005 dev_err(&ua->dev->dev,
1007 rate2, ua->rate);
1011 switch (ua->dev->speed) {
1013 ua->packets_per_second = 1000;
1016 ua->packets_per_second = 8000;
1019 dev_err(&ua->dev->dev, "unknown device speed\n");
1023 ua->capture.channels = fmt_capture->bNrChannels;
1024 ua->playback.channels = fmt_playback->bNrChannels;
1025 ua->capture.frame_bytes =
1026 fmt_capture->bSubframeSize * ua->capture.channels;
1027 ua->playback.frame_bytes =
1028 fmt_playback->bSubframeSize * ua->playback.channels;
1030 epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc;
1032 dev_err(&ua->dev->dev, "invalid capture endpoint\n");
1035 ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd));
1036 ua->capture.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize);
1038 epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc;
1040 dev_err(&ua->dev->dev, "invalid playback endpoint\n");
1043 ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd));
1044 ua->playback.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize);
1048 static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1071 usb_alloc_coherent(ua->dev, size, GFP_KERNEL,
1081 dev_err(&ua->dev->dev, "too many packets\n");
1087 static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
1092 usb_free_coherent(ua->dev,
1098 static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream,
1117 urb->urb.dev = ua->dev;
1126 urb->urb.context = ua;
1139 dev_err(&ua->dev->dev, "internal buffer size error\n");
1151 static void free_usb_related_resources(struct ua101 *ua,
1156 free_stream_urbs(&ua->capture);
1157 free_stream_urbs(&ua->playback);
1158 free_stream_buffers(ua, &ua->capture);
1159 free_stream_buffers(ua, &ua->playback);
1161 for (i = 0; i < ARRAY_SIZE(ua->intf); ++i)
1162 if (ua->intf[i]) {
1163 usb_set_intfdata(ua->intf[i], NULL);
1164 if (ua->intf[i] != interface)
1166 ua->intf[i]);
1172 struct ua101 *ua = card->private_data;
1174 mutex_destroy(&ua->mutex);
1201 struct ua101 *ua;
1224 sizeof(*ua), &card);
1230 ua = card->private_data;
1231 ua->dev = interface_to_usbdev(interface);
1232 ua->card = card;
1233 ua->card_index = card_index;
1234 INIT_LIST_HEAD(&ua->midi_list);
1235 spin_lock_init(&ua->lock);
1236 mutex_init(&ua->mutex);
1237 INIT_LIST_HEAD(&ua->ready_playback_urbs);
1238 tasklet_init(&ua->playback_tasklet,
1239 playback_tasklet, (unsigned long)ua);
1240 init_waitqueue_head(&ua->alsa_capture_wait);
1241 init_waitqueue_head(&ua->rate_feedback_wait);
1242 init_waitqueue_head(&ua->alsa_playback_wait);
1244 ua->intf[0] = interface;
1245 for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) {
1246 ua->intf[i] = usb_ifnum_to_if(ua->dev,
1248 if (!ua->intf[i]) {
1249 dev_err(&ua->dev->dev, "interface %u not found\n",
1255 ua->intf[i], ua);
1257 ua->intf[i] = NULL;
1265 err = detect_usb_format(ua);
1272 usb_make_path(ua->dev, usb_path, sizeof(usb_path));
1273 snprintf(ua->card->longname, sizeof(ua->card->longname),
1275 ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path,
1276 ua->dev->speed == USB_SPEED_HIGH ? "high" : "full");
1278 err = alloc_stream_buffers(ua, &ua->capture);
1281 err = alloc_stream_buffers(ua, &ua->playback);
1285 err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete);
1288 err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete);
1292 err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm);
1295 ua->pcm->private_data = ua;
1296 strcpy(ua->pcm->name, name);
1297 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops);
1298 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops);
1300 err = snd_usbmidi_create(card, ua->intf[INTF_MIDI],
1301 &ua->midi_list, &midi_quirk);
1309 usb_set_intfdata(interface, ua);
1316 free_usb_related_resources(ua, interface);
1324 struct ua101 *ua = usb_get_intfdata(interface);
1327 if (!ua)
1332 set_bit(DISCONNECTED, &ua->states);
1333 wake_up(&ua->rate_feedback_wait);
1336 snd_card_disconnect(ua->card);
1339 __list_for_each(midi, &ua->midi_list)
1341 abort_alsa_playback(ua);
1342 abort_alsa_capture(ua);
1343 mutex_lock(&ua->mutex);
1344 stop_usb_playback(ua);
1345 stop_usb_capture(ua);
1346 mutex_unlock(&ua->mutex);
1348 free_usb_related_resources(ua, interface);
1350 devices_used &= ~(1 << ua->card_index);
1352 snd_card_free_when_closed(ua->card);