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