// 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_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,
};

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;
}