xref: /openbmc/linux/sound/usb/usx2y/usx2yhwdeppcm.c (revision 8365a898)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  */
4 
5 /* USX2Y "rawusb" aka hwdep_pcm implementation
6 
7  Its usb's unableness to atomically handle power of 2 period sized data chuncs
8  at standard samplerates,
9  what led to this part of the usx2y module:
10  It provides the alsa kernel half of the usx2y-alsa-jack driver pair.
11  The pair uses a hardware dependent alsa-device for mmaped pcm transport.
12  Advantage achieved:
13          The usb_hc moves pcm data from/into memory via DMA.
14          That memory is mmaped by jack's usx2y driver.
15          Jack's usx2y driver is the first/last to read/write pcm data.
16          Read/write is a combination of power of 2 period shaping and
17          float/int conversation.
18          Compared to mainline alsa/jack we leave out power of 2 period shaping inside
19          snd-usb-usx2y which needs memcpy() and additional buffers.
20          As a side effect possible unwanted pcm-data coruption resulting of
21          standard alsa's snd-usb-usx2y period shaping scheme falls away.
22          Result is sane jack operation at buffering schemes down to 128frames,
23          2 periods.
24          plain usx2y alsa mode is able to achieve 64frames, 4periods, but only at the
25          cost of easier triggered i.e. aeolus xruns (128 or 256frames,
26          2periods works but is useless cause of crackling).
27 
28  This is a first "proof of concept" implementation.
29  Later, functionalities should migrate to more appropriate places:
30  Userland:
31  - The jackd could mmap its float-pcm buffers directly from alsa-lib.
32  - alsa-lib could provide power of 2 period sized shaping combined with int/float
33    conversation.
34    Currently the usx2y jack driver provides above 2 services.
35  Kernel:
36  - rawusb dma pcm buffer transport should go to snd-usb-lib, so also snd-usb-audio
37    devices can use it.
38    Currently rawusb dma pcm buffer transport (this file) is only available to snd-usb-usx2y.
39 */
40 
41 #include <linux/delay.h>
42 #include <linux/gfp.h>
43 #include "usbusx2yaudio.c"
44 
45 #if defined(USX2Y_NRPACKS_VARIABLE) || USX2Y_NRPACKS == 1
46 
47 #include <sound/hwdep.h>
48 
49 
50 static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs)
51 {
52 	struct urb	*urb = subs->completed_urb;
53 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
54 	int 		i, lens = 0, hwptr_done = subs->hwptr_done;
55 	struct usX2Ydev	*usX2Y = subs->usX2Y;
56 	if (0 > usX2Y->hwdep_pcm_shm->capture_iso_start) { //FIXME
57 		int head = usX2Y->hwdep_pcm_shm->captured_iso_head + 1;
58 		if (head >= ARRAY_SIZE(usX2Y->hwdep_pcm_shm->captured_iso))
59 			head = 0;
60 		usX2Y->hwdep_pcm_shm->capture_iso_start = head;
61 		snd_printdd("cap start %i\n", head);
62 	}
63 	for (i = 0; i < nr_of_packs(); i++) {
64 		if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */
65 			snd_printk(KERN_ERR "active frame status %i. Most probably some hardware problem.\n", urb->iso_frame_desc[i].status);
66 			return urb->iso_frame_desc[i].status;
67 		}
68 		lens += urb->iso_frame_desc[i].actual_length / usX2Y->stride;
69 	}
70 	if ((hwptr_done += lens) >= runtime->buffer_size)
71 		hwptr_done -= runtime->buffer_size;
72 	subs->hwptr_done = hwptr_done;
73 	subs->transfer_done += lens;
74 	/* update the pointer, call callback if necessary */
75 	if (subs->transfer_done >= runtime->period_size) {
76 		subs->transfer_done -= runtime->period_size;
77 		snd_pcm_period_elapsed(subs->pcm_substream);
78 	}
79 	return 0;
80 }
81 
82 static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime,
83 					      struct usX2Ydev * usX2Y)
84 {
85 	return (runtime->buffer_size * 1000) / usX2Y->rate + 1;	//FIXME: so far only correct period_size == 2^x ?
86 }
87 
88 /*
89  * prepare urb for playback data pipe
90  *
91  * we copy the data directly from the pcm buffer.
92  * the current position to be copied is held in hwptr field.
93  * since a urb can handle only a single linear buffer, if the total
94  * transferred area overflows the buffer boundary, we cannot send
95  * it directly from the buffer.  thus the data is once copied to
96  * a temporary buffer and urb points to that.
97  */
98 static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs,
99 					struct urb *urb)
100 {
101 	int count, counts, pack;
102 	struct usX2Ydev *usX2Y = subs->usX2Y;
103 	struct snd_usX2Y_hwdep_pcm_shm *shm = usX2Y->hwdep_pcm_shm;
104 	struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
105 
106 	if (0 > shm->playback_iso_start) {
107 		shm->playback_iso_start = shm->captured_iso_head -
108 			usX2Y_iso_frames_per_buffer(runtime, usX2Y);
109 		if (0 > shm->playback_iso_start)
110 			shm->playback_iso_start += ARRAY_SIZE(shm->captured_iso);
111 		shm->playback_iso_head = shm->playback_iso_start;
112 	}
113 
114 	count = 0;
115 	for (pack = 0; pack < nr_of_packs(); pack++) {
116 		/* calculate the size of a packet */
117 		counts = shm->captured_iso[shm->playback_iso_head].length / usX2Y->stride;
118 		if (counts < 43 || counts > 50) {
119 			snd_printk(KERN_ERR "should not be here with counts=%i\n", counts);
120 			return -EPIPE;
121 		}
122 		/* set up descriptor */
123 		urb->iso_frame_desc[pack].offset = shm->captured_iso[shm->playback_iso_head].offset;
124 		urb->iso_frame_desc[pack].length = shm->captured_iso[shm->playback_iso_head].length;
125 		if (atomic_read(&subs->state) != state_RUNNING)
126 			memset((char *)urb->transfer_buffer + urb->iso_frame_desc[pack].offset, 0,
127 			       urb->iso_frame_desc[pack].length);
128 		if (++shm->playback_iso_head >= ARRAY_SIZE(shm->captured_iso))
129 			shm->playback_iso_head = 0;
130 		count += counts;
131 	}
132 	urb->transfer_buffer_length = count * usX2Y->stride;
133 	return 0;
134 }
135 
136 
137 static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream *subs,
138 						     struct urb *urb)
139 {
140 	int pack;
141 	for (pack = 0; pack < nr_of_packs(); ++pack) {
142 		struct usb_iso_packet_descriptor *desc = urb->iso_frame_desc + pack;
143 		if (NULL != subs) {
144 			struct snd_usX2Y_hwdep_pcm_shm *shm = subs->usX2Y->hwdep_pcm_shm;
145 			int head = shm->captured_iso_head + 1;
146 			if (head >= ARRAY_SIZE(shm->captured_iso))
147 				head = 0;
148 			shm->captured_iso[head].frame = urb->start_frame + pack;
149 			shm->captured_iso[head].offset = desc->offset;
150 			shm->captured_iso[head].length = desc->actual_length;
151 			shm->captured_iso_head = head;
152 			shm->captured_iso_frames++;
153 		}
154 		if ((desc->offset += desc->length * NRURBS*nr_of_packs()) +
155 		    desc->length >= SSS)
156 			desc->offset -= (SSS - desc->length);
157 	}
158 }
159 
160 static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *capsubs,
161 						 struct snd_usX2Y_substream *capsubs2,
162 						 struct snd_usX2Y_substream *playbacksubs,
163 						 int frame)
164 {
165 	int err, state;
166 	struct urb *urb = playbacksubs->completed_urb;
167 
168 	state = atomic_read(&playbacksubs->state);
169 	if (NULL != urb) {
170 		if (state == state_RUNNING)
171 			usX2Y_urb_play_retire(playbacksubs, urb);
172 		else if (state >= state_PRERUNNING)
173 			atomic_inc(&playbacksubs->state);
174 	} else {
175 		switch (state) {
176 		case state_STARTING1:
177 			urb = playbacksubs->urb[0];
178 			atomic_inc(&playbacksubs->state);
179 			break;
180 		case state_STARTING2:
181 			urb = playbacksubs->urb[1];
182 			atomic_inc(&playbacksubs->state);
183 			break;
184 		}
185 	}
186 	if (urb) {
187 		if ((err = usX2Y_hwdep_urb_play_prepare(playbacksubs, urb)) ||
188 		    (err = usX2Y_urb_submit(playbacksubs, urb, frame))) {
189 			return err;
190 		}
191 	}
192 
193 	playbacksubs->completed_urb = NULL;
194 
195 	state = atomic_read(&capsubs->state);
196 	if (state >= state_PREPARED) {
197 		if (state == state_RUNNING) {
198 			if ((err = usX2Y_usbpcm_urb_capt_retire(capsubs)))
199 				return err;
200 		} else if (state >= state_PRERUNNING)
201 			atomic_inc(&capsubs->state);
202 		usX2Y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb);
203 		if (NULL != capsubs2)
204 			usX2Y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb);
205 		if ((err = usX2Y_urb_submit(capsubs, capsubs->completed_urb, frame)))
206 			return err;
207 		if (NULL != capsubs2)
208 			if ((err = usX2Y_urb_submit(capsubs2, capsubs2->completed_urb, frame)))
209 				return err;
210 	}
211 	capsubs->completed_urb = NULL;
212 	if (NULL != capsubs2)
213 		capsubs2->completed_urb = NULL;
214 	return 0;
215 }
216 
217 
218 static void i_usX2Y_usbpcm_urb_complete(struct urb *urb)
219 {
220 	struct snd_usX2Y_substream *subs = urb->context;
221 	struct usX2Ydev *usX2Y = subs->usX2Y;
222 	struct snd_usX2Y_substream *capsubs, *capsubs2, *playbacksubs;
223 
224 	if (unlikely(atomic_read(&subs->state) < state_PREPARED)) {
225 		snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
226 			    usb_get_current_frame_number(usX2Y->dev),
227 			    subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
228 			    urb->status, urb->start_frame);
229 		return;
230 	}
231 	if (unlikely(urb->status)) {
232 		usX2Y_error_urb_status(usX2Y, subs, urb);
233 		return;
234 	}
235 
236 	subs->completed_urb = urb;
237 	capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
238 	capsubs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
239 	playbacksubs = usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
240 	if (capsubs->completed_urb && atomic_read(&capsubs->state) >= state_PREPARED &&
241 	    (NULL == capsubs2 || capsubs2->completed_urb) &&
242 	    (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < state_PREPARED)) {
243 		if (!usX2Y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame))
244 			usX2Y->wait_iso_frame += nr_of_packs();
245 		else {
246 			snd_printdd("\n");
247 			usX2Y_clients_stop(usX2Y);
248 		}
249 	}
250 }
251 
252 
253 static void usX2Y_hwdep_urb_release(struct urb **urb)
254 {
255 	usb_kill_urb(*urb);
256 	usb_free_urb(*urb);
257 	*urb = NULL;
258 }
259 
260 /*
261  * release a substream
262  */
263 static void usX2Y_usbpcm_urbs_release(struct snd_usX2Y_substream *subs)
264 {
265 	int i;
266 	snd_printdd("snd_usX2Y_urbs_release() %i\n", subs->endpoint);
267 	for (i = 0; i < NRURBS; i++)
268 		usX2Y_hwdep_urb_release(subs->urb + i);
269 }
270 
271 static void usX2Y_usbpcm_subs_startup_finish(struct usX2Ydev * usX2Y)
272 {
273 	usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_urb_complete);
274 	usX2Y->prepare_subs = NULL;
275 }
276 
277 static void i_usX2Y_usbpcm_subs_startup(struct urb *urb)
278 {
279 	struct snd_usX2Y_substream *subs = urb->context;
280 	struct usX2Ydev *usX2Y = subs->usX2Y;
281 	struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs;
282 	if (NULL != prepare_subs &&
283 	    urb->start_frame == prepare_subs->urb[0]->start_frame) {
284 		atomic_inc(&prepare_subs->state);
285 		if (prepare_subs == usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]) {
286 			struct snd_usX2Y_substream *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
287 			if (cap_subs2 != NULL)
288 				atomic_inc(&cap_subs2->state);
289 		}
290 		usX2Y_usbpcm_subs_startup_finish(usX2Y);
291 		wake_up(&usX2Y->prepare_wait_queue);
292 	}
293 
294 	i_usX2Y_usbpcm_urb_complete(urb);
295 }
296 
297 /*
298  * initialize a substream's urbs
299  */
300 static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs)
301 {
302 	int i;
303 	unsigned int pipe;
304 	int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
305 	struct usb_device *dev = subs->usX2Y->dev;
306 
307 	pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
308 			usb_rcvisocpipe(dev, subs->endpoint);
309 	subs->maxpacksize = usb_maxpacket(dev, pipe, is_playback);
310 	if (!subs->maxpacksize)
311 		return -EINVAL;
312 
313 	/* allocate and initialize data urbs */
314 	for (i = 0; i < NRURBS; i++) {
315 		struct urb **purb = subs->urb + i;
316 		if (*purb) {
317 			usb_kill_urb(*purb);
318 			continue;
319 		}
320 		*purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL);
321 		if (NULL == *purb) {
322 			usX2Y_usbpcm_urbs_release(subs);
323 			return -ENOMEM;
324 		}
325 		(*purb)->transfer_buffer = is_playback ?
326 			subs->usX2Y->hwdep_pcm_shm->playback : (
327 				subs->endpoint == 0x8 ?
328 				subs->usX2Y->hwdep_pcm_shm->capture0x8 :
329 				subs->usX2Y->hwdep_pcm_shm->capture0xA);
330 
331 		(*purb)->dev = dev;
332 		(*purb)->pipe = pipe;
333 		(*purb)->number_of_packets = nr_of_packs();
334 		(*purb)->context = subs;
335 		(*purb)->interval = 1;
336 		(*purb)->complete = i_usX2Y_usbpcm_subs_startup;
337 	}
338 	return 0;
339 }
340 
341 /*
342  * free the buffer
343  */
344 static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream)
345 {
346 	struct snd_pcm_runtime *runtime = substream->runtime;
347 	struct snd_usX2Y_substream *subs = runtime->private_data,
348 		*cap_subs2 = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
349 	mutex_lock(&subs->usX2Y->pcm_mutex);
350 	snd_printdd("snd_usX2Y_usbpcm_hw_free(%p)\n", substream);
351 
352 	if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) {
353 		struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
354 		atomic_set(&subs->state, state_STOPPED);
355 		usX2Y_usbpcm_urbs_release(subs);
356 		if (!cap_subs->pcm_substream ||
357 		    !cap_subs->pcm_substream->runtime ||
358 		    !cap_subs->pcm_substream->runtime->status ||
359 		    cap_subs->pcm_substream->runtime->status->state < SNDRV_PCM_STATE_PREPARED) {
360 			atomic_set(&cap_subs->state, state_STOPPED);
361 			if (NULL != cap_subs2)
362 				atomic_set(&cap_subs2->state, state_STOPPED);
363 			usX2Y_usbpcm_urbs_release(cap_subs);
364 			if (NULL != cap_subs2)
365 				usX2Y_usbpcm_urbs_release(cap_subs2);
366 		}
367 	} else {
368 		struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
369 		if (atomic_read(&playback_subs->state) < state_PREPARED) {
370 			atomic_set(&subs->state, state_STOPPED);
371 			if (NULL != cap_subs2)
372 				atomic_set(&cap_subs2->state, state_STOPPED);
373 			usX2Y_usbpcm_urbs_release(subs);
374 			if (NULL != cap_subs2)
375 				usX2Y_usbpcm_urbs_release(cap_subs2);
376 		}
377 	}
378 	mutex_unlock(&subs->usX2Y->pcm_mutex);
379 	return 0;
380 }
381 
382 static void usX2Y_usbpcm_subs_startup(struct snd_usX2Y_substream *subs)
383 {
384 	struct usX2Ydev * usX2Y = subs->usX2Y;
385 	usX2Y->prepare_subs = subs;
386 	subs->urb[0]->start_frame = -1;
387 	smp_wmb();	// Make sure above modifications are seen by i_usX2Y_subs_startup()
388 	usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_subs_startup);
389 }
390 
391 static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs)
392 {
393 	int	p, u, err,
394 		stream = subs->pcm_substream->stream;
395 	struct usX2Ydev *usX2Y = subs->usX2Y;
396 
397 	if (SNDRV_PCM_STREAM_CAPTURE == stream) {
398 		usX2Y->hwdep_pcm_shm->captured_iso_head = -1;
399 		usX2Y->hwdep_pcm_shm->captured_iso_frames = 0;
400 	}
401 
402 	for (p = 0; 3 >= (stream + p); p += 2) {
403 		struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p];
404 		if (subs != NULL) {
405 			if ((err = usX2Y_usbpcm_urbs_allocate(subs)) < 0)
406 				return err;
407 			subs->completed_urb = NULL;
408 		}
409 	}
410 
411 	for (p = 0; p < 4; p++) {
412 		struct snd_usX2Y_substream *subs = usX2Y->subs[p];
413 		if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED)
414 			goto start;
415 	}
416 
417  start:
418 	usX2Y_usbpcm_subs_startup(subs);
419 	for (u = 0; u < NRURBS; u++) {
420 		for (p = 0; 3 >= (stream + p); p += 2) {
421 			struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p];
422 			if (subs != NULL) {
423 				struct urb *urb = subs->urb[u];
424 				if (usb_pipein(urb->pipe)) {
425 					unsigned long pack;
426 					if (0 == u)
427 						atomic_set(&subs->state, state_STARTING3);
428 					urb->dev = usX2Y->dev;
429 					for (pack = 0; pack < nr_of_packs(); pack++) {
430 						urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs());
431 						urb->iso_frame_desc[pack].length = subs->maxpacksize;
432 					}
433 					urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs();
434 					if ((err = usb_submit_urb(urb, GFP_KERNEL)) < 0) {
435 						snd_printk (KERN_ERR "cannot usb_submit_urb() for urb %d, err = %d\n", u, err);
436 						err = -EPIPE;
437 						goto cleanup;
438 					}  else {
439 						snd_printdd("%i\n", urb->start_frame);
440 						if (u == 0)
441 							usX2Y->wait_iso_frame = urb->start_frame;
442 					}
443 					urb->transfer_flags = 0;
444 				} else {
445 					atomic_set(&subs->state, state_STARTING1);
446 					break;
447 				}
448 			}
449 		}
450 	}
451 	err = 0;
452 	wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs);
453 	if (atomic_read(&subs->state) != state_PREPARED)
454 		err = -EPIPE;
455 
456  cleanup:
457 	if (err) {
458 		usX2Y_subs_startup_finish(usX2Y);	// Call it now
459 		usX2Y_clients_stop(usX2Y);		// something is completely wroong > stop evrything
460 	}
461 	return err;
462 }
463 
464 /*
465  * prepare callback
466  *
467  * set format and initialize urbs
468  */
469 static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream)
470 {
471 	struct snd_pcm_runtime *runtime = substream->runtime;
472 	struct snd_usX2Y_substream *subs = runtime->private_data;
473 	struct usX2Ydev *usX2Y = subs->usX2Y;
474 	struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE];
475 	int err = 0;
476 	snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream);
477 
478 	if (NULL == usX2Y->hwdep_pcm_shm) {
479 		usX2Y->hwdep_pcm_shm = alloc_pages_exact(sizeof(struct snd_usX2Y_hwdep_pcm_shm),
480 							 GFP_KERNEL);
481 		if (!usX2Y->hwdep_pcm_shm)
482 			return -ENOMEM;
483 		memset(usX2Y->hwdep_pcm_shm, 0, sizeof(struct snd_usX2Y_hwdep_pcm_shm));
484 	}
485 
486 	mutex_lock(&usX2Y->pcm_mutex);
487 	usX2Y_subs_prepare(subs);
488 // Start hardware streams
489 // SyncStream first....
490 	if (atomic_read(&capsubs->state) < state_PREPARED) {
491 		if (usX2Y->format != runtime->format)
492 			if ((err = usX2Y_format_set(usX2Y, runtime->format)) < 0)
493 				goto up_prepare_mutex;
494 		if (usX2Y->rate != runtime->rate)
495 			if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0)
496 				goto up_prepare_mutex;
497 		snd_printdd("starting capture pipe for %s\n", subs == capsubs ?
498 			    "self" : "playpipe");
499 		if (0 > (err = usX2Y_usbpcm_urbs_start(capsubs)))
500 			goto up_prepare_mutex;
501 	}
502 
503 	if (subs != capsubs) {
504 		usX2Y->hwdep_pcm_shm->playback_iso_start = -1;
505 		if (atomic_read(&subs->state) < state_PREPARED) {
506 			while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) >
507 			       usX2Y->hwdep_pcm_shm->captured_iso_frames) {
508 				snd_printdd("Wait: iso_frames_per_buffer=%i,"
509 					    "captured_iso_frames=%i\n",
510 					    usX2Y_iso_frames_per_buffer(runtime, usX2Y),
511 					    usX2Y->hwdep_pcm_shm->captured_iso_frames);
512 				if (msleep_interruptible(10)) {
513 					err = -ERESTARTSYS;
514 					goto up_prepare_mutex;
515 				}
516 			}
517 			if (0 > (err = usX2Y_usbpcm_urbs_start(subs)))
518 				goto up_prepare_mutex;
519 		}
520 		snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n",
521 			    usX2Y_iso_frames_per_buffer(runtime, usX2Y),
522 			    usX2Y->hwdep_pcm_shm->captured_iso_frames);
523 	} else
524 		usX2Y->hwdep_pcm_shm->capture_iso_start = -1;
525 
526  up_prepare_mutex:
527 	mutex_unlock(&usX2Y->pcm_mutex);
528 	return err;
529 }
530 
531 static const struct snd_pcm_hardware snd_usX2Y_4c =
532 {
533 	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
534 				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
535 				 SNDRV_PCM_INFO_MMAP_VALID),
536 	.formats =                 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
537 	.rates =                   SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
538 	.rate_min =                44100,
539 	.rate_max =                48000,
540 	.channels_min =            2,
541 	.channels_max =            4,
542 	.buffer_bytes_max =	(2*128*1024),
543 	.period_bytes_min =	64,
544 	.period_bytes_max =	(128*1024),
545 	.periods_min =		2,
546 	.periods_max =		1024,
547 	.fifo_size =              0
548 };
549 
550 
551 
552 static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream)
553 {
554 	struct snd_usX2Y_substream	*subs = ((struct snd_usX2Y_substream **)
555 					 snd_pcm_substream_chip(substream))[substream->stream];
556 	struct snd_pcm_runtime	*runtime = substream->runtime;
557 
558 	if (!(subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS))
559 		return -EBUSY;
560 
561 	runtime->hw = SNDRV_PCM_STREAM_PLAYBACK == substream->stream ? snd_usX2Y_2c :
562 		(subs->usX2Y->subs[3] ? snd_usX2Y_4c : snd_usX2Y_2c);
563 	runtime->private_data = subs;
564 	subs->pcm_substream = substream;
565 	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000);
566 	return 0;
567 }
568 
569 
570 static int snd_usX2Y_usbpcm_close(struct snd_pcm_substream *substream)
571 {
572 	struct snd_pcm_runtime *runtime = substream->runtime;
573 	struct snd_usX2Y_substream *subs = runtime->private_data;
574 
575 	subs->pcm_substream = NULL;
576 	return 0;
577 }
578 
579 
580 static const struct snd_pcm_ops snd_usX2Y_usbpcm_ops =
581 {
582 	.open =		snd_usX2Y_usbpcm_open,
583 	.close =	snd_usX2Y_usbpcm_close,
584 	.hw_params =	snd_usX2Y_pcm_hw_params,
585 	.hw_free =	snd_usX2Y_usbpcm_hw_free,
586 	.prepare =	snd_usX2Y_usbpcm_prepare,
587 	.trigger =	snd_usX2Y_pcm_trigger,
588 	.pointer =	snd_usX2Y_pcm_pointer,
589 };
590 
591 
592 static int usX2Y_pcms_busy_check(struct snd_card *card)
593 {
594 	struct usX2Ydev	*dev = usX2Y(card);
595 	int i;
596 
597 	for (i = 0; i < dev->pcm_devs * 2; i++) {
598 		struct snd_usX2Y_substream *subs = dev->subs[i];
599 		if (subs && subs->pcm_substream &&
600 		    SUBSTREAM_BUSY(subs->pcm_substream))
601 			return -EBUSY;
602 	}
603 	return 0;
604 }
605 
606 static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file)
607 {
608 	struct snd_card *card = hw->card;
609 	int err;
610 
611 	mutex_lock(&usX2Y(card)->pcm_mutex);
612 	err = usX2Y_pcms_busy_check(card);
613 	if (!err)
614 		usX2Y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS;
615 	mutex_unlock(&usX2Y(card)->pcm_mutex);
616 	return err;
617 }
618 
619 
620 static int snd_usX2Y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file)
621 {
622 	struct snd_card *card = hw->card;
623 	int err;
624 
625 	mutex_lock(&usX2Y(card)->pcm_mutex);
626 	err = usX2Y_pcms_busy_check(card);
627 	if (!err)
628 		usX2Y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS;
629 	mutex_unlock(&usX2Y(card)->pcm_mutex);
630 	return err;
631 }
632 
633 
634 static void snd_usX2Y_hwdep_pcm_vm_open(struct vm_area_struct *area)
635 {
636 }
637 
638 
639 static void snd_usX2Y_hwdep_pcm_vm_close(struct vm_area_struct *area)
640 {
641 }
642 
643 
644 static vm_fault_t snd_usX2Y_hwdep_pcm_vm_fault(struct vm_fault *vmf)
645 {
646 	unsigned long offset;
647 	void *vaddr;
648 
649 	offset = vmf->pgoff << PAGE_SHIFT;
650 	vaddr = (char *)((struct usX2Ydev *)vmf->vma->vm_private_data)->hwdep_pcm_shm + offset;
651 	vmf->page = virt_to_page(vaddr);
652 	get_page(vmf->page);
653 	return 0;
654 }
655 
656 
657 static const struct vm_operations_struct snd_usX2Y_hwdep_pcm_vm_ops = {
658 	.open = snd_usX2Y_hwdep_pcm_vm_open,
659 	.close = snd_usX2Y_hwdep_pcm_vm_close,
660 	.fault = snd_usX2Y_hwdep_pcm_vm_fault,
661 };
662 
663 
664 static int snd_usX2Y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area)
665 {
666 	unsigned long	size = (unsigned long)(area->vm_end - area->vm_start);
667 	struct usX2Ydev	*usX2Y = hw->private_data;
668 
669 	if (!(usX2Y->chip_status & USX2Y_STAT_CHIP_INIT))
670 		return -EBUSY;
671 
672 	/* if userspace tries to mmap beyond end of our buffer, fail */
673 	if (size > PAGE_ALIGN(sizeof(struct snd_usX2Y_hwdep_pcm_shm))) {
674 		snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(struct snd_usX2Y_hwdep_pcm_shm));
675 		return -EINVAL;
676 	}
677 
678 	if (!usX2Y->hwdep_pcm_shm) {
679 		return -ENODEV;
680 	}
681 	area->vm_ops = &snd_usX2Y_hwdep_pcm_vm_ops;
682 	area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
683 	area->vm_private_data = hw->private_data;
684 	return 0;
685 }
686 
687 
688 static void snd_usX2Y_hwdep_pcm_private_free(struct snd_hwdep *hwdep)
689 {
690 	struct usX2Ydev *usX2Y = hwdep->private_data;
691 	if (NULL != usX2Y->hwdep_pcm_shm)
692 		free_pages_exact(usX2Y->hwdep_pcm_shm, sizeof(struct snd_usX2Y_hwdep_pcm_shm));
693 }
694 
695 
696 int usX2Y_hwdep_pcm_new(struct snd_card *card)
697 {
698 	int err;
699 	struct snd_hwdep *hw;
700 	struct snd_pcm *pcm;
701 	struct usb_device *dev = usX2Y(card)->dev;
702 	if (1 != nr_of_packs())
703 		return 0;
704 
705 	if ((err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw)) < 0)
706 		return err;
707 
708 	hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM;
709 	hw->private_data = usX2Y(card);
710 	hw->private_free = snd_usX2Y_hwdep_pcm_private_free;
711 	hw->ops.open = snd_usX2Y_hwdep_pcm_open;
712 	hw->ops.release = snd_usX2Y_hwdep_pcm_release;
713 	hw->ops.mmap = snd_usX2Y_hwdep_pcm_mmap;
714 	hw->exclusive = 1;
715 	sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum);
716 
717 	err = snd_pcm_new(card, NAME_ALLCAPS" hwdep Audio", 2, 1, 1, &pcm);
718 	if (err < 0) {
719 		return err;
720 	}
721 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usX2Y_usbpcm_ops);
722 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_usbpcm_ops);
723 
724 	pcm->private_data = usX2Y(card)->subs;
725 	pcm->info_flags = 0;
726 
727 	sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio");
728 	snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
729 				   SNDRV_DMA_TYPE_CONTINUOUS,
730 				   NULL,
731 				   64*1024, 128*1024);
732 	snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
733 				   SNDRV_DMA_TYPE_CONTINUOUS,
734 				   NULL,
735 				   64*1024, 128*1024);
736 
737 	return 0;
738 }
739 
740 #else
741 
742 int usX2Y_hwdep_pcm_new(struct snd_card *card)
743 {
744 	return 0;
745 }
746 
747 #endif
748