Orange Pi5 kernel

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