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