text: // SPDX-License-Identifier: GPL-2.0-or-later
  /*
   * Linux driver for TerraTec DMX 6Fire USB
   *
   * PCM driver
   *
   * Author:	Torsten Schenk <torsten.schenk@zoho.com>
   * Created:	Jan 01, 2011
   * Copyright:	(C) Torsten Schenk
   */
  
  #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_malloc_pages(alsa_sub,
  					params_buffer_bytes(hw_params));
  }
  
  static int usb6fire_pcm_hw_free(struct snd_pcm_substream *alsa_sub)
  {
  	return snd_pcm_lib_free_pages(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,
  };
  
  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);
  	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_VMALLOC,
  					      NULL, 0, 0);
  
  	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;
  }
  