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