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 static int usx2y_usbpcm_urb_capt_retire(struct snd_usx2y_substream *subs)
50 {
51 struct urb *urb = subs->completed_urb;
52 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
53 int i, lens = 0, hwptr_done = subs->hwptr_done;
54 struct usx2ydev *usx2y = subs->usx2y;
55 int head;
56
57 if (usx2y->hwdep_pcm_shm->capture_iso_start < 0) { //FIXME
58 head = usx2y->hwdep_pcm_shm->captured_iso_head + 1;
59 if (head >= ARRAY_SIZE(usx2y->hwdep_pcm_shm->captured_iso))
60 head = 0;
61 usx2y->hwdep_pcm_shm->capture_iso_start = head;
62 snd_printdd("cap start %i\n", head);
63 }
64 for (i = 0; i < nr_of_packs(); i++) {
65 if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */
66 snd_printk(KERN_ERR
67 "active frame status %i. Most probably some hardware problem.\n",
68 urb->iso_frame_desc[i].status);
69 return urb->iso_frame_desc[i].status;
70 }
71 lens += urb->iso_frame_desc[i].actual_length / usx2y->stride;
72 }
73 hwptr_done += lens;
74 if (hwptr_done >= runtime->buffer_size)
75 hwptr_done -= runtime->buffer_size;
76 subs->hwptr_done = hwptr_done;
77 subs->transfer_done += lens;
78 /* update the pointer, call callback if necessary */
79 if (subs->transfer_done >= runtime->period_size) {
80 subs->transfer_done -= runtime->period_size;
81 snd_pcm_period_elapsed(subs->pcm_substream);
82 }
83 return 0;
84 }
85
86 static int usx2y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime,
87 struct usx2ydev *usx2y)
88 {
89 return (runtime->buffer_size * 1000) / usx2y->rate + 1; //FIXME: so far only correct period_size == 2^x ?
90 }
91
92 /*
93 * prepare urb for playback data pipe
94 *
95 * we copy the data directly from the pcm buffer.
96 * the current position to be copied is held in hwptr field.
97 * since a urb can handle only a single linear buffer, if the total
98 * transferred area overflows the buffer boundary, we cannot send
99 * it directly from the buffer. thus the data is once copied to
100 * a temporary buffer and urb points to that.
101 */
102 static int usx2y_hwdep_urb_play_prepare(struct snd_usx2y_substream *subs,
103 struct urb *urb)
104 {
105 int count, counts, pack;
106 struct usx2ydev *usx2y = subs->usx2y;
107 struct snd_usx2y_hwdep_pcm_shm *shm = usx2y->hwdep_pcm_shm;
108 struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
109
110 if (shm->playback_iso_start < 0) {
111 shm->playback_iso_start = shm->captured_iso_head -
112 usx2y_iso_frames_per_buffer(runtime, usx2y);
113 if (shm->playback_iso_start < 0)
114 shm->playback_iso_start += ARRAY_SIZE(shm->captured_iso);
115 shm->playback_iso_head = shm->playback_iso_start;
116 }
117
118 count = 0;
119 for (pack = 0; pack < nr_of_packs(); pack++) {
120 /* calculate the size of a packet */
121 counts = shm->captured_iso[shm->playback_iso_head].length / usx2y->stride;
122 if (counts < 43 || counts > 50) {
123 snd_printk(KERN_ERR "should not be here with counts=%i\n", counts);
124 return -EPIPE;
125 }
126 /* set up descriptor */
127 urb->iso_frame_desc[pack].offset = shm->captured_iso[shm->playback_iso_head].offset;
128 urb->iso_frame_desc[pack].length = shm->captured_iso[shm->playback_iso_head].length;
129 if (atomic_read(&subs->state) != STATE_RUNNING)
130 memset((char *)urb->transfer_buffer + urb->iso_frame_desc[pack].offset, 0,
131 urb->iso_frame_desc[pack].length);
132 if (++shm->playback_iso_head >= ARRAY_SIZE(shm->captured_iso))
133 shm->playback_iso_head = 0;
134 count += counts;
135 }
136 urb->transfer_buffer_length = count * usx2y->stride;
137 return 0;
138 }
139
140 static void usx2y_usbpcm_urb_capt_iso_advance(struct snd_usx2y_substream *subs,
141 struct urb *urb)
142 {
143 struct usb_iso_packet_descriptor *desc;
144 struct snd_usx2y_hwdep_pcm_shm *shm;
145 int pack, head;
146
147 for (pack = 0; pack < nr_of_packs(); ++pack) {
148 desc = urb->iso_frame_desc + pack;
149 if (subs) {
150 shm = subs->usx2y->hwdep_pcm_shm;
151 head = shm->captured_iso_head + 1;
152 if (head >= ARRAY_SIZE(shm->captured_iso))
153 head = 0;
154 shm->captured_iso[head].frame = urb->start_frame + pack;
155 shm->captured_iso[head].offset = desc->offset;
156 shm->captured_iso[head].length = desc->actual_length;
157 shm->captured_iso_head = head;
158 shm->captured_iso_frames++;
159 }
160 desc->offset += desc->length * NRURBS * nr_of_packs();
161 if (desc->offset + desc->length >= SSS)
162 desc->offset -= (SSS - desc->length);
163 }
164 }
165
166 static int usx2y_usbpcm_usbframe_complete(struct snd_usx2y_substream *capsubs,
167 struct snd_usx2y_substream *capsubs2,
168 struct snd_usx2y_substream *playbacksubs,
169 int frame)
170 {
171 int err, state;
172 struct urb *urb = playbacksubs->completed_urb;
173
174 state = atomic_read(&playbacksubs->state);
175 if (urb) {
176 if (state == STATE_RUNNING)
177 usx2y_urb_play_retire(playbacksubs, urb);
178 else if (state >= STATE_PRERUNNING)
179 atomic_inc(&playbacksubs->state);
180 } else {
181 switch (state) {
182 case STATE_STARTING1:
183 urb = playbacksubs->urb[0];
184 atomic_inc(&playbacksubs->state);
185 break;
186 case STATE_STARTING2:
187 urb = playbacksubs->urb[1];
188 atomic_inc(&playbacksubs->state);
189 break;
190 }
191 }
192 if (urb) {
193 err = usx2y_hwdep_urb_play_prepare(playbacksubs, urb);
194 if (err)
195 return err;
196 err = usx2y_hwdep_urb_play_prepare(playbacksubs, urb);
197 if (err)
198 return err;
199 }
200
201 playbacksubs->completed_urb = NULL;
202
203 state = atomic_read(&capsubs->state);
204 if (state >= STATE_PREPARED) {
205 if (state == STATE_RUNNING) {
206 err = usx2y_usbpcm_urb_capt_retire(capsubs);
207 if (err)
208 return err;
209 } else if (state >= STATE_PRERUNNING) {
210 atomic_inc(&capsubs->state);
211 }
212 usx2y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb);
213 if (capsubs2)
214 usx2y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb);
215 err = usx2y_urb_submit(capsubs, capsubs->completed_urb, frame);
216 if (err)
217 return err;
218 if (capsubs2) {
219 err = usx2y_urb_submit(capsubs2, capsubs2->completed_urb, frame);
220 if (err)
221 return err;
222 }
223 }
224 capsubs->completed_urb = NULL;
225 if (capsubs2)
226 capsubs2->completed_urb = NULL;
227 return 0;
228 }
229
230 static void i_usx2y_usbpcm_urb_complete(struct urb *urb)
231 {
232 struct snd_usx2y_substream *subs = urb->context;
233 struct usx2ydev *usx2y = subs->usx2y;
234 struct snd_usx2y_substream *capsubs, *capsubs2, *playbacksubs;
235
236 if (unlikely(atomic_read(&subs->state) < STATE_PREPARED)) {
237 snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
238 usb_get_current_frame_number(usx2y->dev),
239 subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
240 urb->status, urb->start_frame);
241 return;
242 }
243 if (unlikely(urb->status)) {
244 usx2y_error_urb_status(usx2y, subs, urb);
245 return;
246 }
247
248 subs->completed_urb = urb;
249 capsubs = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE];
250 capsubs2 = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
251 playbacksubs = usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK];
252 if (capsubs->completed_urb && atomic_read(&capsubs->state) >= STATE_PREPARED &&
253 (!capsubs2 || capsubs2->completed_urb) &&
254 (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < STATE_PREPARED)) {
255 if (!usx2y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame)) {
256 usx2y->wait_iso_frame += nr_of_packs();
257 } else {
258 snd_printdd("\n");
259 usx2y_clients_stop(usx2y);
260 }
261 }
262 }
263
264 static void usx2y_hwdep_urb_release(struct urb **urb)
265 {
266 usb_kill_urb(*urb);
267 usb_free_urb(*urb);
268 *urb = NULL;
269 }
270
271 /*
272 * release a substream
273 */
274 static void usx2y_usbpcm_urbs_release(struct snd_usx2y_substream *subs)
275 {
276 int i;
277
278 snd_printdd("snd_usx2y_urbs_release() %i\n", subs->endpoint);
279 for (i = 0; i < NRURBS; i++)
280 usx2y_hwdep_urb_release(subs->urb + i);
281 }
282
283 static void usx2y_usbpcm_subs_startup_finish(struct usx2ydev *usx2y)
284 {
285 usx2y_urbs_set_complete(usx2y, i_usx2y_usbpcm_urb_complete);
286 usx2y->prepare_subs = NULL;
287 }
288
289 static void i_usx2y_usbpcm_subs_startup(struct urb *urb)
290 {
291 struct snd_usx2y_substream *subs = urb->context;
292 struct usx2ydev *usx2y = subs->usx2y;
293 struct snd_usx2y_substream *prepare_subs = usx2y->prepare_subs;
294 struct snd_usx2y_substream *cap_subs2;
295
296 if (prepare_subs &&
297 urb->start_frame == prepare_subs->urb[0]->start_frame) {
298 atomic_inc(&prepare_subs->state);
299 if (prepare_subs == usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]) {
300 cap_subs2 = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
301 if (cap_subs2)
302 atomic_inc(&cap_subs2->state);
303 }
304 usx2y_usbpcm_subs_startup_finish(usx2y);
305 wake_up(&usx2y->prepare_wait_queue);
306 }
307
308 i_usx2y_usbpcm_urb_complete(urb);
309 }
310
311 /*
312 * initialize a substream's urbs
313 */
314 static int usx2y_usbpcm_urbs_allocate(struct snd_usx2y_substream *subs)
315 {
316 int i;
317 unsigned int pipe;
318 int is_playback = subs == subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK];
319 struct usb_device *dev = subs->usx2y->dev;
320 struct urb **purb;
321
322 pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
323 usb_rcvisocpipe(dev, subs->endpoint);
324 subs->maxpacksize = usb_maxpacket(dev, pipe);
325 if (!subs->maxpacksize)
326 return -EINVAL;
327
328 /* allocate and initialize data urbs */
329 for (i = 0; i < NRURBS; i++) {
330 purb = subs->urb + i;
331 if (*purb) {
332 usb_kill_urb(*purb);
333 continue;
334 }
335 *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL);
336 if (!*purb) {
337 usx2y_usbpcm_urbs_release(subs);
338 return -ENOMEM;
339 }
340 (*purb)->transfer_buffer = is_playback ?
341 subs->usx2y->hwdep_pcm_shm->playback : (
342 subs->endpoint == 0x8 ?
343 subs->usx2y->hwdep_pcm_shm->capture0x8 :
344 subs->usx2y->hwdep_pcm_shm->capture0xA);
345
346 (*purb)->dev = dev;
347 (*purb)->pipe = pipe;
348 (*purb)->number_of_packets = nr_of_packs();
349 (*purb)->context = subs;
350 (*purb)->interval = 1;
351 (*purb)->complete = i_usx2y_usbpcm_subs_startup;
352 }
353 return 0;
354 }
355
356 /*
357 * free the buffer
358 */
359 static int snd_usx2y_usbpcm_hw_free(struct snd_pcm_substream *substream)
360 {
361 struct snd_pcm_runtime *runtime = substream->runtime;
362 struct snd_usx2y_substream *subs = runtime->private_data;
363 struct snd_usx2y_substream *cap_subs;
364 struct snd_usx2y_substream *playback_subs;
365 struct snd_usx2y_substream *cap_subs2;
366
367 mutex_lock(&subs->usx2y->pcm_mutex);
368 snd_printdd("%s(%p)\n", __func__, substream);
369
370 cap_subs2 = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
371 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
372 cap_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE];
373 atomic_set(&subs->state, STATE_STOPPED);
374 usx2y_usbpcm_urbs_release(subs);
375 if (!cap_subs->pcm_substream ||
376 !cap_subs->pcm_substream->runtime ||
377 cap_subs->pcm_substream->runtime->state < SNDRV_PCM_STATE_PREPARED) {
378 atomic_set(&cap_subs->state, STATE_STOPPED);
379 if (cap_subs2)
380 atomic_set(&cap_subs2->state, STATE_STOPPED);
381 usx2y_usbpcm_urbs_release(cap_subs);
382 if (cap_subs2)
383 usx2y_usbpcm_urbs_release(cap_subs2);
384 }
385 } else {
386 playback_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK];
387 if (atomic_read(&playback_subs->state) < STATE_PREPARED) {
388 atomic_set(&subs->state, STATE_STOPPED);
389 if (cap_subs2)
390 atomic_set(&cap_subs2->state, STATE_STOPPED);
391 usx2y_usbpcm_urbs_release(subs);
392 if (cap_subs2)
393 usx2y_usbpcm_urbs_release(cap_subs2);
394 }
395 }
396 mutex_unlock(&subs->usx2y->pcm_mutex);
397 return 0;
398 }
399
400 static void usx2y_usbpcm_subs_startup(struct snd_usx2y_substream *subs)
401 {
402 struct usx2ydev *usx2y = subs->usx2y;
403
404 usx2y->prepare_subs = subs;
405 subs->urb[0]->start_frame = -1;
406 smp_wmb(); // Make sure above modifications are seen by i_usx2y_subs_startup()
407 usx2y_urbs_set_complete(usx2y, i_usx2y_usbpcm_subs_startup);
408 }
409
410 static int usx2y_usbpcm_urbs_start(struct snd_usx2y_substream *subs)
411 {
412 int p, u, err, stream = subs->pcm_substream->stream;
413 struct usx2ydev *usx2y = subs->usx2y;
414 struct urb *urb;
415 unsigned long pack;
416
417 if (stream == SNDRV_PCM_STREAM_CAPTURE) {
418 usx2y->hwdep_pcm_shm->captured_iso_head = -1;
419 usx2y->hwdep_pcm_shm->captured_iso_frames = 0;
420 }
421
422 for (p = 0; 3 >= (stream + p); p += 2) {
423 struct snd_usx2y_substream *subs = usx2y->subs[stream + p];
424 if (subs) {
425 err = usx2y_usbpcm_urbs_allocate(subs);
426 if (err < 0)
427 return err;
428 subs->completed_urb = NULL;
429 }
430 }
431
432 for (p = 0; p < 4; p++) {
433 struct snd_usx2y_substream *subs = usx2y->subs[p];
434
435 if (subs && atomic_read(&subs->state) >= STATE_PREPARED)
436 goto start;
437 }
438
439 start:
440 usx2y_usbpcm_subs_startup(subs);
441 for (u = 0; u < NRURBS; u++) {
442 for (p = 0; 3 >= (stream + p); p += 2) {
443 struct snd_usx2y_substream *subs = usx2y->subs[stream + p];
444
445 if (!subs)
446 continue;
447 urb = subs->urb[u];
448 if (usb_pipein(urb->pipe)) {
449 if (!u)
450 atomic_set(&subs->state, STATE_STARTING3);
451 urb->dev = usx2y->dev;
452 for (pack = 0; pack < nr_of_packs(); pack++) {
453 urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs());
454 urb->iso_frame_desc[pack].length = subs->maxpacksize;
455 }
456 urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs();
457 err = usb_submit_urb(urb, GFP_KERNEL);
458 if (err < 0) {
459 snd_printk(KERN_ERR "cannot usb_submit_urb() for urb %d, err = %d\n", u, err);
460 err = -EPIPE;
461 goto cleanup;
462 } else {
463 snd_printdd("%i\n", urb->start_frame);
464 if (!u)
465 usx2y->wait_iso_frame = urb->start_frame;
466 }
467 urb->transfer_flags = 0;
468 } else {
469 atomic_set(&subs->state, STATE_STARTING1);
470 break;
471 }
472 }
473 }
474 err = 0;
475 wait_event(usx2y->prepare_wait_queue, !usx2y->prepare_subs);
476 if (atomic_read(&subs->state) != STATE_PREPARED)
477 err = -EPIPE;
478
479 cleanup:
480 if (err) {
481 usx2y_subs_startup_finish(usx2y); // Call it now
482 usx2y_clients_stop(usx2y); // something is completely wrong > stop everything
483 }
484 return err;
485 }
486
487 #define USX2Y_HWDEP_PCM_PAGES \
488 PAGE_ALIGN(sizeof(struct snd_usx2y_hwdep_pcm_shm))
489
490 /*
491 * prepare callback
492 *
493 * set format and initialize urbs
494 */
495 static int snd_usx2y_usbpcm_prepare(struct snd_pcm_substream *substream)
496 {
497 struct snd_pcm_runtime *runtime = substream->runtime;
498 struct snd_usx2y_substream *subs = runtime->private_data;
499 struct usx2ydev *usx2y = subs->usx2y;
500 struct snd_usx2y_substream *capsubs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE];
501 int err = 0;
502
503 snd_printdd("snd_usx2y_pcm_prepare(%p)\n", substream);
504
505 mutex_lock(&usx2y->pcm_mutex);
506
507 if (!usx2y->hwdep_pcm_shm) {
508 usx2y->hwdep_pcm_shm = alloc_pages_exact(USX2Y_HWDEP_PCM_PAGES,
509 GFP_KERNEL);
510 if (!usx2y->hwdep_pcm_shm) {
511 err = -ENOMEM;
512 goto up_prepare_mutex;
513 }
514 memset(usx2y->hwdep_pcm_shm, 0, USX2Y_HWDEP_PCM_PAGES);
515 }
516
517 usx2y_subs_prepare(subs);
518 // Start hardware streams
519 // SyncStream first....
520 if (atomic_read(&capsubs->state) < STATE_PREPARED) {
521 if (usx2y->format != runtime->format) {
522 err = usx2y_format_set(usx2y, runtime->format);
523 if (err < 0)
524 goto up_prepare_mutex;
525 }
526 if (usx2y->rate != runtime->rate) {
527 err = usx2y_rate_set(usx2y, runtime->rate);
528 if (err < 0)
529 goto up_prepare_mutex;
530 }
531 snd_printdd("starting capture pipe for %s\n", subs == capsubs ?
532 "self" : "playpipe");
533 err = usx2y_usbpcm_urbs_start(capsubs);
534 if (err < 0)
535 goto up_prepare_mutex;
536 }
537
538 if (subs != capsubs) {
539 usx2y->hwdep_pcm_shm->playback_iso_start = -1;
540 if (atomic_read(&subs->state) < STATE_PREPARED) {
541 while (usx2y_iso_frames_per_buffer(runtime, usx2y) >
542 usx2y->hwdep_pcm_shm->captured_iso_frames) {
543 snd_printdd("Wait: iso_frames_per_buffer=%i,captured_iso_frames=%i\n",
544 usx2y_iso_frames_per_buffer(runtime, usx2y),
545 usx2y->hwdep_pcm_shm->captured_iso_frames);
546 if (msleep_interruptible(10)) {
547 err = -ERESTARTSYS;
548 goto up_prepare_mutex;
549 }
550 }
551 err = usx2y_usbpcm_urbs_start(subs);
552 if (err < 0)
553 goto up_prepare_mutex;
554 }
555 snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n",
556 usx2y_iso_frames_per_buffer(runtime, usx2y),
557 usx2y->hwdep_pcm_shm->captured_iso_frames);
558 } else {
559 usx2y->hwdep_pcm_shm->capture_iso_start = -1;
560 }
561
562 up_prepare_mutex:
563 mutex_unlock(&usx2y->pcm_mutex);
564 return err;
565 }
566
567 static const struct snd_pcm_hardware snd_usx2y_4c = {
568 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
569 SNDRV_PCM_INFO_BLOCK_TRANSFER |
570 SNDRV_PCM_INFO_MMAP_VALID),
571 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
572 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
573 .rate_min = 44100,
574 .rate_max = 48000,
575 .channels_min = 2,
576 .channels_max = 4,
577 .buffer_bytes_max = (2*128*1024),
578 .period_bytes_min = 64,
579 .period_bytes_max = (128*1024),
580 .periods_min = 2,
581 .periods_max = 1024,
582 .fifo_size = 0
583 };
584
585 static int snd_usx2y_usbpcm_open(struct snd_pcm_substream *substream)
586 {
587 struct snd_usx2y_substream *subs =
588 ((struct snd_usx2y_substream **)
589 snd_pcm_substream_chip(substream))[substream->stream];
590 struct snd_pcm_runtime *runtime = substream->runtime;
591
592 if (!(subs->usx2y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS))
593 return -EBUSY;
594
595 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
596 runtime->hw = snd_usx2y_2c;
597 else
598 runtime->hw = (subs->usx2y->subs[3] ? snd_usx2y_4c : snd_usx2y_2c);
599 runtime->private_data = subs;
600 subs->pcm_substream = substream;
601 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000);
602 return 0;
603 }
604
605 static int snd_usx2y_usbpcm_close(struct snd_pcm_substream *substream)
606 {
607 struct snd_pcm_runtime *runtime = substream->runtime;
608 struct snd_usx2y_substream *subs = runtime->private_data;
609
610 subs->pcm_substream = NULL;
611 return 0;
612 }
613
614 static const struct snd_pcm_ops snd_usx2y_usbpcm_ops = {
615 .open = snd_usx2y_usbpcm_open,
616 .close = snd_usx2y_usbpcm_close,
617 .hw_params = snd_usx2y_pcm_hw_params,
618 .hw_free = snd_usx2y_usbpcm_hw_free,
619 .prepare = snd_usx2y_usbpcm_prepare,
620 .trigger = snd_usx2y_pcm_trigger,
621 .pointer = snd_usx2y_pcm_pointer,
622 };
623
624 static int usx2y_pcms_busy_check(struct snd_card *card)
625 {
626 struct usx2ydev *dev = usx2y(card);
627 struct snd_usx2y_substream *subs;
628 int i;
629
630 for (i = 0; i < dev->pcm_devs * 2; i++) {
631 subs = dev->subs[i];
632 if (subs && subs->pcm_substream &&
633 SUBSTREAM_BUSY(subs->pcm_substream))
634 return -EBUSY;
635 }
636 return 0;
637 }
638
639 static int snd_usx2y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file)
640 {
641 struct snd_card *card = hw->card;
642 int err;
643
644 mutex_lock(&usx2y(card)->pcm_mutex);
645 err = usx2y_pcms_busy_check(card);
646 if (!err)
647 usx2y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS;
648 mutex_unlock(&usx2y(card)->pcm_mutex);
649 return err;
650 }
651
652 static int snd_usx2y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file)
653 {
654 struct snd_card *card = hw->card;
655 int err;
656
657 mutex_lock(&usx2y(card)->pcm_mutex);
658 err = usx2y_pcms_busy_check(card);
659 if (!err)
660 usx2y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS;
661 mutex_unlock(&usx2y(card)->pcm_mutex);
662 return err;
663 }
664
665 static void snd_usx2y_hwdep_pcm_vm_open(struct vm_area_struct *area)
666 {
667 }
668
669 static void snd_usx2y_hwdep_pcm_vm_close(struct vm_area_struct *area)
670 {
671 }
672
673 static vm_fault_t snd_usx2y_hwdep_pcm_vm_fault(struct vm_fault *vmf)
674 {
675 unsigned long offset;
676 void *vaddr;
677
678 offset = vmf->pgoff << PAGE_SHIFT;
679 vaddr = (char *)((struct usx2ydev *)vmf->vma->vm_private_data)->hwdep_pcm_shm + offset;
680 vmf->page = virt_to_page(vaddr);
681 get_page(vmf->page);
682 return 0;
683 }
684
685 static const struct vm_operations_struct snd_usx2y_hwdep_pcm_vm_ops = {
686 .open = snd_usx2y_hwdep_pcm_vm_open,
687 .close = snd_usx2y_hwdep_pcm_vm_close,
688 .fault = snd_usx2y_hwdep_pcm_vm_fault,
689 };
690
691 static int snd_usx2y_hwdep_pcm_mmap(struct snd_hwdep *hw, struct file *filp, struct vm_area_struct *area)
692 {
693 unsigned long size = (unsigned long)(area->vm_end - area->vm_start);
694 struct usx2ydev *usx2y = hw->private_data;
695
696 if (!(usx2y->chip_status & USX2Y_STAT_CHIP_INIT))
697 return -EBUSY;
698
699 /* if userspace tries to mmap beyond end of our buffer, fail */
700 if (size > USX2Y_HWDEP_PCM_PAGES) {
701 snd_printd("%lu > %lu\n", size, (unsigned long)USX2Y_HWDEP_PCM_PAGES);
702 return -EINVAL;
703 }
704
705 if (!usx2y->hwdep_pcm_shm)
706 return -ENODEV;
707
708 area->vm_ops = &snd_usx2y_hwdep_pcm_vm_ops;
709 vm_flags_set(area, VM_DONTEXPAND | VM_DONTDUMP);
710 area->vm_private_data = hw->private_data;
711 return 0;
712 }
713
714 static void snd_usx2y_hwdep_pcm_private_free(struct snd_hwdep *hwdep)
715 {
716 struct usx2ydev *usx2y = hwdep->private_data;
717
718 if (usx2y->hwdep_pcm_shm)
719 free_pages_exact(usx2y->hwdep_pcm_shm, USX2Y_HWDEP_PCM_PAGES);
720 }
721
722 int usx2y_hwdep_pcm_new(struct snd_card *card)
723 {
724 int err;
725 struct snd_hwdep *hw;
726 struct snd_pcm *pcm;
727 struct usb_device *dev = usx2y(card)->dev;
728
729 if (nr_of_packs() != 1)
730 return 0;
731
732 err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw);
733 if (err < 0)
734 return err;
735
736 hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM;
737 hw->private_data = usx2y(card);
738 hw->private_free = snd_usx2y_hwdep_pcm_private_free;
739 hw->ops.open = snd_usx2y_hwdep_pcm_open;
740 hw->ops.release = snd_usx2y_hwdep_pcm_release;
741 hw->ops.mmap = snd_usx2y_hwdep_pcm_mmap;
742 hw->exclusive = 1;
743 sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum);
744
745 err = snd_pcm_new(card, NAME_ALLCAPS" hwdep Audio", 2, 1, 1, &pcm);
746 if (err < 0)
747 return err;
748
749 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usx2y_usbpcm_ops);
750 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usx2y_usbpcm_ops);
751
752 pcm->private_data = usx2y(card)->subs;
753 pcm->info_flags = 0;
754
755 sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio");
756 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
757 SNDRV_DMA_TYPE_CONTINUOUS,
758 NULL,
759 64*1024, 128*1024);
760 snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
761 SNDRV_DMA_TYPE_CONTINUOUS,
762 NULL,
763 64*1024, 128*1024);
764
765 return 0;
766 }
767
768 #else
769
770 int usx2y_hwdep_pcm_new(struct snd_card *card)
771 {
772 return 0;
773 }
774
775 #endif
776
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.