cregit-Linux how code gets into the kernel

Release 4.8 sound/mips/sgio2audio.c

Directory: sound/mips
/*
 *   Sound driver for Silicon Graphics O2 Workstations A/V board audio.
 *
 *   Copyright 2003 Vivien Chappelier <vivien.chappelier@linux-mips.org>
 *   Copyright 2008 Thomas Bogendoerfer <tsbogend@alpha.franken.de>
 *   Mxier part taken from mace_audio.c:
 *   Copyright 2007 Thorben Jändling <tj.trevelyan@gmail.com>
 *
 *   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.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/module.h>

#include <asm/ip32/ip32_ints.h>
#include <asm/ip32/mace.h>

#include <sound/core.h>
#include <sound/control.h>
#include <sound/pcm.h>

#define SNDRV_GET_ID
#include <sound/initval.h>
#include <sound/ad1843.h>


MODULE_AUTHOR("Vivien Chappelier <vivien.chappelier@linux-mips.org>");
MODULE_DESCRIPTION("SGI O2 Audio");
MODULE_LICENSE("GPL");
MODULE_SUPPORTED_DEVICE("{{Silicon Graphics, O2 Audio}}");


static int index = SNDRV_DEFAULT_IDX1;  
/* Index 0-MAX */

static char *id = SNDRV_DEFAULT_STR1;   
/* ID for this card */

module_param(index, int, 0444);
MODULE_PARM_DESC(index, "Index value for SGI O2 soundcard.");
module_param(id, charp, 0444);
MODULE_PARM_DESC(id, "ID string for SGI O2 soundcard.");



#define AUDIO_CONTROL_RESET              BIT(0) 
/* 1: reset audio interface */

#define AUDIO_CONTROL_CODEC_PRESENT      BIT(1) 
/* 1: codec detected */


#define CODEC_CONTROL_WORD_SHIFT        0

#define CODEC_CONTROL_READ              BIT(16)

#define CODEC_CONTROL_ADDRESS_SHIFT     17


#define CHANNEL_CONTROL_RESET           BIT(10) 
/* 1: reset channel */

#define CHANNEL_DMA_ENABLE              BIT(9)  
/* 1: enable DMA transfer */

#define CHANNEL_INT_THRESHOLD_DISABLED  (0 << 5) 
/* interrupt disabled */

#define CHANNEL_INT_THRESHOLD_25        (1 << 5) 
/* int on buffer >25% full */

#define CHANNEL_INT_THRESHOLD_50        (2 << 5) 
/* int on buffer >50% full */

#define CHANNEL_INT_THRESHOLD_75        (3 << 5) 
/* int on buffer >75% full */

#define CHANNEL_INT_THRESHOLD_EMPTY     (4 << 5) 
/* int on buffer empty */

#define CHANNEL_INT_THRESHOLD_NOT_EMPTY (5 << 5) 
/* int on buffer !empty */

#define CHANNEL_INT_THRESHOLD_FULL      (6 << 5) 
/* int on buffer empty */

#define CHANNEL_INT_THRESHOLD_NOT_FULL  (7 << 5) 
/* int on buffer !empty */


#define CHANNEL_RING_SHIFT              12

#define CHANNEL_RING_SIZE               (1 << CHANNEL_RING_SHIFT)

#define CHANNEL_RING_MASK               (CHANNEL_RING_SIZE - 1)


#define CHANNEL_LEFT_SHIFT 40

#define CHANNEL_RIGHT_SHIFT 8


struct snd_sgio2audio_chan {
	
int idx;
	
struct snd_pcm_substream *substream;
	
int pos;
	
snd_pcm_uframes_t size;
	
spinlock_t lock;
};

/* definition of the chip-specific record */

struct snd_sgio2audio {
	
struct snd_card *card;

	/* codec */
	
struct snd_ad1843 ad1843;
	
spinlock_t ad1843_lock;

	/* channels */
	
struct snd_sgio2audio_chan channel[3];

