1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include "pcm.h"
17#include "chip.h"
18#include "comm.h"
19#include "control.h"
20
21enum {
22 OUT_N_CHANNELS = 6, IN_N_CHANNELS = 4
23};
24
25
26
27
28static const int rates_in_packet_size[] = { 228, 228, 420, 420, 404, 404 };
29static const int rates_out_packet_size[] = { 228, 228, 420, 420, 604, 604 };
30static const int rates[] = { 44100, 48000, 88200, 96000, 176400, 192000 };
31static const int rates_alsaid[] = {
32 SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_48000,
33 SNDRV_PCM_RATE_88200, SNDRV_PCM_RATE_96000,
34 SNDRV_PCM_RATE_176400, SNDRV_PCM_RATE_192000 };
35
36enum {
37 OUT_EP = 6, IN_EP = 2, MAX_BUFSIZE = 128 * 1024
38};
39
40enum {
41 STREAM_DISABLED,
42 STREAM_STARTING,
43 STREAM_RUNNING,
44 STREAM_STOPPING
45};
46
47static const struct snd_pcm_hardware pcm_hw = {
48 .info = SNDRV_PCM_INFO_MMAP |
49 SNDRV_PCM_INFO_INTERLEAVED |
50 SNDRV_PCM_INFO_BLOCK_TRANSFER |
51 SNDRV_PCM_INFO_MMAP_VALID |
52 SNDRV_PCM_INFO_BATCH,
53
54 .formats = SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE,
55
56 .rates = SNDRV_PCM_RATE_44100 |
57 SNDRV_PCM_RATE_48000 |
58 SNDRV_PCM_RATE_88200 |
59 SNDRV_PCM_RATE_96000 |
60 SNDRV_PCM_RATE_176400 |
61 SNDRV_PCM_RATE_192000,
62
63 .rate_min = 44100,
64 .rate_max = 192000,
65 .channels_min = 1,
66 .channels_max = 0,
67 .buffer_bytes_max = MAX_BUFSIZE,
68 .period_bytes_min = PCM_N_PACKETS_PER_URB * (PCM_MAX_PACKET_SIZE - 4),
69 .period_bytes_max = MAX_BUFSIZE,
70 .periods_min = 2,
71 .periods_max = 1024
72};
73
74static int usb6fire_pcm_set_rate(struct pcm_runtime *rt)
75{
76 int ret;
77 struct control_runtime *ctrl_rt = rt->chip->control;
78
79 ctrl_rt->usb_streaming = false;
80 ret = ctrl_rt->update_streaming(ctrl_rt);
81 if (ret < 0) {
82 snd_printk(KERN_ERR PREFIX "error stopping streaming while "
83 "setting samplerate %d.\n", rates[rt->rate]);
84 return ret;
85 }
86
87 ret = ctrl_rt->set_rate(ctrl_rt, rt->rate);
88 if (ret < 0) {
89 snd_printk(KERN_ERR PREFIX "error setting samplerate %d.\n",
90 rates[rt->rate]);
91 return ret;
92 }
93
94 ret = ctrl_rt->set_channels(ctrl_rt, OUT_N_CHANNELS, IN_N_CHANNELS,
95 false, false);
96 if (ret < 0) {
97 snd_printk(KERN_ERR PREFIX "error initializing channels "
98 "while setting samplerate %d.\n",
99 rates[rt->rate]);
100 return ret;
101 }
102
103 ctrl_rt->usb_streaming = true;
104 ret = ctrl_rt->update_streaming(ctrl_rt);
105 if (ret < 0) {
106 snd_printk(KERN_ERR PREFIX "error starting streaming while "
107 "setting samplerate %d.\n", rates[rt->rate]);
108 return ret;
109 }
110
111 rt->in_n_analog = IN_N_CHANNELS;
112 rt->out_n_analog = OUT_N_CHANNELS;
113 rt->in_packet_size = rates_in_packet_size[rt->rate];
114 rt->out_packet_size = rates_out_packet_size[rt->rate];
115 return 0;
116}
117
118static struct pcm_substream *usb6fire_pcm_get_substream(
119 struct snd_pcm_substream *alsa_sub)
120{
121 struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
122
123 if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
124 return &rt->playback;
125 else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE)
126 return &rt->capture;
127 snd_printk(KERN_ERR PREFIX "error getting pcm substream slot.\n");
128 return NULL;
129}
130
131
132static void usb6fire_pcm_stream_stop(struct pcm_runtime *rt)
133{
134 int i;
135 struct control_runtime *ctrl_rt = rt->chip->control;
136
137 if (rt->stream_state != STREAM_DISABLED) {
138
139 rt->stream_state = STREAM_STOPPING;
140
141 for (i = 0; i < PCM_N_URBS; i++) {
142 usb_kill_urb(&rt->in_urbs[i].instance);
143 usb_kill_urb(&rt->out_urbs[i].instance);
144 }
145 ctrl_rt->usb_streaming = false;
146 ctrl_rt->update_streaming(ctrl_rt);
147 rt->stream_state = STREAM_DISABLED;
148 }
149}
150
151
152static int usb6fire_pcm_stream_start(struct pcm_runtime *rt)
153{
154 int ret;
155 int i;
156 int k;
157 struct usb_iso_packet_descriptor *packet;
158
159 if (rt->stream_state == STREAM_DISABLED) {
160
161 rt->stream_wait_cond = false;
162 rt->stream_state = STREAM_STARTING;
163 for (i = 0; i < PCM_N_URBS; i++) {
164 for (k = 0; k < PCM_N_PACKETS_PER_URB; k++) {
165 packet = &rt->in_urbs[i].packets[k];
166 packet->offset = k * rt->in_packet_size;
167 packet->length = rt->in_packet_size;
168 packet->actual_length = 0;
169 packet->status = 0;
170 }
171 ret = usb_submit_urb(&rt->in_urbs[i].instance,
172 GFP_ATOMIC);
173 if (ret) {
174 usb6fire_pcm_stream_stop(rt);
175 return ret;
176 }
177 }
178
179
180 wait_event_timeout(rt->stream_wait_queue, rt->stream_wait_cond,
181 HZ);
182 if (rt->stream_wait_cond)
183 rt->stream_state = STREAM_RUNNING;
184 else {
185 usb6fire_pcm_stream_stop(rt);
186 return -EIO;
187 }
188 }
189 return 0;
190}
191
192
193static void usb6fire_pcm_capture(struct pcm_substream *sub, struct pcm_urb *urb)
194{
195 int i;
196 int frame;
197 int frame_count;
198 unsigned int total_length = 0;
199 struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
200 struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
201 u32 *src = NULL;
202 u32 *dest = (u32 *) (alsa_rt->dma_area + sub->dma_off
203 * (alsa_rt->frame_bits >> 3));
204 u32 *dest_end = (u32 *) (alsa_rt->dma_area + alsa_rt->buffer_size
205 * (alsa_rt->frame_bits >> 3));
206 int bytes_per_frame = alsa_rt->channels << 2;
207
208 for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
209
210
211 if (urb->packets[i].actual_length > 4)
212 frame_count = (urb->packets[i].actual_length - 4)
213 / (rt->in_n_analog << 2);
214 else
215 frame_count = 0;
216
217 if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
218 src = (u32 *) (urb->buffer + total_length);
219 else if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
220 src = (u32 *) (urb->buffer - 1 + total_length);
221 else
222 return;
223 src++;
224 total_length += urb->packets[i].length;
225 for (frame = 0; frame < frame_count; frame++) {
226 memcpy(dest, src, bytes_per_frame);
227 dest += alsa_rt->channels;
228 src += rt->in_n_analog;
229 sub->dma_off++;
230 sub->period_off++;
231 if (dest == dest_end) {
232 sub->dma_off = 0;
233 dest = (u32 *) alsa_rt->dma_area;
234 }
235 }
236 }
237}
238
239
240static void usb6fire_pcm_playback(struct pcm_substream *sub,
241 struct pcm_urb *urb)
242{
243 int i;
244 int frame;
245 int frame_count;
246 struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
247 struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
248 u32 *src = (u32 *) (alsa_rt->dma_area + sub->dma_off
249 * (alsa_rt->frame_bits >> 3));
250 u32 *src_end = (u32 *) (alsa_rt->dma_area + alsa_rt->buffer_size
251 * (alsa_rt->frame_bits >> 3));
252 u32 *dest;
253 int bytes_per_frame = alsa_rt->channels << 2;
254
255 if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
256 dest = (u32 *) (urb->buffer - 1);
257 else if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
258 dest = (u32 *) (urb->buffer);
259 else {
260 snd_printk(KERN_ERR PREFIX "Unknown sample format.");
261 return;
262 }
263
264 for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
265
266
267 if (urb->packets[i].length > 4)
268 frame_count = (urb->packets[i].length - 4)
269 / (rt->out_n_analog << 2);
270 else
271 frame_count = 0;
272 dest++;
273 for (frame = 0; frame < frame_count; frame++) {
274 memcpy(dest, src, bytes_per_frame);
275 src += alsa_rt->channels;
276 dest += rt->out_n_analog;
277 sub->dma_off++;
278 sub->period_off++;
279 if (src == src_end) {
280 src = (u32 *) alsa_rt->dma_area;
281 sub->dma_off = 0;
282 }
283 }
284 }
285}
286
287static void usb6fire_pcm_in_urb_handler(struct urb *usb_urb)
288{
289 struct pcm_urb *in_urb = usb_urb->context;
290 struct pcm_urb *out_urb = in_urb->peer;
291 struct pcm_runtime *rt = in_urb->chip->pcm;
292 struct pcm_substream *sub;
293 unsigned long flags;
294 int total_length = 0;
295 int frame_count;
296 int frame;
297 int channel;
298 int i;
299 u8 *dest;
300
301 if (usb_urb->status || rt->panic || rt->stream_state == STREAM_STOPPING)
302 return;
303 for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
304 if (in_urb->packets[i].status) {
305 rt->panic = true;
306 return;
307 }
308
309 if (rt->stream_state == STREAM_DISABLED) {
310 snd_printk(KERN_ERR PREFIX "internal error: "
311 "stream disabled in in-urb handler.\n");
312 return;
313 }
314
315
316 sub = &rt->capture;
317 spin_lock_irqsave(&sub->lock, flags);
318 if (sub->active) {
319 usb6fire_pcm_capture(sub, in_urb);
320 if (sub->period_off >= sub->instance->runtime->period_size) {
321 sub->period_off %= sub->instance->runtime->period_size;
322 spin_unlock_irqrestore(&sub->lock, flags);
323 snd_pcm_period_elapsed(sub->instance);
324 } else
325 spin_unlock_irqrestore(&sub->lock, flags);
326 } else
327 spin_unlock_irqrestore(&sub->lock, flags);
328
329
330 for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
331 out_urb->packets[i].offset = total_length;
332 out_urb->packets[i].length = (in_urb->packets[i].actual_length
333 - 4) / (rt->in_n_analog << 2)
334 * (rt->out_n_analog << 2) + 4;
335 out_urb->packets[i].status = 0;
336 total_length += out_urb->packets[i].length;
337 }
338 memset(out_urb->buffer, 0, total_length);
339
340
341 sub = &rt->playback;
342 spin_lock_irqsave(&sub->lock, flags);
343 if (sub->active) {
344 usb6fire_pcm_playback(sub, out_urb);
345 if (sub->period_off >= sub->instance->runtime->period_size) {
346 sub->period_off %= sub->instance->runtime->period_size;
347 spin_unlock_irqrestore(&sub->lock, flags);
348 snd_pcm_period_elapsed(sub->instance);
349 } else
350 spin_unlock_irqrestore(&sub->lock, flags);
351 } else
352 spin_unlock_irqrestore(&sub->lock, flags);
353
354
355 dest = out_urb->buffer;
356 for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
357 if (out_urb->packets[i].length >= 4) {
358 frame_count = (out_urb->packets[i].length - 4)
359 / (rt->out_n_analog << 2);
360 *(dest++) = 0xaa;
361 *(dest++) = 0xaa;
362 *(dest++) = frame_count;
363 *(dest++) = 0x00;
364 for (frame = 0; frame < frame_count; frame++)
365 for (channel = 0;
366 channel < rt->out_n_analog;
367 channel++) {
368 dest += 3;
369 *(dest++) = 0x40;
370 }
371 }
372 usb_submit_urb(&out_urb->instance, GFP_ATOMIC);
373 usb_submit_urb(&in_urb->instance, GFP_ATOMIC);
374}
375
376static void usb6fire_pcm_out_urb_handler(struct urb *usb_urb)
377{
378 struct pcm_urb *urb = usb_urb->context;
379 struct pcm_runtime *rt = urb->chip->pcm;
380
381 if (rt->stream_state == STREAM_STARTING) {
382 rt->stream_wait_cond = true;
383 wake_up(&rt->stream_wait_queue);
384 }
385}
386
387static int usb6fire_pcm_open(struct snd_pcm_substream *alsa_sub)
388{
389 struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
390 struct pcm_substream *sub = NULL;
391 struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
392
393 if (rt->panic)
394 return -EPIPE;
395
396 mutex_lock(&rt->stream_mutex);
397 alsa_rt->hw = pcm_hw;
398
399 if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK) {
400 if (rt->rate < ARRAY_SIZE(rates))
401 alsa_rt->hw.rates = rates_alsaid[rt->rate];
402 alsa_rt->hw.channels_max = OUT_N_CHANNELS;
403 sub = &rt->playback;
404 } else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE) {
405 if (rt->rate < ARRAY_SIZE(rates))
406 alsa_rt->hw.rates = rates_alsaid[rt->rate];
407 alsa_rt->hw.channels_max = IN_N_CHANNELS;
408 sub = &rt->capture;
409 }
410
411 if (!sub) {
412 mutex_unlock(&rt->stream_mutex);
413 snd_printk(KERN_ERR PREFIX "invalid stream type.\n");
414 return -EINVAL;
415 }
416
417 sub->instance = alsa_sub;
418 sub->active = false;
419 mutex_unlock(&rt->stream_mutex);
420 return 0;
421}
422
423static int usb6fire_pcm_close(struct snd_pcm_substream *alsa_sub)
424{
425 struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
426 struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
427 unsigned long flags;
428
429 if (rt->panic)
430 return 0;
431
432 mutex_lock(&rt->stream_mutex);
433 if (sub) {
434
435 spin_lock_irqsave(&sub->lock, flags);
436 sub->instance = NULL;
437 sub->active = false;
438 spin_unlock_irqrestore(&sub->lock, flags);
439
440
441 if (!rt->playback.instance && !rt->capture.instance) {
442 usb6fire_pcm_stream_stop(rt);
443 rt->rate = ARRAY_SIZE(rates);
444 }
445 }
446 mutex_unlock(&rt->stream_mutex);
447 return 0;
448}
449
450static int usb6fire_pcm_hw_params(struct snd_pcm_substream *alsa_sub,
451 struct snd_pcm_hw_params *hw_params)
452{
453 return snd_pcm_lib_alloc_vmalloc_buffer(alsa_sub,
454 params_buffer_bytes(hw_params));
455}
456
457static int usb6fire_pcm_hw_free(struct snd_pcm_substream *alsa_sub)
458{
459 return snd_pcm_lib_free_vmalloc_buffer(alsa_sub);
460}
461
462static int usb6fire_pcm_prepare(struct snd_pcm_substream *alsa_sub)
463{
464 struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
465 struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
466 struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
467 int ret;
468
469 if (rt->panic)
470 return -EPIPE;
471 if (!sub)
472 return -ENODEV;
473
474 mutex_lock(&rt->stream_mutex);
475 sub->dma_off = 0;
476 sub->period_off = 0;
477
478 if (rt->stream_state == STREAM_DISABLED) {
479 for (rt->rate = 0; rt->rate < ARRAY_SIZE(rates); rt->rate++)
480 if (alsa_rt->rate == rates[rt->rate])
481 break;
482 if (rt->rate == ARRAY_SIZE(rates)) {
483 mutex_unlock(&rt->stream_mutex);
484 snd_printk("invalid rate %d in prepare.\n",
485 alsa_rt->rate);
486 return -EINVAL;
487 }
488
489 ret = usb6fire_pcm_set_rate(rt);
490 if (ret) {
491 mutex_unlock(&rt->stream_mutex);
492 return ret;
493 }
494 ret = usb6fire_pcm_stream_start(rt);
495 if (ret) {
496 mutex_unlock(&rt->stream_mutex);
497 snd_printk(KERN_ERR PREFIX
498 "could not start pcm stream.\n");
499 return ret;
500 }
501 }
502 mutex_unlock(&rt->stream_mutex);
503 return 0;
504}
505
506static int usb6fire_pcm_trigger(struct snd_pcm_substream *alsa_sub, int cmd)
507{
508 struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
509 struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
510 unsigned long flags;
511
512 if (rt->panic)
513 return -EPIPE;
514 if (!sub)
515 return -ENODEV;
516
517 switch (cmd) {
518 case SNDRV_PCM_TRIGGER_START:
519 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
520 spin_lock_irqsave(&sub->lock, flags);
521 sub->active = true;
522 spin_unlock_irqrestore(&sub->lock, flags);
523 return 0;
524
525 case SNDRV_PCM_TRIGGER_STOP:
526 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
527 spin_lock_irqsave(&sub->lock, flags);
528 sub->active = false;
529 spin_unlock_irqrestore(&sub->lock, flags);
530 return 0;
531
532 default:
533 return -EINVAL;
534 }
535}
536
537static snd_pcm_uframes_t usb6fire_pcm_pointer(
538 struct snd_pcm_substream *alsa_sub)
539{
540 struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
541 struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
542 unsigned long flags;
543 snd_pcm_uframes_t ret;
544
545 if (rt->panic || !sub)
546 return SNDRV_PCM_POS_XRUN;
547
548 spin_lock_irqsave(&sub->lock, flags);
549 ret = sub->dma_off;
550 spin_unlock_irqrestore(&sub->lock, flags);
551 return ret;
552}
553
554static struct snd_pcm_ops pcm_ops = {
555 .open = usb6fire_pcm_open,
556 .close = usb6fire_pcm_close,
557 .ioctl = snd_pcm_lib_ioctl,
558 .hw_params = usb6fire_pcm_hw_params,
559 .hw_free = usb6fire_pcm_hw_free,
560 .prepare = usb6fire_pcm_prepare,
561 .trigger = usb6fire_pcm_trigger,
562 .pointer = usb6fire_pcm_pointer,
563 .page = snd_pcm_lib_get_vmalloc_page,
564 .mmap = snd_pcm_lib_mmap_vmalloc,
565};
566
567static void usb6fire_pcm_init_urb(struct pcm_urb *urb,
568 struct sfire_chip *chip, bool in, int ep,
569 void (*handler)(struct urb *))
570{
571 urb->chip = chip;
572 usb_init_urb(&urb->instance);
573 urb->instance.transfer_buffer = urb->buffer;
574 urb->instance.transfer_buffer_length =
575 PCM_N_PACKETS_PER_URB * PCM_MAX_PACKET_SIZE;
576 urb->instance.dev = chip->dev;
577 urb->instance.pipe = in ? usb_rcvisocpipe(chip->dev, ep)
578 : usb_sndisocpipe(chip->dev, ep);
579 urb->instance.interval = 1;
580 urb->instance.complete = handler;
581 urb->instance.context = urb;
582 urb->instance.number_of_packets = PCM_N_PACKETS_PER_URB;
583}
584
585static int usb6fire_pcm_buffers_init(struct pcm_runtime *rt)
586{
587 int i;
588
589 for (i = 0; i < PCM_N_URBS; i++) {
590 rt->out_urbs[i].buffer = kzalloc(PCM_N_PACKETS_PER_URB
591 * PCM_MAX_PACKET_SIZE, GFP_KERNEL);
592 if (!rt->out_urbs[i].buffer)
593 return -ENOMEM;
594 rt->in_urbs[i].buffer = kzalloc(PCM_N_PACKETS_PER_URB
595 * PCM_MAX_PACKET_SIZE, GFP_KERNEL);
596 if (!rt->in_urbs[i].buffer)
597 return -ENOMEM;
598 }
599 return 0;
600}
601
602static void usb6fire_pcm_buffers_destroy(struct pcm_runtime *rt)
603{
604 int i;
605
606 for (i = 0; i < PCM_N_URBS; i++) {
607 kfree(rt->out_urbs[i].buffer);
608 kfree(rt->in_urbs[i].buffer);
609 }
610}
611
612int usb6fire_pcm_init(struct sfire_chip *chip)
613{
614 int i;
615 int ret;
616 struct snd_pcm *pcm;
617 struct pcm_runtime *rt =
618 kzalloc(sizeof(struct pcm_runtime), GFP_KERNEL);
619
620 if (!rt)
621 return -ENOMEM;
622
623 ret = usb6fire_pcm_buffers_init(rt);
624 if (ret) {
625 usb6fire_pcm_buffers_destroy(rt);
626 kfree(rt);
627 return ret;
628 }
629
630 rt->chip = chip;
631 rt->stream_state = STREAM_DISABLED;
632 rt->rate = ARRAY_SIZE(rates);
633 init_waitqueue_head(&rt->stream_wait_queue);
634 mutex_init(&rt->stream_mutex);
635
636 spin_lock_init(&rt->playback.lock);
637 spin_lock_init(&rt->capture.lock);
638
639 for (i = 0; i < PCM_N_URBS; i++) {
640 usb6fire_pcm_init_urb(&rt->in_urbs[i], chip, true, IN_EP,
641 usb6fire_pcm_in_urb_handler);
642 usb6fire_pcm_init_urb(&rt->out_urbs[i], chip, false, OUT_EP,
643 usb6fire_pcm_out_urb_handler);
644
645 rt->in_urbs[i].peer = &rt->out_urbs[i];
646 rt->out_urbs[i].peer = &rt->in_urbs[i];
647 }
648
649 ret = snd_pcm_new(chip->card, "DMX6FireUSB", 0, 1, 1, &pcm);
650 if (ret < 0) {
651 usb6fire_pcm_buffers_destroy(rt);
652 kfree(rt);
653 snd_printk(KERN_ERR PREFIX "cannot create pcm instance.\n");
654 return ret;
655 }
656
657 pcm->private_data = rt;
658 strcpy(pcm->name, "DMX 6Fire USB");
659 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops);
660 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_ops);
661
662 if (ret) {
663 usb6fire_pcm_buffers_destroy(rt);
664 kfree(rt);
665 snd_printk(KERN_ERR PREFIX
666 "error preallocating pcm buffers.\n");
667 return ret;
668 }
669 rt->instance = pcm;
670
671 chip->pcm = rt;
672 return 0;
673}
674
675void usb6fire_pcm_abort(struct sfire_chip *chip)
676{
677 struct pcm_runtime *rt = chip->pcm;
678 unsigned long flags;
679 int i;
680
681 if (rt) {
682 rt->panic = true;
683
684 if (rt->playback.instance) {
685 snd_pcm_stream_lock_irqsave(rt->playback.instance, flags);
686 snd_pcm_stop(rt->playback.instance,
687 SNDRV_PCM_STATE_XRUN);
688 snd_pcm_stream_unlock_irqrestore(rt->playback.instance, flags);
689 }
690
691 if (rt->capture.instance) {
692 snd_pcm_stream_lock_irqsave(rt->capture.instance, flags);
693 snd_pcm_stop(rt->capture.instance,
694 SNDRV_PCM_STATE_XRUN);
695 snd_pcm_stream_unlock_irqrestore(rt->capture.instance, flags);
696 }
697
698 for (i = 0; i < PCM_N_URBS; i++) {
699 usb_poison_urb(&rt->in_urbs[i].instance);
700 usb_poison_urb(&rt->out_urbs[i].instance);
701 }
702
703 }
704}
705
706void usb6fire_pcm_destroy(struct sfire_chip *chip)
707{
708 struct pcm_runtime *rt = chip->pcm;
709
710 usb6fire_pcm_buffers_destroy(rt);
711 kfree(rt);
712 chip->pcm = NULL;
713}
714
