usb/usx2y/usbusx2yaudio.c

58 static int usx2y_urb_capt_retire(struct snd_usx2y_substream *subs)
60 	struct urb	*urb = subs->completed_urb;
61 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
63 	int		i, len, lens = 0, hwptr_done = subs->hwptr_done;
65 	struct usx2ydev	*usx2y = subs->usx2y;
97 	subs->hwptr_done = hwptr_done;
98 	subs->transfer_done += lens;
100 	if (subs->transfer_done >= runtime->period_size) {
101 		subs->transfer_done -= runtime->period_size;
102 		snd_pcm_period_elapsed(subs->pcm_substream);
117 static int usx2y_urb_play_prepare(struct snd_usx2y_substream *subs,
121 	struct usx2ydev *usx2y = subs->usx2y;
122 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
141 	if (atomic_read(&subs->state) >= STATE_PRERUNNING) {
142 		if (subs->hwptr + count > runtime->buffer_size) {
146 			len = runtime->buffer_size - subs->hwptr;
147 			urb->transfer_buffer = subs->tmpbuf;
148 			memcpy(subs->tmpbuf, runtime->dma_area +
149 			       subs->hwptr * usx2y->stride, len * usx2y->stride);
150 			memcpy(subs->tmpbuf + len * usx2y->stride,
152 			subs->hwptr += count;
153 			subs->hwptr -= runtime->buffer_size;
156 			urb->transfer_buffer = runtime->dma_area + subs->hwptr * usx2y->stride;
157 			subs->hwptr += count;
158 			if (subs->hwptr >= runtime->buffer_size)
159 				subs->hwptr -= runtime->buffer_size;
162 		urb->transfer_buffer = subs->tmpbuf;
173 static void usx2y_urb_play_retire(struct snd_usx2y_substream *subs, struct urb *urb)
175 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
176 	int		len = urb->actual_length / subs->usx2y->stride;
178 	subs->transfer_done += len;
179 	subs->hwptr_done +=  len;
180 	if (subs->hwptr_done >= runtime->buffer_size)
181 		subs->hwptr_done -= runtime->buffer_size;
182 	if (subs->transfer_done >= runtime->period_size) {
183 		subs->transfer_done -= runtime->period_size;
184 		snd_pcm_period_elapsed(subs->pcm_substream);
188 static int usx2y_urb_submit(struct snd_usx2y_substream *subs, struct urb *urb, int frame)
196 	urb->dev = subs->usx2y->dev; /* we need to set this at each time */
260 	struct snd_usx2y_substream *subs;
265 		subs = usx2y->subs[s];
266 		if (subs) {
267 			snd_printdd("%i %p state=%i\n", s, subs, atomic_read(&subs->state));
268 			atomic_set(&subs->state, STATE_STOPPED);
272 		subs = usx2y->subs[s];
273 		if (subs) {
274 			if (atomic_read(&subs->state) >= STATE_PRERUNNING)
275 				snd_pcm_stop_xrun(subs->pcm_substream);
277 				urb = subs->urb[u];
289 				   struct snd_usx2y_substream *subs, struct urb *urb)
291 	snd_printk(KERN_ERR "ep=%i stalled with status=%i\n", subs->endpoint, urb->status);
298 	struct snd_usx2y_substream *subs = urb->context;
299 	struct usx2ydev *usx2y = subs->usx2y;
302 	if (unlikely(atomic_read(&subs->state) < STATE_PREPARED)) {
305 			    subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
310 		usx2y_error_urb_status(usx2y, subs, urb);
314 	subs->completed_urb = urb;
316 	capsubs = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE];
317 	playbacksubs = usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK];
335 	struct snd_usx2y_substream *subs;
340 		subs = usx2y->subs[s];
341 		if (subs) {
343 				urb = subs->urb[u];
359 	struct snd_usx2y_substream *subs = urb->context;
360 	struct usx2ydev *usx2y = subs->usx2y;
374 static void usx2y_subs_prepare(struct snd_usx2y_substream *subs)
377 		    subs, subs->endpoint, subs->urb[0], subs->urb[1]);
379 	subs->hwptr = 0;
380 	subs->hwptr_done = 0;
381 	subs->transfer_done = 0;
398 static void usx2y_urbs_release(struct snd_usx2y_substream *subs)
402 	snd_printdd("%s %i\n", __func__, subs->endpoint);
404 		usx2y_urb_release(subs->urb + i,
405 				  subs != subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]);
407 	kfree(subs->tmpbuf);
408 	subs->tmpbuf = NULL;
414 static int usx2y_urbs_allocate(struct snd_usx2y_substream *subs)
418 	int is_playback = subs == subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK];
419 	struct usb_device *dev = subs->usx2y->dev;
422 	pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
423 			usb_rcvisocpipe(dev, subs->endpoint);
424 	subs->maxpacksize = usb_maxpacket(dev, pipe);
425 	if (!subs->maxpacksize)
428 	if (is_playback && !subs->tmpbuf) {	/* allocate a temporary buffer for playback */
429 		subs->tmpbuf = kcalloc(nr_of_packs(), subs->maxpacksize, GFP_KERNEL);
430 		if (!subs->tmpbuf)
435 		purb = subs->urb + i;
442 			usx2y_urbs_release(subs);
448 				kmalloc_array(subs->maxpacksize,
451 				usx2y_urbs_release(subs);
458 		(*purb)->context = subs;
465 static void usx2y_subs_startup(struct snd_usx2y_substream *subs)
467 	struct usx2ydev *usx2y = subs->usx2y;
469 	usx2y->prepare_subs = subs;
470 	subs->urb[0]->start_frame = -1;
475 static int usx2y_urbs_start(struct snd_usx2y_substream *subs)
478 	struct usx2ydev *usx2y = subs->usx2y;
482 	err = usx2y_urbs_allocate(subs);
485 	subs->completed_urb = NULL;
487 		struct snd_usx2y_substream *subs = usx2y->subs[i];
489 		if (subs && atomic_read(&subs->state) >= STATE_PREPARED)
494 	usx2y_subs_startup(subs);
496 		urb = subs->urb[i];
499 				atomic_set(&subs->state, STATE_STARTING3);
502 				urb->iso_frame_desc[pack].offset = subs->maxpacksize * pack;
503 				urb->iso_frame_desc[pack].length = subs->maxpacksize;
505 			urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs();
517 			atomic_set(&subs->state, STATE_STARTING1);
523 	if (atomic_read(&subs->state) != STATE_PREPARED)
539 	struct snd_usx2y_substream *subs = substream->runtime->private_data;
541 	return subs->hwptr_done;
549 	struct snd_usx2y_substream *subs = substream->runtime->private_data;
554 		if (atomic_read(&subs->state) == STATE_PREPARED &&
555 		    atomic_read(&subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]->state) >= STATE_PREPARED) {
556 			atomic_set(&subs->state, STATE_PRERUNNING);
564 		if (atomic_read(&subs->state) >= STATE_PRERUNNING)
565 			atomic_set(&subs->state, STATE_PREPARED);
776 	struct snd_usx2y_substream *subs;
786 		subs = dev->subs[i];
787 		if (!subs)
789 		test_substream = subs->pcm_substream;
813 	struct snd_usx2y_substream *subs = runtime->private_data;
816 	mutex_lock(&subs->usx2y->pcm_mutex);
820 		cap_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE];
821 		atomic_set(&subs->state, STATE_STOPPED);
822 		usx2y_urbs_release(subs);
830 		playback_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK];
832 			atomic_set(&subs->state, STATE_STOPPED);
833 			usx2y_urbs_release(subs);
836 	mutex_unlock(&subs->usx2y->pcm_mutex);
848 	struct snd_usx2y_substream *subs = runtime->private_data;
849 	struct usx2ydev *usx2y = subs->usx2y;
850 	struct snd_usx2y_substream *capsubs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE];
856 	usx2y_subs_prepare(subs);
870 		snd_printdd("starting capture pipe for %s\n", subs == capsubs ? "self" : "playpipe");
876 	if (subs != capsubs && atomic_read(&subs->state) < STATE_PREPARED)
877 		err = usx2y_urbs_start(subs);
905 	struct snd_usx2y_substream	*subs =
910 	if (subs->usx2y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)
914 	runtime->private_data = subs;
915 	subs->pcm_substream = substream;
923 	struct snd_usx2y_substream *subs = runtime->private_data;
925 	subs->pcm_substream = NULL;
966 		usx2y(card)->subs + 2 * usx2y(card)->pcm_devs;