	/* resources */
	
void *ring_base;
	
dma_addr_t ring_base_dma;
};

/* AD1843 access */

/*
 * read_ad1843_reg returns the current contents of a 16 bit AD1843 register.
 *
 * Returns unsigned register value on success, -errno on failure.
 */

static int read_ad1843_reg(void *priv, int reg) { struct snd_sgio2audio *chip = priv; int val; unsigned long flags; spin_lock_irqsave(&chip->ad1843_lock, flags); writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) | CODEC_CONTROL_READ, &mace->perif.audio.codec_control); wmb(); val = readq(&mace->perif.audio.codec_control); /* flush bus */ udelay(200); val = readq(&mace->perif.audio.codec_read); spin_unlock_irqrestore(&chip->ad1843_lock, flags); return val; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer107100.00%1100.00%
Total107100.00%1100.00%

/* * write_ad1843_reg writes the specified value to a 16 bit AD1843 register. */
static int write_ad1843_reg(void *priv, int reg, int word) { struct snd_sgio2audio *chip = priv; int val; unsigned long flags; spin_lock_irqsave(&chip->ad1843_lock, flags); writeq((reg << CODEC_CONTROL_ADDRESS_SHIFT) | (word << CODEC_CONTROL_WORD_SHIFT), &mace->perif.audio.codec_control); wmb(); val = readq(&mace->perif.audio.codec_control); /* flush bus */ udelay(200); spin_unlock_irqrestore(&chip->ad1843_lock, flags); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer100100.00%1100.00%
Total100100.00%1100.00%


static int sgio2audio_gain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol); uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; uinfo->value.integer.max = ad1843_get_gain_max(&chip->ad1843, (int)kcontrol->private_value); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer74100.00%1100.00%
Total74100.00%1100.00%


static int sgio2audio_gain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol); int vol; vol = ad1843_get_gain(&chip->ad1843, (int)kcontrol->private_value); ucontrol->value.integer.value[0] = (vol >> 8) & 0xFF; ucontrol->value.integer.value[1] = vol & 0xFF; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer83100.00%1100.00%
Total83100.00%1100.00%


static int sgio2audio_gain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol); int newvol, oldvol; oldvol = ad1843_get_gain(&chip->ad1843, kcontrol->private_value); newvol = (ucontrol->value.integer.value[0] << 8) | ucontrol->value.integer.value[1]; newvol = ad1843_set_gain(&chip->ad1843, kcontrol->private_value, newvol); return newvol != oldvol; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer94100.00%1100.00%
Total94100.00%1100.00%


static int sgio2audio_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char * const texts[3] = { "Cam Mic", "Mic", "Line" }; return snd_ctl_enum_info(uinfo, 1, 3, texts); }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer4086.96%150.00%
takashi iwaitakashi iwai613.04%150.00%
Total46100.00%2100.00%


static int sgio2audio_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = ad1843_get_recsrc(&chip->ad1843); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer48100.00%1100.00%
Total48100.00%1100.00%


static int sgio2audio_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_sgio2audio *chip = snd_kcontrol_chip(kcontrol); int newsrc, oldsrc; oldsrc = ad1843_get_recsrc(&chip->ad1843); newsrc = ad1843_set_recsrc(&chip->ad1843, ucontrol->value.enumerated.item[0]); return newsrc != oldsrc; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer67100.00%1100.00%
Total67100.00%1100.00%

