projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging/easycap: reduce code nesting in easycap_sound.c
[deliverable/linux.git] / drivers / staging / easycap / easycap_sound.c
1 /******************************************************************************
2 * *
3 * easycap_sound.c *
4 * *
5 * Audio driver for EasyCAP USB2.0 Video Capture Device DC60 *
6 * *
7 * *
8 ******************************************************************************/
9 /*
10 *
11 * Copyright (C) 2010 R.M. Thomas <rmthomas@sciolus.org>
12 *
13 *
14 * This is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * The software is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this software; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 *
28 */
29 /*****************************************************************************/
30
31 #include "easycap.h"
32
33 #ifndef CONFIG_EASYCAP_OSS
34 /*--------------------------------------------------------------------------*/
35 /*
36 * PARAMETERS USED WHEN REGISTERING THE AUDIO INTERFACE
37 */
38 /*--------------------------------------------------------------------------*/
39 static const struct snd_pcm_hardware alsa_hardware = {
40 .info = SNDRV_PCM_INFO_BLOCK_TRANSFER |
41 SNDRV_PCM_INFO_MMAP |
42 SNDRV_PCM_INFO_INTERLEAVED |
43 SNDRV_PCM_INFO_MMAP_VALID,
44 .formats = SNDRV_PCM_FMTBIT_S16_LE,
45 .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_48000,
46 .rate_min = 32000,
47 .rate_max = 48000,
48 .channels_min = 2,
49 .channels_max = 2,
50 .buffer_bytes_max = PAGE_SIZE *
51 PAGES_PER_AUDIO_FRAGMENT *
52 AUDIO_FRAGMENT_MANY,
53 .period_bytes_min = PAGE_SIZE * PAGES_PER_AUDIO_FRAGMENT,
54 .period_bytes_max = PAGE_SIZE * PAGES_PER_AUDIO_FRAGMENT * 2,
55 .periods_min = AUDIO_FRAGMENT_MANY,
56 .periods_max = AUDIO_FRAGMENT_MANY * 2,
57 };
58
59
60 /*****************************************************************************/
61 /*---------------------------------------------------------------------------*/
62 /*
63 * ON COMPLETION OF AN AUDIO URB ITS DATA IS COPIED TO THE DAM BUFFER
64 * PROVIDED peasycap->audio_idle IS ZERO. REGARDLESS OF THIS BEING TRUE,
65 * IT IS RESUBMITTED PROVIDED peasycap->audio_isoc_streaming IS NOT ZERO.
66 */
67 /*---------------------------------------------------------------------------*/
68 void
69 easycap_alsa_complete(struct urb *purb)
70 {
71 struct easycap *peasycap;
72 struct snd_pcm_substream *pss;
73 struct snd_pcm_runtime *prt;
74 int dma_bytes, fragment_bytes;
75 int isfragment;
76 u8 *p1, *p2;
77 s16 tmp;
78 int i, j, more, much, rc;
79 #ifdef UPSAMPLE
80 int k;
81 s16 oldaudio, newaudio, delta;
82 #endif /*UPSAMPLE*/
83
84 JOT(16, "\n");
85
86 if (!purb) {
87 SAY("ERROR: purb is NULL\n");
88 return;
89 }
90 peasycap = purb->context;
91 if (!peasycap) {
92 SAY("ERROR: peasycap is NULL\n");
93 return;
94 }
95 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
96 SAY("ERROR: bad peasycap\n");
97 return;
98 }
99 much = 0;
100 if (peasycap->audio_idle) {
101 JOM(16, "%i=audio_idle %i=audio_isoc_streaming\n",
102 peasycap->audio_idle, peasycap->audio_isoc_streaming);
103 if (peasycap->audio_isoc_streaming)
104 goto resubmit;
105 }
106 /*---------------------------------------------------------------------------*/
107 pss = peasycap->psubstream;
108 if (!pss)
109 goto resubmit;
110 prt = pss->runtime;
111 if (!prt)
112 goto resubmit;
113 dma_bytes = (int)prt->dma_bytes;
114 if (0 == dma_bytes)
115 goto resubmit;
116 fragment_bytes = 4 * ((int)prt->period_size);
117 if (0 == fragment_bytes)
118 goto resubmit;
119 /* -------------------------------------------------------------------------*/
120 if (purb->status) {
121 if ((-ESHUTDOWN == purb->status) || (-ENOENT == purb->status)) {
122 JOM(16, "urb status -ESHUTDOWN or -ENOENT\n");
123 return;
124 }
125 SAM("ERROR: non-zero urb status: -%s: %d\n",
126 strerror(purb->status), purb->status);
127 goto resubmit;
128 }
129 /*---------------------------------------------------------------------------*/
130 /*
131 * PROCEED HERE WHEN NO ERROR
132 */
133 /*---------------------------------------------------------------------------*/
134
135 #ifdef UPSAMPLE
136 oldaudio = peasycap->oldaudio;
137 #endif /*UPSAMPLE*/
138
139 for (i = 0; i < purb->number_of_packets; i++) {
140 if (purb->iso_frame_desc[i].status < 0) {
141 SAM("-%s: %d\n",
142 strerror(purb->iso_frame_desc[i].status),
143 purb->iso_frame_desc[i].status);
144 }
145 if (purb->iso_frame_desc[i].status) {
146 JOM(12, "discarding audio samples because "
147 "%i=purb->iso_frame_desc[i].status\n",
148 purb->iso_frame_desc[i].status);
149 continue;
150 }
151 more = purb->iso_frame_desc[i].actual_length;
152 if (more == 0) {
153 peasycap->audio_mt++;
154 continue;
155 }
156 if (0 > more) {
157 SAM("MISTAKE: more is negative\n");
158 return;
159 }
160
161 if (peasycap->audio_mt) {
162 JOM(12, "%4i empty audio urb frames\n",
163 peasycap->audio_mt);
164 peasycap->audio_mt = 0;
165 }
166
167 p1 = (u8 *)(purb->transfer_buffer +
168 purb->iso_frame_desc[i].offset);
169
170 /*
171 * COPY more BYTES FROM ISOC BUFFER
172 * TO THE DMA BUFFER, CONVERTING
173 * 8-BIT MONO TO 16-BIT SIGNED
174 * LITTLE-ENDIAN SAMPLES IF NECESSARY
175 */
176 while (more) {
177 much = dma_bytes - peasycap->dma_fill;
178 if (0 > much) {
179 SAM("MISTAKE: much is negative\n");
180 return;
181 }
182 if (0 == much) {
183 peasycap->dma_fill = 0;
184 peasycap->dma_next = fragment_bytes;
185 JOM(8, "wrapped dma buffer\n");
186 }
187 if (!peasycap->microphone) {
188 if (much > more)
189 much = more;
190 memcpy(prt->dma_area + peasycap->dma_fill,
191 p1, much);
192 p1 += much;
193 more -= much;
194 } else {
195 #ifdef UPSAMPLE
196 if (much % 16)
197 JOM(8, "MISTAKE? much"
198 " is not divisible by 16\n");
199 if (much > (16 * more))
200 much = 16 * more;
201 p2 = (u8 *)(prt->dma_area + peasycap->dma_fill);
202
203 for (j = 0; j < (much / 16); j++) {
204 newaudio = ((int) *p1) - 128;
205 newaudio = 128 * newaudio;
206
207 delta = (newaudio - oldaudio) / 4;
208 tmp = oldaudio + delta;
209
210 for (k = 0; k < 4; k++) {
211 *p2 = (0x00FF & tmp);
212 *(p2 + 1) = (0xFF00 & tmp) >> 8;
213 p2 += 2;
214 *p2 = (0x00FF & tmp);
215 *(p2 + 1) = (0xFF00 & tmp) >> 8;
216 p2 += 2;
217 tmp += delta;
218 }
219 p1++;
220 more--;
221 oldaudio = tmp;
222 }
223 #else /*!UPSAMPLE*/
224 if (much > (2 * more))
225 much = 2 * more;
226 p2 = (u8 *)(prt->dma_area + peasycap->dma_fill);
227
228 for (j = 0; j < (much / 2); j++) {
229 tmp = ((int) *p1) - 128;
230 tmp = 128 * tmp;
231 *p2 = (0x00FF & tmp);
232 *(p2 + 1) = (0xFF00 & tmp) >> 8;
233 p1++;
234 p2 += 2;
235 more--;
236 }
237 #endif /*UPSAMPLE*/
238 }
239 peasycap->dma_fill += much;
240 if (peasycap->dma_fill >= peasycap->dma_next) {
241 isfragment = peasycap->dma_fill / fragment_bytes;
242 if (0 > isfragment) {
243 SAM("MISTAKE: isfragment is negative\n");
244 return;
245 }
246 peasycap->dma_read = (isfragment - 1) * fragment_bytes;
247 peasycap->dma_next = (isfragment + 1) * fragment_bytes;
248 if (dma_bytes < peasycap->dma_next)
249 peasycap->dma_next = fragment_bytes;
250
251 if (0 <= peasycap->dma_read) {
252 JOM(8, "snd_pcm_period_elapsed(), %i="
253 "isfragment\n", isfragment);
254 snd_pcm_period_elapsed(pss);
255 }
256 }
257 }
258
259 #ifdef UPSAMPLE
260 peasycap->oldaudio = oldaudio;
261 #endif /*UPSAMPLE*/
262
263 }
264 /*---------------------------------------------------------------------------*/
265 /*
266 * RESUBMIT THIS URB
267 */
268 /*---------------------------------------------------------------------------*/
269 resubmit:
270 if (peasycap->audio_isoc_streaming == 0)
271 return;
272
273 rc = usb_submit_urb(purb, GFP_ATOMIC);
274 if (rc) {
275 if ((-ENODEV != rc) && (-ENOENT != rc)) {
276 SAM("ERROR: while %i=audio_idle, usb_submit_urb failed "
277 "with rc: -%s :%d\n",
278 peasycap->audio_idle, strerror(rc), rc);
279 }
280 if (0 < peasycap->audio_isoc_streaming)
281 peasycap->audio_isoc_streaming--;
282 }
283 return;
284 }
285 /*****************************************************************************/
286 static int easycap_alsa_open(struct snd_pcm_substream *pss)
287 {
288 struct snd_pcm *psnd_pcm;
289 struct snd_card *psnd_card;
290 struct easycap *peasycap;
291
292 JOT(4, "\n");
293 if (!pss) {
294 SAY("ERROR: pss is NULL\n");
295 return -EFAULT;
296 }
297 psnd_pcm = pss->pcm;
298 if (!psnd_pcm) {
299 SAY("ERROR: psnd_pcm is NULL\n");
300 return -EFAULT;
301 }
302 psnd_card = psnd_pcm->card;
303 if (!psnd_card) {
304 SAY("ERROR: psnd_card is NULL\n");
305 return -EFAULT;
306 }
307
308 peasycap = psnd_card->private_data;
309 if (!peasycap) {
310 SAY("ERROR: peasycap is NULL\n");
311 return -EFAULT;
312 }
313 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
314 SAY("ERROR: bad peasycap\n");
315 return -EFAULT;
316 }
317 if (peasycap->psnd_card != psnd_card) {
318 SAM("ERROR: bad peasycap->psnd_card\n");
319 return -EFAULT;
320 }
321 if (peasycap->psubstream) {
322 SAM("ERROR: bad peasycap->psubstream\n");
323 return -EFAULT;
324 }
325 pss->private_data = peasycap;
326 peasycap->psubstream = pss;
327 pss->runtime->hw = peasycap->alsa_hardware;
328 pss->runtime->private_data = peasycap;
329 pss->private_data = peasycap;
330
331 if (0 != easycap_sound_setup(peasycap)) {
332 JOM(4, "ending unsuccessfully\n");
333 return -EFAULT;
334 }
335 JOM(4, "ending successfully\n");
336 return 0;
337 }
338 /*****************************************************************************/
339 static int easycap_alsa_close(struct snd_pcm_substream *pss)
340 {
341 struct easycap *peasycap;
342
343 JOT(4, "\n");
344 if (!pss) {
345 SAY("ERROR: pss is NULL\n");
346 return -EFAULT;
347 }
348 peasycap = snd_pcm_substream_chip(pss);
349 if (!peasycap) {
350 SAY("ERROR: peasycap is NULL\n");
351 return -EFAULT;
352 }
353 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
354 SAY("ERROR: bad peasycap\n");
355 return -EFAULT;
356 }
357 pss->private_data = NULL;
358 peasycap->psubstream = NULL;
359 JOT(4, "ending successfully\n");
360 return 0;
361 }
362 /*****************************************************************************/
363 static int easycap_alsa_vmalloc(struct snd_pcm_substream *pss, size_t sz)
364 {
365 struct snd_pcm_runtime *prt;
366 JOT(4, "\n");
367
368 if (!pss) {
369 SAY("ERROR: pss is NULL\n");
370 return -EFAULT;
371 }
372 prt = pss->runtime;
373 if (!prt) {
374 SAY("ERROR: substream.runtime is NULL\n");
375 return -EFAULT;
376 }
377 if (prt->dma_area) {
378 if (prt->dma_bytes > sz)
379 return 0;
380 vfree(prt->dma_area);
381 }
382 prt->dma_area = vmalloc(sz);
383 if (!prt->dma_area)
384 return -ENOMEM;
385 prt->dma_bytes = sz;
386 return 0;
387 }
388 /*****************************************************************************/
389 static int easycap_alsa_hw_params(struct snd_pcm_substream *pss,
390 struct snd_pcm_hw_params *phw)
391 {
392 int rc;
393
394 JOT(4, "%i\n", (params_buffer_bytes(phw)));
395 if (!pss) {
396 SAY("ERROR: pss is NULL\n");
397 return -EFAULT;
398 }
399 rc = easycap_alsa_vmalloc(pss, params_buffer_bytes(phw));
400 if (rc)
401 return rc;
402 return 0;
403 }
404 /*****************************************************************************/
405 static int easycap_alsa_hw_free(struct snd_pcm_substream *pss)
406 {
407 struct snd_pcm_runtime *prt;
408 JOT(4, "\n");
409
410 if (!pss) {
411 SAY("ERROR: pss is NULL\n");
412 return -EFAULT;
413 }
414 prt = pss->runtime;
415 if (!prt) {
416 SAY("ERROR: substream.runtime is NULL\n");
417 return -EFAULT;
418 }
419 if (prt->dma_area) {
420 JOT(8, "prt->dma_area = %p\n", prt->dma_area);
421 vfree(prt->dma_area);
422 prt->dma_area = NULL;
423 } else
424 JOT(8, "dma_area already freed\n");
425 return 0;
426 }
427 /*****************************************************************************/
428 static int easycap_alsa_prepare(struct snd_pcm_substream *pss)
429 {
430 struct easycap *peasycap;
431 struct snd_pcm_runtime *prt;
432
433 JOT(4, "\n");
434 if (!pss) {
435 SAY("ERROR: pss is NULL\n");
436 return -EFAULT;
437 }
438 prt = pss->runtime;
439 peasycap = snd_pcm_substream_chip(pss);
440 if (!peasycap) {
441 SAY("ERROR: peasycap is NULL\n");
442 return -EFAULT;
443 }
444 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
445 SAY("ERROR: bad peasycap\n");
446 return -EFAULT;
447 }
448
449 JOM(16, "ALSA decides %8i Hz=rate\n", pss->runtime->rate);
450 JOM(16, "ALSA decides %8ld =period_size\n", pss->runtime->period_size);
451 JOM(16, "ALSA decides %8i =periods\n", pss->runtime->periods);
452 JOM(16, "ALSA decides %8ld =buffer_size\n", pss->runtime->buffer_size);
453 JOM(16, "ALSA decides %8zd =dma_bytes\n", pss->runtime->dma_bytes);
454 JOM(16, "ALSA decides %8ld =boundary\n", pss->runtime->boundary);
455 JOM(16, "ALSA decides %8i =period_step\n", pss->runtime->period_step);
456 JOM(16, "ALSA decides %8i =sample_bits\n", pss->runtime->sample_bits);
457 JOM(16, "ALSA decides %8i =frame_bits\n", pss->runtime->frame_bits);
458 JOM(16, "ALSA decides %8ld =min_align\n", pss->runtime->min_align);
459 JOM(12, "ALSA decides %8ld =hw_ptr_base\n", pss->runtime->hw_ptr_base);
460 JOM(12, "ALSA decides %8ld =hw_ptr_interrupt\n",
461 pss->runtime->hw_ptr_interrupt);
462
463 if (prt->dma_bytes != 4 * ((int)prt->period_size) * ((int)prt->periods)) {
464 SAY("MISTAKE: unexpected ALSA parameters\n");
465 return -ENOENT;
466 }
467 return 0;
468 }
469 /*****************************************************************************/
470 static int easycap_alsa_ack(struct snd_pcm_substream *pss)
471 {
472 return 0;
473 }
474 /*****************************************************************************/
475 static int easycap_alsa_trigger(struct snd_pcm_substream *pss, int cmd)
476 {
477 struct easycap *peasycap;
478 int retval;
479
480 JOT(4, "%i=cmd cf %i=START %i=STOP\n", cmd, SNDRV_PCM_TRIGGER_START,
481 SNDRV_PCM_TRIGGER_STOP);
482 if (!pss) {
483 SAY("ERROR: pss is NULL\n");
484 return -EFAULT;
485 }
486 peasycap = snd_pcm_substream_chip(pss);
487 if (!peasycap) {
488 SAY("ERROR: peasycap is NULL\n");
489 return -EFAULT;
490 }
491 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
492 SAY("ERROR: bad peasycap\n");
493 return -EFAULT;
494 }
495
496 switch (cmd) {
497 case SNDRV_PCM_TRIGGER_START: {
498 peasycap->audio_idle = 0;
499 break;
500 }
501 case SNDRV_PCM_TRIGGER_STOP: {
502 peasycap->audio_idle = 1;
503 break;
504 }
505 default:
506 retval = -EINVAL;
507 }
508 return 0;
509 }
510 /*****************************************************************************/
511 static snd_pcm_uframes_t easycap_alsa_pointer(struct snd_pcm_substream *pss)
512 {
513 struct easycap *peasycap;
514 snd_pcm_uframes_t offset;
515
516 JOT(16, "\n");
517 if (!pss) {
518 SAY("ERROR: pss is NULL\n");
519 return -EFAULT;
520 }
521 peasycap = snd_pcm_substream_chip(pss);
522 if (!peasycap) {
523 SAY("ERROR: peasycap is NULL\n");
524 return -EFAULT;
525 }
526 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
527 SAY("ERROR: bad peasycap\n");
528 return -EFAULT;
529 }
530 if ((0 != peasycap->audio_eof) || (0 != peasycap->audio_idle)) {
531 JOM(8, "returning -EIO because "
532 "%i=audio_idle %i=audio_eof\n",
533 peasycap->audio_idle, peasycap->audio_eof);
534 return -EIO;
535 }
536 /*---------------------------------------------------------------------------*/
537 if (0 > peasycap->dma_read) {
538 JOM(8, "returning -EBUSY\n");
539 return -EBUSY;
540 }
541 offset = ((snd_pcm_uframes_t)peasycap->dma_read)/4;
542 JOM(8, "ALSA decides %8i =hw_ptr_base\n", (int)pss->runtime->hw_ptr_base);
543 JOM(8, "ALSA decides %8i =hw_ptr_interrupt\n",
544 (int)pss->runtime->hw_ptr_interrupt);
545 JOM(8, "%7i=offset %7i=dma_read %7i=dma_next\n",
546 (int)offset, peasycap->dma_read, peasycap->dma_next);
547 return offset;
548 }
549 /*****************************************************************************/
550 static struct page *
551 easycap_alsa_page(struct snd_pcm_substream *pss, unsigned long offset)
552 {
553 return vmalloc_to_page(pss->runtime->dma_area + offset);
554 }
555 /*****************************************************************************/
556
557 static struct snd_pcm_ops easycap_alsa_pcm_ops = {
558 .open = easycap_alsa_open,
559 .close = easycap_alsa_close,
560 .ioctl = snd_pcm_lib_ioctl,
561 .hw_params = easycap_alsa_hw_params,
562 .hw_free = easycap_alsa_hw_free,
563 .prepare = easycap_alsa_prepare,
564 .ack = easycap_alsa_ack,
565 .trigger = easycap_alsa_trigger,
566 .pointer = easycap_alsa_pointer,
567 .page = easycap_alsa_page,
568 };
569
570 /*****************************************************************************/
571 /*---------------------------------------------------------------------------*/
572 /*
573 * THE FUNCTION snd_card_create() HAS THIS_MODULE AS AN ARGUMENT. THIS
574 * MEANS MODULE easycap. BEWARE.
575 */
576 /*---------------------------------------------------------------------------*/
577 int easycap_alsa_probe(struct easycap *peasycap)
578 {
579 int rc;
580 struct snd_card *psnd_card;
581 struct snd_pcm *psnd_pcm;
582
583 if (!peasycap) {
584 SAY("ERROR: peasycap is NULL\n");
585 return -ENODEV;
586 }
587 if (memcmp(&peasycap->telltale[0], TELLTALE, strlen(TELLTALE))) {
588 SAY("ERROR: bad peasycap\n");
589 return -EFAULT;
590 }
591 if (0 > peasycap->minor) {
592 SAY("ERROR: no minor\n");
593 return -ENODEV;
594 }
595
596 peasycap->alsa_hardware = alsa_hardware;
597 if (peasycap->microphone) {
598 peasycap->alsa_hardware.rates = SNDRV_PCM_RATE_32000;
599 peasycap->alsa_hardware.rate_min = 32000;
600 peasycap->alsa_hardware.rate_max = 32000;
601 } else {
602 peasycap->alsa_hardware.rates = SNDRV_PCM_RATE_48000;
603 peasycap->alsa_hardware.rate_min = 48000;
604 peasycap->alsa_hardware.rate_max = 48000;
605 }
606
607 if (0 != snd_card_create(SNDRV_DEFAULT_IDX1, "easycap_alsa",
608 THIS_MODULE, 0, &psnd_card)) {
609 SAY("ERROR: Cannot do ALSA snd_card_create()\n");
610 return -EFAULT;
611 }
612
613 sprintf(&psnd_card->id[0], "EasyALSA%i", peasycap->minor);
614 strcpy(&psnd_card->driver[0], EASYCAP_DRIVER_DESCRIPTION);
615 strcpy(&psnd_card->shortname[0], "easycap_alsa");
616 sprintf(&psnd_card->longname[0], "%s", &psnd_card->shortname[0]);
617
618 psnd_card->dev = &peasycap->pusb_device->dev;
619 psnd_card->private_data = peasycap;
620 peasycap->psnd_card = psnd_card;
621
622 rc = snd_pcm_new(psnd_card, "easycap_pcm", 0, 0, 1, &psnd_pcm);
623 if (rc) {
624 SAM("ERROR: Cannot do ALSA snd_pcm_new()\n");
625 snd_card_free(psnd_card);
626 return -EFAULT;
627 }
628
629 snd_pcm_set_ops(psnd_pcm, SNDRV_PCM_STREAM_CAPTURE,
630 &easycap_alsa_pcm_ops);
631 psnd_pcm->info_flags = 0;
632 strcpy(&psnd_pcm->name[0], &psnd_card->id[0]);
633 psnd_pcm->private_data = peasycap;
634 peasycap->psnd_pcm = psnd_pcm;
635 peasycap->psubstream = NULL;
636
637 rc = snd_card_register(psnd_card);
638 if (rc) {
639 SAM("ERROR: Cannot do ALSA snd_card_register()\n");
640 snd_card_free(psnd_card);
641 return -EFAULT;
642 }
643
644 SAM("registered %s\n", &psnd_card->id[0]);
645 return 0;
646 }
647 #endif /*! CONFIG_EASYCAP_OSS */
648
649 /*****************************************************************************/
650 /*****************************************************************************/
651 /*****************************************************************************/
652 /*****************************************************************************/
653 /*****************************************************************************/
654 /*****************************************************************************/
655 /*---------------------------------------------------------------------------*/
656 /*
657 * COMMON AUDIO INITIALIZATION
658 */
659 /*---------------------------------------------------------------------------*/
660 int
661 easycap_sound_setup(struct easycap *peasycap)
662 {
663 int rc;
664
665 JOM(4, "starting initialization\n");
666
667 if (!peasycap) {
668 SAY("ERROR: peasycap is NULL.\n");
669 return -EFAULT;
670 }
671 if (!peasycap->pusb_device) {
672 SAM("ERROR: peasycap->pusb_device is NULL\n");
673 return -ENODEV;
674 }
675 JOM(16, "0x%08lX=peasycap->pusb_device\n", (long int)peasycap->pusb_device);
676
677 rc = audio_setup(peasycap);
678 JOM(8, "audio_setup() returned %i\n", rc);
679
680 if (!peasycap->pusb_device) {
681 SAM("ERROR: peasycap->pusb_device has become NULL\n");
682 return -ENODEV;
683 }
684 /*---------------------------------------------------------------------------*/
685 if (!peasycap->pusb_device) {
686 SAM("ERROR: peasycap->pusb_device has become NULL\n");
687 return -ENODEV;
688 }
689 rc = usb_set_interface(peasycap->pusb_device, peasycap->audio_interface,
690 peasycap->audio_altsetting_on);
691 JOM(8, "usb_set_interface(.,%i,%i) returned %i\n", peasycap->audio_interface,
692 peasycap->audio_altsetting_on, rc);
693
694 rc = wakeup_device(peasycap->pusb_device);
695 JOM(8, "wakeup_device() returned %i\n", rc);
696
697 peasycap->audio_eof = 0;
698 peasycap->audio_idle = 0;
699
700 peasycap->timeval1.tv_sec = 0;
701 peasycap->timeval1.tv_usec = 0;
702
703 submit_audio_urbs(peasycap);
704
705 JOM(4, "finished initialization\n");
706 return 0;
707 }
708 /*****************************************************************************/
709 /*---------------------------------------------------------------------------*/
710 /*
711 * SUBMIT ALL AUDIO URBS.
712 */
713 /*---------------------------------------------------------------------------*/
714 int
715 submit_audio_urbs(struct easycap *peasycap)
716 {
717 struct data_urb *pdata_urb;
718 struct urb *purb;
719 struct list_head *plist_head;
720 int j, isbad, nospc, m, rc;
721 int isbuf;
722
723 if (!peasycap) {
724 SAY("ERROR: peasycap is NULL\n");
725 return -EFAULT;
726 }
727 if (!peasycap->purb_audio_head) {
728 SAM("ERROR: peasycap->urb_audio_head uninitialized\n");
729 return -EFAULT;
730 }
731 if (!peasycap->pusb_device) {
732 SAM("ERROR: peasycap->pusb_device is NULL\n");
733 return -EFAULT;
734 }
735
736 if (peasycap->audio_isoc_streaming) {
737 JOM(4, "already streaming audio urbs\n");
738 return 0;
739 }
740
741 JOM(4, "initial submission of all audio urbs\n");
742 rc = usb_set_interface(peasycap->pusb_device,
743 peasycap->audio_interface,
744 peasycap->audio_altsetting_on);
745 JOM(8, "usb_set_interface(.,%i,%i) returned %i\n",
746 peasycap->audio_interface,
747 peasycap->audio_altsetting_on, rc);
748
749 isbad = 0;
750 nospc = 0;
751 m = 0;
752 list_for_each(plist_head, peasycap->purb_audio_head) {
753 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
754 if (pdata_urb && pdata_urb->purb) {
755 purb = pdata_urb->purb;
756 isbuf = pdata_urb->isbuf;
757
758 purb->interval = 1;
759 purb->dev = peasycap->pusb_device;
760 purb->pipe = usb_rcvisocpipe(peasycap->pusb_device,
761 peasycap->audio_endpointnumber);
762 purb->transfer_flags = URB_ISO_ASAP;
763 purb->transfer_buffer = peasycap->audio_isoc_buffer[isbuf].pgo;
764 purb->transfer_buffer_length = peasycap->audio_isoc_buffer_size;
765 #ifdef CONFIG_EASYCAP_OSS
766 purb->complete = easyoss_complete;
767 #else /* CONFIG_EASYCAP_OSS */
768 purb->complete = easycap_alsa_complete;
769 #endif /* CONFIG_EASYCAP_OSS */
770 purb->context = peasycap;
771 purb->start_frame = 0;
772 purb->number_of_packets = peasycap->audio_isoc_framesperdesc;
773 for (j = 0; j < peasycap->audio_isoc_framesperdesc; j++) {
774 purb->iso_frame_desc[j].offset = j * peasycap->audio_isoc_maxframesize;
775 purb->iso_frame_desc[j].length = peasycap->audio_isoc_maxframesize;
776 }
777
778 rc = usb_submit_urb(purb, GFP_KERNEL);
779 if (rc) {
780 isbad++;
781 SAM("ERROR: usb_submit_urb() failed"
782 " for urb with rc: -%s: %d\n",
783 strerror(rc), rc);
784 } else {
785 m++;
786 }
787 } else {
788 isbad++;
789 }
790 }
791 if (nospc) {
792 SAM("-ENOSPC=usb_submit_urb() for %i urbs\n", nospc);
793 SAM("..... possibly inadequate USB bandwidth\n");
794 peasycap->audio_eof = 1;
795 }
796 if (isbad) {
797 JOM(4, "attempting cleanup instead of submitting\n");
798 list_for_each(plist_head, (peasycap->purb_audio_head)) {
799 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
800 if (pdata_urb && pdata_urb->purb)
801 usb_kill_urb(pdata_urb->purb);
802 }
803 peasycap->audio_isoc_streaming = 0;
804 } else {
805 peasycap->audio_isoc_streaming = m;
806 JOM(4, "submitted %i audio urbs\n", m);
807 }
808
809 return 0;
810 }
811 /*****************************************************************************/
812 /*---------------------------------------------------------------------------*/
813 /*
814 * KILL ALL AUDIO URBS.
815 */
816 /*---------------------------------------------------------------------------*/
817 int
818 kill_audio_urbs(struct easycap *peasycap)
819 {
820 int m;
821 struct list_head *plist_head;
822 struct data_urb *pdata_urb;
823
824 if (!peasycap) {
825 SAY("ERROR: peasycap is NULL\n");
826 return -EFAULT;
827 }
828
829 if (!peasycap->audio_isoc_streaming) {
830 JOM(8, "%i=audio_isoc_streaming, no audio urbs killed\n",
831 peasycap->audio_isoc_streaming);
832 return 0;
833 }
834
835 if (!peasycap->purb_audio_head) {
836 SAM("ERROR: peasycap->purb_audio_head is NULL\n");
837 return -EFAULT;
838 }
839
840 peasycap->audio_isoc_streaming = 0;
841 JOM(4, "killing audio urbs\n");
842 m = 0;
843 list_for_each(plist_head, (peasycap->purb_audio_head)) {
844 pdata_urb = list_entry(plist_head, struct data_urb, list_head);
845 if (pdata_urb && pdata_urb->purb) {
846 usb_kill_urb(pdata_urb->purb);
847 m++;
848 }
849 }
850 JOM(4, "%i audio urbs killed\n", m);
851
852 return 0;
853 }
854 /*****************************************************************************/
Linux kernel - Deliverables
This page took 0.050335 seconds and 5 git commands to generate.