sound/usb/6fire/pcm.c - third_party/linux - Git at Google

 /*
  * Linux driver for TerraTec DMX 6Fire USB
  *
  * PCM driver
  *
  * Author:	Torsten Schenk <torsten.schenk@zoho.com>
  * Created:	Jan 01, 2011
  * Copyright:	(C) Torsten Schenk
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  */

 #include "pcm.h"
 #include "chip.h"
 #include "comm.h"
 #include "control.h"

 enum {
 	OUT_N_CHANNELS = 6, IN_N_CHANNELS = 4
 };

 /* keep next two synced with
  * FW_EP_W_MAX_PACKET_SIZE[] and RATES_MAX_PACKET_SIZE
  * and CONTROL_RATE_XXX in control.h */
 static const int rates_in_packet_size[] = { 228, 228, 420, 420, 404, 404 };
 static const int rates_out_packet_size[] = { 228, 228, 420, 420, 604, 604 };
 static const int rates[] = { 44100, 48000, 88200, 96000, 176400, 192000 };
 static const int rates_alsaid[] = {
 	SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_48000,
 	SNDRV_PCM_RATE_88200, SNDRV_PCM_RATE_96000,
 	SNDRV_PCM_RATE_176400, SNDRV_PCM_RATE_192000 };

 enum { /* settings for pcm */
 	OUT_EP = 6, IN_EP = 2, MAX_BUFSIZE = 128 * 1024
 };

 enum { /* pcm streaming states */
 	STREAM_DISABLED, /* no pcm streaming */
 	STREAM_STARTING, /* pcm streaming requested, waiting to become ready */
 	STREAM_RUNNING, /* pcm streaming running */
 	STREAM_STOPPING
 };

 static const struct snd_pcm_hardware pcm_hw = {
 	.info = SNDRV_PCM_INFO_MMAP |
 		SNDRV_PCM_INFO_INTERLEAVED |
 		SNDRV_PCM_INFO_BLOCK_TRANSFER |
 		SNDRV_PCM_INFO_MMAP_VALID |
 		SNDRV_PCM_INFO_BATCH,

 	.formats = SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE,

 	.rates = SNDRV_PCM_RATE_44100 |
 		SNDRV_PCM_RATE_48000 |
 		SNDRV_PCM_RATE_88200 |
 		SNDRV_PCM_RATE_96000 |
 		SNDRV_PCM_RATE_176400 |
 		SNDRV_PCM_RATE_192000,

 	.rate_min = 44100,
 	.rate_max = 192000,
 	.channels_min = 1,
 	.channels_max = 0, /* set in pcm_open, depending on capture/playback */
 	.buffer_bytes_max = MAX_BUFSIZE,
 	.period_bytes_min = PCM_N_PACKETS_PER_URB * (PCM_MAX_PACKET_SIZE - 4),
 	.period_bytes_max = MAX_BUFSIZE,
 	.periods_min = 2,
 	.periods_max = 1024
 };

 static int usb6fire_pcm_set_rate(struct pcm_runtime *rt)
 {
 	int ret;
 	struct control_runtime *ctrl_rt = rt->chip->control;

 	ctrl_rt->usb_streaming = false;
 	ret = ctrl_rt->update_streaming(ctrl_rt);
 	if (ret < 0) {
 		dev_err(&rt->chip->dev->dev,
 			"error stopping streaming while setting samplerate %d.\n",
 			rates[rt->rate]);
 		return ret;
 	}

 	ret = ctrl_rt->set_rate(ctrl_rt, rt->rate);
 	if (ret < 0) {
 		dev_err(&rt->chip->dev->dev,
 			"error setting samplerate %d.\n",
 			rates[rt->rate]);
 		return ret;
 	}

 	ret = ctrl_rt->set_channels(ctrl_rt, OUT_N_CHANNELS, IN_N_CHANNELS,
 			false, false);
 	if (ret < 0) {
 		dev_err(&rt->chip->dev->dev,
 			"error initializing channels while setting samplerate %d.\n",
 			rates[rt->rate]);
 		return ret;
 	}

 	ctrl_rt->usb_streaming = true;
 	ret = ctrl_rt->update_streaming(ctrl_rt);
 	if (ret < 0) {
 		dev_err(&rt->chip->dev->dev,
 			"error starting streaming while setting samplerate %d.\n",
 			rates[rt->rate]);
 		return ret;
 	}

 	rt->in_n_analog = IN_N_CHANNELS;
 	rt->out_n_analog = OUT_N_CHANNELS;
 	rt->in_packet_size = rates_in_packet_size[rt->rate];
 	rt->out_packet_size = rates_out_packet_size[rt->rate];
 	return 0;
 }

 static struct pcm_substream *usb6fire_pcm_get_substream(
 		struct snd_pcm_substream *alsa_sub)
 {
 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);

 	if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
 		return &rt->playback;
 	else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE)
 		return &rt->capture;
 	dev_err(&rt->chip->dev->dev, "error getting pcm substream slot.\n");
 	return NULL;
 }

 /* call with stream_mutex locked */
 static void usb6fire_pcm_stream_stop(struct pcm_runtime *rt)
 {
 	int i;
 	struct control_runtime *ctrl_rt = rt->chip->control;

 	if (rt->stream_state != STREAM_DISABLED) {

 		rt->stream_state = STREAM_STOPPING;

 		for (i = 0; i < PCM_N_URBS; i++) {
 			usb_kill_urb(&rt->in_urbs[i].instance);
 			usb_kill_urb(&rt->out_urbs[i].instance);
 		}
 		ctrl_rt->usb_streaming = false;
 		ctrl_rt->update_streaming(ctrl_rt);
 		rt->stream_state = STREAM_DISABLED;
 	}
 }

 /* call with stream_mutex locked */
 static int usb6fire_pcm_stream_start(struct pcm_runtime *rt)
 {
 	int ret;
 	int i;
 	int k;
 	struct usb_iso_packet_descriptor *packet;

 	if (rt->stream_state == STREAM_DISABLED) {
 		/* submit our in urbs */
 		rt->stream_wait_cond = false;
 		rt->stream_state = STREAM_STARTING;
 		for (i = 0; i < PCM_N_URBS; i++) {
 			for (k = 0; k < PCM_N_PACKETS_PER_URB; k++) {
 				packet = &rt->in_urbs[i].packets[k];
 				packet->offset = k * rt->in_packet_size;
 				packet->length = rt->in_packet_size;
 				packet->actual_length = 0;
 				packet->status = 0;
 			}
 			ret = usb_submit_urb(&rt->in_urbs[i].instance,
 					GFP_ATOMIC);
 			if (ret) {
 				usb6fire_pcm_stream_stop(rt);
 				return ret;
 			}
 		}

 		/* wait for first out urb to return (sent in in urb handler) */
 		wait_event_timeout(rt->stream_wait_queue, rt->stream_wait_cond,
 				HZ);
 		if (rt->stream_wait_cond)
 			rt->stream_state = STREAM_RUNNING;
 		else {
 			usb6fire_pcm_stream_stop(rt);
 			return -EIO;
 		}
 	}
 	return 0;
 }

 /* call with substream locked */
 static void usb6fire_pcm_capture(struct pcm_substream *sub, struct pcm_urb *urb)
 {
 	int i;
 	int frame;
 	int frame_count;
 	unsigned int total_length = 0;
 	struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
 	struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
 	u32 *src = NULL;
 	u32 *dest = (u32 *) (alsa_rt->dma_area + sub->dma_off
 			* (alsa_rt->frame_bits >> 3));
 	u32 *dest_end = (u32 *) (alsa_rt->dma_area + alsa_rt->buffer_size
 			* (alsa_rt->frame_bits >> 3));
 	int bytes_per_frame = alsa_rt->channels << 2;

 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
 		/* at least 4 header bytes for valid packet.
 		 * after that: 32 bits per sample for analog channels */
 		if (urb->packets[i].actual_length > 4)
 			frame_count = (urb->packets[i].actual_length - 4)
 					/ (rt->in_n_analog << 2);
 		else
 			frame_count = 0;

 		if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
 			src = (u32 *) (urb->buffer + total_length);
 		else if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
 			src = (u32 *) (urb->buffer - 1 + total_length);
 		else
 			return;
 		src++; /* skip leading 4 bytes of every packet */
 		total_length += urb->packets[i].length;
 		for (frame = 0; frame < frame_count; frame++) {
 			memcpy(dest, src, bytes_per_frame);
 			dest += alsa_rt->channels;
 			src += rt->in_n_analog;
 			sub->dma_off++;
 			sub->period_off++;
 			if (dest == dest_end) {
 				sub->dma_off = 0;
 				dest = (u32 *) alsa_rt->dma_area;
 			}
 		}
 	}
 }

 /* call with substream locked */
 static void usb6fire_pcm_playback(struct pcm_substream *sub,
 		struct pcm_urb *urb)
 {
 	int i;
 	int frame;
 	int frame_count;
 	struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
 	struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
 	u32 *src = (u32 *) (alsa_rt->dma_area + sub->dma_off
 			* (alsa_rt->frame_bits >> 3));
 	u32 *src_end = (u32 *) (alsa_rt->dma_area + alsa_rt->buffer_size
 			* (alsa_rt->frame_bits >> 3));
 	u32 *dest;
 	int bytes_per_frame = alsa_rt->channels << 2;

 	if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
 		dest = (u32 *) (urb->buffer - 1);
 	else if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
 		dest = (u32 *) (urb->buffer);
 	else {
 		dev_err(&rt->chip->dev->dev, "Unknown sample format.");
 		return;
 	}

 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
 		/* at least 4 header bytes for valid packet.
 		 * after that: 32 bits per sample for analog channels */
 		if (urb->packets[i].length > 4)
 			frame_count = (urb->packets[i].length - 4)
 					/ (rt->out_n_analog << 2);
 		else
 			frame_count = 0;
 		dest++; /* skip leading 4 bytes of every frame */
 		for (frame = 0; frame < frame_count; frame++) {
 			memcpy(dest, src, bytes_per_frame);
 			src += alsa_rt->channels;
 			dest += rt->out_n_analog;
 			sub->dma_off++;
 			sub->period_off++;
 			if (src == src_end) {
 				src = (u32 *) alsa_rt->dma_area;
 				sub->dma_off = 0;
 			}
 		}
 	}
 }

 static void usb6fire_pcm_in_urb_handler(struct urb *usb_urb)
 {
 	struct pcm_urb *in_urb = usb_urb->context;
 	struct pcm_urb *out_urb = in_urb->peer;
 	struct pcm_runtime *rt = in_urb->chip->pcm;
 	struct pcm_substream *sub;
 	unsigned long flags;
 	int total_length = 0;
 	int frame_count;
 	int frame;
 	int channel;
 	int i;
 	u8 *dest;

 	if (usb_urb->status || rt->panic || rt->stream_state == STREAM_STOPPING)
 		return;
 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
 		if (in_urb->packets[i].status) {
 			rt->panic = true;
 			return;
 		}

 	if (rt->stream_state == STREAM_DISABLED) {
 		dev_err(&rt->chip->dev->dev,
 			"internal error: stream disabled in in-urb handler.\n");
 		return;
 	}

 	/* receive our capture data */
 	sub = &rt->capture;
 	spin_lock_irqsave(&sub->lock, flags);
 	if (sub->active) {
 		usb6fire_pcm_capture(sub, in_urb);
 		if (sub->period_off >= sub->instance->runtime->period_size) {
 			sub->period_off %= sub->instance->runtime->period_size;
 			spin_unlock_irqrestore(&sub->lock, flags);
 			snd_pcm_period_elapsed(sub->instance);
 		} else
 			spin_unlock_irqrestore(&sub->lock, flags);
 	} else
 		spin_unlock_irqrestore(&sub->lock, flags);

 	/* setup out urb structure */
 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
 		out_urb->packets[i].offset = total_length;
 		out_urb->packets[i].length = (in_urb->packets[i].actual_length
 				- 4) / (rt->in_n_analog << 2)
 				* (rt->out_n_analog << 2) + 4;
 		out_urb->packets[i].status = 0;
 		total_length += out_urb->packets[i].length;
 	}
 	memset(out_urb->buffer, 0, total_length);

 	/* now send our playback data (if a free out urb was found) */
 	sub = &rt->playback;
 	spin_lock_irqsave(&sub->lock, flags);
 	if (sub->active) {
 		usb6fire_pcm_playback(sub, out_urb);
 		if (sub->period_off >= sub->instance->runtime->period_size) {
 			sub->period_off %= sub->instance->runtime->period_size;
 			spin_unlock_irqrestore(&sub->lock, flags);
 			snd_pcm_period_elapsed(sub->instance);
 		} else
 			spin_unlock_irqrestore(&sub->lock, flags);
 	} else
 		spin_unlock_irqrestore(&sub->lock, flags);

 	/* setup the 4th byte of each sample (0x40 for analog channels) */
 	dest = out_urb->buffer;
 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
 		if (out_urb->packets[i].length >= 4) {
 			frame_count = (out_urb->packets[i].length - 4)
 					/ (rt->out_n_analog << 2);
 			*(dest++) = 0xaa;
 			*(dest++) = 0xaa;
 			*(dest++) = frame_count;
 			*(dest++) = 0x00;
 			for (frame = 0; frame < frame_count; frame++)
 				for (channel = 0;
 						channel < rt->out_n_analog;
 						channel++) {
 					dest += 3; /* skip sample data */
 					*(dest++) = 0x40;
 				}
 		}
 	usb_submit_urb(&out_urb->instance, GFP_ATOMIC);
 	usb_submit_urb(&in_urb->instance, GFP_ATOMIC);
 }

 static void usb6fire_pcm_out_urb_handler(struct urb *usb_urb)
 {
 	struct pcm_urb *urb = usb_urb->context;
 	struct pcm_runtime *rt = urb->chip->pcm;

 	if (rt->stream_state == STREAM_STARTING) {
 		rt->stream_wait_cond = true;
 		wake_up(&rt->stream_wait_queue);
 	}
 }

 static int usb6fire_pcm_open(struct snd_pcm_substream *alsa_sub)
 {
 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 	struct pcm_substream *sub = NULL;
 	struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;

 	if (rt->panic)
 		return -EPIPE;

 	mutex_lock(&rt->stream_mutex);
 	alsa_rt->hw = pcm_hw;

 	if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 		if (rt->rate < ARRAY_SIZE(rates))
 			alsa_rt->hw.rates = rates_alsaid[rt->rate];
 		alsa_rt->hw.channels_max = OUT_N_CHANNELS;
 		sub = &rt->playback;
 	} else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE) {
 		if (rt->rate < ARRAY_SIZE(rates))
 			alsa_rt->hw.rates = rates_alsaid[rt->rate];
 		alsa_rt->hw.channels_max = IN_N_CHANNELS;
 		sub = &rt->capture;
 	}

 	if (!sub) {
 		mutex_unlock(&rt->stream_mutex);
 		dev_err(&rt->chip->dev->dev, "invalid stream type.\n");
 		return -EINVAL;
 	}

 	sub->instance = alsa_sub;
 	sub->active = false;
 	mutex_unlock(&rt->stream_mutex);
 	return 0;
 }

 static int usb6fire_pcm_close(struct snd_pcm_substream *alsa_sub)
 {
 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 	unsigned long flags;

 	if (rt->panic)
 		return 0;

 	mutex_lock(&rt->stream_mutex);
 	if (sub) {
 		/* deactivate substream */
 		spin_lock_irqsave(&sub->lock, flags);
 		sub->instance = NULL;
 		sub->active = false;
 		spin_unlock_irqrestore(&sub->lock, flags);

 		/* all substreams closed? if so, stop streaming */
 		if (!rt->playback.instance && !rt->capture.instance) {
 			usb6fire_pcm_stream_stop(rt);
 			rt->rate = ARRAY_SIZE(rates);
 		}
 	}
 	mutex_unlock(&rt->stream_mutex);
 	return 0;
 }

 static int usb6fire_pcm_hw_params(struct snd_pcm_substream *alsa_sub,
 		struct snd_pcm_hw_params *hw_params)
 {
 	return snd_pcm_lib_alloc_vmalloc_buffer(alsa_sub,
 						params_buffer_bytes(hw_params));
 }

 static int usb6fire_pcm_hw_free(struct snd_pcm_substream *alsa_sub)
 {
 	return snd_pcm_lib_free_vmalloc_buffer(alsa_sub);
 }

 static int usb6fire_pcm_prepare(struct snd_pcm_substream *alsa_sub)
 {
 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 	struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
 	int ret;

 	if (rt->panic)
 		return -EPIPE;
 	if (!sub)
 		return -ENODEV;

 	mutex_lock(&rt->stream_mutex);
 	sub->dma_off = 0;
 	sub->period_off = 0;

 	if (rt->stream_state == STREAM_DISABLED) {
 		for (rt->rate = 0; rt->rate < ARRAY_SIZE(rates); rt->rate++)
 			if (alsa_rt->rate == rates[rt->rate])
 				break;
 		if (rt->rate == ARRAY_SIZE(rates)) {
 			mutex_unlock(&rt->stream_mutex);
 			dev_err(&rt->chip->dev->dev,
 				"invalid rate %d in prepare.\n",
 				alsa_rt->rate);
 			return -EINVAL;
 		}

 		ret = usb6fire_pcm_set_rate(rt);
 		if (ret) {
 			mutex_unlock(&rt->stream_mutex);
 			return ret;
 		}
 		ret = usb6fire_pcm_stream_start(rt);
 		if (ret) {
 			mutex_unlock(&rt->stream_mutex);
 			dev_err(&rt->chip->dev->dev,
 				"could not start pcm stream.\n");
 			return ret;
 		}
 	}
 	mutex_unlock(&rt->stream_mutex);
 	return 0;
 }

 static int usb6fire_pcm_trigger(struct snd_pcm_substream *alsa_sub, int cmd)
 {
 	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 	unsigned long flags;

 	if (rt->panic)
 		return -EPIPE;
 	if (!sub)
 		return -ENODEV;

 	switch (cmd) {
 	case SNDRV_PCM_TRIGGER_START:
 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 		spin_lock_irqsave(&sub->lock, flags);
 		sub->active = true;
 		spin_unlock_irqrestore(&sub->lock, flags);
 		return 0;

 	case SNDRV_PCM_TRIGGER_STOP:
 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 		spin_lock_irqsave(&sub->lock, flags);
 		sub->active = false;
 		spin_unlock_irqrestore(&sub->lock, flags);
 		return 0;

 	default:
 		return -EINVAL;
 	}
 }

 static snd_pcm_uframes_t usb6fire_pcm_pointer(
 		struct snd_pcm_substream *alsa_sub)
 {
 	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
 	unsigned long flags;
 	snd_pcm_uframes_t ret;

 	if (rt->panic || !sub)
 		return SNDRV_PCM_POS_XRUN;

 	spin_lock_irqsave(&sub->lock, flags);
 	ret = sub->dma_off;
 	spin_unlock_irqrestore(&sub->lock, flags);
 	return ret;
 }

 static const struct snd_pcm_ops pcm_ops = {
 	.open = usb6fire_pcm_open,
 	.close = usb6fire_pcm_close,
 	.ioctl = snd_pcm_lib_ioctl,
 	.hw_params = usb6fire_pcm_hw_params,
 	.hw_free = usb6fire_pcm_hw_free,
 	.prepare = usb6fire_pcm_prepare,
 	.trigger = usb6fire_pcm_trigger,
 	.pointer = usb6fire_pcm_pointer,
 	.page = snd_pcm_lib_get_vmalloc_page,
 	.mmap = snd_pcm_lib_mmap_vmalloc,
 };

 static void usb6fire_pcm_init_urb(struct pcm_urb *urb,
 				  struct sfire_chip *chip, bool in, int ep,
 				  void (*handler)(struct urb *))
 {
 	urb->chip = chip;
 	usb_init_urb(&urb->instance);
 	urb->instance.transfer_buffer = urb->buffer;
 	urb->instance.transfer_buffer_length =
 			PCM_N_PACKETS_PER_URB * PCM_MAX_PACKET_SIZE;
 	urb->instance.dev = chip->dev;
 	urb->instance.pipe = in ? usb_rcvisocpipe(chip->dev, ep)
 			: usb_sndisocpipe(chip->dev, ep);
 	urb->instance.interval = 1;
 	urb->instance.complete = handler;
 	urb->instance.context = urb;
 	urb->instance.number_of_packets = PCM_N_PACKETS_PER_URB;
 }

 static int usb6fire_pcm_buffers_init(struct pcm_runtime *rt)
 {
 	int i;

 	for (i = 0; i < PCM_N_URBS; i++) {
 		rt->out_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
 						 PCM_N_PACKETS_PER_URB,
 						 GFP_KERNEL);
 		if (!rt->out_urbs[i].buffer)
 			return -ENOMEM;
 		rt->in_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
 						PCM_N_PACKETS_PER_URB,
 						GFP_KERNEL);
 		if (!rt->in_urbs[i].buffer)
 			return -ENOMEM;
 	}
 	return 0;
 }

 static void usb6fire_pcm_buffers_destroy(struct pcm_runtime *rt)
 {
 	int i;

 	for (i = 0; i < PCM_N_URBS; i++) {
 		kfree(rt->out_urbs[i].buffer);
 		kfree(rt->in_urbs[i].buffer);
 	}
 }

 int usb6fire_pcm_init(struct sfire_chip *chip)
 {
 	int i;
 	int ret;
 	struct snd_pcm *pcm;
 	struct pcm_runtime *rt =
 			kzalloc(sizeof(struct pcm_runtime), GFP_KERNEL);

 	if (!rt)
 		return -ENOMEM;

 	ret = usb6fire_pcm_buffers_init(rt);
 	if (ret) {
 		usb6fire_pcm_buffers_destroy(rt);
 		kfree(rt);
 		return ret;
 	}

 	rt->chip = chip;
 	rt->stream_state = STREAM_DISABLED;
 	rt->rate = ARRAY_SIZE(rates);
 	init_waitqueue_head(&rt->stream_wait_queue);
 	mutex_init(&rt->stream_mutex);

 	spin_lock_init(&rt->playback.lock);
 	spin_lock_init(&rt->capture.lock);

 	for (i = 0; i < PCM_N_URBS; i++) {
 		usb6fire_pcm_init_urb(&rt->in_urbs[i], chip, true, IN_EP,
 				usb6fire_pcm_in_urb_handler);
 		usb6fire_pcm_init_urb(&rt->out_urbs[i], chip, false, OUT_EP,
 				usb6fire_pcm_out_urb_handler);

 		rt->in_urbs[i].peer = &rt->out_urbs[i];
 		rt->out_urbs[i].peer = &rt->in_urbs[i];
 	}

 	ret = snd_pcm_new(chip->card, "DMX6FireUSB", 0, 1, 1, &pcm);
 	if (ret < 0) {
 		usb6fire_pcm_buffers_destroy(rt);
 		kfree(rt);
 		dev_err(&chip->dev->dev, "cannot create pcm instance.\n");
 		return ret;
 	}

 	pcm->private_data = rt;
 	strcpy(pcm->name, "DMX 6Fire USB");
 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops);
 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_ops);

 	if (ret) {
 		usb6fire_pcm_buffers_destroy(rt);
 		kfree(rt);
 		dev_err(&chip->dev->dev,
 			"error preallocating pcm buffers.\n");
 		return ret;
 	}
 	rt->instance = pcm;

 	chip->pcm = rt;
 	return 0;
 }

 void usb6fire_pcm_abort(struct sfire_chip *chip)
 {
 	struct pcm_runtime *rt = chip->pcm;
 	int i;

 	if (rt) {
 		rt->panic = true;

 		if (rt->playback.instance)
 			snd_pcm_stop_xrun(rt->playback.instance);

 		if (rt->capture.instance)
 			snd_pcm_stop_xrun(rt->capture.instance);

 		for (i = 0; i < PCM_N_URBS; i++) {
 			usb_poison_urb(&rt->in_urbs[i].instance);
 			usb_poison_urb(&rt->out_urbs[i].instance);
 		}

 	}
 }

 void usb6fire_pcm_destroy(struct sfire_chip *chip)
 {
 	struct pcm_runtime *rt = chip->pcm;

 	usb6fire_pcm_buffers_destroy(rt);
 	kfree(rt);
 	chip->pcm = NULL;
 }
	/*
	* Linux driver for TerraTec DMX 6Fire USB
	*
	* PCM driver
	*
	* Author: Torsten Schenk <torsten.schenk@zoho.com>
	* Created: Jan 01, 2011
	* Copyright: (C) Torsten Schenk
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*/

	#include "pcm.h"
	#include "chip.h"
	#include "comm.h"
	#include "control.h"

	enum {
	OUT_N_CHANNELS = 6, IN_N_CHANNELS = 4
	};

	/* keep next two synced with
	* FW_EP_W_MAX_PACKET_SIZE[] and RATES_MAX_PACKET_SIZE
	* and CONTROL_RATE_XXX in control.h */
	static const int rates_in_packet_size[] = { 228, 228, 420, 420, 404, 404 };
	static const int rates_out_packet_size[] = { 228, 228, 420, 420, 604, 604 };
	static const int rates[] = { 44100, 48000, 88200, 96000, 176400, 192000 };
	static const int rates_alsaid[] = {
	SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_48000,
	SNDRV_PCM_RATE_88200, SNDRV_PCM_RATE_96000,
	SNDRV_PCM_RATE_176400, SNDRV_PCM_RATE_192000 };

	enum { /* settings for pcm */
	OUT_EP = 6, IN_EP = 2, MAX_BUFSIZE = 128 * 1024
	};

	enum { /* pcm streaming states */
	STREAM_DISABLED, /* no pcm streaming */
	STREAM_STARTING, /* pcm streaming requested, waiting to become ready */
	STREAM_RUNNING, /* pcm streaming running */
	STREAM_STOPPING
	};

	static const struct snd_pcm_hardware pcm_hw = {
	.info = SNDRV_PCM_INFO_MMAP \|
	SNDRV_PCM_INFO_INTERLEAVED \|
	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	SNDRV_PCM_INFO_MMAP_VALID \|
	SNDRV_PCM_INFO_BATCH,

	.formats = SNDRV_PCM_FMTBIT_S24_LE \| SNDRV_PCM_FMTBIT_S32_LE,

	.rates = SNDRV_PCM_RATE_44100 \|
	SNDRV_PCM_RATE_48000 \|
	SNDRV_PCM_RATE_88200 \|
	SNDRV_PCM_RATE_96000 \|
	SNDRV_PCM_RATE_176400 \|
	SNDRV_PCM_RATE_192000,

	.rate_min = 44100,
	.rate_max = 192000,
	.channels_min = 1,
	.channels_max = 0, /* set in pcm_open, depending on capture/playback */
	.buffer_bytes_max = MAX_BUFSIZE,
	.period_bytes_min = PCM_N_PACKETS_PER_URB * (PCM_MAX_PACKET_SIZE - 4),
	.period_bytes_max = MAX_BUFSIZE,
	.periods_min = 2,
	.periods_max = 1024
	};

	static int usb6fire_pcm_set_rate(struct pcm_runtime *rt)
	{
	int ret;
	struct control_runtime *ctrl_rt = rt->chip->control;

	ctrl_rt->usb_streaming = false;
	ret = ctrl_rt->update_streaming(ctrl_rt);
	if (ret < 0) {
	dev_err(&rt->chip->dev->dev,
	"error stopping streaming while setting samplerate %d.\n",
	rates[rt->rate]);
	return ret;
	}

	ret = ctrl_rt->set_rate(ctrl_rt, rt->rate);
	if (ret < 0) {
	dev_err(&rt->chip->dev->dev,
	"error setting samplerate %d.\n",
	rates[rt->rate]);
	return ret;
	}

	ret = ctrl_rt->set_channels(ctrl_rt, OUT_N_CHANNELS, IN_N_CHANNELS,
	false, false);
	if (ret < 0) {
	dev_err(&rt->chip->dev->dev,
	"error initializing channels while setting samplerate %d.\n",
	rates[rt->rate]);
	return ret;
	}

	ctrl_rt->usb_streaming = true;
	ret = ctrl_rt->update_streaming(ctrl_rt);
	if (ret < 0) {
	dev_err(&rt->chip->dev->dev,
	"error starting streaming while setting samplerate %d.\n",
	rates[rt->rate]);
	return ret;
	}

	rt->in_n_analog = IN_N_CHANNELS;
	rt->out_n_analog = OUT_N_CHANNELS;
	rt->in_packet_size = rates_in_packet_size[rt->rate];
	rt->out_packet_size = rates_out_packet_size[rt->rate];
	return 0;
	}

	static struct pcm_substream *usb6fire_pcm_get_substream(
	struct snd_pcm_substream *alsa_sub)
	{
	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);

	if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
	return &rt->playback;
	else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE)
	return &rt->capture;
	dev_err(&rt->chip->dev->dev, "error getting pcm substream slot.\n");
	return NULL;
	}

	/* call with stream_mutex locked */
	static void usb6fire_pcm_stream_stop(struct pcm_runtime *rt)
	{
	int i;
	struct control_runtime *ctrl_rt = rt->chip->control;

	if (rt->stream_state != STREAM_DISABLED) {

	rt->stream_state = STREAM_STOPPING;

	for (i = 0; i < PCM_N_URBS; i++) {
	usb_kill_urb(&rt->in_urbs[i].instance);
	usb_kill_urb(&rt->out_urbs[i].instance);
	}
	ctrl_rt->usb_streaming = false;
	ctrl_rt->update_streaming(ctrl_rt);
	rt->stream_state = STREAM_DISABLED;
	}
	}

	/* call with stream_mutex locked */
	static int usb6fire_pcm_stream_start(struct pcm_runtime *rt)
	{
	int ret;
	int i;
	int k;
	struct usb_iso_packet_descriptor *packet;

	if (rt->stream_state == STREAM_DISABLED) {
	/* submit our in urbs */
	rt->stream_wait_cond = false;
	rt->stream_state = STREAM_STARTING;
	for (i = 0; i < PCM_N_URBS; i++) {
	for (k = 0; k < PCM_N_PACKETS_PER_URB; k++) {
	packet = &rt->in_urbs[i].packets[k];
	packet->offset = k * rt->in_packet_size;
	packet->length = rt->in_packet_size;
	packet->actual_length = 0;
	packet->status = 0;
	}
	ret = usb_submit_urb(&rt->in_urbs[i].instance,
	GFP_ATOMIC);
	if (ret) {
	usb6fire_pcm_stream_stop(rt);
	return ret;
	}
	}

	/* wait for first out urb to return (sent in in urb handler) */
	wait_event_timeout(rt->stream_wait_queue, rt->stream_wait_cond,
	HZ);
	if (rt->stream_wait_cond)
	rt->stream_state = STREAM_RUNNING;
	else {
	usb6fire_pcm_stream_stop(rt);
	return -EIO;
	}
	}
	return 0;
	}

	/* call with substream locked */
	static void usb6fire_pcm_capture(struct pcm_substream sub, struct pcm_urb urb)
	{
	int i;
	int frame;
	int frame_count;
	unsigned int total_length = 0;
	struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
	struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
	u32 *src = NULL;
	u32 dest = (u32 ) (alsa_rt->dma_area + sub->dma_off
	* (alsa_rt->frame_bits >> 3));
	u32 dest_end = (u32 ) (alsa_rt->dma_area + alsa_rt->buffer_size
	* (alsa_rt->frame_bits >> 3));
	int bytes_per_frame = alsa_rt->channels << 2;

	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
	/* at least 4 header bytes for valid packet.
	* after that: 32 bits per sample for analog channels */
	if (urb->packets[i].actual_length > 4)
	frame_count = (urb->packets[i].actual_length - 4)
	/ (rt->in_n_analog << 2);
	else
	frame_count = 0;

	if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
	src = (u32 *) (urb->buffer + total_length);
	else if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
	src = (u32 *) (urb->buffer - 1 + total_length);
	else
	return;
	src++; /* skip leading 4 bytes of every packet */
	total_length += urb->packets[i].length;
	for (frame = 0; frame < frame_count; frame++) {
	memcpy(dest, src, bytes_per_frame);
	dest += alsa_rt->channels;
	src += rt->in_n_analog;
	sub->dma_off++;
	sub->period_off++;
	if (dest == dest_end) {
	sub->dma_off = 0;
	dest = (u32 *) alsa_rt->dma_area;
	}
	}
	}
	}

	/* call with substream locked */
	static void usb6fire_pcm_playback(struct pcm_substream *sub,
	struct pcm_urb *urb)
	{
	int i;
	int frame;
	int frame_count;
	struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
	struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
	u32 src = (u32 ) (alsa_rt->dma_area + sub->dma_off
	* (alsa_rt->frame_bits >> 3));
	u32 src_end = (u32 ) (alsa_rt->dma_area + alsa_rt->buffer_size
	* (alsa_rt->frame_bits >> 3));
	u32 *dest;
	int bytes_per_frame = alsa_rt->channels << 2;

	if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
	dest = (u32 *) (urb->buffer - 1);
	else if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
	dest = (u32 *) (urb->buffer);
	else {
	dev_err(&rt->chip->dev->dev, "Unknown sample format.");
	return;
	}

	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
	/* at least 4 header bytes for valid packet.
	* after that: 32 bits per sample for analog channels */
	if (urb->packets[i].length > 4)
	frame_count = (urb->packets[i].length - 4)
	/ (rt->out_n_analog << 2);
	else
	frame_count = 0;
	dest++; /* skip leading 4 bytes of every frame */
	for (frame = 0; frame < frame_count; frame++) {
	memcpy(dest, src, bytes_per_frame);
	src += alsa_rt->channels;
	dest += rt->out_n_analog;
	sub->dma_off++;
	sub->period_off++;
	if (src == src_end) {
	src = (u32 *) alsa_rt->dma_area;
	sub->dma_off = 0;
	}
	}
	}
	}

	static void usb6fire_pcm_in_urb_handler(struct urb *usb_urb)
	{
	struct pcm_urb *in_urb = usb_urb->context;
	struct pcm_urb *out_urb = in_urb->peer;
	struct pcm_runtime *rt = in_urb->chip->pcm;
	struct pcm_substream *sub;
	unsigned long flags;
	int total_length = 0;
	int frame_count;
	int frame;
	int channel;
	int i;
	u8 *dest;

	if (usb_urb->status \|\| rt->panic \|\| rt->stream_state == STREAM_STOPPING)
	return;
	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
	if (in_urb->packets[i].status) {
	rt->panic = true;
	return;
	}

	if (rt->stream_state == STREAM_DISABLED) {
	dev_err(&rt->chip->dev->dev,
	"internal error: stream disabled in in-urb handler.\n");
	return;
	}

	/* receive our capture data */
	sub = &rt->capture;
	spin_lock_irqsave(&sub->lock, flags);
	if (sub->active) {
	usb6fire_pcm_capture(sub, in_urb);
	if (sub->period_off >= sub->instance->runtime->period_size) {
	sub->period_off %= sub->instance->runtime->period_size;
	spin_unlock_irqrestore(&sub->lock, flags);
	snd_pcm_period_elapsed(sub->instance);
	} else
	spin_unlock_irqrestore(&sub->lock, flags);
	} else
	spin_unlock_irqrestore(&sub->lock, flags);

	/* setup out urb structure */
	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
	out_urb->packets[i].offset = total_length;
	out_urb->packets[i].length = (in_urb->packets[i].actual_length
	- 4) / (rt->in_n_analog << 2)
	* (rt->out_n_analog << 2) + 4;
	out_urb->packets[i].status = 0;
	total_length += out_urb->packets[i].length;
	}
	memset(out_urb->buffer, 0, total_length);

	/* now send our playback data (if a free out urb was found) */
	sub = &rt->playback;
	spin_lock_irqsave(&sub->lock, flags);
	if (sub->active) {
	usb6fire_pcm_playback(sub, out_urb);
	if (sub->period_off >= sub->instance->runtime->period_size) {
	sub->period_off %= sub->instance->runtime->period_size;
	spin_unlock_irqrestore(&sub->lock, flags);
	snd_pcm_period_elapsed(sub->instance);
	} else
	spin_unlock_irqrestore(&sub->lock, flags);
	} else
	spin_unlock_irqrestore(&sub->lock, flags);

	/* setup the 4th byte of each sample (0x40 for analog channels) */
	dest = out_urb->buffer;
	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
	if (out_urb->packets[i].length >= 4) {
	frame_count = (out_urb->packets[i].length - 4)
	/ (rt->out_n_analog << 2);
	*(dest++) = 0xaa;
	*(dest++) = 0xaa;
	*(dest++) = frame_count;
	*(dest++) = 0x00;
	for (frame = 0; frame < frame_count; frame++)
	for (channel = 0;
	channel < rt->out_n_analog;
	channel++) {
	dest += 3; /* skip sample data */
	*(dest++) = 0x40;
	}
	}
	usb_submit_urb(&out_urb->instance, GFP_ATOMIC);
	usb_submit_urb(&in_urb->instance, GFP_ATOMIC);
	}

	static void usb6fire_pcm_out_urb_handler(struct urb *usb_urb)
	{
	struct pcm_urb *urb = usb_urb->context;
	struct pcm_runtime *rt = urb->chip->pcm;

	if (rt->stream_state == STREAM_STARTING) {
	rt->stream_wait_cond = true;
	wake_up(&rt->stream_wait_queue);
	}
	}

	static int usb6fire_pcm_open(struct snd_pcm_substream *alsa_sub)
	{
	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
	struct pcm_substream *sub = NULL;
	struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;

	if (rt->panic)
	return -EPIPE;

	mutex_lock(&rt->stream_mutex);
	alsa_rt->hw = pcm_hw;

	if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	if (rt->rate < ARRAY_SIZE(rates))
	alsa_rt->hw.rates = rates_alsaid[rt->rate];
	alsa_rt->hw.channels_max = OUT_N_CHANNELS;
	sub = &rt->playback;
	} else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE) {
	if (rt->rate < ARRAY_SIZE(rates))
	alsa_rt->hw.rates = rates_alsaid[rt->rate];
	alsa_rt->hw.channels_max = IN_N_CHANNELS;
	sub = &rt->capture;
	}

	if (!sub) {
	mutex_unlock(&rt->stream_mutex);
	dev_err(&rt->chip->dev->dev, "invalid stream type.\n");
	return -EINVAL;
	}

	sub->instance = alsa_sub;
	sub->active = false;
	mutex_unlock(&rt->stream_mutex);
	return 0;
	}

	static int usb6fire_pcm_close(struct snd_pcm_substream *alsa_sub)
	{
	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
	unsigned long flags;

	if (rt->panic)
	return 0;

	mutex_lock(&rt->stream_mutex);
	if (sub) {
	/* deactivate substream */
	spin_lock_irqsave(&sub->lock, flags);
	sub->instance = NULL;
	sub->active = false;
	spin_unlock_irqrestore(&sub->lock, flags);

	/* all substreams closed? if so, stop streaming */
	if (!rt->playback.instance && !rt->capture.instance) {
	usb6fire_pcm_stream_stop(rt);
	rt->rate = ARRAY_SIZE(rates);
	}
	}
	mutex_unlock(&rt->stream_mutex);
	return 0;
	}

	static int usb6fire_pcm_hw_params(struct snd_pcm_substream *alsa_sub,
	struct snd_pcm_hw_params *hw_params)
	{
	return snd_pcm_lib_alloc_vmalloc_buffer(alsa_sub,
	params_buffer_bytes(hw_params));
	}

	static int usb6fire_pcm_hw_free(struct snd_pcm_substream *alsa_sub)
	{
	return snd_pcm_lib_free_vmalloc_buffer(alsa_sub);
	}

	static int usb6fire_pcm_prepare(struct snd_pcm_substream *alsa_sub)
	{
	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
	struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
	int ret;

	if (rt->panic)
	return -EPIPE;
	if (!sub)
	return -ENODEV;

	mutex_lock(&rt->stream_mutex);
	sub->dma_off = 0;
	sub->period_off = 0;

	if (rt->stream_state == STREAM_DISABLED) {
	for (rt->rate = 0; rt->rate < ARRAY_SIZE(rates); rt->rate++)
	if (alsa_rt->rate == rates[rt->rate])
	break;
	if (rt->rate == ARRAY_SIZE(rates)) {
	mutex_unlock(&rt->stream_mutex);
	dev_err(&rt->chip->dev->dev,
	"invalid rate %d in prepare.\n",
	alsa_rt->rate);
	return -EINVAL;
	}

	ret = usb6fire_pcm_set_rate(rt);
	if (ret) {
	mutex_unlock(&rt->stream_mutex);
	return ret;
	}
	ret = usb6fire_pcm_stream_start(rt);
	if (ret) {
	mutex_unlock(&rt->stream_mutex);
	dev_err(&rt->chip->dev->dev,
	"could not start pcm stream.\n");
	return ret;
	}
	}
	mutex_unlock(&rt->stream_mutex);
	return 0;
	}

	static int usb6fire_pcm_trigger(struct snd_pcm_substream *alsa_sub, int cmd)
	{
	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
	unsigned long flags;

	if (rt->panic)
	return -EPIPE;
	if (!sub)
	return -ENODEV;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	spin_lock_irqsave(&sub->lock, flags);
	sub->active = true;
	spin_unlock_irqrestore(&sub->lock, flags);
	return 0;

	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	spin_lock_irqsave(&sub->lock, flags);
	sub->active = false;
	spin_unlock_irqrestore(&sub->lock, flags);
	return 0;

	default:
	return -EINVAL;
	}
	}

	static snd_pcm_uframes_t usb6fire_pcm_pointer(
	struct snd_pcm_substream *alsa_sub)
	{
	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
	unsigned long flags;
	snd_pcm_uframes_t ret;

	if (rt->panic \|\| !sub)
	return SNDRV_PCM_POS_XRUN;

	spin_lock_irqsave(&sub->lock, flags);
	ret = sub->dma_off;
	spin_unlock_irqrestore(&sub->lock, flags);
	return ret;
	}

	static const struct snd_pcm_ops pcm_ops = {
	.open = usb6fire_pcm_open,
	.close = usb6fire_pcm_close,
	.ioctl = snd_pcm_lib_ioctl,
	.hw_params = usb6fire_pcm_hw_params,
	.hw_free = usb6fire_pcm_hw_free,
	.prepare = usb6fire_pcm_prepare,
	.trigger = usb6fire_pcm_trigger,
	.pointer = usb6fire_pcm_pointer,
	.page = snd_pcm_lib_get_vmalloc_page,
	.mmap = snd_pcm_lib_mmap_vmalloc,
	};

	static void usb6fire_pcm_init_urb(struct pcm_urb *urb,
	struct sfire_chip *chip, bool in, int ep,
	void (handler)(struct urb ))
	{
	urb->chip = chip;
	usb_init_urb(&urb->instance);
	urb->instance.transfer_buffer = urb->buffer;
	urb->instance.transfer_buffer_length =
	PCM_N_PACKETS_PER_URB * PCM_MAX_PACKET_SIZE;
	urb->instance.dev = chip->dev;
	urb->instance.pipe = in ? usb_rcvisocpipe(chip->dev, ep)
	: usb_sndisocpipe(chip->dev, ep);
	urb->instance.interval = 1;
	urb->instance.complete = handler;
	urb->instance.context = urb;
	urb->instance.number_of_packets = PCM_N_PACKETS_PER_URB;
	}

	static int usb6fire_pcm_buffers_init(struct pcm_runtime *rt)
	{
	int i;

	for (i = 0; i < PCM_N_URBS; i++) {
	rt->out_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
	PCM_N_PACKETS_PER_URB,
	GFP_KERNEL);
	if (!rt->out_urbs[i].buffer)
	return -ENOMEM;
	rt->in_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
	PCM_N_PACKETS_PER_URB,
	GFP_KERNEL);
	if (!rt->in_urbs[i].buffer)
	return -ENOMEM;
	}
	return 0;
	}

	static void usb6fire_pcm_buffers_destroy(struct pcm_runtime *rt)
	{
	int i;

	for (i = 0; i < PCM_N_URBS; i++) {
	kfree(rt->out_urbs[i].buffer);
	kfree(rt->in_urbs[i].buffer);
	}
	}

	int usb6fire_pcm_init(struct sfire_chip *chip)
	{
	int i;
	int ret;
	struct snd_pcm *pcm;
	struct pcm_runtime *rt =
	kzalloc(sizeof(struct pcm_runtime), GFP_KERNEL);

	if (!rt)
	return -ENOMEM;

	ret = usb6fire_pcm_buffers_init(rt);
	if (ret) {
	usb6fire_pcm_buffers_destroy(rt);
	kfree(rt);
	return ret;
	}

	rt->chip = chip;
	rt->stream_state = STREAM_DISABLED;
	rt->rate = ARRAY_SIZE(rates);
	init_waitqueue_head(&rt->stream_wait_queue);
	mutex_init(&rt->stream_mutex);

	spin_lock_init(&rt->playback.lock);
	spin_lock_init(&rt->capture.lock);

	for (i = 0; i < PCM_N_URBS; i++) {
	usb6fire_pcm_init_urb(&rt->in_urbs[i], chip, true, IN_EP,
	usb6fire_pcm_in_urb_handler);
	usb6fire_pcm_init_urb(&rt->out_urbs[i], chip, false, OUT_EP,
	usb6fire_pcm_out_urb_handler);

	rt->in_urbs[i].peer = &rt->out_urbs[i];
	rt->out_urbs[i].peer = &rt->in_urbs[i];
	}

	ret = snd_pcm_new(chip->card, "DMX6FireUSB", 0, 1, 1, &pcm);
	if (ret < 0) {
	usb6fire_pcm_buffers_destroy(rt);
	kfree(rt);
	dev_err(&chip->dev->dev, "cannot create pcm instance.\n");
	return ret;
	}

	pcm->private_data = rt;
	strcpy(pcm->name, "DMX 6Fire USB");
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops);
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_ops);

	if (ret) {
	usb6fire_pcm_buffers_destroy(rt);
	kfree(rt);
	dev_err(&chip->dev->dev,
	"error preallocating pcm buffers.\n");
	return ret;
	}
	rt->instance = pcm;

	chip->pcm = rt;
	return 0;
	}

	void usb6fire_pcm_abort(struct sfire_chip *chip)
	{
	struct pcm_runtime *rt = chip->pcm;
	int i;

	if (rt) {
	rt->panic = true;

	if (rt->playback.instance)
	snd_pcm_stop_xrun(rt->playback.instance);

	if (rt->capture.instance)
	snd_pcm_stop_xrun(rt->capture.instance);

	for (i = 0; i < PCM_N_URBS; i++) {
	usb_poison_urb(&rt->in_urbs[i].instance);
	usb_poison_urb(&rt->out_urbs[i].instance);
	}

	}
	}

	void usb6fire_pcm_destroy(struct sfire_chip *chip)
	{
	struct pcm_runtime *rt = chip->pcm;

	usb6fire_pcm_buffers_destroy(rt);
	kfree(rt);
	chip->pcm = NULL;
	}