/* dac1/pcm0 mixer control */ static struct snd_kcontrol_new sgio2audio_ctrl_pcm0 = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Volume", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .private_value = AD1843_GAIN_PCM_0, .info = sgio2audio_gain_info, .get = sgio2audio_gain_get, .put = sgio2audio_gain_put, }; /* dac2/pcm1 mixer control */ static struct snd_kcontrol_new sgio2audio_ctrl_pcm1 = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Volume", .index = 1, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .private_value = AD1843_GAIN_PCM_1, .info = sgio2audio_gain_info, .get = sgio2audio_gain_get, .put = sgio2audio_gain_put, }; /* record level mixer control */ static struct snd_kcontrol_new sgio2audio_ctrl_reclevel = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Volume", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .private_value = AD1843_GAIN_RECLEV, .info = sgio2audio_gain_info, .get = sgio2audio_gain_get, .put = sgio2audio_gain_put, }; /* record level source control */ static struct snd_kcontrol_new sgio2audio_ctrl_recsource = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Source", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = sgio2audio_source_info, .get = sgio2audio_source_get, .put = sgio2audio_source_put, }; /* line mixer control */ static struct snd_kcontrol_new sgio2audio_ctrl_line = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line Playback Volume", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .private_value = AD1843_GAIN_LINE, .info = sgio2audio_gain_info, .get = sgio2audio_gain_get, .put = sgio2audio_gain_put, }; /* cd mixer control */ static struct snd_kcontrol_new sgio2audio_ctrl_cd = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line Playback Volume", .index = 1, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .private_value = AD1843_GAIN_LINE_2, .info = sgio2audio_gain_info, .get = sgio2audio_gain_get, .put = sgio2audio_gain_put, }; /* mic mixer control */ static struct snd_kcontrol_new sgio2audio_ctrl_mic = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Mic Playback Volume", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .private_value = AD1843_GAIN_MIC, .info = sgio2audio_gain_info, .get = sgio2audio_gain_get, .put = sgio2audio_gain_put, };
static int snd_sgio2audio_new_mixer(struct snd_sgio2audio *chip) { int err; err = snd_ctl_add(chip->card, snd_ctl_new1(&sgio2audio_ctrl_pcm0, chip)); if (err < 0) return err; err = snd_ctl_add(chip->card, snd_ctl_new1(&sgio2audio_ctrl_pcm1, chip)); if (err < 0) return err; err = snd_ctl_add(chip->card, snd_ctl_new1(&sgio2audio_ctrl_reclevel, chip)); if (err < 0) return err; err = snd_ctl_add(chip->card, snd_ctl_new1(&sgio2audio_ctrl_recsource, chip)); if (err < 0) return err; err = snd_ctl_add(chip->card, snd_ctl_new1(&sgio2audio_ctrl_line, chip)); if (err < 0) return err; err = snd_ctl_add(chip->card, snd_ctl_new1(&sgio2audio_ctrl_cd, chip)); if (err < 0) return err; err = snd_ctl_add(chip->card, snd_ctl_new1(&sgio2audio_ctrl_mic, chip)); if (err < 0) return err; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer199100.00%1100.00%
Total199100.00%1100.00%

/* low-level audio interface DMA */ /* get data out of bounce buffer, count must be a multiple of 32 */ /* returns 1 if a period has elapsed */
static int snd_sgio2audio_dma_pull_frag(struct snd_sgio2audio *chip, unsigned int ch, unsigned int count) { int ret; unsigned long src_base, src_pos, dst_mask; unsigned char *dst_base; int dst_pos; u64 *src; s16 *dst; u64 x; unsigned long flags; struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime; spin_lock_irqsave(&chip->channel[ch].lock, flags); src_base = (unsigned long) chip->ring_base | (ch << CHANNEL_RING_SHIFT); src_pos = readq(&mace->perif.audio.chan[ch].read_ptr); dst_base = runtime->dma_area; dst_pos = chip->channel[ch].pos; dst_mask = frames_to_bytes(runtime, runtime->buffer_size) - 1; /* check if a period has elapsed */ chip->channel[ch].size += (count >> 3); /* in frames */ ret = chip->channel[ch].size >= runtime->period_size; chip->channel[ch].size %= runtime->period_size; while (count) { src = (u64 *)(src_base + src_pos); dst = (s16 *)(dst_base + dst_pos); x = *src; dst[0] = (x >> CHANNEL_LEFT_SHIFT) & 0xffff; dst[1] = (x >> CHANNEL_RIGHT_SHIFT) & 0xffff; src_pos = (src_pos + sizeof(u64)) & CHANNEL_RING_MASK; dst_pos = (dst_pos + 2 * sizeof(s16)) & dst_mask; count -= sizeof(u64); } writeq(src_pos, &mace->perif.audio.chan[ch].read_ptr); /* in bytes */ chip->channel[ch].pos = dst_pos; spin_unlock_irqrestore(&chip->channel[ch].lock, flags); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer339100.00%1100.00%
Total339100.00%1100.00%

/* put some DMA data in bounce buffer, count must be a multiple of 32 */ /* returns 1 if a period has elapsed */
static int snd_sgio2audio_dma_push_frag(struct snd_sgio2audio *chip, unsigned int ch, unsigned int count) { int ret; s64 l, r; unsigned long dst_base, dst_pos, src_mask; unsigned char *src_base; int src_pos; u64 *dst; s16 *src; unsigned long flags; struct snd_pcm_runtime *runtime = chip->channel[ch].substream->runtime; spin_lock_irqsave(&chip->channel[ch].lock, flags); dst_base = (unsigned long)chip->ring_base | (ch << CHANNEL_RING_SHIFT); dst_pos = readq(&mace->perif.audio.chan[ch].write_ptr); src_base = runtime->dma_area; src_pos = chip->channel[ch].pos; src_mask = frames_to_bytes(runtime, runtime->buffer_size) - 1; /* check if a period has elapsed */ chip->channel[ch].size += (count >> 3); /* in frames */ ret = chip->channel[ch].size >= runtime->period_size; chip->channel[ch].size %= runtime->period_size; while (count) { src = (s16 *)(src_base + src_pos); dst = (u64 *)(dst_base + dst_pos); l = src[0]; /* sign extend */ r = src[1]; /* sign extend */ *dst = ((l & 0x00ffffff) << CHANNEL_LEFT_SHIFT) | ((r & 0x00ffffff) << CHANNEL_RIGHT_SHIFT); dst_pos = (dst_pos + sizeof(u64)) & CHANNEL_RING_MASK; src_pos = (src_pos + 2 * sizeof(s16)) & src_mask; count -= sizeof(u64); } writeq(dst_pos, &mace->perif.audio.chan[ch].write_ptr); /* in bytes */ chip->channel[ch].pos = src_pos; spin_unlock_irqrestore(&chip->channel[ch].lock, flags); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer349100.00%1100.00%
Total349100.00%1100.00%


static int snd_sgio2audio_dma_start(struct snd_pcm_substream *substream) { struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream); struct snd_sgio2audio_chan *chan = substream->runtime->private_data; int ch = chan->idx; /* reset DMA channel */ writeq(CHANNEL_CONTROL_RESET, &mace->perif.audio.chan[ch].control); udelay(10); writeq(0, &mace->perif.audio.chan[ch].control); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { /* push a full buffer */ snd_sgio2audio_dma_push_frag(chip, ch, CHANNEL_RING_SIZE - 32); } /* set DMA to wake on 50% empty and enable interrupt */ writeq(CHANNEL_DMA_ENABLE | CHANNEL_INT_THRESHOLD_50, &mace->perif.audio.chan[ch].control); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer130100.00%1100.00%
Total130100.00%1100.00%


static int snd_sgio2audio_dma_stop(struct snd_pcm_substream *substream) { struct snd_sgio2audio_chan *chan = substream->runtime->private_data; writeq(0, &mace->perif.audio.chan[chan->idx].control); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer46100.00%1100.00%
Total46100.00%1100.00%


static irqreturn_t snd_sgio2audio_dma_in_isr(int irq, void *dev_id) { struct snd_sgio2audio_chan *chan = dev_id; struct snd_pcm_substream *substream; struct snd_sgio2audio *chip; int count, ch; substream = chan->substream; chip = snd_pcm_substream_chip(substream); ch = chan->idx; /* empty the ring */ count = CHANNEL_RING_SIZE - readq(&mace->perif.audio.chan[ch].depth) - 32; if (snd_sgio2audio_dma_pull_frag(chip, ch, count)) snd_pcm_period_elapsed(substream); return IRQ_HANDLED; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer97100.00%1100.00%
Total97100.00%1100.00%


static irqreturn_t snd_sgio2audio_dma_out_isr(int irq, void *dev_id) { struct snd_sgio2audio_chan *chan = dev_id; struct snd_pcm_substream *substream; struct snd_sgio2audio *chip; int count, ch; substream = chan->substream; chip = snd_pcm_substream_chip(substream); ch = chan->idx; /* fill the ring */ count = CHANNEL_RING_SIZE - readq(&mace->perif.audio.chan[ch].depth) - 32; if (snd_sgio2audio_dma_push_frag(chip, ch, count)) snd_pcm_period_elapsed(substream); return IRQ_HANDLED; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer97100.00%1100.00%
Total97100.00%1100.00%


static irqreturn_t snd_sgio2audio_error_isr(int irq, void *dev_id) { struct snd_sgio2audio_chan *chan = dev_id; struct snd_pcm_substream *substream; substream = chan->substream; snd_sgio2audio_dma_stop(substream); snd_sgio2audio_dma_start(substream); return IRQ_HANDLED; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer44100.00%1100.00%
Total44100.00%1100.00%

/* PCM part */ /* PCM hardware definition */ static struct snd_pcm_hardware snd_sgio2audio_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER), .formats = SNDRV_PCM_FMTBIT_S16_BE, .rates = SNDRV_PCM_RATE_8000_48000, .rate_min = 8000, .rate_max = 48000, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 65536, .period_bytes_min = 32768, .period_bytes_max = 65536, .periods_min = 1, .periods_max = 1024, }; /* PCM playback open callback */
static int snd_sgio2audio_playback1_open(struct snd_pcm_substream *substream) { struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; runtime->hw = snd_sgio2audio_pcm_hw; runtime->private_data = &chip->channel[1]; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer51100.00%1100.00%
Total51100.00%1100.00%


static int snd_sgio2audio_playback2_open(struct snd_pcm_substream *substream) { struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; runtime->hw = snd_sgio2audio_pcm_hw; runtime->private_data = &chip->channel[2]; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer51100.00%1100.00%
Total51100.00%1100.00%

/* PCM capture open callback */
static int snd_sgio2audio_capture_open(struct snd_pcm_substream *substream) { struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; runtime->hw = snd_sgio2audio_pcm_hw; runtime->private_data = &chip->channel[0]; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer51100.00%1100.00%
Total51100.00%1100.00%

/* PCM close callback */
static int snd_sgio2audio_pcm_close(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; runtime->private_data = NULL; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer29100.00%1100.00%
Total29100.00%1100.00%

/* hw_params callback */
static int snd_sgio2audio_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { return snd_pcm_lib_alloc_vmalloc_buffer(substream, params_buffer_bytes(hw_params)); }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer2385.19%150.00%
clemens ladischclemens ladisch414.81%150.00%
Total27100.00%2100.00%

/* hw_free callback */
static int snd_sgio2audio_pcm_hw_free(struct snd_pcm_substream *substream) { return snd_pcm_lib_free_vmalloc_buffer(substream); }

Contributors

PersonTokensPropCommitsCommitProp
thomas bogendoerferthomas bogendoerfer1588.24%150.00%
clemens ladischclemens ladisch211.76%150.00%
Total17100.00%2100.00%

/* prepare callback */
static int snd_sgio2audio_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; struct snd_sgio2audio_chan *chan = substream->runtime->private_data; int ch = chan->idx; unsigned long flags; spin_lock_irqsave(&chip->channel[ch].lock, flags); /* Setup the pseudo-dma transfer pointers. */ chip