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