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