Datasets:
kye
/
all-torvalds-c-code-1

Dataset card Data Studio Files Community
python_code
stringlengths
0
1.8M
repo_name
stringclasses
7 values
file_path
stringlengths
5
99
// SPDX-License-Identifier: GPL-2.0 /* * Sound driver for Nintendo 64. * * Copyright 2021 Lauri Kasanen */ #include <linux/dma-mapping.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/io.h> #include <linux/log2.h> #include <linux/module.h> #include <linux/platform_device.h> #include <linux/spinlock.h> #include <sound/control.h> #include <sound/core.h> #include <sound/initval.h> #include <sound/pcm.h> #include <sound/pcm_params.h> MODULE_AUTHOR("Lauri Kasanen <[email protected]>"); MODULE_DESCRIPTION("N64 Audio"); MODULE_LICENSE("GPL"); #define AI_NTSC_DACRATE 48681812 #define AI_STATUS_BUSY (1 << 30) #define AI_STATUS_FULL (1 << 31) #define AI_ADDR_REG 0 #define AI_LEN_REG 1 #define AI_CONTROL_REG 2 #define AI_STATUS_REG 3 #define AI_RATE_REG 4 #define AI_BITCLOCK_REG 5 #define MI_INTR_REG 2 #define MI_MASK_REG 3 #define MI_INTR_AI 0x04 #define MI_MASK_CLR_AI 0x0010 #define MI_MASK_SET_AI 0x0020 struct n64audio { u32 __iomem *ai_reg_base; u32 __iomem *mi_reg_base; void *ring_base; dma_addr_t ring_base_dma; struct snd_card *card; struct { struct snd_pcm_substream *substream; int pos, nextpos; u32 writesize; u32 bufsize; spinlock_t lock; } chan; }; static void n64audio_write_reg(struct n64audio *priv, const u8 reg, const u32 value) { writel(value, priv->ai_reg_base + reg); } static void n64mi_write_reg(struct n64audio *priv, const u8 reg, const u32 value) { writel(value, priv->mi_reg_base + reg); } static u32 n64mi_read_reg(struct n64audio *priv, const u8 reg) { return readl(priv->mi_reg_base + reg); } static void n64audio_push(struct n64audio *priv) { struct snd_pcm_runtime *runtime = priv->chan.substream->runtime; unsigned long flags; u32 count; spin_lock_irqsave(&priv->chan.lock, flags); count = priv->chan.writesize; memcpy(priv->ring_base + priv->chan.nextpos, runtime->dma_area + priv->chan.nextpos, count); /* * The hw registers are double-buffered, and the IRQ fires essentially * one period behind. The core only allows one period's distance, so we * keep a private DMA buffer to afford two. */ n64audio_write_reg(priv, AI_ADDR_REG, priv->ring_base_dma + priv->chan.nextpos); barrier(); n64audio_write_reg(priv, AI_LEN_REG, count); priv->chan.nextpos += count; priv->chan.nextpos %= priv->chan.bufsize; runtime->delay = runtime->period_size; spin_unlock_irqrestore(&priv->chan.lock, flags); } static irqreturn_t n64audio_isr(int irq, void *dev_id) { struct n64audio *priv = dev_id; const u32 intrs = n64mi_read_reg(priv, MI_INTR_REG); unsigned long flags; // Check it's ours if (!(intrs & MI_INTR_AI)) return IRQ_NONE; n64audio_write_reg(priv, AI_STATUS_REG, 1); if (priv->chan.substream && snd_pcm_running(priv->chan.substream)) { spin_lock_irqsave(&priv->chan.lock, flags); priv->chan.pos = priv->chan.nextpos; spin_unlock_irqrestore(&priv->chan.lock, flags); snd_pcm_period_elapsed(priv->chan.substream); if (priv->chan.substream && snd_pcm_running(priv->chan.substream)) n64audio_push(priv); } return IRQ_HANDLED; } static const struct snd_pcm_hardware n64audio_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 = 32768, .period_bytes_min = 1024, .period_bytes_max = 32768, .periods_min = 3, // 3 periods lets the double-buffering hw read one buffer behind safely .periods_max = 128, }; static int hw_rule_period_size(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE); int changed = 0; /* * The DMA unit has errata on (start + len) & 0x3fff == 0x2000. * This constraint makes sure that the period size is not a power of two, * which combined with dma_alloc_coherent aligning the buffer to the largest * PoT <= size guarantees it won't be hit. */ if (is_power_of_2(c->min)) { c->min += 2; changed = 1; } if (is_power_of_2(c->max)) { c->max -= 2; changed = 1; } if (snd_interval_checkempty(c)) { c->empty = 1; return -EINVAL; } return changed; } static int n64audio_pcm_open(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; int err; runtime->hw = n64audio_pcm_hw; err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); if (err < 0) return err; err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2); if (err < 0) return err; err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, hw_rule_period_size, NULL, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1); if (err < 0) return err; return 0; } static int n64audio_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct n64audio *priv = substream->pcm->private_data; u32 rate; rate = ((2 * AI_NTSC_DACRATE / runtime->rate) + 1) / 2 - 1; n64audio_write_reg(priv, AI_RATE_REG, rate); rate /= 66; if (rate > 16) rate = 16; n64audio_write_reg(priv, AI_BITCLOCK_REG, rate - 1); spin_lock_irq(&priv->chan.lock); /* Setup the pseudo-dma transfer pointers. */ priv->chan.pos = 0; priv->chan.nextpos = 0; priv->chan.substream = substream; priv->chan.writesize = snd_pcm_lib_period_bytes(substream); priv->chan.bufsize = snd_pcm_lib_buffer_bytes(substream); spin_unlock_irq(&priv->chan.lock); return 0; } static int n64audio_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { struct n64audio *priv = substream->pcm->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: n64audio_push(substream->pcm->private_data); n64audio_write_reg(priv, AI_CONTROL_REG, 1); n64mi_write_reg(priv, MI_MASK_REG, MI_MASK_SET_AI); break; case SNDRV_PCM_TRIGGER_STOP: n64audio_write_reg(priv, AI_CONTROL_REG, 0); n64mi_write_reg(priv, MI_MASK_REG, MI_MASK_CLR_AI); break; default: return -EINVAL; } return 0; } static snd_pcm_uframes_t n64audio_pcm_pointer(struct snd_pcm_substream *substream) { struct n64audio *priv = substream->pcm->private_data; return bytes_to_frames(substream->runtime, priv->chan.pos); } static int n64audio_pcm_close(struct snd_pcm_substream *substream) { struct n64audio *priv = substream->pcm->private_data; priv->chan.substream = NULL; return 0; } static const struct snd_pcm_ops n64audio_pcm_ops = { .open = n64audio_pcm_open, .prepare = n64audio_pcm_prepare, .trigger = n64audio_pcm_trigger, .pointer = n64audio_pcm_pointer, .close = n64audio_pcm_close, }; /* * The target device is embedded and RAM-constrained. We save RAM * by initializing in __init code that gets dropped late in boot. * For the same reason there is no module or unloading support. */ static int __init n64audio_probe(struct platform_device *pdev) { struct snd_card *card; struct snd_pcm *pcm; struct n64audio *priv; int err, irq; err = snd_card_new(&pdev->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, THIS_MODULE, sizeof(*priv), &card); if (err < 0) return err; priv = card->private_data; spin_lock_init(&priv->chan.lock); priv->card = card; priv->ring_base = dma_alloc_coherent(card->dev, 32 * 1024, &priv->ring_base_dma, GFP_DMA|GFP_KERNEL); if (!priv->ring_base) { err = -ENOMEM; goto fail_card; } priv->mi_reg_base = devm_platform_ioremap_resource(pdev, 0); if (IS_ERR(priv->mi_reg_base)) { err = PTR_ERR(priv->mi_reg_base); goto fail_dma_alloc; } priv->ai_reg_base = devm_platform_ioremap_resource(pdev, 1); if (IS_ERR(priv->ai_reg_base)) { err = PTR_ERR(priv->ai_reg_base); goto fail_dma_alloc; } err = snd_pcm_new(card, "N64 Audio", 0, 1, 0, &pcm); if (err < 0) goto fail_dma_alloc; pcm->private_data = priv; strcpy(pcm->name, "N64 Audio"); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &n64audio_pcm_ops); snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, card->dev, 0, 0); strcpy(card->driver, "N64 Audio"); strcpy(card->shortname, "N64 Audio"); strcpy(card->longname, "N64 Audio"); irq = platform_get_irq(pdev, 0); if (irq < 0) { err = -EINVAL; goto fail_dma_alloc; } if (devm_request_irq(&pdev->dev, irq, n64audio_isr, IRQF_SHARED, "N64 Audio", priv)) { err = -EBUSY; goto fail_dma_alloc; } err = snd_card_register(card); if (err < 0) goto fail_dma_alloc; return 0; fail_dma_alloc: dma_free_coherent(card->dev, 32 * 1024, priv->ring_base, priv->ring_base_dma); fail_card: snd_card_free(card); return err; } static struct platform_driver n64audio_driver = { .driver = { .name = "n64audio", }, }; static int __init n64audio_init(void) { return platform_driver_probe(&n64audio_driver, n64audio_probe); } module_init(n64audio_init);
linux-master
sound/mips/snd-n64.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Sound driver for Silicon Graphics O2 Workstations A/V board audio. * * Copyright 2003 Vivien Chappelier <[email protected]> * Copyright 2008 Thomas Bogendoerfer <[email protected]> * Mxier part taken from mace_audio.c: * Copyright 2007 Thorben Jändling <[email protected]> */ #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 <[email protected]>"); MODULE_DESCRIPTION("SGI O2 Audio"); MODULE_LICENSE("GPL"); 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; } /* * 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; } 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; } 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; } 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; } 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); } 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; } 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; } /* dac1/pcm0 mixer control */ static const 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 const 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 const 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 const 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 const 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 const 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 const 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; } /* 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; } /* 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; } 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; } 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; } 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; } 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; } 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; } /* PCM part */ /* PCM hardware definition */ static const 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; } 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; } /* 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; } /* 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; } /* 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->channel[ch].pos = 0; chip->channel[ch].size = 0; chip->channel[ch].substream = substream; /* set AD1843 format */ /* hardware format is always S16_LE */ switch (substream->stream) { case SNDRV_PCM_STREAM_PLAYBACK: ad1843_setup_dac(&chip->ad1843, ch - 1, runtime->rate, SNDRV_PCM_FORMAT_S16_LE, runtime->channels); break; case SNDRV_PCM_STREAM_CAPTURE: ad1843_setup_adc(&chip->ad1843, runtime->rate, SNDRV_PCM_FORMAT_S16_LE, runtime->channels); break; } spin_unlock_irqrestore(&chip->channel[ch].lock, flags); return 0; } /* trigger callback */ static int snd_sgio2audio_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { switch (cmd) { case SNDRV_PCM_TRIGGER_START: /* start the PCM engine */ snd_sgio2audio_dma_start(substream); break; case SNDRV_PCM_TRIGGER_STOP: /* stop the PCM engine */ snd_sgio2audio_dma_stop(substream); break; default: return -EINVAL; } return 0; } /* pointer callback */ static snd_pcm_uframes_t snd_sgio2audio_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_sgio2audio *chip = snd_pcm_substream_chip(substream); struct snd_sgio2audio_chan *chan = substream->runtime->private_data; /* get the current hardware pointer */ return bytes_to_frames(substream->runtime, chip->channel[chan->idx].pos); } /* operators */ static const struct snd_pcm_ops snd_sgio2audio_playback1_ops = { .open = snd_sgio2audio_playback1_open, .close = snd_sgio2audio_pcm_close, .prepare = snd_sgio2audio_pcm_prepare, .trigger = snd_sgio2audio_pcm_trigger, .pointer = snd_sgio2audio_pcm_pointer, }; static const struct snd_pcm_ops snd_sgio2audio_playback2_ops = { .open = snd_sgio2audio_playback2_open, .close = snd_sgio2audio_pcm_close, .prepare = snd_sgio2audio_pcm_prepare, .trigger = snd_sgio2audio_pcm_trigger, .pointer = snd_sgio2audio_pcm_pointer, }; static const struct snd_pcm_ops snd_sgio2audio_capture_ops = { .open = snd_sgio2audio_capture_open, .close = snd_sgio2audio_pcm_close, .prepare = snd_sgio2audio_pcm_prepare, .trigger = snd_sgio2audio_pcm_trigger, .pointer = snd_sgio2audio_pcm_pointer, }; /* * definitions of capture are omitted here... */ /* create a pcm device */ static int snd_sgio2audio_new_pcm(struct snd_sgio2audio *chip) { struct snd_pcm *pcm; int err; /* create first pcm device with one outputs and one input */ err = snd_pcm_new(chip->card, "SGI O2 Audio", 0, 1, 1, &pcm); if (err < 0) return err; pcm->private_data = chip; strcpy(pcm->name, "SGI O2 DAC1"); /* set operators */ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sgio2audio_playback1_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sgio2audio_capture_ops); snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0); /* create second pcm device with one outputs and no input */ err = snd_pcm_new(chip->card, "SGI O2 Audio", 1, 1, 0, &pcm); if (err < 0) return err; pcm->private_data = chip; strcpy(pcm->name, "SGI O2 DAC2"); /* set operators */ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sgio2audio_playback2_ops); snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0); return 0; } static struct { int idx; int irq; irqreturn_t (*isr)(int, void *); const char *desc; } snd_sgio2_isr_table[] = { { .idx = 0, .irq = MACEISA_AUDIO1_DMAT_IRQ, .isr = snd_sgio2audio_dma_in_isr, .desc = "Capture DMA Channel 0" }, { .idx = 0, .irq = MACEISA_AUDIO1_OF_IRQ, .isr = snd_sgio2audio_error_isr, .desc = "Capture Overflow" }, { .idx = 1, .irq = MACEISA_AUDIO2_DMAT_IRQ, .isr = snd_sgio2audio_dma_out_isr, .desc = "Playback DMA Channel 1" }, { .idx = 1, .irq = MACEISA_AUDIO2_MERR_IRQ, .isr = snd_sgio2audio_error_isr, .desc = "Memory Error Channel 1" }, { .idx = 2, .irq = MACEISA_AUDIO3_DMAT_IRQ, .isr = snd_sgio2audio_dma_out_isr, .desc = "Playback DMA Channel 2" }, { .idx = 2, .irq = MACEISA_AUDIO3_MERR_IRQ, .isr = snd_sgio2audio_error_isr, .desc = "Memory Error Channel 2" } }; /* ALSA driver */ static int snd_sgio2audio_free(struct snd_sgio2audio *chip) { int i; /* reset interface */ writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control); udelay(1); writeq(0, &mace->perif.audio.control); /* release IRQ's */ for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++) free_irq(snd_sgio2_isr_table[i].irq, &chip->channel[snd_sgio2_isr_table[i].idx]); dma_free_coherent(chip->card->dev, MACEISA_RINGBUFFERS_SIZE, chip->ring_base, chip->ring_base_dma); /* release card data */ kfree(chip); return 0; } static int snd_sgio2audio_dev_free(struct snd_device *device) { struct snd_sgio2audio *chip = device->device_data; return snd_sgio2audio_free(chip); } static const struct snd_device_ops ops = { .dev_free = snd_sgio2audio_dev_free, }; static int snd_sgio2audio_create(struct snd_card *card, struct snd_sgio2audio **rchip) { struct snd_sgio2audio *chip; int i, err; *rchip = NULL; /* check if a codec is attached to the interface */ /* (Audio or Audio/Video board present) */ if (!(readq(&mace->perif.audio.control) & AUDIO_CONTROL_CODEC_PRESENT)) return -ENOENT; chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) return -ENOMEM; chip->card = card; chip->ring_base = dma_alloc_coherent(card->dev, MACEISA_RINGBUFFERS_SIZE, &chip->ring_base_dma, GFP_KERNEL); if (chip->ring_base == NULL) { printk(KERN_ERR "sgio2audio: could not allocate ring buffers\n"); kfree(chip); return -ENOMEM; } spin_lock_init(&chip->ad1843_lock); /* initialize channels */ for (i = 0; i < 3; i++) { spin_lock_init(&chip->channel[i].lock); chip->channel[i].idx = i; } /* allocate IRQs */ for (i = 0; i < ARRAY_SIZE(snd_sgio2_isr_table); i++) { if (request_irq(snd_sgio2_isr_table[i].irq, snd_sgio2_isr_table[i].isr, 0, snd_sgio2_isr_table[i].desc, &chip->channel[snd_sgio2_isr_table[i].idx])) { snd_sgio2audio_free(chip); printk(KERN_ERR "sgio2audio: cannot allocate irq %d\n", snd_sgio2_isr_table[i].irq); return -EBUSY; } } /* reset the interface */ writeq(AUDIO_CONTROL_RESET, &mace->perif.audio.control); udelay(1); writeq(0, &mace->perif.audio.control); msleep_interruptible(1); /* give time to recover */ /* set ring base */ writeq(chip->ring_base_dma, &mace->perif.ctrl.ringbase); /* attach the AD1843 codec */ chip->ad1843.read = read_ad1843_reg; chip->ad1843.write = write_ad1843_reg; chip->ad1843.chip = chip; /* initialize the AD1843 codec */ err = ad1843_init(&chip->ad1843); if (err < 0) { snd_sgio2audio_free(chip); return err; } err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); if (err < 0) { snd_sgio2audio_free(chip); return err; } *rchip = chip; return 0; } static int snd_sgio2audio_probe(struct platform_device *pdev) { struct snd_card *card; struct snd_sgio2audio *chip; int err; err = snd_card_new(&pdev->dev, index, id, THIS_MODULE, 0, &card); if (err < 0) return err; err = snd_sgio2audio_create(card, &chip); if (err < 0) { snd_card_free(card); return err; } err = snd_sgio2audio_new_pcm(chip); if (err < 0) { snd_card_free(card); return err; } err = snd_sgio2audio_new_mixer(chip); if (err < 0) { snd_card_free(card); return err; } strcpy(card->driver, "SGI O2 Audio"); strcpy(card->shortname, "SGI O2 Audio"); sprintf(card->longname, "%s irq %i-%i", card->shortname, MACEISA_AUDIO1_DMAT_IRQ, MACEISA_AUDIO3_MERR_IRQ); err = snd_card_register(card); if (err < 0) { snd_card_free(card); return err; } platform_set_drvdata(pdev, card); return 0; } static void snd_sgio2audio_remove(struct platform_device *pdev) { struct snd_card *card = platform_get_drvdata(pdev); snd_card_free(card); } static struct platform_driver sgio2audio_driver = { .probe = snd_sgio2audio_probe, .remove_new = snd_sgio2audio_remove, .driver = { .name = "sgio2audio", } }; module_platform_driver(sgio2audio_driver);
linux-master
sound/mips/sgio2audio.c
// SPDX-License-Identifier: GPL-2.0-only /* * * Copyright Adrian McMenamin 2005, 2006, 2007 * <[email protected]> * Requires firmware (BSD licenced) available from: * http://linuxdc.cvs.sourceforge.net/linuxdc/linux-sh-dc/sound/oss/aica/firmware/ * or the maintainer */ #include <linux/init.h> #include <linux/jiffies.h> #include <linux/slab.h> #include <linux/time.h> #include <linux/wait.h> #include <linux/module.h> #include <linux/platform_device.h> #include <linux/firmware.h> #include <linux/timer.h> #include <linux/delay.h> #include <linux/workqueue.h> #include <linux/io.h> #include <sound/core.h> #include <sound/control.h> #include <sound/pcm.h> #include <sound/initval.h> #include <sound/info.h> #include <asm/dma.h> #include <mach/sysasic.h> #include "aica.h" MODULE_AUTHOR("Adrian McMenamin <[email protected]>"); MODULE_DESCRIPTION("Dreamcast AICA sound (pcm) driver"); MODULE_LICENSE("GPL"); MODULE_FIRMWARE("aica_firmware.bin"); /* module parameters */ #define CARD_NAME "AICA" static int index = -1; static char *id; static bool enable = 1; module_param(index, int, 0444); MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard."); module_param(id, charp, 0444); MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard."); module_param(enable, bool, 0644); MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard."); /* Simple platform device */ static struct platform_device *pd; static struct resource aica_memory_space[2] = { { .name = "AICA ARM CONTROL", .start = ARM_RESET_REGISTER, .flags = IORESOURCE_MEM, .end = ARM_RESET_REGISTER + 3, }, { .name = "AICA Sound RAM", .start = SPU_MEMORY_BASE, .flags = IORESOURCE_MEM, .end = SPU_MEMORY_BASE + 0x200000 - 1, }, }; /* SPU specific functions */ /* spu_write_wait - wait for G2-SH FIFO to clear */ static void spu_write_wait(void) { int time_count; time_count = 0; while (1) { if (!(readl(G2_FIFO) & 0x11)) break; /* To ensure hardware failure doesn't wedge kernel */ time_count++; if (time_count > 0x10000) { snd_printk ("WARNING: G2 FIFO appears to be blocked.\n"); break; } } } /* spu_memset - write to memory in SPU address space */ static void spu_memset(u32 toi, u32 what, int length) { int i; unsigned long flags; if (snd_BUG_ON(length % 4)) return; for (i = 0; i < length; i++) { if (!(i % 8)) spu_write_wait(); local_irq_save(flags); writel(what, toi + SPU_MEMORY_BASE); local_irq_restore(flags); toi++; } } /* spu_memload - write to SPU address space */ static void spu_memload(u32 toi, const void *from, int length) { unsigned long flags; const u32 *froml = from; u32 __iomem *to = (u32 __iomem *) (SPU_MEMORY_BASE + toi); int i; u32 val; length = DIV_ROUND_UP(length, 4); spu_write_wait(); for (i = 0; i < length; i++) { if (!(i % 8)) spu_write_wait(); val = *froml; local_irq_save(flags); writel(val, to); local_irq_restore(flags); froml++; to++; } } /* spu_disable - set spu registers to stop sound output */ static void spu_disable(void) { int i; unsigned long flags; u32 regval; spu_write_wait(); regval = readl(ARM_RESET_REGISTER); regval |= 1; spu_write_wait(); local_irq_save(flags); writel(regval, ARM_RESET_REGISTER); local_irq_restore(flags); for (i = 0; i < 64; i++) { spu_write_wait(); regval = readl(SPU_REGISTER_BASE + (i * 0x80)); regval = (regval & ~0x4000) | 0x8000; spu_write_wait(); local_irq_save(flags); writel(regval, SPU_REGISTER_BASE + (i * 0x80)); local_irq_restore(flags); } } /* spu_enable - set spu registers to enable sound output */ static void spu_enable(void) { unsigned long flags; u32 regval = readl(ARM_RESET_REGISTER); regval &= ~1; spu_write_wait(); local_irq_save(flags); writel(regval, ARM_RESET_REGISTER); local_irq_restore(flags); } /* * Halt the sound processor, clear the memory, * load some default ARM7 code, and then restart ARM7 */ static void spu_reset(void) { unsigned long flags; spu_disable(); spu_memset(0, 0, 0x200000 / 4); /* Put ARM7 in endless loop */ local_irq_save(flags); __raw_writel(0xea000002, SPU_MEMORY_BASE); local_irq_restore(flags); spu_enable(); } /* aica_chn_start - write to spu to start playback */ static void aica_chn_start(void) { unsigned long flags; spu_write_wait(); local_irq_save(flags); writel(AICA_CMD_KICK | AICA_CMD_START, (u32 *) AICA_CONTROL_POINT); local_irq_restore(flags); } /* aica_chn_halt - write to spu to halt playback */ static void aica_chn_halt(void) { unsigned long flags; spu_write_wait(); local_irq_save(flags); writel(AICA_CMD_KICK | AICA_CMD_STOP, (u32 *) AICA_CONTROL_POINT); local_irq_restore(flags); } /* ALSA code below */ static const struct snd_pcm_hardware snd_pcm_aica_playback_hw = { .info = (SNDRV_PCM_INFO_NONINTERLEAVED), .formats = (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_IMA_ADPCM), .rates = SNDRV_PCM_RATE_8000_48000, .rate_min = 8000, .rate_max = 48000, .channels_min = 1, .channels_max = 2, .buffer_bytes_max = AICA_BUFFER_SIZE, .period_bytes_min = AICA_PERIOD_SIZE, .period_bytes_max = AICA_PERIOD_SIZE, .periods_min = AICA_PERIOD_NUMBER, .periods_max = AICA_PERIOD_NUMBER, }; static int aica_dma_transfer(int channels, int buffer_size, struct snd_pcm_substream *substream) { int q, err, period_offset; struct snd_card_aica *dreamcastcard; struct snd_pcm_runtime *runtime; unsigned long flags; err = 0; dreamcastcard = substream->pcm->private_data; period_offset = dreamcastcard->clicks; period_offset %= (AICA_PERIOD_NUMBER / channels); runtime = substream->runtime; for (q = 0; q < channels; q++) { local_irq_save(flags); err = dma_xfer(AICA_DMA_CHANNEL, (unsigned long) (runtime->dma_area + (AICA_BUFFER_SIZE * q) / channels + AICA_PERIOD_SIZE * period_offset), AICA_CHANNEL0_OFFSET + q * CHANNEL_OFFSET + AICA_PERIOD_SIZE * period_offset, buffer_size / channels, AICA_DMA_MODE); if (unlikely(err < 0)) { local_irq_restore(flags); break; } dma_wait_for_completion(AICA_DMA_CHANNEL); local_irq_restore(flags); } return err; } static void startup_aica(struct snd_card_aica *dreamcastcard) { spu_memload(AICA_CHANNEL0_CONTROL_OFFSET, dreamcastcard->channel, sizeof(struct aica_channel)); aica_chn_start(); } static void run_spu_dma(struct work_struct *work) { int buffer_size; struct snd_pcm_runtime *runtime; struct snd_card_aica *dreamcastcard; dreamcastcard = container_of(work, struct snd_card_aica, spu_dma_work); runtime = dreamcastcard->substream->runtime; if (unlikely(dreamcastcard->dma_check == 0)) { buffer_size = frames_to_bytes(runtime, runtime->buffer_size); if (runtime->channels > 1) dreamcastcard->channel->flags |= 0x01; aica_dma_transfer(runtime->channels, buffer_size, dreamcastcard->substream); startup_aica(dreamcastcard); dreamcastcard->clicks = buffer_size / (AICA_PERIOD_SIZE * runtime->channels); return; } else { aica_dma_transfer(runtime->channels, AICA_PERIOD_SIZE * runtime->channels, dreamcastcard->substream); snd_pcm_period_elapsed(dreamcastcard->substream); dreamcastcard->clicks++; if (unlikely(dreamcastcard->clicks >= AICA_PERIOD_NUMBER)) dreamcastcard->clicks %= AICA_PERIOD_NUMBER; mod_timer(&dreamcastcard->timer, jiffies + 1); } } static void aica_period_elapsed(struct timer_list *t) { struct snd_card_aica *dreamcastcard = from_timer(dreamcastcard, t, timer); struct snd_pcm_substream *substream = dreamcastcard->substream; /*timer function - so cannot sleep */ int play_period; struct snd_pcm_runtime *runtime; runtime = substream->runtime; dreamcastcard = substream->pcm->private_data; /* Have we played out an additional period? */ play_period = frames_to_bytes(runtime, readl (AICA_CONTROL_CHANNEL_SAMPLE_NUMBER)) / AICA_PERIOD_SIZE; if (play_period == dreamcastcard->current_period) { /* reschedule the timer */ mod_timer(&(dreamcastcard->timer), jiffies + 1); return; } if (runtime->channels > 1) dreamcastcard->current_period = play_period; if (unlikely(dreamcastcard->dma_check == 0)) dreamcastcard->dma_check = 1; schedule_work(&(dreamcastcard->spu_dma_work)); } static void spu_begin_dma(struct snd_pcm_substream *substream) { struct snd_card_aica *dreamcastcard; struct snd_pcm_runtime *runtime; runtime = substream->runtime; dreamcastcard = substream->pcm->private_data; /*get the queue to do the work */ schedule_work(&(dreamcastcard->spu_dma_work)); mod_timer(&dreamcastcard->timer, jiffies + 4); } static int snd_aicapcm_pcm_open(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime; struct aica_channel *channel; struct snd_card_aica *dreamcastcard; if (!enable) return -ENOENT; dreamcastcard = substream->pcm->private_data; channel = kmalloc(sizeof(struct aica_channel), GFP_KERNEL); if (!channel) return -ENOMEM; /* set defaults for channel */ channel->sfmt = SM_8BIT; channel->cmd = AICA_CMD_START; channel->vol = dreamcastcard->master_volume; channel->pan = 0x80; channel->pos = 0; channel->flags = 0; /* default to mono */ dreamcastcard->channel = channel; runtime = substream->runtime; runtime->hw = snd_pcm_aica_playback_hw; spu_enable(); dreamcastcard->clicks = 0; dreamcastcard->current_period = 0; dreamcastcard->dma_check = 0; return 0; } static int snd_aicapcm_pcm_close(struct snd_pcm_substream *substream) { struct snd_card_aica *dreamcastcard = substream->pcm->private_data; flush_work(&(dreamcastcard->spu_dma_work)); del_timer(&dreamcastcard->timer); dreamcastcard->substream = NULL; kfree(dreamcastcard->channel); spu_disable(); return 0; } static int snd_aicapcm_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_card_aica *dreamcastcard = substream->pcm->private_data; if ((substream->runtime)->format == SNDRV_PCM_FORMAT_S16_LE) dreamcastcard->channel->sfmt = SM_16BIT; dreamcastcard->channel->freq = substream->runtime->rate; dreamcastcard->substream = substream; return 0; } static int snd_aicapcm_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { switch (cmd) { case SNDRV_PCM_TRIGGER_START: spu_begin_dma(substream); break; case SNDRV_PCM_TRIGGER_STOP: aica_chn_halt(); break; default: return -EINVAL; } return 0; } static unsigned long snd_aicapcm_pcm_pointer(struct snd_pcm_substream *substream) { return readl(AICA_CONTROL_CHANNEL_SAMPLE_NUMBER); } static const struct snd_pcm_ops snd_aicapcm_playback_ops = { .open = snd_aicapcm_pcm_open, .close = snd_aicapcm_pcm_close, .prepare = snd_aicapcm_pcm_prepare, .trigger = snd_aicapcm_pcm_trigger, .pointer = snd_aicapcm_pcm_pointer, }; /* TO DO: set up to handle more than one pcm instance */ static int __init snd_aicapcmchip(struct snd_card_aica *dreamcastcard, int pcm_index) { struct snd_pcm *pcm; int err; /* AICA has no capture ability */ err = snd_pcm_new(dreamcastcard->card, "AICA PCM", pcm_index, 1, 0, &pcm); if (unlikely(err < 0)) return err; pcm->private_data = dreamcastcard; strcpy(pcm->name, "AICA PCM"); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_aicapcm_playback_ops); /* Allocate the DMA buffers */ snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, NULL, AICA_BUFFER_SIZE, AICA_BUFFER_SIZE); return 0; } /* Mixer controls */ #define aica_pcmswitch_info snd_ctl_boolean_mono_info static int aica_pcmswitch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.integer.value[0] = 1; /* TO DO: Fix me */ return 0; } static int aica_pcmswitch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { if (ucontrol->value.integer.value[0] == 1) return 0; /* TO DO: Fix me */ else aica_chn_halt(); return 0; } static int aica_pcmvolume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = 0xFF; return 0; } static int aica_pcmvolume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_card_aica *dreamcastcard; dreamcastcard = kcontrol->private_data; if (unlikely(!dreamcastcard->channel)) return -ETXTBSY; /* we've not yet been set up */ ucontrol->value.integer.value[0] = dreamcastcard->channel->vol; return 0; } static int aica_pcmvolume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_card_aica *dreamcastcard; unsigned int vol; dreamcastcard = kcontrol->private_data; if (unlikely(!dreamcastcard->channel)) return -ETXTBSY; vol = ucontrol->value.integer.value[0]; if (vol > 0xff) return -EINVAL; if (unlikely(dreamcastcard->channel->vol == vol)) return 0; dreamcastcard->channel->vol = ucontrol->value.integer.value[0]; dreamcastcard->master_volume = ucontrol->value.integer.value[0]; spu_memload(AICA_CHANNEL0_CONTROL_OFFSET, dreamcastcard->channel, sizeof(struct aica_channel)); return 1; } static const struct snd_kcontrol_new snd_aica_pcmswitch_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Switch", .index = 0, .info = aica_pcmswitch_info, .get = aica_pcmswitch_get, .put = aica_pcmswitch_put }; static const struct snd_kcontrol_new snd_aica_pcmvolume_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Volume", .index = 0, .info = aica_pcmvolume_info, .get = aica_pcmvolume_get, .put = aica_pcmvolume_put }; static int load_aica_firmware(void) { int err; const struct firmware *fw_entry; spu_reset(); err = request_firmware(&fw_entry, "aica_firmware.bin", &pd->dev); if (unlikely(err)) return err; /* write firmware into memory */ spu_disable(); spu_memload(0, fw_entry->data, fw_entry->size); spu_enable(); release_firmware(fw_entry); return err; } static int add_aicamixer_controls(struct snd_card_aica *dreamcastcard) { int err; err = snd_ctl_add (dreamcastcard->card, snd_ctl_new1(&snd_aica_pcmvolume_control, dreamcastcard)); if (unlikely(err < 0)) return err; err = snd_ctl_add (dreamcastcard->card, snd_ctl_new1(&snd_aica_pcmswitch_control, dreamcastcard)); if (unlikely(err < 0)) return err; return 0; } static void snd_aica_remove(struct platform_device *devptr) { struct snd_card_aica *dreamcastcard; dreamcastcard = platform_get_drvdata(devptr); snd_card_free(dreamcastcard->card); kfree(dreamcastcard); } static int snd_aica_probe(struct platform_device *devptr) { int err; struct snd_card_aica *dreamcastcard; dreamcastcard = kzalloc(sizeof(struct snd_card_aica), GFP_KERNEL); if (unlikely(!dreamcastcard)) return -ENOMEM; err = snd_card_new(&devptr->dev, index, SND_AICA_DRIVER, THIS_MODULE, 0, &dreamcastcard->card); if (unlikely(err < 0)) { kfree(dreamcastcard); return err; } strcpy(dreamcastcard->card->driver, "snd_aica"); strcpy(dreamcastcard->card->shortname, SND_AICA_DRIVER); strcpy(dreamcastcard->card->longname, "Yamaha AICA Super Intelligent Sound Processor for SEGA Dreamcast"); /* Prepare to use the queue */ INIT_WORK(&(dreamcastcard->spu_dma_work), run_spu_dma); timer_setup(&dreamcastcard->timer, aica_period_elapsed, 0); /* Load the PCM 'chip' */ err = snd_aicapcmchip(dreamcastcard, 0); if (unlikely(err < 0)) goto freedreamcast; /* Add basic controls */ err = add_aicamixer_controls(dreamcastcard); if (unlikely(err < 0)) goto freedreamcast; /* Register the card with ALSA subsystem */ err = snd_card_register(dreamcastcard->card); if (unlikely(err < 0)) goto freedreamcast; platform_set_drvdata(devptr, dreamcastcard); snd_printk ("ALSA Driver for Yamaha AICA Super Intelligent Sound Processor\n"); return 0; freedreamcast: snd_card_free(dreamcastcard->card); kfree(dreamcastcard); return err; } static struct platform_driver snd_aica_driver = { .probe = snd_aica_probe, .remove_new = snd_aica_remove, .driver = { .name = SND_AICA_DRIVER, }, }; static int __init aica_init(void) { int err; err = platform_driver_register(&snd_aica_driver); if (unlikely(err < 0)) return err; pd = platform_device_register_simple(SND_AICA_DRIVER, -1, aica_memory_space, 2); if (IS_ERR(pd)) { platform_driver_unregister(&snd_aica_driver); return PTR_ERR(pd); } /* Load the firmware */ return load_aica_firmware(); } static void __exit aica_exit(void) { platform_device_unregister(pd); platform_driver_unregister(&snd_aica_driver); /* Kill any sound still playing and reset ARM7 to safe state */ spu_reset(); } module_init(aica_init); module_exit(aica_exit);
linux-master
sound/sh/aica.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * sh_dac_audio.c - SuperH DAC audio driver for ALSA * * Copyright (c) 2009 by Rafael Ignacio Zurita <[email protected]> * * Based on sh_dac_audio.c (Copyright (C) 2004, 2005 by Andriy Skulysh) */ #include <linux/hrtimer.h> #include <linux/interrupt.h> #include <linux/io.h> #include <linux/platform_device.h> #include <linux/slab.h> #include <linux/module.h> #include <sound/core.h> #include <sound/initval.h> #include <sound/pcm.h> #include <sound/sh_dac_audio.h> #include <asm/clock.h> #include <asm/hd64461.h> #include <mach/hp6xx.h> #include <cpu/dac.h> MODULE_AUTHOR("Rafael Ignacio Zurita <[email protected]>"); MODULE_DESCRIPTION("SuperH DAC audio driver"); MODULE_LICENSE("GPL"); /* Module Parameters */ static int index = SNDRV_DEFAULT_IDX1; static char *id = SNDRV_DEFAULT_STR1; module_param(index, int, 0444); MODULE_PARM_DESC(index, "Index value for SuperH DAC audio."); module_param(id, charp, 0444); MODULE_PARM_DESC(id, "ID string for SuperH DAC audio."); /* main struct */ struct snd_sh_dac { struct snd_card *card; struct snd_pcm_substream *substream; struct hrtimer hrtimer; ktime_t wakeups_per_second; int rate; int empty; char *data_buffer, *buffer_begin, *buffer_end; int processed; /* bytes proccesed, to compare with period_size */ int buffer_size; struct dac_audio_pdata *pdata; }; static void dac_audio_start_timer(struct snd_sh_dac *chip) { hrtimer_start(&chip->hrtimer, chip->wakeups_per_second, HRTIMER_MODE_REL); } static void dac_audio_stop_timer(struct snd_sh_dac *chip) { hrtimer_cancel(&chip->hrtimer); } static void dac_audio_reset(struct snd_sh_dac *chip) { dac_audio_stop_timer(chip); chip->buffer_begin = chip->buffer_end = chip->data_buffer; chip->processed = 0; chip->empty = 1; } static void dac_audio_set_rate(struct snd_sh_dac *chip) { chip->wakeups_per_second = 1000000000 / chip->rate; } /* PCM INTERFACE */ static const struct snd_pcm_hardware snd_sh_dac_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_HALF_DUPLEX), .formats = SNDRV_PCM_FMTBIT_U8, .rates = SNDRV_PCM_RATE_8000, .rate_min = 8000, .rate_max = 8000, .channels_min = 1, .channels_max = 1, .buffer_bytes_max = (48*1024), .period_bytes_min = 1, .period_bytes_max = (48*1024), .periods_min = 1, .periods_max = 1024, }; static int snd_sh_dac_pcm_open(struct snd_pcm_substream *substream) { struct snd_sh_dac *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; runtime->hw = snd_sh_dac_pcm_hw; chip->substream = substream; chip->buffer_begin = chip->buffer_end = chip->data_buffer; chip->processed = 0; chip->empty = 1; chip->pdata->start(chip->pdata); return 0; } static int snd_sh_dac_pcm_close(struct snd_pcm_substream *substream) { struct snd_sh_dac *chip = snd_pcm_substream_chip(substream); chip->substream = NULL; dac_audio_stop_timer(chip); chip->pdata->stop(chip->pdata); return 0; } static int snd_sh_dac_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_sh_dac *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = chip->substream->runtime; chip->buffer_size = runtime->buffer_size; memset(chip->data_buffer, 0, chip->pdata->buffer_size); return 0; } static int snd_sh_dac_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_sh_dac *chip = snd_pcm_substream_chip(substream); switch (cmd) { case SNDRV_PCM_TRIGGER_START: dac_audio_start_timer(chip); break; case SNDRV_PCM_TRIGGER_STOP: chip->buffer_begin = chip->buffer_end = chip->data_buffer; chip->processed = 0; chip->empty = 1; dac_audio_stop_timer(chip); break; default: return -EINVAL; } return 0; } static int snd_sh_dac_pcm_copy(struct snd_pcm_substream *substream, int channel, unsigned long pos, struct iov_iter *src, unsigned long count) { /* channel is not used (interleaved data) */ struct snd_sh_dac *chip = snd_pcm_substream_chip(substream); if (copy_from_iter_toio(chip->data_buffer + pos, src, count)) return -EFAULT; chip->buffer_end = chip->data_buffer + pos + count; if (chip->empty) { chip->empty = 0; dac_audio_start_timer(chip); } return 0; } static int snd_sh_dac_pcm_silence(struct snd_pcm_substream *substream, int channel, unsigned long pos, unsigned long count) { /* channel is not used (interleaved data) */ struct snd_sh_dac *chip = snd_pcm_substream_chip(substream); memset_io(chip->data_buffer + pos, 0, count); chip->buffer_end = chip->data_buffer + pos + count; if (chip->empty) { chip->empty = 0; dac_audio_start_timer(chip); } return 0; } static snd_pcm_uframes_t snd_sh_dac_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_sh_dac *chip = snd_pcm_substream_chip(substream); int pointer = chip->buffer_begin - chip->data_buffer; return pointer; } /* pcm ops */ static const struct snd_pcm_ops snd_sh_dac_pcm_ops = { .open = snd_sh_dac_pcm_open, .close = snd_sh_dac_pcm_close, .prepare = snd_sh_dac_pcm_prepare, .trigger = snd_sh_dac_pcm_trigger, .pointer = snd_sh_dac_pcm_pointer, .copy = snd_sh_dac_pcm_copy, .fill_silence = snd_sh_dac_pcm_silence, .mmap = snd_pcm_lib_mmap_iomem, }; static int snd_sh_dac_pcm(struct snd_sh_dac *chip, int device) { int err; struct snd_pcm *pcm; /* device should be always 0 for us */ err = snd_pcm_new(chip->card, "SH_DAC PCM", device, 1, 0, &pcm); if (err < 0) return err; pcm->private_data = chip; strcpy(pcm->name, "SH_DAC PCM"); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sh_dac_pcm_ops); /* buffer size=48K */ snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, NULL, 48 * 1024, 48 * 1024); return 0; } /* END OF PCM INTERFACE */ /* driver .remove -- destructor */ static void snd_sh_dac_remove(struct platform_device *devptr) { snd_card_free(platform_get_drvdata(devptr)); } /* free -- it has been defined by create */ static int snd_sh_dac_free(struct snd_sh_dac *chip) { /* release the data */ kfree(chip->data_buffer); kfree(chip); return 0; } static int snd_sh_dac_dev_free(struct snd_device *device) { struct snd_sh_dac *chip = device->device_data; return snd_sh_dac_free(chip); } static enum hrtimer_restart sh_dac_audio_timer(struct hrtimer *handle) { struct snd_sh_dac *chip = container_of(handle, struct snd_sh_dac, hrtimer); struct snd_pcm_runtime *runtime = chip->substream->runtime; ssize_t b_ps = frames_to_bytes(runtime, runtime->period_size); if (!chip->empty) { sh_dac_output(*chip->buffer_begin, chip->pdata->channel); chip->buffer_begin++; chip->processed++; if (chip->processed >= b_ps) { chip->processed -= b_ps; snd_pcm_period_elapsed(chip->substream); } if (chip->buffer_begin == (chip->data_buffer + chip->buffer_size - 1)) chip->buffer_begin = chip->data_buffer; if (chip->buffer_begin == chip->buffer_end) chip->empty = 1; } if (!chip->empty) hrtimer_start(&chip->hrtimer, chip->wakeups_per_second, HRTIMER_MODE_REL); return HRTIMER_NORESTART; } /* create -- chip-specific constructor for the cards components */ static int snd_sh_dac_create(struct snd_card *card, struct platform_device *devptr, struct snd_sh_dac **rchip) { struct snd_sh_dac *chip; int err; static const struct snd_device_ops ops = { .dev_free = snd_sh_dac_dev_free, }; *rchip = NULL; chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) return -ENOMEM; chip->card = card; hrtimer_init(&chip->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); chip->hrtimer.function = sh_dac_audio_timer; dac_audio_reset(chip); chip->rate = 8000; dac_audio_set_rate(chip); chip->pdata = devptr->dev.platform_data; chip->data_buffer = kmalloc(chip->pdata->buffer_size, GFP_KERNEL); if (chip->data_buffer == NULL) { kfree(chip); return -ENOMEM; } err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); if (err < 0) { snd_sh_dac_free(chip); return err; } *rchip = chip; return 0; } /* driver .probe -- constructor */ static int snd_sh_dac_probe(struct platform_device *devptr) { struct snd_sh_dac *chip; struct snd_card *card; int err; err = snd_card_new(&devptr->dev, index, id, THIS_MODULE, 0, &card); if (err < 0) { snd_printk(KERN_ERR "cannot allocate the card\n"); return err; } err = snd_sh_dac_create(card, devptr, &chip); if (err < 0) goto probe_error; err = snd_sh_dac_pcm(chip, 0); if (err < 0) goto probe_error; strcpy(card->driver, "snd_sh_dac"); strcpy(card->shortname, "SuperH DAC audio driver"); printk(KERN_INFO "%s %s", card->longname, card->shortname); err = snd_card_register(card); if (err < 0) goto probe_error; snd_printk(KERN_INFO "ALSA driver for SuperH DAC audio"); platform_set_drvdata(devptr, card); return 0; probe_error: snd_card_free(card); return err; } /* * "driver" definition */ static struct platform_driver sh_dac_driver = { .probe = snd_sh_dac_probe, .remove_new = snd_sh_dac_remove, .driver = { .name = "dac_audio", }, }; module_platform_driver(sh_dac_driver);
linux-master
sound/sh/sh_dac_audio.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * USB Audio Driver for ALSA * * Quirks and vendor-specific extensions for mixer interfaces * * Copyright (c) 2002 by Takashi Iwai <[email protected]> * * Many codes borrowed from audio.c by * Alan Cox ([email protected]) * Thomas Sailer ([email protected]) * * Audio Advantage Micro II support added by: * Przemek Rudy ([email protected]) */ #include <linux/hid.h> #include <linux/init.h> #include <linux/math64.h> #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <sound/asoundef.h> #include <sound/core.h> #include <sound/control.h> #include <sound/hda_verbs.h> #include <sound/hwdep.h> #include <sound/info.h> #include <sound/tlv.h> #include "usbaudio.h" #include "mixer.h" #include "mixer_quirks.h" #include "mixer_scarlett.h" #include "mixer_scarlett_gen2.h" #include "mixer_us16x08.h" #include "mixer_s1810c.h" #include "helper.h" struct std_mono_table { unsigned int unitid, control, cmask; int val_type; const char *name; snd_kcontrol_tlv_rw_t *tlv_callback; }; /* This function allows for the creation of standard UAC controls. * See the quirks for M-Audio FTUs or Ebox-44. * If you don't want to set a TLV callback pass NULL. * * Since there doesn't seem to be a devices that needs a multichannel * version, we keep it mono for simplicity. */ static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer, unsigned int unitid, unsigned int control, unsigned int cmask, int val_type, unsigned int idx_off, const char *name, snd_kcontrol_tlv_rw_t *tlv_callback) { struct usb_mixer_elem_info *cval; struct snd_kcontrol *kctl; cval = kzalloc(sizeof(*cval), GFP_KERNEL); if (!cval) return -ENOMEM; snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid); cval->val_type = val_type; cval->channels = 1; cval->control = control; cval->cmask = cmask; cval->idx_off = idx_off; /* get_min_max() is called only for integer volumes later, * so provide a short-cut for booleans */ cval->min = 0; cval->max = 1; cval->res = 0; cval->dBmin = 0; cval->dBmax = 0; /* Create control */ kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval); if (!kctl) { kfree(cval); return -ENOMEM; } /* Set name */ snprintf(kctl->id.name, sizeof(kctl->id.name), name); kctl->private_free = snd_usb_mixer_elem_free; /* set TLV */ if (tlv_callback) { kctl->tlv.c = tlv_callback; kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ | SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; } /* Add control to mixer */ return snd_usb_mixer_add_control(&cval->head, kctl); } static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer, unsigned int unitid, unsigned int control, unsigned int cmask, int val_type, const char *name, snd_kcontrol_tlv_rw_t *tlv_callback) { return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask, val_type, 0 /* Offset */, name, tlv_callback); } /* * Create a set of standard UAC controls from a table */ static int snd_create_std_mono_table(struct usb_mixer_interface *mixer, const struct std_mono_table *t) { int err; while (t->name != NULL) { err = snd_create_std_mono_ctl(mixer, t->unitid, t->control, t->cmask, t->val_type, t->name, t->tlv_callback); if (err < 0) return err; t++; } return 0; } static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer, int id, usb_mixer_elem_resume_func_t resume, const struct snd_kcontrol_new *knew, struct usb_mixer_elem_list **listp) { struct usb_mixer_elem_list *list; struct snd_kcontrol *kctl; list = kzalloc(sizeof(*list), GFP_KERNEL); if (!list) return -ENOMEM; if (listp) *listp = list; list->mixer = mixer; list->id = id; list->resume = resume; kctl = snd_ctl_new1(knew, list); if (!kctl) { kfree(list); return -ENOMEM; } kctl->private_free = snd_usb_mixer_elem_free; /* don't use snd_usb_mixer_add_control() here, this is a special list element */ return snd_usb_mixer_add_list(list, kctl, false); } /* * Sound Blaster remote control configuration * * format of remote control data: * Extigy: xx 00 * Audigy 2 NX: 06 80 xx 00 00 00 * Live! 24-bit: 06 80 xx yy 22 83 */ static const struct rc_config { u32 usb_id; u8 offset; u8 length; u8 packet_length; u8 min_packet_length; /* minimum accepted length of the URB result */ u8 mute_mixer_id; u32 mute_code; } rc_configs[] = { { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */ { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */ { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */ { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */ { USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ { USB_ID(0x041e, 0x3237), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ { USB_ID(0x041e, 0x3263), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */ { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */ }; static void snd_usb_soundblaster_remote_complete(struct urb *urb) { struct usb_mixer_interface *mixer = urb->context; const struct rc_config *rc = mixer->rc_cfg; u32 code; if (urb->status < 0 || urb->actual_length < rc->min_packet_length) return; code = mixer->rc_buffer[rc->offset]; if (rc->length == 2) code |= mixer->rc_buffer[rc->offset + 1] << 8; /* the Mute button actually changes the mixer control */ if (code == rc->mute_code) snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id); mixer->rc_code = code; wmb(); wake_up(&mixer->rc_waitq); } static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf, long count, loff_t *offset) { struct usb_mixer_interface *mixer = hw->private_data; int err; u32 rc_code; if (count != 1 && count != 4) return -EINVAL; err = wait_event_interruptible(mixer->rc_waitq, (rc_code = xchg(&mixer->rc_code, 0)) != 0); if (err == 0) { if (count == 1) err = put_user(rc_code, buf); else err = put_user(rc_code, (u32 __user *)buf); } return err < 0 ? err : count; } static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file, poll_table *wait) { struct usb_mixer_interface *mixer = hw->private_data; poll_wait(file, &mixer->rc_waitq, wait); return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0; } static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer) { struct snd_hwdep *hwdep; int err, len, i; for (i = 0; i < ARRAY_SIZE(rc_configs); ++i) if (rc_configs[i].usb_id == mixer->chip->usb_id) break; if (i >= ARRAY_SIZE(rc_configs)) return 0; mixer->rc_cfg = &rc_configs[i]; len = mixer->rc_cfg->packet_length; init_waitqueue_head(&mixer->rc_waitq); err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep); if (err < 0) return err; snprintf(hwdep->name, sizeof(hwdep->name), "%s remote control", mixer->chip->card->shortname); hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC; hwdep->private_data = mixer; hwdep->ops.read = snd_usb_sbrc_hwdep_read; hwdep->ops.poll = snd_usb_sbrc_hwdep_poll; hwdep->exclusive = 1; mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL); if (!mixer->rc_urb) return -ENOMEM; mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL); if (!mixer->rc_setup_packet) { usb_free_urb(mixer->rc_urb); mixer->rc_urb = NULL; return -ENOMEM; } mixer->rc_setup_packet->bRequestType = USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE; mixer->rc_setup_packet->bRequest = UAC_GET_MEM; mixer->rc_setup_packet->wValue = cpu_to_le16(0); mixer->rc_setup_packet->wIndex = cpu_to_le16(0); mixer->rc_setup_packet->wLength = cpu_to_le16(len); usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev, usb_rcvctrlpipe(mixer->chip->dev, 0), (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len, snd_usb_soundblaster_remote_complete, mixer); return 0; } #define snd_audigy2nx_led_info snd_ctl_boolean_mono_info static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.integer.value[0] = kcontrol->private_value >> 8; return 0; } static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer, int value, int index) { struct snd_usb_audio *chip = mixer->chip; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; if (chip->usb_id == USB_ID(0x041e, 0x3042)) err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), 0x24, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, !value, 0, NULL, 0); /* USB X-Fi S51 Pro */ if (chip->usb_id == USB_ID(0x041e, 0x30df)) err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), 0x24, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, !value, 0, NULL, 0); else err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), 0x24, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, value, index + 2, NULL, 0); snd_usb_unlock_shutdown(chip); return err; } static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); struct usb_mixer_interface *mixer = list->mixer; int index = kcontrol->private_value & 0xff; unsigned int value = ucontrol->value.integer.value[0]; int old_value = kcontrol->private_value >> 8; int err; if (value > 1) return -EINVAL; if (value == old_value) return 0; kcontrol->private_value = (value << 8) | index; err = snd_audigy2nx_led_update(mixer, value, index); return err < 0 ? err : 1; } static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list) { int priv_value = list->kctl->private_value; return snd_audigy2nx_led_update(list->mixer, priv_value >> 8, priv_value & 0xff); } /* name and private_value are set dynamically */ static const struct snd_kcontrol_new snd_audigy2nx_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .info = snd_audigy2nx_led_info, .get = snd_audigy2nx_led_get, .put = snd_audigy2nx_led_put, }; static const char * const snd_audigy2nx_led_names[] = { "CMSS LED Switch", "Power LED Switch", "Dolby Digital LED Switch", }; static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer) { int i, err; for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) { struct snd_kcontrol_new knew; /* USB X-Fi S51 doesn't have a CMSS LED */ if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0) continue; /* USB X-Fi S51 Pro doesn't have one either */ if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0) continue; if (i > 1 && /* Live24ext has 2 LEDs only */ (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || mixer->chip->usb_id == USB_ID(0x041e, 0x3042) || mixer->chip->usb_id == USB_ID(0x041e, 0x30df) || mixer->chip->usb_id == USB_ID(0x041e, 0x3048))) break; knew = snd_audigy2nx_control; knew.name = snd_audigy2nx_led_names[i]; knew.private_value = (1 << 8) | i; /* LED on as default */ err = add_single_ctl_with_resume(mixer, 0, snd_audigy2nx_led_resume, &knew, NULL); if (err < 0) return err; } return 0; } static void snd_audigy2nx_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { static const struct sb_jack { int unitid; const char *name; } jacks_audigy2nx[] = { {4, "dig in "}, {7, "line in"}, {19, "spk out"}, {20, "hph out"}, {-1, NULL} }, jacks_live24ext[] = { {4, "line in"}, /* &1=Line, &2=Mic*/ {3, "hph out"}, /* headphones */ {0, "RC "}, /* last command, 6 bytes see rc_config above */ {-1, NULL} }; const struct sb_jack *jacks; struct usb_mixer_interface *mixer = entry->private_data; int i, err; u8 buf[3]; snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname); if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020)) jacks = jacks_audigy2nx; else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) jacks = jacks_live24ext; else return; for (i = 0; jacks[i].name; ++i) { snd_iprintf(buffer, "%s: ", jacks[i].name); err = snd_usb_lock_shutdown(mixer->chip); if (err < 0) return; err = snd_usb_ctl_msg(mixer->chip->dev, usb_rcvctrlpipe(mixer->chip->dev, 0), UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, jacks[i].unitid << 8, buf, 3); snd_usb_unlock_shutdown(mixer->chip); if (err == 3 && (buf[0] == 3 || buf[0] == 6)) snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]); else snd_iprintf(buffer, "?\n"); } } /* EMU0204 */ static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char * const texts[2] = {"1/2", "3/4"}; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); } static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.enumerated.item[0] = kcontrol->private_value; return 0; } static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer, int value) { struct snd_usb_audio *chip = mixer->chip; int err; unsigned char buf[2]; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; buf[0] = 0x01; buf[1] = value ? 0x02 : 0x01; err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 0x0400, 0x0e00, buf, 2); snd_usb_unlock_shutdown(chip); return err; } static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); struct usb_mixer_interface *mixer = list->mixer; unsigned int value = ucontrol->value.enumerated.item[0]; int err; if (value > 1) return -EINVAL; if (value == kcontrol->private_value) return 0; kcontrol->private_value = value; err = snd_emu0204_ch_switch_update(mixer, value); return err < 0 ? err : 1; } static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list) { return snd_emu0204_ch_switch_update(list->mixer, list->kctl->private_value); } static const struct snd_kcontrol_new snd_emu0204_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Front Jack Channels", .info = snd_emu0204_ch_switch_info, .get = snd_emu0204_ch_switch_get, .put = snd_emu0204_ch_switch_put, .private_value = 0, }; static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer) { return add_single_ctl_with_resume(mixer, 0, snd_emu0204_ch_switch_resume, &snd_emu0204_control, NULL); } /* ASUS Xonar U1 / U3 controls */ static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02); return 0; } static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer, unsigned char status) { struct snd_usb_audio *chip = mixer->chip; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), 0x08, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 50, 0, &status, 1); snd_usb_unlock_shutdown(chip); return err; } static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); u8 old_status, new_status; int err; old_status = kcontrol->private_value; if (ucontrol->value.integer.value[0]) new_status = old_status | 0x02; else new_status = old_status & ~0x02; if (new_status == old_status) return 0; kcontrol->private_value = new_status; err = snd_xonar_u1_switch_update(list->mixer, new_status); return err < 0 ? err : 1; } static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list) { return snd_xonar_u1_switch_update(list->mixer, list->kctl->private_value); } static const struct snd_kcontrol_new snd_xonar_u1_output_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Digital Playback Switch", .info = snd_ctl_boolean_mono_info, .get = snd_xonar_u1_switch_get, .put = snd_xonar_u1_switch_put, .private_value = 0x05, }; static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer) { return add_single_ctl_with_resume(mixer, 0, snd_xonar_u1_switch_resume, &snd_xonar_u1_output_switch, NULL); } /* Digidesign Mbox 1 helper functions */ static int snd_mbox1_is_spdif_synced(struct snd_usb_audio *chip) { unsigned char buff[3]; int err; int is_spdif_synced; /* Read clock source */ err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), 0x81, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3); if (err < 0) return err; /* spdif sync: buff is all zeroes */ is_spdif_synced = !(buff[0] | buff[1] | buff[2]); return is_spdif_synced; } static int snd_mbox1_set_clk_source(struct snd_usb_audio *chip, int rate_or_zero) { /* 2 possibilities: Internal -> expects sample rate * S/PDIF sync -> expects rate = 0 */ unsigned char buff[3]; buff[0] = (rate_or_zero >> 0) & 0xff; buff[1] = (rate_or_zero >> 8) & 0xff; buff[2] = (rate_or_zero >> 16) & 0xff; /* Set clock source */ return snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), 0x1, USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3); } static int snd_mbox1_is_spdif_input(struct snd_usb_audio *chip) { /* Hardware gives 2 possibilities: ANALOG Source -> 0x01 * S/PDIF Source -> 0x02 */ int err; unsigned char source[1]; /* Read input source */ err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), 0x81, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0x00, 0x500, source, 1); if (err < 0) return err; return (source[0] == 2); } static int snd_mbox1_set_input_source(struct snd_usb_audio *chip, int is_spdif) { /* NB: Setting the input source to S/PDIF resets the clock source to S/PDIF * Hardware expects 2 possibilities: ANALOG Source -> 0x01 * S/PDIF Source -> 0x02 */ unsigned char buff[1]; buff[0] = (is_spdif & 1) + 1; /* Set input source */ return snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), 0x1, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1); } /* Digidesign Mbox 1 clock source switch (internal/spdif) */ static int snd_mbox1_clk_switch_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); struct snd_usb_audio *chip = list->mixer->chip; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) goto err; err = snd_mbox1_is_spdif_synced(chip); if (err < 0) goto err; kctl->private_value = err; err = 0; ucontrol->value.enumerated.item[0] = kctl->private_value; err: snd_usb_unlock_shutdown(chip); return err; } static int snd_mbox1_clk_switch_update(struct usb_mixer_interface *mixer, int is_spdif_sync) { struct snd_usb_audio *chip = mixer->chip; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = snd_mbox1_is_spdif_input(chip); if (err < 0) goto err; err = snd_mbox1_is_spdif_synced(chip); if (err < 0) goto err; /* FIXME: hardcoded sample rate */ err = snd_mbox1_set_clk_source(chip, is_spdif_sync ? 0 : 48000); if (err < 0) goto err; err = snd_mbox1_is_spdif_synced(chip); err: snd_usb_unlock_shutdown(chip); return err; } static int snd_mbox1_clk_switch_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); struct usb_mixer_interface *mixer = list->mixer; int err; bool cur_val, new_val; cur_val = kctl->private_value; new_val = ucontrol->value.enumerated.item[0]; if (cur_val == new_val) return 0; kctl->private_value = new_val; err = snd_mbox1_clk_switch_update(mixer, new_val); return err < 0 ? err : 1; } static int snd_mbox1_clk_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char *const texts[2] = { "Internal", "S/PDIF" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); } static int snd_mbox1_clk_switch_resume(struct usb_mixer_elem_list *list) { return snd_mbox1_clk_switch_update(list->mixer, list->kctl->private_value); } /* Digidesign Mbox 1 input source switch (analog/spdif) */ static int snd_mbox1_src_switch_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.enumerated.item[0] = kctl->private_value; return 0; } static int snd_mbox1_src_switch_update(struct usb_mixer_interface *mixer, int is_spdif_input) { struct snd_usb_audio *chip = mixer->chip; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = snd_mbox1_is_spdif_input(chip); if (err < 0) goto err; err = snd_mbox1_set_input_source(chip, is_spdif_input); if (err < 0) goto err; err = snd_mbox1_is_spdif_input(chip); if (err < 0) goto err; err = snd_mbox1_is_spdif_synced(chip); err: snd_usb_unlock_shutdown(chip); return err; } static int snd_mbox1_src_switch_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); struct usb_mixer_interface *mixer = list->mixer; int err; bool cur_val, new_val; cur_val = kctl->private_value; new_val = ucontrol->value.enumerated.item[0]; if (cur_val == new_val) return 0; kctl->private_value = new_val; err = snd_mbox1_src_switch_update(mixer, new_val); return err < 0 ? err : 1; } static int snd_mbox1_src_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char *const texts[2] = { "Analog", "S/PDIF" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); } static int snd_mbox1_src_switch_resume(struct usb_mixer_elem_list *list) { return snd_mbox1_src_switch_update(list->mixer, list->kctl->private_value); } static const struct snd_kcontrol_new snd_mbox1_clk_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Clock Source", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_mbox1_clk_switch_info, .get = snd_mbox1_clk_switch_get, .put = snd_mbox1_clk_switch_put, .private_value = 0 }; static const struct snd_kcontrol_new snd_mbox1_src_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Input Source", .index = 1, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_mbox1_src_switch_info, .get = snd_mbox1_src_switch_get, .put = snd_mbox1_src_switch_put, .private_value = 0 }; static int snd_mbox1_controls_create(struct usb_mixer_interface *mixer) { int err; err = add_single_ctl_with_resume(mixer, 0, snd_mbox1_clk_switch_resume, &snd_mbox1_clk_switch, NULL); if (err < 0) return err; return add_single_ctl_with_resume(mixer, 1, snd_mbox1_src_switch_resume, &snd_mbox1_src_switch, NULL); } /* Native Instruments device quirks */ #define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex)) static int snd_ni_control_init_val(struct usb_mixer_interface *mixer, struct snd_kcontrol *kctl) { struct usb_device *dev = mixer->chip->dev; unsigned int pval = kctl->private_value; u8 value; int err; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), (pval >> 16) & 0xff, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 0, pval & 0xffff, &value, 1); if (err < 0) { dev_err(&dev->dev, "unable to issue vendor read request (ret = %d)", err); return err; } kctl->private_value |= ((unsigned int)value << 24); return 0; } static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.integer.value[0] = kcontrol->private_value >> 24; return 0; } static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list) { struct snd_usb_audio *chip = list->mixer->chip; unsigned int pval = list->kctl->private_value; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), (pval >> 16) & 0xff, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, pval >> 24, pval & 0xffff, NULL, 0, 1000); snd_usb_unlock_shutdown(chip); return err; } static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); u8 oldval = (kcontrol->private_value >> 24) & 0xff; u8 newval = ucontrol->value.integer.value[0]; int err; if (oldval == newval) return 0; kcontrol->private_value &= ~(0xff << 24); kcontrol->private_value |= (unsigned int)newval << 24; err = snd_ni_update_cur_val(list); return err < 0 ? err : 1; } static const struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = { { .name = "Direct Thru Channel A", .private_value = _MAKE_NI_CONTROL(0x01, 0x03), }, { .name = "Direct Thru Channel B", .private_value = _MAKE_NI_CONTROL(0x01, 0x05), }, { .name = "Phono Input Channel A", .private_value = _MAKE_NI_CONTROL(0x02, 0x03), }, { .name = "Phono Input Channel B", .private_value = _MAKE_NI_CONTROL(0x02, 0x05), }, }; static const struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = { { .name = "Direct Thru Channel A", .private_value = _MAKE_NI_CONTROL(0x01, 0x03), }, { .name = "Direct Thru Channel B", .private_value = _MAKE_NI_CONTROL(0x01, 0x05), }, { .name = "Direct Thru Channel C", .private_value = _MAKE_NI_CONTROL(0x01, 0x07), }, { .name = "Direct Thru Channel D", .private_value = _MAKE_NI_CONTROL(0x01, 0x09), }, { .name = "Phono Input Channel A", .private_value = _MAKE_NI_CONTROL(0x02, 0x03), }, { .name = "Phono Input Channel B", .private_value = _MAKE_NI_CONTROL(0x02, 0x05), }, { .name = "Phono Input Channel C", .private_value = _MAKE_NI_CONTROL(0x02, 0x07), }, { .name = "Phono Input Channel D", .private_value = _MAKE_NI_CONTROL(0x02, 0x09), }, }; static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer, const struct snd_kcontrol_new *kc, unsigned int count) { int i, err = 0; struct snd_kcontrol_new template = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .get = snd_nativeinstruments_control_get, .put = snd_nativeinstruments_control_put, .info = snd_ctl_boolean_mono_info, }; for (i = 0; i < count; i++) { struct usb_mixer_elem_list *list; template.name = kc[i].name; template.private_value = kc[i].private_value; err = add_single_ctl_with_resume(mixer, 0, snd_ni_update_cur_val, &template, &list); if (err < 0) break; snd_ni_control_init_val(mixer, list->kctl); } return err; } /* M-Audio FastTrack Ultra quirks */ /* FTU Effect switch (also used by C400/C600) */ static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char *const texts[8] = { "Room 1", "Room 2", "Room 3", "Hall 1", "Hall 2", "Plate", "Delay", "Echo" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); } static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer, struct snd_kcontrol *kctl) { struct usb_device *dev = mixer->chip->dev; unsigned int pval = kctl->private_value; int err; unsigned char value[2]; value[0] = 0x00; value[1] = 0x00; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, pval & 0xff00, snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8), value, 2); if (err < 0) return err; kctl->private_value |= (unsigned int)value[0] << 24; return 0; } static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.enumerated.item[0] = kctl->private_value >> 24; return 0; } static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list) { struct snd_usb_audio *chip = list->mixer->chip; unsigned int pval = list->kctl->private_value; unsigned char value[2]; int err; value[0] = pval >> 24; value[1] = 0; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, pval & 0xff00, snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8), value, 2); snd_usb_unlock_shutdown(chip); return err; } static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); unsigned int pval = list->kctl->private_value; int cur_val, err, new_val; cur_val = pval >> 24; new_val = ucontrol->value.enumerated.item[0]; if (cur_val == new_val) return 0; kctl->private_value &= ~(0xff << 24); kctl->private_value |= new_val << 24; err = snd_ftu_eff_switch_update(list); return err < 0 ? err : 1; } static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer, int validx, int bUnitID) { static struct snd_kcontrol_new template = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Effect Program Switch", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_ftu_eff_switch_info, .get = snd_ftu_eff_switch_get, .put = snd_ftu_eff_switch_put }; struct usb_mixer_elem_list *list; int err; err = add_single_ctl_with_resume(mixer, bUnitID, snd_ftu_eff_switch_update, &template, &list); if (err < 0) return err; list->kctl->private_value = (validx << 8) | bUnitID; snd_ftu_eff_switch_init(mixer, list->kctl); return 0; } /* Create volume controls for FTU devices*/ static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer) { char name[64]; unsigned int control, cmask; int in, out, err; const unsigned int id = 5; const int val_type = USB_MIXER_S16; for (out = 0; out < 8; out++) { control = out + 1; for (in = 0; in < 8; in++) { cmask = 1 << in; snprintf(name, sizeof(name), "AIn%d - Out%d Capture Volume", in + 1, out + 1); err = snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, &snd_usb_mixer_vol_tlv); if (err < 0) return err; } for (in = 8; in < 16; in++) { cmask = 1 << in; snprintf(name, sizeof(name), "DIn%d - Out%d Playback Volume", in - 7, out + 1); err = snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, &snd_usb_mixer_vol_tlv); if (err < 0) return err; } } return 0; } /* This control needs a volume quirk, see mixer.c */ static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer) { static const char name[] = "Effect Volume"; const unsigned int id = 6; const int val_type = USB_MIXER_U8; const unsigned int control = 2; const unsigned int cmask = 0; return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, snd_usb_mixer_vol_tlv); } /* This control needs a volume quirk, see mixer.c */ static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer) { static const char name[] = "Effect Duration"; const unsigned int id = 6; const int val_type = USB_MIXER_S16; const unsigned int control = 3; const unsigned int cmask = 0; return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, snd_usb_mixer_vol_tlv); } /* This control needs a volume quirk, see mixer.c */ static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer) { static const char name[] = "Effect Feedback Volume"; const unsigned int id = 6; const int val_type = USB_MIXER_U8; const unsigned int control = 4; const unsigned int cmask = 0; return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, NULL); } static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer) { unsigned int cmask; int err, ch; char name[48]; const unsigned int id = 7; const int val_type = USB_MIXER_S16; const unsigned int control = 7; for (ch = 0; ch < 4; ++ch) { cmask = 1 << ch; snprintf(name, sizeof(name), "Effect Return %d Volume", ch + 1); err = snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, snd_usb_mixer_vol_tlv); if (err < 0) return err; } return 0; } static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer) { unsigned int cmask; int err, ch; char name[48]; const unsigned int id = 5; const int val_type = USB_MIXER_S16; const unsigned int control = 9; for (ch = 0; ch < 8; ++ch) { cmask = 1 << ch; snprintf(name, sizeof(name), "Effect Send AIn%d Volume", ch + 1); err = snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, snd_usb_mixer_vol_tlv); if (err < 0) return err; } for (ch = 8; ch < 16; ++ch) { cmask = 1 << ch; snprintf(name, sizeof(name), "Effect Send DIn%d Volume", ch - 7); err = snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, snd_usb_mixer_vol_tlv); if (err < 0) return err; } return 0; } static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer) { int err; err = snd_ftu_create_volume_ctls(mixer); if (err < 0) return err; err = snd_ftu_create_effect_switch(mixer, 1, 6); if (err < 0) return err; err = snd_ftu_create_effect_volume_ctl(mixer); if (err < 0) return err; err = snd_ftu_create_effect_duration_ctl(mixer); if (err < 0) return err; err = snd_ftu_create_effect_feedback_ctl(mixer); if (err < 0) return err; err = snd_ftu_create_effect_return_ctls(mixer); if (err < 0) return err; err = snd_ftu_create_effect_send_ctls(mixer); if (err < 0) return err; return 0; } void snd_emuusb_set_samplerate(struct snd_usb_audio *chip, unsigned char samplerate_id) { struct usb_mixer_interface *mixer; struct usb_mixer_elem_info *cval; int unitid = 12; /* SampleRate ExtensionUnit ID */ list_for_each_entry(mixer, &chip->mixer_list, list) { if (mixer->id_elems[unitid]) { cval = mixer_elem_list_to_info(mixer->id_elems[unitid]); snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, cval->control << 8, samplerate_id); snd_usb_mixer_notify_id(mixer, unitid); break; } } } /* M-Audio Fast Track C400/C600 */ /* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */ static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer) { char name[64]; unsigned int cmask, offset; int out, chan, err; int num_outs = 0; int num_ins = 0; const unsigned int id = 0x40; const int val_type = USB_MIXER_S16; const int control = 1; switch (mixer->chip->usb_id) { case USB_ID(0x0763, 0x2030): num_outs = 6; num_ins = 4; break; case USB_ID(0x0763, 0x2031): num_outs = 8; num_ins = 6; break; } for (chan = 0; chan < num_outs + num_ins; chan++) { for (out = 0; out < num_outs; out++) { if (chan < num_outs) { snprintf(name, sizeof(name), "PCM%d-Out%d Playback Volume", chan + 1, out + 1); } else { snprintf(name, sizeof(name), "In%d-Out%d Playback Volume", chan - num_outs + 1, out + 1); } cmask = (out == 0) ? 0 : 1 << (out - 1); offset = chan * num_outs; err = snd_create_std_mono_ctl_offset(mixer, id, control, cmask, val_type, offset, name, &snd_usb_mixer_vol_tlv); if (err < 0) return err; } } return 0; } /* This control needs a volume quirk, see mixer.c */ static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer) { static const char name[] = "Effect Volume"; const unsigned int id = 0x43; const int val_type = USB_MIXER_U8; const unsigned int control = 3; const unsigned int cmask = 0; return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, snd_usb_mixer_vol_tlv); } /* This control needs a volume quirk, see mixer.c */ static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer) { static const char name[] = "Effect Duration"; const unsigned int id = 0x43; const int val_type = USB_MIXER_S16; const unsigned int control = 4; const unsigned int cmask = 0; return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, snd_usb_mixer_vol_tlv); } /* This control needs a volume quirk, see mixer.c */ static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer) { static const char name[] = "Effect Feedback Volume"; const unsigned int id = 0x43; const int val_type = USB_MIXER_U8; const unsigned int control = 5; const unsigned int cmask = 0; return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, NULL); } static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer) { char name[64]; unsigned int cmask; int chan, err; int num_outs = 0; int num_ins = 0; const unsigned int id = 0x42; const int val_type = USB_MIXER_S16; const int control = 1; switch (mixer->chip->usb_id) { case USB_ID(0x0763, 0x2030): num_outs = 6; num_ins = 4; break; case USB_ID(0x0763, 0x2031): num_outs = 8; num_ins = 6; break; } for (chan = 0; chan < num_outs + num_ins; chan++) { if (chan < num_outs) { snprintf(name, sizeof(name), "Effect Send DOut%d", chan + 1); } else { snprintf(name, sizeof(name), "Effect Send AIn%d", chan - num_outs + 1); } cmask = (chan == 0) ? 0 : 1 << (chan - 1); err = snd_create_std_mono_ctl(mixer, id, control, cmask, val_type, name, &snd_usb_mixer_vol_tlv); if (err < 0) return err; } return 0; } static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer) { char name[64]; unsigned int cmask; int chan, err; int num_outs = 0; int offset = 0; const unsigned int id = 0x40; const int val_type = USB_MIXER_S16; const int control = 1; switch (mixer->chip->usb_id) { case USB_ID(0x0763, 0x2030): num_outs = 6; offset = 0x3c; /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */ break; case USB_ID(0x0763, 0x2031): num_outs = 8; offset = 0x70; /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */ break; } for (chan = 0; chan < num_outs; chan++) { snprintf(name, sizeof(name), "Effect Return %d", chan + 1); cmask = (chan == 0) ? 0 : 1 << (chan + (chan % 2) * num_outs - 1); err = snd_create_std_mono_ctl_offset(mixer, id, control, cmask, val_type, offset, name, &snd_usb_mixer_vol_tlv); if (err < 0) return err; } return 0; } static int snd_c400_create_mixer(struct usb_mixer_interface *mixer) { int err; err = snd_c400_create_vol_ctls(mixer); if (err < 0) return err; err = snd_c400_create_effect_vol_ctls(mixer); if (err < 0) return err; err = snd_c400_create_effect_ret_vol_ctls(mixer); if (err < 0) return err; err = snd_ftu_create_effect_switch(mixer, 2, 0x43); if (err < 0) return err; err = snd_c400_create_effect_volume_ctl(mixer); if (err < 0) return err; err = snd_c400_create_effect_duration_ctl(mixer); if (err < 0) return err; err = snd_c400_create_effect_feedback_ctl(mixer); if (err < 0) return err; return 0; } /* * The mixer units for Ebox-44 are corrupt, and even where they * are valid they presents mono controls as L and R channels of * stereo. So we provide a good mixer here. */ static const struct std_mono_table ebox44_table[] = { { .unitid = 4, .control = 1, .cmask = 0x0, .val_type = USB_MIXER_INV_BOOLEAN, .name = "Headphone Playback Switch" }, { .unitid = 4, .control = 2, .cmask = 0x1, .val_type = USB_MIXER_S16, .name = "Headphone A Mix Playback Volume" }, { .unitid = 4, .control = 2, .cmask = 0x2, .val_type = USB_MIXER_S16, .name = "Headphone B Mix Playback Volume" }, { .unitid = 7, .control = 1, .cmask = 0x0, .val_type = USB_MIXER_INV_BOOLEAN, .name = "Output Playback Switch" }, { .unitid = 7, .control = 2, .cmask = 0x1, .val_type = USB_MIXER_S16, .name = "Output A Playback Volume" }, { .unitid = 7, .control = 2, .cmask = 0x2, .val_type = USB_MIXER_S16, .name = "Output B Playback Volume" }, { .unitid = 10, .control = 1, .cmask = 0x0, .val_type = USB_MIXER_INV_BOOLEAN, .name = "Input Capture Switch" }, { .unitid = 10, .control = 2, .cmask = 0x1, .val_type = USB_MIXER_S16, .name = "Input A Capture Volume" }, { .unitid = 10, .control = 2, .cmask = 0x2, .val_type = USB_MIXER_S16, .name = "Input B Capture Volume" }, {} }; /* Audio Advantage Micro II findings: * * Mapping spdif AES bits to vendor register.bit: * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01 * AES2: [0 0 0 0 0 0 0 0] * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request * (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices * * power on values: * r2: 0x10 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set * just after it to 0xa0, presumably it disables/mutes some analog * parts when there is no audio.) * r9: 0x28 * * Optical transmitter on/off: * vendor register.bit: 9.1 * 0 - on (0x28 register value) * 1 - off (0x2a register value) * */ static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); struct snd_usb_audio *chip = list->mixer->chip; int err; struct usb_interface *iface; struct usb_host_interface *alts; unsigned int ep; unsigned char data[3]; int rate; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff; ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff; ucontrol->value.iec958.status[2] = 0x00; /* use known values for that card: interface#1 altsetting#1 */ iface = usb_ifnum_to_if(chip->dev, 1); if (!iface || iface->num_altsetting < 2) { err = -EINVAL; goto end; } alts = &iface->altsetting[1]; if (get_iface_desc(alts)->bNumEndpoints < 1) { err = -EINVAL; goto end; } ep = get_endpoint(alts, 0)->bEndpointAddress; err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR, USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN, UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, sizeof(data)); if (err < 0) goto end; rate = data[0] | (data[1] << 8) | (data[2] << 16); ucontrol->value.iec958.status[3] = (rate == 48000) ? IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100; err = 0; end: snd_usb_unlock_shutdown(chip); return err; } static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list) { struct snd_usb_audio *chip = list->mixer->chip; unsigned int pval = list->kctl->private_value; u8 reg; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; reg = ((pval >> 4) & 0xf0) | (pval & 0x0f); err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, reg, 2, NULL, 0); if (err < 0) goto end; reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20; reg |= (pval >> 12) & 0x0f; err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, reg, 3, NULL, 0); if (err < 0) goto end; end: snd_usb_unlock_shutdown(chip); return err; } static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); unsigned int pval, pval_old; int err; pval = pval_old = kcontrol->private_value; pval &= 0xfffff0f0; pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8; pval |= (ucontrol->value.iec958.status[0] & 0x0f); pval &= 0xffff0fff; pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8; /* The frequency bits in AES3 cannot be set via register access. */ /* Silently ignore any bits from the request that cannot be set. */ if (pval == pval_old) return 0; kcontrol->private_value = pval; err = snd_microii_spdif_default_update(list); return err < 0 ? err : 1; } static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.iec958.status[0] = 0x0f; ucontrol->value.iec958.status[1] = 0xff; ucontrol->value.iec958.status[2] = 0x00; ucontrol->value.iec958.status[3] = 0x00; return 0; } static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02); return 0; } static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list) { struct snd_usb_audio *chip = list->mixer->chip; u8 reg = list->kctl->private_value; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, reg, 9, NULL, 0); snd_usb_unlock_shutdown(chip); return err; } static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); u8 reg; int err; reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a; if (reg != list->kctl->private_value) return 0; kcontrol->private_value = reg; err = snd_microii_spdif_switch_update(list); return err < 0 ? err : 1; } static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = { { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), .info = snd_microii_spdif_info, .get = snd_microii_spdif_default_get, .put = snd_microii_spdif_default_put, .private_value = 0x00000100UL,/* reset value */ }, { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK), .info = snd_microii_spdif_info, .get = snd_microii_spdif_mask_get, }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), .info = snd_ctl_boolean_mono_info, .get = snd_microii_spdif_switch_get, .put = snd_microii_spdif_switch_put, .private_value = 0x00000028UL,/* reset value */ } }; static int snd_microii_controls_create(struct usb_mixer_interface *mixer) { int err, i; static const usb_mixer_elem_resume_func_t resume_funcs[] = { snd_microii_spdif_default_update, NULL, snd_microii_spdif_switch_update }; for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) { err = add_single_ctl_with_resume(mixer, 0, resume_funcs[i], &snd_microii_mixer_spdif[i], NULL); if (err < 0) return err; } return 0; } /* Creative Sound Blaster E1 */ static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.integer.value[0] = kcontrol->private_value; return 0; } static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer, unsigned char state) { struct snd_usb_audio *chip = mixer->chip; int err; unsigned char buff[2]; buff[0] = 0x02; buff[1] = state ? 0x02 : 0x00; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 0x0202, 3, buff, 2); snd_usb_unlock_shutdown(chip); return err; } static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); unsigned char value = !!ucontrol->value.integer.value[0]; int err; if (kcontrol->private_value == value) return 0; kcontrol->private_value = value; err = snd_soundblaster_e1_switch_update(list->mixer, value); return err < 0 ? err : 1; } static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list) { return snd_soundblaster_e1_switch_update(list->mixer, list->kctl->private_value); } static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char *const texts[2] = { "Mic", "Aux" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); } static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Input Source", .info = snd_soundblaster_e1_switch_info, .get = snd_soundblaster_e1_switch_get, .put = snd_soundblaster_e1_switch_put, .private_value = 0, }; static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer) { return add_single_ctl_with_resume(mixer, 0, snd_soundblaster_e1_switch_resume, &snd_soundblaster_e1_input_switch, NULL); } /* * Dell WD15 dock jack detection * * The WD15 contains an ALC4020 USB audio controller and ALC3263 audio codec * from Realtek. It is a UAC 1 device, and UAC 1 does not support jack * detection. Instead, jack detection works by sending HD Audio commands over * vendor-type USB messages. */ #define HDA_VERB_CMD(V, N, D) (((N) << 20) | ((V) << 8) | (D)) #define REALTEK_HDA_VALUE 0x0038 #define REALTEK_HDA_SET 62 #define REALTEK_MANUAL_MODE 72 #define REALTEK_HDA_GET_OUT 88 #define REALTEK_HDA_GET_IN 89 #define REALTEK_AUDIO_FUNCTION_GROUP 0x01 #define REALTEK_LINE1 0x1a #define REALTEK_VENDOR_REGISTERS 0x20 #define REALTEK_HP_OUT 0x21 #define REALTEK_CBJ_CTRL2 0x50 #define REALTEK_JACK_INTERRUPT_NODE 5 #define REALTEK_MIC_FLAG 0x100 static int realtek_hda_set(struct snd_usb_audio *chip, u32 cmd) { struct usb_device *dev = chip->dev; __be32 buf = cpu_to_be32(cmd); return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_HDA_SET, USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT, REALTEK_HDA_VALUE, 0, &buf, sizeof(buf)); } static int realtek_hda_get(struct snd_usb_audio *chip, u32 cmd, u32 *value) { struct usb_device *dev = chip->dev; int err; __be32 buf = cpu_to_be32(cmd); err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_HDA_GET_OUT, USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT, REALTEK_HDA_VALUE, 0, &buf, sizeof(buf)); if (err < 0) return err; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), REALTEK_HDA_GET_IN, USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_IN, REALTEK_HDA_VALUE, 0, &buf, sizeof(buf)); if (err < 0) return err; *value = be32_to_cpu(buf); return 0; } static int realtek_ctl_connector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; struct snd_usb_audio *chip = cval->head.mixer->chip; u32 pv = kcontrol->private_value; u32 node_id = pv & 0xff; u32 sense; u32 cbj_ctrl2; bool presence; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = realtek_hda_get(chip, HDA_VERB_CMD(AC_VERB_GET_PIN_SENSE, node_id, 0), &sense); if (err < 0) goto err; if (pv & REALTEK_MIC_FLAG) { err = realtek_hda_set(chip, HDA_VERB_CMD(AC_VERB_SET_COEF_INDEX, REALTEK_VENDOR_REGISTERS, REALTEK_CBJ_CTRL2)); if (err < 0) goto err; err = realtek_hda_get(chip, HDA_VERB_CMD(AC_VERB_GET_PROC_COEF, REALTEK_VENDOR_REGISTERS, 0), &cbj_ctrl2); if (err < 0) goto err; } err: snd_usb_unlock_shutdown(chip); if (err < 0) return err; presence = sense & AC_PINSENSE_PRESENCE; if (pv & REALTEK_MIC_FLAG) presence = presence && (cbj_ctrl2 & 0x0070) == 0x0070; ucontrol->value.integer.value[0] = presence; return 0; } static const struct snd_kcontrol_new realtek_connector_ctl_ro = { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = "", /* will be filled later manually */ .access = SNDRV_CTL_ELEM_ACCESS_READ, .info = snd_ctl_boolean_mono_info, .get = realtek_ctl_connector_get, }; static int realtek_resume_jack(struct usb_mixer_elem_list *list) { snd_ctl_notify(list->mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &list->kctl->id); return 0; } static int realtek_add_jack(struct usb_mixer_interface *mixer, char *name, u32 val) { struct usb_mixer_elem_info *cval; struct snd_kcontrol *kctl; cval = kzalloc(sizeof(*cval), GFP_KERNEL); if (!cval) return -ENOMEM; snd_usb_mixer_elem_init_std(&cval->head, mixer, REALTEK_JACK_INTERRUPT_NODE); cval->head.resume = realtek_resume_jack; cval->val_type = USB_MIXER_BOOLEAN; cval->channels = 1; cval->min = 0; cval->max = 1; kctl = snd_ctl_new1(&realtek_connector_ctl_ro, cval); if (!kctl) { kfree(cval); return -ENOMEM; } kctl->private_value = val; strscpy(kctl->id.name, name, sizeof(kctl->id.name)); kctl->private_free = snd_usb_mixer_elem_free; return snd_usb_mixer_add_control(&cval->head, kctl); } static int dell_dock_mixer_create(struct usb_mixer_interface *mixer) { int err; struct usb_device *dev = mixer->chip->dev; /* Power down the audio codec to avoid loud pops in the next step. */ realtek_hda_set(mixer->chip, HDA_VERB_CMD(AC_VERB_SET_POWER_STATE, REALTEK_AUDIO_FUNCTION_GROUP, AC_PWRST_D3)); /* * Turn off 'manual mode' in case it was enabled. This removes the need * to power cycle the dock after it was attached to a Windows machine. */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_MANUAL_MODE, USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0, NULL, 0); err = realtek_add_jack(mixer, "Line Out Jack", REALTEK_LINE1); if (err < 0) return err; err = realtek_add_jack(mixer, "Headphone Jack", REALTEK_HP_OUT); if (err < 0) return err; err = realtek_add_jack(mixer, "Headset Mic Jack", REALTEK_HP_OUT | REALTEK_MIC_FLAG); if (err < 0) return err; return 0; } static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id) { u16 buf = 0; snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, (UAC_FU_VOLUME << 8) | ch, snd_usb_ctrl_intf(chip) | (id << 8), &buf, 2); } static int dell_dock_mixer_init(struct usb_mixer_interface *mixer) { /* fix to 0dB playback volumes */ dell_dock_init_vol(mixer->chip, 1, 16); dell_dock_init_vol(mixer->chip, 2, 16); dell_dock_init_vol(mixer->chip, 1, 19); dell_dock_init_vol(mixer->chip, 2, 19); return 0; } /* RME Class Compliant device quirks */ #define SND_RME_GET_STATUS1 23 #define SND_RME_GET_CURRENT_FREQ 17 #define SND_RME_CLK_SYSTEM_SHIFT 16 #define SND_RME_CLK_SYSTEM_MASK 0x1f #define SND_RME_CLK_AES_SHIFT 8 #define SND_RME_CLK_SPDIF_SHIFT 12 #define SND_RME_CLK_AES_SPDIF_MASK 0xf #define SND_RME_CLK_SYNC_SHIFT 6 #define SND_RME_CLK_SYNC_MASK 0x3 #define SND_RME_CLK_FREQMUL_SHIFT 18 #define SND_RME_CLK_FREQMUL_MASK 0x7 #define SND_RME_CLK_SYSTEM(x) \ ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK) #define SND_RME_CLK_AES(x) \ ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK) #define SND_RME_CLK_SPDIF(x) \ ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK) #define SND_RME_CLK_SYNC(x) \ ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK) #define SND_RME_CLK_FREQMUL(x) \ ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK) #define SND_RME_CLK_AES_LOCK 0x1 #define SND_RME_CLK_AES_SYNC 0x4 #define SND_RME_CLK_SPDIF_LOCK 0x2 #define SND_RME_CLK_SPDIF_SYNC 0x8 #define SND_RME_SPDIF_IF_SHIFT 4 #define SND_RME_SPDIF_FORMAT_SHIFT 5 #define SND_RME_BINARY_MASK 0x1 #define SND_RME_SPDIF_IF(x) \ ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK) #define SND_RME_SPDIF_FORMAT(x) \ ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK) static const u32 snd_rme_rate_table[] = { 32000, 44100, 48000, 50000, 64000, 88200, 96000, 100000, 128000, 176400, 192000, 200000, 256000, 352800, 384000, 400000, 512000, 705600, 768000, 800000 }; /* maximum number of items for AES and S/PDIF rates for above table */ #define SND_RME_RATE_IDX_AES_SPDIF_NUM 12 enum snd_rme_domain { SND_RME_DOMAIN_SYSTEM, SND_RME_DOMAIN_AES, SND_RME_DOMAIN_SPDIF }; enum snd_rme_clock_status { SND_RME_CLOCK_NOLOCK, SND_RME_CLOCK_LOCK, SND_RME_CLOCK_SYNC }; static int snd_rme_read_value(struct snd_usb_audio *chip, unsigned int item, u32 *value) { struct usb_device *dev = chip->dev; int err; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), item, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 0, 0, value, sizeof(*value)); if (err < 0) dev_err(&dev->dev, "unable to issue vendor read request %d (ret = %d)", item, err); return err; } static int snd_rme_get_status1(struct snd_kcontrol *kcontrol, u32 *status1) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); struct snd_usb_audio *chip = list->mixer->chip; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1); snd_usb_unlock_shutdown(chip); return err; } static int snd_rme_rate_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { u32 status1; u32 rate = 0; int idx; int err; err = snd_rme_get_status1(kcontrol, &status1); if (err < 0) return err; switch (kcontrol->private_value) { case SND_RME_DOMAIN_SYSTEM: idx = SND_RME_CLK_SYSTEM(status1); if (idx < ARRAY_SIZE(snd_rme_rate_table)) rate = snd_rme_rate_table[idx]; break; case SND_RME_DOMAIN_AES: idx = SND_RME_CLK_AES(status1); if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM) rate = snd_rme_rate_table[idx]; break; case SND_RME_DOMAIN_SPDIF: idx = SND_RME_CLK_SPDIF(status1); if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM) rate = snd_rme_rate_table[idx]; break; default: return -EINVAL; } ucontrol->value.integer.value[0] = rate; return 0; } static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { u32 status1; int idx = SND_RME_CLOCK_NOLOCK; int err; err = snd_rme_get_status1(kcontrol, &status1); if (err < 0) return err; switch (kcontrol->private_value) { case SND_RME_DOMAIN_AES: /* AES */ if (status1 & SND_RME_CLK_AES_SYNC) idx = SND_RME_CLOCK_SYNC; else if (status1 & SND_RME_CLK_AES_LOCK) idx = SND_RME_CLOCK_LOCK; break; case SND_RME_DOMAIN_SPDIF: /* SPDIF */ if (status1 & SND_RME_CLK_SPDIF_SYNC) idx = SND_RME_CLOCK_SYNC; else if (status1 & SND_RME_CLK_SPDIF_LOCK) idx = SND_RME_CLOCK_LOCK; break; default: return -EINVAL; } ucontrol->value.enumerated.item[0] = idx; return 0; } static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { u32 status1; int err; err = snd_rme_get_status1(kcontrol, &status1); if (err < 0) return err; ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1); return 0; } static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { u32 status1; int err; err = snd_rme_get_status1(kcontrol, &status1); if (err < 0) return err; ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1); return 0; } static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { u32 status1; int err; err = snd_rme_get_status1(kcontrol, &status1); if (err < 0) return err; ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1); return 0; } static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); struct snd_usb_audio *chip = list->mixer->chip; u32 status1; const u64 num = 104857600000000ULL; u32 den; unsigned int freq; int err; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1); if (err < 0) goto end; err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den); if (err < 0) goto end; freq = (den == 0) ? 0 : div64_u64(num, den); freq <<= SND_RME_CLK_FREQMUL(status1); ucontrol->value.integer.value[0] = freq; end: snd_usb_unlock_shutdown(chip); return err; } static int snd_rme_rate_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; switch (kcontrol->private_value) { case SND_RME_DOMAIN_SYSTEM: uinfo->value.integer.min = 32000; uinfo->value.integer.max = 800000; break; case SND_RME_DOMAIN_AES: case SND_RME_DOMAIN_SPDIF: default: uinfo->value.integer.min = 0; uinfo->value.integer.max = 200000; } uinfo->value.integer.step = 0; return 0; } static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char *const sync_states[] = { "No Lock", "Lock", "Sync" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(sync_states), sync_states); } static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char *const spdif_if[] = { "Coaxial", "Optical" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(spdif_if), spdif_if); } static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char *const optical_type[] = { "Consumer", "Professional" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(optical_type), optical_type); } static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char *const sync_sources[] = { "Internal", "AES", "SPDIF", "Internal" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(sync_sources), sync_sources); } static const struct snd_kcontrol_new snd_rme_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "AES Rate", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_rate_info, .get = snd_rme_rate_get, .private_value = SND_RME_DOMAIN_AES }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "AES Sync", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_sync_state_info, .get = snd_rme_sync_state_get, .private_value = SND_RME_DOMAIN_AES }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "SPDIF Rate", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_rate_info, .get = snd_rme_rate_get, .private_value = SND_RME_DOMAIN_SPDIF }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "SPDIF Sync", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_sync_state_info, .get = snd_rme_sync_state_get, .private_value = SND_RME_DOMAIN_SPDIF }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "SPDIF Interface", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_spdif_if_info, .get = snd_rme_spdif_if_get, }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "SPDIF Format", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_spdif_format_info, .get = snd_rme_spdif_format_get, }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Sync Source", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_sync_source_info, .get = snd_rme_sync_source_get }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "System Rate", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_rate_info, .get = snd_rme_rate_get, .private_value = SND_RME_DOMAIN_SYSTEM }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Current Frequency", .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .info = snd_rme_rate_info, .get = snd_rme_current_freq_get } }; static int snd_rme_controls_create(struct usb_mixer_interface *mixer) { int err, i; for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) { err = add_single_ctl_with_resume(mixer, 0, NULL, &snd_rme_controls[i], NULL); if (err < 0) return err; } return 0; } /* * RME Babyface Pro (FS) * * These devices exposes a couple of DSP functions via request to EP0. * Switches are available via control registers, while routing is controlled * by controlling the volume on each possible crossing point. * Volume control is linear, from -inf (dec. 0) to +6dB (dec. 65536) with * 0dB being at dec. 32768. */ enum { SND_BBFPRO_CTL_REG1 = 0, SND_BBFPRO_CTL_REG2 }; #define SND_BBFPRO_CTL_REG_MASK 1 #define SND_BBFPRO_CTL_IDX_MASK 0xff #define SND_BBFPRO_CTL_IDX_SHIFT 1 #define SND_BBFPRO_CTL_VAL_MASK 1 #define SND_BBFPRO_CTL_VAL_SHIFT 9 #define SND_BBFPRO_CTL_REG1_CLK_MASTER 0 #define SND_BBFPRO_CTL_REG1_CLK_OPTICAL 1 #define SND_BBFPRO_CTL_REG1_SPDIF_PRO 7 #define SND_BBFPRO_CTL_REG1_SPDIF_EMPH 8 #define SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL 10 #define SND_BBFPRO_CTL_REG2_48V_AN1 0 #define SND_BBFPRO_CTL_REG2_48V_AN2 1 #define SND_BBFPRO_CTL_REG2_SENS_IN3 2 #define SND_BBFPRO_CTL_REG2_SENS_IN4 3 #define SND_BBFPRO_CTL_REG2_PAD_AN1 4 #define SND_BBFPRO_CTL_REG2_PAD_AN2 5 #define SND_BBFPRO_MIXER_IDX_MASK 0x1ff #define SND_BBFPRO_MIXER_VAL_MASK 0x3ffff #define SND_BBFPRO_MIXER_VAL_SHIFT 9 #define SND_BBFPRO_MIXER_VAL_MIN 0 // -inf #define SND_BBFPRO_MIXER_VAL_MAX 65536 // +6dB #define SND_BBFPRO_USBREQ_CTL_REG1 0x10 #define SND_BBFPRO_USBREQ_CTL_REG2 0x17 #define SND_BBFPRO_USBREQ_MIXER 0x12 static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg, u8 index, u8 value) { int err; u16 usb_req, usb_idx, usb_val; struct snd_usb_audio *chip = mixer->chip; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; if (reg == SND_BBFPRO_CTL_REG1) { usb_req = SND_BBFPRO_USBREQ_CTL_REG1; if (index == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) { usb_idx = 3; usb_val = value ? 3 : 0; } else { usb_idx = 1 << index; usb_val = value ? usb_idx : 0; } } else { usb_req = SND_BBFPRO_USBREQ_CTL_REG2; usb_idx = 1 << index; usb_val = value ? usb_idx : 0; } err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), usb_req, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, usb_val, usb_idx, NULL, 0); snd_usb_unlock_shutdown(chip); return err; } static int snd_bbfpro_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { u8 reg, idx, val; int pv; pv = kcontrol->private_value; reg = pv & SND_BBFPRO_CTL_REG_MASK; idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; val = kcontrol->private_value >> SND_BBFPRO_CTL_VAL_SHIFT; if ((reg == SND_BBFPRO_CTL_REG1 && idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) || (reg == SND_BBFPRO_CTL_REG2 && (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) { ucontrol->value.enumerated.item[0] = val; } else { ucontrol->value.integer.value[0] = val; } return 0; } static int snd_bbfpro_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { u8 reg, idx; int pv; pv = kcontrol->private_value; reg = pv & SND_BBFPRO_CTL_REG_MASK; idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; if (reg == SND_BBFPRO_CTL_REG1 && idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) { static const char * const texts[2] = { "AutoSync", "Internal" }; return snd_ctl_enum_info(uinfo, 1, 2, texts); } else if (reg == SND_BBFPRO_CTL_REG2 && (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || idx == SND_BBFPRO_CTL_REG2_SENS_IN4)) { static const char * const texts[2] = { "-10dBV", "+4dBu" }; return snd_ctl_enum_info(uinfo, 1, 2, texts); } uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = 1; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; return 0; } static int snd_bbfpro_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int err; u8 reg, idx; int old_value, pv, val; struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); struct usb_mixer_interface *mixer = list->mixer; pv = kcontrol->private_value; reg = pv & SND_BBFPRO_CTL_REG_MASK; idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; old_value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK; if ((reg == SND_BBFPRO_CTL_REG1 && idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) || (reg == SND_BBFPRO_CTL_REG2 && (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 || idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) { val = ucontrol->value.enumerated.item[0]; } else { val = ucontrol->value.integer.value[0]; } if (val > 1) return -EINVAL; if (val == old_value) return 0; kcontrol->private_value = reg | ((idx & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT) | ((val & SND_BBFPRO_CTL_VAL_MASK) << SND_BBFPRO_CTL_VAL_SHIFT); err = snd_bbfpro_ctl_update(mixer, reg, idx, val); return err < 0 ? err : 1; } static int snd_bbfpro_ctl_resume(struct usb_mixer_elem_list *list) { u8 reg, idx; int value, pv; pv = list->kctl->private_value; reg = pv & SND_BBFPRO_CTL_REG_MASK; idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK; value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK; return snd_bbfpro_ctl_update(list->mixer, reg, idx, value); } static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index, u32 value) { struct snd_usb_audio *chip = mixer->chip; int err; u16 idx; u16 usb_idx, usb_val; u32 v; err = snd_usb_lock_shutdown(chip); if (err < 0) return err; idx = index & SND_BBFPRO_MIXER_IDX_MASK; // 18 bit linear volume, split so 2 bits end up in index. v = value & SND_BBFPRO_MIXER_VAL_MASK; usb_idx = idx | (v & 0x3) << 14; usb_val = (v >> 2) & 0xffff; err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), SND_BBFPRO_USBREQ_MIXER, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, usb_val, usb_idx, NULL, 0); snd_usb_unlock_shutdown(chip); return err; } static int snd_bbfpro_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.integer.value[0] = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT; return 0; } static int snd_bbfpro_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = SND_BBFPRO_MIXER_VAL_MIN; uinfo->value.integer.max = SND_BBFPRO_MIXER_VAL_MAX; return 0; } static int snd_bbfpro_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int err; u16 idx; u32 new_val, old_value, uvalue; struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol); struct usb_mixer_interface *mixer = list->mixer; uvalue = ucontrol->value.integer.value[0]; idx = kcontrol->private_value & SND_BBFPRO_MIXER_IDX_MASK; old_value = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT; if (uvalue > SND_BBFPRO_MIXER_VAL_MAX) return -EINVAL; if (uvalue == old_value) return 0; new_val = uvalue & SND_BBFPRO_MIXER_VAL_MASK; kcontrol->private_value = idx | (new_val << SND_BBFPRO_MIXER_VAL_SHIFT); err = snd_bbfpro_vol_update(mixer, idx, new_val); return err < 0 ? err : 1; } static int snd_bbfpro_vol_resume(struct usb_mixer_elem_list *list) { int pv = list->kctl->private_value; u16 idx = pv & SND_BBFPRO_MIXER_IDX_MASK; u32 val = (pv >> SND_BBFPRO_MIXER_VAL_SHIFT) & SND_BBFPRO_MIXER_VAL_MASK; return snd_bbfpro_vol_update(list->mixer, idx, val); } // Predfine elements static const struct snd_kcontrol_new snd_bbfpro_ctl_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .index = 0, .info = snd_bbfpro_ctl_info, .get = snd_bbfpro_ctl_get, .put = snd_bbfpro_ctl_put }; static const struct snd_kcontrol_new snd_bbfpro_vol_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .index = 0, .info = snd_bbfpro_vol_info, .get = snd_bbfpro_vol_get, .put = snd_bbfpro_vol_put }; static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg, u8 index, char *name) { struct snd_kcontrol_new knew = snd_bbfpro_ctl_control; knew.name = name; knew.private_value = (reg & SND_BBFPRO_CTL_REG_MASK) | ((index & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT); return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume, &knew, NULL); } static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index, char *name) { struct snd_kcontrol_new knew = snd_bbfpro_vol_control; knew.name = name; knew.private_value = index & SND_BBFPRO_MIXER_IDX_MASK; return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume, &knew, NULL); } static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer) { int err, i, o; char name[48]; static const char * const input[] = { "AN1", "AN2", "IN3", "IN4", "AS1", "AS2", "ADAT3", "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"}; static const char * const output[] = { "AN1", "AN2", "PH3", "PH4", "AS1", "AS2", "ADAT3", "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"}; for (o = 0 ; o < 12 ; ++o) { for (i = 0 ; i < 12 ; ++i) { // Line routing snprintf(name, sizeof(name), "%s-%s-%s Playback Volume", (i < 2 ? "Mic" : "Line"), input[i], output[o]); err = snd_bbfpro_vol_add(mixer, (26 * o + i), name); if (err < 0) return err; // PCM routing... yes, it is output remapping snprintf(name, sizeof(name), "PCM-%s-%s Playback Volume", output[i], output[o]); err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i), name); if (err < 0) return err; } } // Control Reg 1 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, SND_BBFPRO_CTL_REG1_CLK_OPTICAL, "Sample Clock Source"); if (err < 0) return err; err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, SND_BBFPRO_CTL_REG1_SPDIF_PRO, "IEC958 Pro Mask"); if (err < 0) return err; err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, SND_BBFPRO_CTL_REG1_SPDIF_EMPH, "IEC958 Emphasis"); if (err < 0) return err; err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1, SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL, "IEC958 Switch"); if (err < 0) return err; // Control Reg 2 err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, SND_BBFPRO_CTL_REG2_48V_AN1, "Mic-AN1 48V"); if (err < 0) return err; err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, SND_BBFPRO_CTL_REG2_48V_AN2, "Mic-AN2 48V"); if (err < 0) return err; err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, SND_BBFPRO_CTL_REG2_SENS_IN3, "Line-IN3 Sens."); if (err < 0) return err; err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, SND_BBFPRO_CTL_REG2_SENS_IN4, "Line-IN4 Sens."); if (err < 0) return err; err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, SND_BBFPRO_CTL_REG2_PAD_AN1, "Mic-AN1 PAD"); if (err < 0) return err; err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2, SND_BBFPRO_CTL_REG2_PAD_AN2, "Mic-AN2 PAD"); if (err < 0) return err; return 0; } /* * Pioneer DJ DJM Mixers * * These devices generally have options for soft-switching the playback and * capture sources in addition to the recording level. Although different * devices have different configurations, there seems to be canonical values * for specific capture/playback types: See the definitions of these below. * * The wValue is masked with the stereo channel number. e.g. Setting Ch2 to * capture phono would be 0x0203. Capture, playback and capture level have * different wIndexes. */ // Capture types #define SND_DJM_CAP_LINE 0x00 #define SND_DJM_CAP_CDLINE 0x01 #define SND_DJM_CAP_DIGITAL 0x02 #define SND_DJM_CAP_PHONO 0x03 #define SND_DJM_CAP_PFADER 0x06 #define SND_DJM_CAP_XFADERA 0x07 #define SND_DJM_CAP_XFADERB 0x08 #define SND_DJM_CAP_MIC 0x09 #define SND_DJM_CAP_AUX 0x0d #define SND_DJM_CAP_RECOUT 0x0a #define SND_DJM_CAP_NONE 0x0f #define SND_DJM_CAP_CH1PFADER 0x11 #define SND_DJM_CAP_CH2PFADER 0x12 #define SND_DJM_CAP_CH3PFADER 0x13 #define SND_DJM_CAP_CH4PFADER 0x14 // Playback types #define SND_DJM_PB_CH1 0x00 #define SND_DJM_PB_CH2 0x01 #define SND_DJM_PB_AUX 0x04 #define SND_DJM_WINDEX_CAP 0x8002 #define SND_DJM_WINDEX_CAPLVL 0x8003 #define SND_DJM_WINDEX_PB 0x8016 // kcontrol->private_value layout #define SND_DJM_VALUE_MASK 0x0000ffff #define SND_DJM_GROUP_MASK 0x00ff0000 #define SND_DJM_DEVICE_MASK 0xff000000 #define SND_DJM_GROUP_SHIFT 16 #define SND_DJM_DEVICE_SHIFT 24 // device table index // used for the snd_djm_devices table, so please update accordingly #define SND_DJM_250MK2_IDX 0x0 #define SND_DJM_750_IDX 0x1 #define SND_DJM_850_IDX 0x2 #define SND_DJM_900NXS2_IDX 0x3 #define SND_DJM_750MK2_IDX 0x4 #define SND_DJM_CTL(_name, suffix, _default_value, _windex) { \ .name = _name, \ .options = snd_djm_opts_##suffix, \ .noptions = ARRAY_SIZE(snd_djm_opts_##suffix), \ .default_value = _default_value, \ .wIndex = _windex } #define SND_DJM_DEVICE(suffix) { \ .controls = snd_djm_ctls_##suffix, \ .ncontrols = ARRAY_SIZE(snd_djm_ctls_##suffix) } struct snd_djm_device { const char *name; const struct snd_djm_ctl *controls; size_t ncontrols; }; struct snd_djm_ctl { const char *name; const u16 *options; size_t noptions; u16 default_value; u16 wIndex; }; static const char *snd_djm_get_label_caplevel(u16 wvalue) { switch (wvalue) { case 0x0000: return "-19dB"; case 0x0100: return "-15dB"; case 0x0200: return "-10dB"; case 0x0300: return "-5dB"; default: return NULL; } }; static const char *snd_djm_get_label_cap_common(u16 wvalue) { switch (wvalue & 0x00ff) { case SND_DJM_CAP_LINE: return "Control Tone LINE"; case SND_DJM_CAP_CDLINE: return "Control Tone CD/LINE"; case SND_DJM_CAP_DIGITAL: return "Control Tone DIGITAL"; case SND_DJM_CAP_PHONO: return "Control Tone PHONO"; case SND_DJM_CAP_PFADER: return "Post Fader"; case SND_DJM_CAP_XFADERA: return "Cross Fader A"; case SND_DJM_CAP_XFADERB: return "Cross Fader B"; case SND_DJM_CAP_MIC: return "Mic"; case SND_DJM_CAP_RECOUT: return "Rec Out"; case SND_DJM_CAP_AUX: return "Aux"; case SND_DJM_CAP_NONE: return "None"; case SND_DJM_CAP_CH1PFADER: return "Post Fader Ch1"; case SND_DJM_CAP_CH2PFADER: return "Post Fader Ch2"; case SND_DJM_CAP_CH3PFADER: return "Post Fader Ch3"; case SND_DJM_CAP_CH4PFADER: return "Post Fader Ch4"; default: return NULL; } }; // The DJM-850 has different values for CD/LINE and LINE capture // control options than the other DJM declared in this file. static const char *snd_djm_get_label_cap_850(u16 wvalue) { switch (wvalue & 0x00ff) { case 0x00: return "Control Tone CD/LINE"; case 0x01: return "Control Tone LINE"; default: return snd_djm_get_label_cap_common(wvalue); } }; static const char *snd_djm_get_label_cap(u8 device_idx, u16 wvalue) { switch (device_idx) { case SND_DJM_850_IDX: return snd_djm_get_label_cap_850(wvalue); default: return snd_djm_get_label_cap_common(wvalue); } }; static const char *snd_djm_get_label_pb(u16 wvalue) { switch (wvalue & 0x00ff) { case SND_DJM_PB_CH1: return "Ch1"; case SND_DJM_PB_CH2: return "Ch2"; case SND_DJM_PB_AUX: return "Aux"; default: return NULL; } }; static const char *snd_djm_get_label(u8 device_idx, u16 wvalue, u16 windex) { switch (windex) { case SND_DJM_WINDEX_CAPLVL: return snd_djm_get_label_caplevel(wvalue); case SND_DJM_WINDEX_CAP: return snd_djm_get_label_cap(device_idx, wvalue); case SND_DJM_WINDEX_PB: return snd_djm_get_label_pb(wvalue); default: return NULL; } }; // common DJM capture level option values static const u16 snd_djm_opts_cap_level[] = { 0x0000, 0x0100, 0x0200, 0x0300 }; // DJM-250MK2 static const u16 snd_djm_opts_250mk2_cap1[] = { 0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a }; static const u16 snd_djm_opts_250mk2_cap2[] = { 0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a }; static const u16 snd_djm_opts_250mk2_cap3[] = { 0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d }; static const u16 snd_djm_opts_250mk2_pb1[] = { 0x0100, 0x0101, 0x0104 }; static const u16 snd_djm_opts_250mk2_pb2[] = { 0x0200, 0x0201, 0x0204 }; static const u16 snd_djm_opts_250mk2_pb3[] = { 0x0300, 0x0301, 0x0304 }; static const struct snd_djm_ctl snd_djm_ctls_250mk2[] = { SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), SND_DJM_CTL("Ch1 Input", 250mk2_cap1, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch2 Input", 250mk2_cap2, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch3 Input", 250mk2_cap3, 0, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch1 Output", 250mk2_pb1, 0, SND_DJM_WINDEX_PB), SND_DJM_CTL("Ch2 Output", 250mk2_pb2, 1, SND_DJM_WINDEX_PB), SND_DJM_CTL("Ch3 Output", 250mk2_pb3, 2, SND_DJM_WINDEX_PB) }; // DJM-750 static const u16 snd_djm_opts_750_cap1[] = { 0x0101, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f }; static const u16 snd_djm_opts_750_cap2[] = { 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f }; static const u16 snd_djm_opts_750_cap3[] = { 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f }; static const u16 snd_djm_opts_750_cap4[] = { 0x0401, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f }; static const struct snd_djm_ctl snd_djm_ctls_750[] = { SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), SND_DJM_CTL("Ch1 Input", 750_cap1, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch2 Input", 750_cap2, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch3 Input", 750_cap3, 0, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch4 Input", 750_cap4, 0, SND_DJM_WINDEX_CAP) }; // DJM-850 static const u16 snd_djm_opts_850_cap1[] = { 0x0100, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f }; static const u16 snd_djm_opts_850_cap2[] = { 0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f }; static const u16 snd_djm_opts_850_cap3[] = { 0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f }; static const u16 snd_djm_opts_850_cap4[] = { 0x0400, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f }; static const struct snd_djm_ctl snd_djm_ctls_850[] = { SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), SND_DJM_CTL("Ch1 Input", 850_cap1, 1, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch2 Input", 850_cap2, 0, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch3 Input", 850_cap3, 0, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch4 Input", 850_cap4, 1, SND_DJM_WINDEX_CAP) }; // DJM-900NXS2 static const u16 snd_djm_opts_900nxs2_cap1[] = { 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a }; static const u16 snd_djm_opts_900nxs2_cap2[] = { 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a }; static const u16 snd_djm_opts_900nxs2_cap3[] = { 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a }; static const u16 snd_djm_opts_900nxs2_cap4[] = { 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a }; static const u16 snd_djm_opts_900nxs2_cap5[] = { 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 }; static const struct snd_djm_ctl snd_djm_ctls_900nxs2[] = { SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), SND_DJM_CTL("Ch1 Input", 900nxs2_cap1, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch2 Input", 900nxs2_cap2, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch3 Input", 900nxs2_cap3, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch4 Input", 900nxs2_cap4, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch5 Input", 900nxs2_cap5, 3, SND_DJM_WINDEX_CAP) }; // DJM-750MK2 static const u16 snd_djm_opts_750mk2_cap1[] = { 0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a }; static const u16 snd_djm_opts_750mk2_cap2[] = { 0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a }; static const u16 snd_djm_opts_750mk2_cap3[] = { 0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a }; static const u16 snd_djm_opts_750mk2_cap4[] = { 0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a }; static const u16 snd_djm_opts_750mk2_cap5[] = { 0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 }; static const u16 snd_djm_opts_750mk2_pb1[] = { 0x0100, 0x0101, 0x0104 }; static const u16 snd_djm_opts_750mk2_pb2[] = { 0x0200, 0x0201, 0x0204 }; static const u16 snd_djm_opts_750mk2_pb3[] = { 0x0300, 0x0301, 0x0304 }; static const struct snd_djm_ctl snd_djm_ctls_750mk2[] = { SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL), SND_DJM_CTL("Ch1 Input", 750mk2_cap1, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch2 Input", 750mk2_cap2, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch3 Input", 750mk2_cap3, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch4 Input", 750mk2_cap4, 2, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch5 Input", 750mk2_cap5, 3, SND_DJM_WINDEX_CAP), SND_DJM_CTL("Ch1 Output", 750mk2_pb1, 0, SND_DJM_WINDEX_PB), SND_DJM_CTL("Ch2 Output", 750mk2_pb2, 1, SND_DJM_WINDEX_PB), SND_DJM_CTL("Ch3 Output", 750mk2_pb3, 2, SND_DJM_WINDEX_PB) }; static const struct snd_djm_device snd_djm_devices[] = { [SND_DJM_250MK2_IDX] = SND_DJM_DEVICE(250mk2), [SND_DJM_750_IDX] = SND_DJM_DEVICE(750), [SND_DJM_850_IDX] = SND_DJM_DEVICE(850), [SND_DJM_900NXS2_IDX] = SND_DJM_DEVICE(900nxs2), [SND_DJM_750MK2_IDX] = SND_DJM_DEVICE(750mk2), }; static int snd_djm_controls_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *info) { unsigned long private_value = kctl->private_value; u8 device_idx = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; u8 ctl_idx = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; const struct snd_djm_device *device = &snd_djm_devices[device_idx]; const char *name; const struct snd_djm_ctl *ctl; size_t noptions; if (ctl_idx >= device->ncontrols) return -EINVAL; ctl = &device->controls[ctl_idx]; noptions = ctl->noptions; if (info->value.enumerated.item >= noptions) info->value.enumerated.item = noptions - 1; name = snd_djm_get_label(device_idx, ctl->options[info->value.enumerated.item], ctl->wIndex); if (!name) return -EINVAL; strscpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name)); info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; info->count = 1; info->value.enumerated.items = noptions; return 0; } static int snd_djm_controls_update(struct usb_mixer_interface *mixer, u8 device_idx, u8 group, u16 value) { int err; const struct snd_djm_device *device = &snd_djm_devices[device_idx]; if ((group >= device->ncontrols) || value >= device->controls[group].noptions) return -EINVAL; err = snd_usb_lock_shutdown(mixer->chip); if (err) return err; err = snd_usb_ctl_msg( mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0), USB_REQ_SET_FEATURE, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, device->controls[group].options[value], device->controls[group].wIndex, NULL, 0); snd_usb_unlock_shutdown(mixer->chip); return err; } static int snd_djm_controls_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem) { elem->value.enumerated.item[0] = kctl->private_value & SND_DJM_VALUE_MASK; return 0; } static int snd_djm_controls_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); struct usb_mixer_interface *mixer = list->mixer; unsigned long private_value = kctl->private_value; u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; u16 value = elem->value.enumerated.item[0]; kctl->private_value = (((unsigned long)device << SND_DJM_DEVICE_SHIFT) | (group << SND_DJM_GROUP_SHIFT) | value); return snd_djm_controls_update(mixer, device, group, value); } static int snd_djm_controls_resume(struct usb_mixer_elem_list *list) { unsigned long private_value = list->kctl->private_value; u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT; u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT; u16 value = (private_value & SND_DJM_VALUE_MASK); return snd_djm_controls_update(list->mixer, device, group, value); } static int snd_djm_controls_create(struct usb_mixer_interface *mixer, const u8 device_idx) { int err, i; u16 value; const struct snd_djm_device *device = &snd_djm_devices[device_idx]; struct snd_kcontrol_new knew = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .index = 0, .info = snd_djm_controls_info, .get = snd_djm_controls_get, .put = snd_djm_controls_put }; for (i = 0; i < device->ncontrols; i++) { value = device->controls[i].default_value; knew.name = device->controls[i].name; knew.private_value = ( ((unsigned long)device_idx << SND_DJM_DEVICE_SHIFT) | (i << SND_DJM_GROUP_SHIFT) | value); err = snd_djm_controls_update(mixer, device_idx, i, value); if (err) return err; err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume, &knew, NULL); if (err) return err; } return 0; } int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer) { int err = 0; err = snd_usb_soundblaster_remote_init(mixer); if (err < 0) return err; switch (mixer->chip->usb_id) { /* Tascam US-16x08 */ case USB_ID(0x0644, 0x8047): err = snd_us16x08_controls_create(mixer); break; case USB_ID(0x041e, 0x3020): case USB_ID(0x041e, 0x3040): case USB_ID(0x041e, 0x3042): case USB_ID(0x041e, 0x30df): case USB_ID(0x041e, 0x3048): err = snd_audigy2nx_controls_create(mixer); if (err < 0) break; snd_card_ro_proc_new(mixer->chip->card, "audigy2nx", mixer, snd_audigy2nx_proc_read); break; /* EMU0204 */ case USB_ID(0x041e, 0x3f19): err = snd_emu0204_controls_create(mixer); break; case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */ case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */ err = snd_c400_create_mixer(mixer); break; case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */ case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ err = snd_ftu_create_mixer(mixer); break; case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */ case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */ case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */ err = snd_xonar_u1_controls_create(mixer); break; case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */ err = snd_microii_controls_create(mixer); break; case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */ err = snd_mbox1_controls_create(mixer); break; case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */ err = snd_nativeinstruments_create_mixer(mixer, snd_nativeinstruments_ta6_mixers, ARRAY_SIZE(snd_nativeinstruments_ta6_mixers)); break; case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */ err = snd_nativeinstruments_create_mixer(mixer, snd_nativeinstruments_ta10_mixers, ARRAY_SIZE(snd_nativeinstruments_ta10_mixers)); break; case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */ /* detection is disabled in mixer_maps.c */ err = snd_create_std_mono_table(mixer, ebox44_table); break; case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */ case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */ case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */ case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */ case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */ err = snd_scarlett_controls_create(mixer); break; case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */ case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */ case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */ case USB_ID(0x1235, 0x8211): /* Focusrite Scarlett Solo 3rd Gen */ case USB_ID(0x1235, 0x8210): /* Focusrite Scarlett 2i2 3rd Gen */ case USB_ID(0x1235, 0x8212): /* Focusrite Scarlett 4i4 3rd Gen */ case USB_ID(0x1235, 0x8213): /* Focusrite Scarlett 8i6 3rd Gen */ case USB_ID(0x1235, 0x8214): /* Focusrite Scarlett 18i8 3rd Gen */ case USB_ID(0x1235, 0x8215): /* Focusrite Scarlett 18i20 3rd Gen */ case USB_ID(0x1235, 0x820c): /* Focusrite Clarett+ 8Pre */ err = snd_scarlett_gen2_init(mixer); break; case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */ err = snd_soundblaster_e1_switch_create(mixer); break; case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ err = dell_dock_mixer_create(mixer); if (err < 0) break; err = dell_dock_mixer_init(mixer); break; case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */ case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */ case USB_ID(0x2a39, 0x3fd4): /* RME */ err = snd_rme_controls_create(mixer); break; case USB_ID(0x194f, 0x010c): /* Presonus Studio 1810c */ err = snd_sc1810_init_mixer(mixer); break; case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */ err = snd_bbfpro_controls_create(mixer); break; case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */ err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX); break; case USB_ID(0x08e4, 0x017f): /* Pioneer DJ DJM-750 */ err = snd_djm_controls_create(mixer, SND_DJM_750_IDX); break; case USB_ID(0x2b73, 0x001b): /* Pioneer DJ DJM-750MK2 */ err = snd_djm_controls_create(mixer, SND_DJM_750MK2_IDX); break; case USB_ID(0x08e4, 0x0163): /* Pioneer DJ DJM-850 */ err = snd_djm_controls_create(mixer, SND_DJM_850_IDX); break; case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */ err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX); break; } return err; } void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer) { switch (mixer->chip->usb_id) { case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */ dell_dock_mixer_init(mixer); break; } } void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer, int unitid) { if (!mixer->rc_cfg) return; /* unit ids specific to Extigy/Audigy 2 NX: */ switch (unitid) { case 0: /* remote control */ mixer->rc_urb->dev = mixer->chip->dev; usb_submit_urb(mixer->rc_urb, GFP_ATOMIC); break; case 4: /* digital in jack */ case 7: /* line in jacks */ case 19: /* speaker out jacks */ case 20: /* headphones out jack */ break; /* live24ext: 4 = line-in jack */ case 3: /* hp-out jack (may actuate Mute) */ if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) || mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id); break; default: usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid); break; } } static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer, struct usb_mixer_elem_info *cval, struct snd_kcontrol *kctl) { /* Approximation using 10 ranges based on output measurement on hw v1.2. * This seems close to the cubic mapping e.g. alsamixer uses. */ static const DECLARE_TLV_DB_RANGE(scale, 0, 1, TLV_DB_MINMAX_ITEM(-5300, -4970), 2, 5, TLV_DB_MINMAX_ITEM(-4710, -4160), 6, 7, TLV_DB_MINMAX_ITEM(-3884, -3710), 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560), 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324), 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031), 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393), 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032), 32, 40, TLV_DB_MINMAX_ITEM(-968, -490), 41, 50, TLV_DB_MINMAX_ITEM(-441, 0), ); if (cval->min == 0 && cval->max == 50) { usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n"); kctl->tlv.p = scale; kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; } else if (cval->min == 0 && cval->max <= 1000) { /* Some other clearly broken DragonFly variant. * At least a 0..53 variant (hw v1.0) exists. */ usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device"); kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; } } void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer, struct usb_mixer_elem_info *cval, int unitid, struct snd_kcontrol *kctl) { switch (mixer->chip->usb_id) { case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */ if (unitid == 7 && cval->control == UAC_FU_VOLUME) snd_dragonfly_quirk_db_scale(mixer, cval, kctl); break; /* lowest playback value is muted on some devices */ case USB_ID(0x0d8c, 0x000c): /* C-Media */ case USB_ID(0x0d8c, 0x0014): /* C-Media */ case USB_ID(0x19f7, 0x0003): /* RODE NT-USB */ if (strstr(kctl->id.name, "Playback")) cval->min_mute = 1; break; } }
linux-master
sound/usb/mixer_quirks.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * (Tentative) USB Audio Driver for ALSA * * Mixer control part * * Copyright (c) 2002 by Takashi Iwai <[email protected]> * * Many codes borrowed from audio.c by * Alan Cox ([email protected]) * Thomas Sailer ([email protected]) */ /* * TODOs, for both the mixer and the streaming interfaces: * * - support for UAC2 effect units * - support for graphical equalizers * - RANGE and MEM set commands (UAC2) * - RANGE and MEM interrupt dispatchers (UAC2) * - audio channel clustering (UAC2) * - audio sample rate converter units (UAC2) * - proper handling of clock multipliers (UAC2) * - dispatch clock change notifications (UAC2) * - stop PCM streams which use a clock that became invalid * - stop PCM streams which use a clock selector that has changed * - parse available sample rates again when clock sources changed */ #include <linux/bitops.h> #include <linux/init.h> #include <linux/list.h> #include <linux/log2.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <linux/usb/audio-v3.h> #include <sound/core.h> #include <sound/control.h> #include <sound/hwdep.h> #include <sound/info.h> #include <sound/tlv.h> #include "usbaudio.h" #include "mixer.h" #include "helper.h" #include "mixer_quirks.h" #include "power.h" #define MAX_ID_ELEMS 256 struct usb_audio_term { int id; int type; int channels; unsigned int chconfig; int name; }; struct usbmix_name_map; struct mixer_build { struct snd_usb_audio *chip; struct usb_mixer_interface *mixer; unsigned char *buffer; unsigned int buflen; DECLARE_BITMAP(unitbitmap, MAX_ID_ELEMS); DECLARE_BITMAP(termbitmap, MAX_ID_ELEMS); struct usb_audio_term oterm; const struct usbmix_name_map *map; const struct usbmix_selector_map *selector_map; }; /*E-mu 0202/0404/0204 eXtension Unit(XU) control*/ enum { USB_XU_CLOCK_RATE = 0xe301, USB_XU_CLOCK_SOURCE = 0xe302, USB_XU_DIGITAL_IO_STATUS = 0xe303, USB_XU_DEVICE_OPTIONS = 0xe304, USB_XU_DIRECT_MONITORING = 0xe305, USB_XU_METERING = 0xe306 }; enum { USB_XU_CLOCK_SOURCE_SELECTOR = 0x02, /* clock source*/ USB_XU_CLOCK_RATE_SELECTOR = 0x03, /* clock rate */ USB_XU_DIGITAL_FORMAT_SELECTOR = 0x01, /* the spdif format */ USB_XU_SOFT_LIMIT_SELECTOR = 0x03 /* soft limiter */ }; /* * manual mapping of mixer names * if the mixer topology is too complicated and the parsed names are * ambiguous, add the entries in usbmixer_maps.c. */ #include "mixer_maps.c" static const struct usbmix_name_map * find_map(const struct usbmix_name_map *p, int unitid, int control) { if (!p) return NULL; for (; p->id; p++) { if (p->id == unitid && (!control || !p->control || control == p->control)) return p; } return NULL; } /* get the mapped name if the unit matches */ static int check_mapped_name(const struct usbmix_name_map *p, char *buf, int buflen) { int len; if (!p || !p->name) return 0; buflen--; len = strscpy(buf, p->name, buflen); return len < 0 ? buflen : len; } /* ignore the error value if ignore_ctl_error flag is set */ #define filter_error(cval, err) \ ((cval)->head.mixer->ignore_ctl_error ? 0 : (err)) /* check whether the control should be ignored */ static inline int check_ignored_ctl(const struct usbmix_name_map *p) { if (!p || p->name || p->dB) return 0; return 1; } /* dB mapping */ static inline void check_mapped_dB(const struct usbmix_name_map *p, struct usb_mixer_elem_info *cval) { if (p && p->dB) { cval->dBmin = p->dB->min; cval->dBmax = p->dB->max; cval->min_mute = p->dB->min_mute; cval->initialized = 1; } } /* get the mapped selector source name */ static int check_mapped_selector_name(struct mixer_build *state, int unitid, int index, char *buf, int buflen) { const struct usbmix_selector_map *p; int len; if (!state->selector_map) return 0; for (p = state->selector_map; p->id; p++) { if (p->id == unitid && index < p->count) { len = strscpy(buf, p->names[index], buflen); return len < 0 ? buflen : len; } } return 0; } /* * find an audio control unit with the given unit id */ static void *find_audio_control_unit(struct mixer_build *state, unsigned char unit) { /* we just parse the header */ struct uac_feature_unit_descriptor *hdr = NULL; while ((hdr = snd_usb_find_desc(state->buffer, state->buflen, hdr, USB_DT_CS_INTERFACE)) != NULL) { if (hdr->bLength >= 4 && hdr->bDescriptorSubtype >= UAC_INPUT_TERMINAL && hdr->bDescriptorSubtype <= UAC3_SAMPLE_RATE_CONVERTER && hdr->bUnitID == unit) return hdr; } return NULL; } /* * copy a string with the given id */ static int snd_usb_copy_string_desc(struct snd_usb_audio *chip, int index, char *buf, int maxlen) { int len = usb_string(chip->dev, index, buf, maxlen - 1); if (len < 0) return 0; buf[len] = 0; return len; } /* * convert from the byte/word on usb descriptor to the zero-based integer */ static int convert_signed_value(struct usb_mixer_elem_info *cval, int val) { switch (cval->val_type) { case USB_MIXER_BOOLEAN: return !!val; case USB_MIXER_INV_BOOLEAN: return !val; case USB_MIXER_U8: val &= 0xff; break; case USB_MIXER_S8: val &= 0xff; if (val >= 0x80) val -= 0x100; break; case USB_MIXER_U16: val &= 0xffff; break; case USB_MIXER_S16: val &= 0xffff; if (val >= 0x8000) val -= 0x10000; break; } return val; } /* * convert from the zero-based int to the byte/word for usb descriptor */ static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val) { switch (cval->val_type) { case USB_MIXER_BOOLEAN: return !!val; case USB_MIXER_INV_BOOLEAN: return !val; case USB_MIXER_S8: case USB_MIXER_U8: return val & 0xff; case USB_MIXER_S16: case USB_MIXER_U16: return val & 0xffff; } return 0; /* not reached */ } static int get_relative_value(struct usb_mixer_elem_info *cval, int val) { if (!cval->res) cval->res = 1; if (val < cval->min) return 0; else if (val >= cval->max) return DIV_ROUND_UP(cval->max - cval->min, cval->res); else return (val - cval->min) / cval->res; } static int get_abs_value(struct usb_mixer_elem_info *cval, int val) { if (val < 0) return cval->min; if (!cval->res) cval->res = 1; val *= cval->res; val += cval->min; if (val > cval->max) return cval->max; return val; } static int uac2_ctl_value_size(int val_type) { switch (val_type) { case USB_MIXER_S32: case USB_MIXER_U32: return 4; case USB_MIXER_S16: case USB_MIXER_U16: return 2; default: return 1; } return 0; /* unreachable */ } /* * retrieve a mixer value */ static inline int mixer_ctrl_intf(struct usb_mixer_interface *mixer) { return get_iface_desc(mixer->hostif)->bInterfaceNumber; } static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret) { struct snd_usb_audio *chip = cval->head.mixer->chip; unsigned char buf[2]; int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1; int timeout = 10; int idx = 0, err; err = snd_usb_lock_shutdown(chip); if (err < 0) return -EIO; while (timeout-- > 0) { idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8); err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), request, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, validx, idx, buf, val_len); if (err >= val_len) { *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len)); err = 0; goto out; } else if (err == -ETIMEDOUT) { goto out; } } usb_audio_dbg(chip, "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n", request, validx, idx, cval->val_type); err = -EINVAL; out: snd_usb_unlock_shutdown(chip); return err; } static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret) { struct snd_usb_audio *chip = cval->head.mixer->chip; /* enough space for one range */ unsigned char buf[sizeof(__u16) + 3 * sizeof(__u32)]; unsigned char *val; int idx = 0, ret, val_size, size; __u8 bRequest; val_size = uac2_ctl_value_size(cval->val_type); if (request == UAC_GET_CUR) { bRequest = UAC2_CS_CUR; size = val_size; } else { bRequest = UAC2_CS_RANGE; size = sizeof(__u16) + 3 * val_size; } memset(buf, 0, sizeof(buf)); if (snd_usb_lock_shutdown(chip)) return -EIO; idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8); ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), bRequest, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, validx, idx, buf, size); snd_usb_unlock_shutdown(chip); if (ret < 0) { usb_audio_dbg(chip, "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n", request, validx, idx, cval->val_type); return ret; } /* FIXME: how should we handle multiple triplets here? */ switch (request) { case UAC_GET_CUR: val = buf; break; case UAC_GET_MIN: val = buf + sizeof(__u16); break; case UAC_GET_MAX: val = buf + sizeof(__u16) + val_size; break; case UAC_GET_RES: val = buf + sizeof(__u16) + val_size * 2; break; default: return -EINVAL; } *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(val, val_size)); return 0; } static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret) { validx += cval->idx_off; return (cval->head.mixer->protocol == UAC_VERSION_1) ? get_ctl_value_v1(cval, request, validx, value_ret) : get_ctl_value_v2(cval, request, validx, value_ret); } static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value) { return get_ctl_value(cval, UAC_GET_CUR, validx, value); } /* channel = 0: master, 1 = first channel */ static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval, int channel, int *value) { return get_ctl_value(cval, UAC_GET_CUR, (cval->control << 8) | channel, value); } int snd_usb_get_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int index, int *value) { int err; if (cval->cached & (1 << channel)) { *value = cval->cache_val[index]; return 0; } err = get_cur_mix_raw(cval, channel, value); if (err < 0) { if (!cval->head.mixer->ignore_ctl_error) usb_audio_dbg(cval->head.mixer->chip, "cannot get current value for control %d ch %d: err = %d\n", cval->control, channel, err); return err; } cval->cached |= 1 << channel; cval->cache_val[index] = *value; return 0; } /* * set a mixer value */ int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int value_set) { struct snd_usb_audio *chip = cval->head.mixer->chip; unsigned char buf[4]; int idx = 0, val_len, err, timeout = 10; validx += cval->idx_off; if (cval->head.mixer->protocol == UAC_VERSION_1) { val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1; } else { /* UAC_VERSION_2/3 */ val_len = uac2_ctl_value_size(cval->val_type); /* FIXME */ if (request != UAC_SET_CUR) { usb_audio_dbg(chip, "RANGE setting not yet supported\n"); return -EINVAL; } request = UAC2_CS_CUR; } value_set = convert_bytes_value(cval, value_set); buf[0] = value_set & 0xff; buf[1] = (value_set >> 8) & 0xff; buf[2] = (value_set >> 16) & 0xff; buf[3] = (value_set >> 24) & 0xff; err = snd_usb_lock_shutdown(chip); if (err < 0) return -EIO; while (timeout-- > 0) { idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8); err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), request, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, validx, idx, buf, val_len); if (err >= 0) { err = 0; goto out; } else if (err == -ETIMEDOUT) { goto out; } } usb_audio_dbg(chip, "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n", request, validx, idx, cval->val_type, buf[0], buf[1]); err = -EINVAL; out: snd_usb_unlock_shutdown(chip); return err; } static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value) { return snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, validx, value); } int snd_usb_set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel, int index, int value) { int err; unsigned int read_only = (channel == 0) ? cval->master_readonly : cval->ch_readonly & (1 << (channel - 1)); if (read_only) { usb_audio_dbg(cval->head.mixer->chip, "%s(): channel %d of control %d is read_only\n", __func__, channel, cval->control); return 0; } err = snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel, value); if (err < 0) return err; cval->cached |= 1 << channel; cval->cache_val[index] = value; return 0; } /* * TLV callback for mixer volume controls */ int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag, unsigned int size, unsigned int __user *_tlv) { struct usb_mixer_elem_info *cval = kcontrol->private_data; DECLARE_TLV_DB_MINMAX(scale, 0, 0); if (size < sizeof(scale)) return -ENOMEM; if (cval->min_mute) scale[0] = SNDRV_CTL_TLVT_DB_MINMAX_MUTE; scale[2] = cval->dBmin; scale[3] = cval->dBmax; if (copy_to_user(_tlv, scale, sizeof(scale))) return -EFAULT; return 0; } /* * parser routines begin here... */ static int parse_audio_unit(struct mixer_build *state, int unitid); /* * check if the input/output channel routing is enabled on the given bitmap. * used for mixer unit parser */ static int check_matrix_bitmap(unsigned char *bmap, int ich, int och, int num_outs) { int idx = ich * num_outs + och; return bmap[idx >> 3] & (0x80 >> (idx & 7)); } /* * add an alsa control element * search and increment the index until an empty slot is found. * * if failed, give up and free the control instance. */ int snd_usb_mixer_add_list(struct usb_mixer_elem_list *list, struct snd_kcontrol *kctl, bool is_std_info) { struct usb_mixer_interface *mixer = list->mixer; int err; while (snd_ctl_find_id(mixer->chip->card, &kctl->id)) kctl->id.index++; err = snd_ctl_add(mixer->chip->card, kctl); if (err < 0) { usb_audio_dbg(mixer->chip, "cannot add control (err = %d)\n", err); return err; } list->kctl = kctl; list->is_std_info = is_std_info; list->next_id_elem = mixer->id_elems[list->id]; mixer->id_elems[list->id] = list; return 0; } /* * get a terminal name string */ static struct iterm_name_combo { int type; char *name; } iterm_names[] = { { 0x0300, "Output" }, { 0x0301, "Speaker" }, { 0x0302, "Headphone" }, { 0x0303, "HMD Audio" }, { 0x0304, "Desktop Speaker" }, { 0x0305, "Room Speaker" }, { 0x0306, "Com Speaker" }, { 0x0307, "LFE" }, { 0x0600, "External In" }, { 0x0601, "Analog In" }, { 0x0602, "Digital In" }, { 0x0603, "Line" }, { 0x0604, "Legacy In" }, { 0x0605, "IEC958 In" }, { 0x0606, "1394 DA Stream" }, { 0x0607, "1394 DV Stream" }, { 0x0700, "Embedded" }, { 0x0701, "Noise Source" }, { 0x0702, "Equalization Noise" }, { 0x0703, "CD" }, { 0x0704, "DAT" }, { 0x0705, "DCC" }, { 0x0706, "MiniDisk" }, { 0x0707, "Analog Tape" }, { 0x0708, "Phonograph" }, { 0x0709, "VCR Audio" }, { 0x070a, "Video Disk Audio" }, { 0x070b, "DVD Audio" }, { 0x070c, "TV Tuner Audio" }, { 0x070d, "Satellite Rec Audio" }, { 0x070e, "Cable Tuner Audio" }, { 0x070f, "DSS Audio" }, { 0x0710, "Radio Receiver" }, { 0x0711, "Radio Transmitter" }, { 0x0712, "Multi-Track Recorder" }, { 0x0713, "Synthesizer" }, { 0 }, }; static int get_term_name(struct snd_usb_audio *chip, struct usb_audio_term *iterm, unsigned char *name, int maxlen, int term_only) { struct iterm_name_combo *names; int len; if (iterm->name) { len = snd_usb_copy_string_desc(chip, iterm->name, name, maxlen); if (len) return len; } /* virtual type - not a real terminal */ if (iterm->type >> 16) { if (term_only) return 0; switch (iterm->type >> 16) { case UAC3_SELECTOR_UNIT: strcpy(name, "Selector"); return 8; case UAC3_PROCESSING_UNIT: strcpy(name, "Process Unit"); return 12; case UAC3_EXTENSION_UNIT: strcpy(name, "Ext Unit"); return 8; case UAC3_MIXER_UNIT: strcpy(name, "Mixer"); return 5; default: return sprintf(name, "Unit %d", iterm->id); } } switch (iterm->type & 0xff00) { case 0x0100: strcpy(name, "PCM"); return 3; case 0x0200: strcpy(name, "Mic"); return 3; case 0x0400: strcpy(name, "Headset"); return 7; case 0x0500: strcpy(name, "Phone"); return 5; } for (names = iterm_names; names->type; names++) { if (names->type == iterm->type) { strcpy(name, names->name); return strlen(names->name); } } return 0; } /* * Get logical cluster information for UAC3 devices. */ static int get_cluster_channels_v3(struct mixer_build *state, unsigned int cluster_id) { struct uac3_cluster_header_descriptor c_header; int err; err = snd_usb_ctl_msg(state->chip->dev, usb_rcvctrlpipe(state->chip->dev, 0), UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, cluster_id, snd_usb_ctrl_intf(state->chip), &c_header, sizeof(c_header)); if (err < 0) goto error; if (err != sizeof(c_header)) { err = -EIO; goto error; } return c_header.bNrChannels; error: usb_audio_err(state->chip, "cannot request logical cluster ID: %d (err: %d)\n", cluster_id, err); return err; } /* * Get number of channels for a Mixer Unit. */ static int uac_mixer_unit_get_channels(struct mixer_build *state, struct uac_mixer_unit_descriptor *desc) { int mu_channels; switch (state->mixer->protocol) { case UAC_VERSION_1: case UAC_VERSION_2: default: if (desc->bLength < sizeof(*desc) + desc->bNrInPins + 1) return 0; /* no bmControls -> skip */ mu_channels = uac_mixer_unit_bNrChannels(desc); break; case UAC_VERSION_3: mu_channels = get_cluster_channels_v3(state, uac3_mixer_unit_wClusterDescrID(desc)); break; } return mu_channels; } /* * Parse Input Terminal Unit */ static int __check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term); static int parse_term_uac1_iterm_unit(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id) { struct uac_input_terminal_descriptor *d = p1; term->type = le16_to_cpu(d->wTerminalType); term->channels = d->bNrChannels; term->chconfig = le16_to_cpu(d->wChannelConfig); term->name = d->iTerminal; return 0; } static int parse_term_uac2_iterm_unit(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id) { struct uac2_input_terminal_descriptor *d = p1; int err; /* call recursively to verify the referenced clock entity */ err = __check_input_term(state, d->bCSourceID, term); if (err < 0) return err; /* save input term properties after recursion, * to ensure they are not overriden by the recursion calls */ term->id = id; term->type = le16_to_cpu(d->wTerminalType); term->channels = d->bNrChannels; term->chconfig = le32_to_cpu(d->bmChannelConfig); term->name = d->iTerminal; return 0; } static int parse_term_uac3_iterm_unit(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id) { struct uac3_input_terminal_descriptor *d = p1; int err; /* call recursively to verify the referenced clock entity */ err = __check_input_term(state, d->bCSourceID, term); if (err < 0) return err; /* save input term properties after recursion, * to ensure they are not overriden by the recursion calls */ term->id = id; term->type = le16_to_cpu(d->wTerminalType); err = get_cluster_channels_v3(state, le16_to_cpu(d->wClusterDescrID)); if (err < 0) return err; term->channels = err; /* REVISIT: UAC3 IT doesn't have channels cfg */ term->chconfig = 0; term->name = le16_to_cpu(d->wTerminalDescrStr); return 0; } static int parse_term_mixer_unit(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id) { struct uac_mixer_unit_descriptor *d = p1; int protocol = state->mixer->protocol; int err; err = uac_mixer_unit_get_channels(state, d); if (err <= 0) return err; term->type = UAC3_MIXER_UNIT << 16; /* virtual type */ term->channels = err; if (protocol != UAC_VERSION_3) { term->chconfig = uac_mixer_unit_wChannelConfig(d, protocol); term->name = uac_mixer_unit_iMixer(d); } return 0; } static int parse_term_selector_unit(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id) { struct uac_selector_unit_descriptor *d = p1; int err; /* call recursively to retrieve the channel info */ err = __check_input_term(state, d->baSourceID[0], term); if (err < 0) return err; term->type = UAC3_SELECTOR_UNIT << 16; /* virtual type */ term->id = id; if (state->mixer->protocol != UAC_VERSION_3) term->name = uac_selector_unit_iSelector(d); return 0; } static int parse_term_proc_unit(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id, int vtype) { struct uac_processing_unit_descriptor *d = p1; int protocol = state->mixer->protocol; int err; if (d->bNrInPins) { /* call recursively to retrieve the channel info */ err = __check_input_term(state, d->baSourceID[0], term); if (err < 0) return err; } term->type = vtype << 16; /* virtual type */ term->id = id; if (protocol == UAC_VERSION_3) return 0; if (!term->channels) { term->channels = uac_processing_unit_bNrChannels(d); term->chconfig = uac_processing_unit_wChannelConfig(d, protocol); } term->name = uac_processing_unit_iProcessing(d, protocol); return 0; } static int parse_term_effect_unit(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id) { struct uac2_effect_unit_descriptor *d = p1; int err; err = __check_input_term(state, d->bSourceID, term); if (err < 0) return err; term->type = UAC3_EFFECT_UNIT << 16; /* virtual type */ term->id = id; return 0; } static int parse_term_uac2_clock_source(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id) { struct uac_clock_source_descriptor *d = p1; term->type = UAC3_CLOCK_SOURCE << 16; /* virtual type */ term->id = id; term->name = d->iClockSource; return 0; } static int parse_term_uac3_clock_source(struct mixer_build *state, struct usb_audio_term *term, void *p1, int id) { struct uac3_clock_source_descriptor *d = p1; term->type = UAC3_CLOCK_SOURCE << 16; /* virtual type */ term->id = id; term->name = le16_to_cpu(d->wClockSourceStr); return 0; } #define PTYPE(a, b) ((a) << 8 | (b)) /* * parse the source unit recursively until it reaches to a terminal * or a branched unit. */ static int __check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term) { int protocol = state->mixer->protocol; void *p1; unsigned char *hdr; for (;;) { /* a loop in the terminal chain? */ if (test_and_set_bit(id, state->termbitmap)) return -EINVAL; p1 = find_audio_control_unit(state, id); if (!p1) break; if (!snd_usb_validate_audio_desc(p1, protocol)) break; /* bad descriptor */ hdr = p1; term->id = id; switch (PTYPE(protocol, hdr[2])) { case PTYPE(UAC_VERSION_1, UAC_FEATURE_UNIT): case PTYPE(UAC_VERSION_2, UAC_FEATURE_UNIT): case PTYPE(UAC_VERSION_3, UAC3_FEATURE_UNIT): { /* the header is the same for all versions */ struct uac_feature_unit_descriptor *d = p1; id = d->bSourceID; break; /* continue to parse */ } case PTYPE(UAC_VERSION_1, UAC_INPUT_TERMINAL): return parse_term_uac1_iterm_unit(state, term, p1, id); case PTYPE(UAC_VERSION_2, UAC_INPUT_TERMINAL): return parse_term_uac2_iterm_unit(state, term, p1, id); case PTYPE(UAC_VERSION_3, UAC_INPUT_TERMINAL): return parse_term_uac3_iterm_unit(state, term, p1, id); case PTYPE(UAC_VERSION_1, UAC_MIXER_UNIT): case PTYPE(UAC_VERSION_2, UAC_MIXER_UNIT): case PTYPE(UAC_VERSION_3, UAC3_MIXER_UNIT): return parse_term_mixer_unit(state, term, p1, id); case PTYPE(UAC_VERSION_1, UAC_SELECTOR_UNIT): case PTYPE(UAC_VERSION_2, UAC_SELECTOR_UNIT): case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SELECTOR): case PTYPE(UAC_VERSION_3, UAC3_SELECTOR_UNIT): case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SELECTOR): return parse_term_selector_unit(state, term, p1, id); case PTYPE(UAC_VERSION_1, UAC1_PROCESSING_UNIT): case PTYPE(UAC_VERSION_2, UAC2_PROCESSING_UNIT_V2): case PTYPE(UAC_VERSION_3, UAC3_PROCESSING_UNIT): return parse_term_proc_unit(state, term, p1, id, UAC3_PROCESSING_UNIT); case PTYPE(UAC_VERSION_2, UAC2_EFFECT_UNIT): case PTYPE(UAC_VERSION_3, UAC3_EFFECT_UNIT): return parse_term_effect_unit(state, term, p1, id); case PTYPE(UAC_VERSION_1, UAC1_EXTENSION_UNIT): case PTYPE(UAC_VERSION_2, UAC2_EXTENSION_UNIT_V2): case PTYPE(UAC_VERSION_3, UAC3_EXTENSION_UNIT): return parse_term_proc_unit(state, term, p1, id, UAC3_EXTENSION_UNIT); case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SOURCE): return parse_term_uac2_clock_source(state, term, p1, id); case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SOURCE): return parse_term_uac3_clock_source(state, term, p1, id); default: return -ENODEV; } } return -ENODEV; } static int check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term) { memset(term, 0, sizeof(*term)); memset(state->termbitmap, 0, sizeof(state->termbitmap)); return __check_input_term(state, id, term); } /* * Feature Unit */ /* feature unit control information */ struct usb_feature_control_info { int control; const char *name; int type; /* data type for uac1 */ int type_uac2; /* data type for uac2 if different from uac1, else -1 */ }; static const struct usb_feature_control_info audio_feature_info[] = { { UAC_FU_MUTE, "Mute", USB_MIXER_INV_BOOLEAN, -1 }, { UAC_FU_VOLUME, "Volume", USB_MIXER_S16, -1 }, { UAC_FU_BASS, "Tone Control - Bass", USB_MIXER_S8, -1 }, { UAC_FU_MID, "Tone Control - Mid", USB_MIXER_S8, -1 }, { UAC_FU_TREBLE, "Tone Control - Treble", USB_MIXER_S8, -1 }, { UAC_FU_GRAPHIC_EQUALIZER, "Graphic Equalizer", USB_MIXER_S8, -1 }, /* FIXME: not implemented yet */ { UAC_FU_AUTOMATIC_GAIN, "Auto Gain Control", USB_MIXER_BOOLEAN, -1 }, { UAC_FU_DELAY, "Delay Control", USB_MIXER_U16, USB_MIXER_U32 }, { UAC_FU_BASS_BOOST, "Bass Boost", USB_MIXER_BOOLEAN, -1 }, { UAC_FU_LOUDNESS, "Loudness", USB_MIXER_BOOLEAN, -1 }, /* UAC2 specific */ { UAC2_FU_INPUT_GAIN, "Input Gain Control", USB_MIXER_S16, -1 }, { UAC2_FU_INPUT_GAIN_PAD, "Input Gain Pad Control", USB_MIXER_S16, -1 }, { UAC2_FU_PHASE_INVERTER, "Phase Inverter Control", USB_MIXER_BOOLEAN, -1 }, }; static void usb_mixer_elem_info_free(struct usb_mixer_elem_info *cval) { kfree(cval); } /* private_free callback */ void snd_usb_mixer_elem_free(struct snd_kcontrol *kctl) { usb_mixer_elem_info_free(kctl->private_data); kctl->private_data = NULL; } /* * interface to ALSA control for feature/mixer units */ /* volume control quirks */ static void volume_control_quirks(struct usb_mixer_elem_info *cval, struct snd_kcontrol *kctl) { struct snd_usb_audio *chip = cval->head.mixer->chip; switch (chip->usb_id) { case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */ case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C600 */ if (strcmp(kctl->id.name, "Effect Duration") == 0) { cval->min = 0x0000; cval->max = 0xffff; cval->res = 0x00e6; break; } if (strcmp(kctl->id.name, "Effect Volume") == 0 || strcmp(kctl->id.name, "Effect Feedback Volume") == 0) { cval->min = 0x00; cval->max = 0xff; break; } if (strstr(kctl->id.name, "Effect Return") != NULL) { cval->min = 0xb706; cval->max = 0xff7b; cval->res = 0x0073; break; } if ((strstr(kctl->id.name, "Playback Volume") != NULL) || (strstr(kctl->id.name, "Effect Send") != NULL)) { cval->min = 0xb5fb; /* -73 dB = 0xb6ff */ cval->max = 0xfcfe; cval->res = 0x0073; } break; case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */ if (strcmp(kctl->id.name, "Effect Duration") == 0) { usb_audio_info(chip, "set quirk for FTU Effect Duration\n"); cval->min = 0x0000; cval->max = 0x7f00; cval->res = 0x0100; break; } if (strcmp(kctl->id.name, "Effect Volume") == 0 || strcmp(kctl->id.name, "Effect Feedback Volume") == 0) { usb_audio_info(chip, "set quirks for FTU Effect Feedback/Volume\n"); cval->min = 0x00; cval->max = 0x7f; break; } break; case USB_ID(0x0d8c, 0x0103): if (!strcmp(kctl->id.name, "PCM Playback Volume")) { usb_audio_info(chip, "set volume quirk for CM102-A+/102S+\n"); cval->min = -256; } break; case USB_ID(0x0471, 0x0101): case USB_ID(0x0471, 0x0104): case USB_ID(0x0471, 0x0105): case USB_ID(0x0672, 0x1041): /* quirk for UDA1321/N101. * note that detection between firmware 2.1.1.7 (N101) * and later 2.1.1.21 is not very clear from datasheets. * I hope that the min value is -15360 for newer firmware --jk */ if (!strcmp(kctl->id.name, "PCM Playback Volume") && cval->min == -15616) { usb_audio_info(chip, "set volume quirk for UDA1321/N101 chip\n"); cval->max = -256; } break; case USB_ID(0x046d, 0x09a4): if (!strcmp(kctl->id.name, "Mic Capture Volume")) { usb_audio_info(chip, "set volume quirk for QuickCam E3500\n"); cval->min = 6080; cval->max = 8768; cval->res = 192; } break; case USB_ID(0x046d, 0x0807): /* Logitech Webcam C500 */ case USB_ID(0x046d, 0x0808): case USB_ID(0x046d, 0x0809): case USB_ID(0x046d, 0x0819): /* Logitech Webcam C210 */ case USB_ID(0x046d, 0x081b): /* HD Webcam c310 */ case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */ case USB_ID(0x046d, 0x0825): /* HD Webcam c270 */ case USB_ID(0x046d, 0x0826): /* HD Webcam c525 */ case USB_ID(0x046d, 0x08ca): /* Logitech Quickcam Fusion */ case USB_ID(0x046d, 0x0991): case USB_ID(0x046d, 0x09a2): /* QuickCam Communicate Deluxe/S7500 */ /* Most audio usb devices lie about volume resolution. * Most Logitech webcams have res = 384. * Probably there is some logitech magic behind this number --fishor */ if (!strcmp(kctl->id.name, "Mic Capture Volume")) { usb_audio_info(chip, "set resolution quirk: cval->res = 384\n"); cval->res = 384; } break; case USB_ID(0x0495, 0x3042): /* ESS Technology Asus USB DAC */ if ((strstr(kctl->id.name, "Playback Volume") != NULL) || strstr(kctl->id.name, "Capture Volume") != NULL) { cval->min >>= 8; cval->max = 0; cval->res = 1; } break; case USB_ID(0x1224, 0x2a25): /* Jieli Technology USB PHY 2.0 */ if (!strcmp(kctl->id.name, "Mic Capture Volume")) { usb_audio_info(chip, "set resolution quirk: cval->res = 16\n"); cval->res = 16; } break; } } /* forcibly initialize the current mixer value; if GET_CUR fails, set to * the minimum as default */ static void init_cur_mix_raw(struct usb_mixer_elem_info *cval, int ch, int idx) { int val, err; err = snd_usb_get_cur_mix_value(cval, ch, idx, &val); if (!err) return; if (!cval->head.mixer->ignore_ctl_error) usb_audio_warn(cval->head.mixer->chip, "%d:%d: failed to get current value for ch %d (%d)\n", cval->head.id, mixer_ctrl_intf(cval->head.mixer), ch, err); snd_usb_set_cur_mix_value(cval, ch, idx, cval->min); } /* * retrieve the minimum and maximum values for the specified control */ static int get_min_max_with_quirks(struct usb_mixer_elem_info *cval, int default_min, struct snd_kcontrol *kctl) { int i, idx; /* for failsafe */ cval->min = default_min; cval->max = cval->min + 1; cval->res = 1; cval->dBmin = cval->dBmax = 0; if (cval->val_type == USB_MIXER_BOOLEAN || cval->val_type == USB_MIXER_INV_BOOLEAN) { cval->initialized = 1; } else { int minchn = 0; if (cval->cmask) { for (i = 0; i < MAX_CHANNELS; i++) if (cval->cmask & (1 << i)) { minchn = i + 1; break; } } if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 || get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) { usb_audio_err(cval->head.mixer->chip, "%d:%d: cannot get min/max values for control %d (id %d)\n", cval->head.id, mixer_ctrl_intf(cval->head.mixer), cval->control, cval->head.id); return -EINVAL; } if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) { cval->res = 1; } else if (cval->head.mixer->protocol == UAC_VERSION_1) { int last_valid_res = cval->res; while (cval->res > 1) { if (snd_usb_mixer_set_ctl_value(cval, UAC_SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0) break; cval->res /= 2; } if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) cval->res = last_valid_res; } if (cval->res == 0) cval->res = 1; /* Additional checks for the proper resolution * * Some devices report smaller resolutions than actually * reacting. They don't return errors but simply clip * to the lower aligned value. */ if (cval->min + cval->res < cval->max) { int last_valid_res = cval->res; int saved, test, check; if (get_cur_mix_raw(cval, minchn, &saved) < 0) goto no_res_check; for (;;) { test = saved; if (test < cval->max) test += cval->res; else test -= cval->res; if (test < cval->min || test > cval->max || snd_usb_set_cur_mix_value(cval, minchn, 0, test) || get_cur_mix_raw(cval, minchn, &check)) { cval->res = last_valid_res; break; } if (test == check) break; cval->res *= 2; } snd_usb_set_cur_mix_value(cval, minchn, 0, saved); } no_res_check: cval->initialized = 1; } if (kctl) volume_control_quirks(cval, kctl); /* USB descriptions contain the dB scale in 1/256 dB unit * while ALSA TLV contains in 1/100 dB unit */ cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256; cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256; if (cval->dBmin > cval->dBmax) { /* something is wrong; assume it's either from/to 0dB */ if (cval->dBmin < 0) cval->dBmax = 0; else if (cval->dBmin > 0) cval->dBmin = 0; if (cval->dBmin > cval->dBmax) { /* totally crap, return an error */ return -EINVAL; } } else { /* if the max volume is too low, it's likely a bogus range; * here we use -96dB as the threshold */ if (cval->dBmax <= -9600) { usb_audio_info(cval->head.mixer->chip, "%d:%d: bogus dB values (%d/%d), disabling dB reporting\n", cval->head.id, mixer_ctrl_intf(cval->head.mixer), cval->dBmin, cval->dBmax); cval->dBmin = cval->dBmax = 0; } } /* initialize all elements */ if (!cval->cmask) { init_cur_mix_raw(cval, 0, 0); } else { idx = 0; for (i = 0; i < MAX_CHANNELS; i++) { if (cval->cmask & (1 << i)) { init_cur_mix_raw(cval, i + 1, idx); idx++; } } } return 0; } #define get_min_max(cval, def) get_min_max_with_quirks(cval, def, NULL) /* get a feature/mixer unit info */ static int mixer_ctl_feature_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *cval = kcontrol->private_data; if (cval->val_type == USB_MIXER_BOOLEAN || cval->val_type == USB_MIXER_INV_BOOLEAN) uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; else uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = cval->channels; if (cval->val_type == USB_MIXER_BOOLEAN || cval->val_type == USB_MIXER_INV_BOOLEAN) { uinfo->value.integer.min = 0; uinfo->value.integer.max = 1; } else { if (!cval->initialized) { get_min_max_with_quirks(cval, 0, kcontrol); if (cval->initialized && cval->dBmin >= cval->dBmax) { kcontrol->vd[0].access &= ~(SNDRV_CTL_ELEM_ACCESS_TLV_READ | SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK); snd_ctl_notify(cval->head.mixer->chip->card, SNDRV_CTL_EVENT_MASK_INFO, &kcontrol->id); } } uinfo->value.integer.min = 0; uinfo->value.integer.max = DIV_ROUND_UP(cval->max - cval->min, cval->res); } return 0; } /* get the current value from feature/mixer unit */ static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; int c, cnt, val, err; ucontrol->value.integer.value[0] = cval->min; if (cval->cmask) { cnt = 0; for (c = 0; c < MAX_CHANNELS; c++) { if (!(cval->cmask & (1 << c))) continue; err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &val); if (err < 0) return filter_error(cval, err); val = get_relative_value(cval, val); ucontrol->value.integer.value[cnt] = val; cnt++; } return 0; } else { /* master channel */ err = snd_usb_get_cur_mix_value(cval, 0, 0, &val); if (err < 0) return filter_error(cval, err); val = get_relative_value(cval, val); ucontrol->value.integer.value[0] = val; } return 0; } /* put the current value to feature/mixer unit */ static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; int c, cnt, val, oval, err; int changed = 0; if (cval->cmask) { cnt = 0; for (c = 0; c < MAX_CHANNELS; c++) { if (!(cval->cmask & (1 << c))) continue; err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &oval); if (err < 0) return filter_error(cval, err); val = ucontrol->value.integer.value[cnt]; val = get_abs_value(cval, val); if (oval != val) { snd_usb_set_cur_mix_value(cval, c + 1, cnt, val); changed = 1; } cnt++; } } else { /* master channel */ err = snd_usb_get_cur_mix_value(cval, 0, 0, &oval); if (err < 0) return filter_error(cval, err); val = ucontrol->value.integer.value[0]; val = get_abs_value(cval, val); if (val != oval) { snd_usb_set_cur_mix_value(cval, 0, 0, val); changed = 1; } } return changed; } /* get the boolean value from the master channel of a UAC control */ static int mixer_ctl_master_bool_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; int val, err; err = snd_usb_get_cur_mix_value(cval, 0, 0, &val); if (err < 0) return filter_error(cval, err); val = (val != 0); ucontrol->value.integer.value[0] = val; return 0; } static int get_connector_value(struct usb_mixer_elem_info *cval, char *name, int *val) { struct snd_usb_audio *chip = cval->head.mixer->chip; int idx = 0, validx, ret; validx = cval->control << 8 | 0; ret = snd_usb_lock_shutdown(chip) ? -EIO : 0; if (ret) goto error; idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8); if (cval->head.mixer->protocol == UAC_VERSION_2) { struct uac2_connectors_ctl_blk uac2_conn; ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, validx, idx, &uac2_conn, sizeof(uac2_conn)); if (val) *val = !!uac2_conn.bNrChannels; } else { /* UAC_VERSION_3 */ struct uac3_insertion_ctl_blk uac3_conn; ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, validx, idx, &uac3_conn, sizeof(uac3_conn)); if (val) *val = !!uac3_conn.bmConInserted; } snd_usb_unlock_shutdown(chip); if (ret < 0) { if (name && strstr(name, "Speaker")) { if (val) *val = 1; return 0; } error: usb_audio_err(chip, "cannot get connectors status: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n", UAC_GET_CUR, validx, idx, cval->val_type); if (val) *val = 0; return filter_error(cval, ret); } return ret; } /* get the connectors status and report it as boolean type */ static int mixer_ctl_connector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; int ret, val; ret = get_connector_value(cval, kcontrol->id.name, &val); if (ret < 0) return ret; ucontrol->value.integer.value[0] = val; return 0; } static const struct snd_kcontrol_new usb_feature_unit_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", /* will be filled later manually */ .info = mixer_ctl_feature_info, .get = mixer_ctl_feature_get, .put = mixer_ctl_feature_put, }; /* the read-only variant */ static const struct snd_kcontrol_new usb_feature_unit_ctl_ro = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", /* will be filled later manually */ .info = mixer_ctl_feature_info, .get = mixer_ctl_feature_get, .put = NULL, }; /* * A control which shows the boolean value from reading a UAC control on * the master channel. */ static const struct snd_kcontrol_new usb_bool_master_control_ctl_ro = { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = "", /* will be filled later manually */ .access = SNDRV_CTL_ELEM_ACCESS_READ, .info = snd_ctl_boolean_mono_info, .get = mixer_ctl_master_bool_get, .put = NULL, }; static const struct snd_kcontrol_new usb_connector_ctl_ro = { .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = "", /* will be filled later manually */ .access = SNDRV_CTL_ELEM_ACCESS_READ, .info = snd_ctl_boolean_mono_info, .get = mixer_ctl_connector_get, .put = NULL, }; /* * This symbol is exported in order to allow the mixer quirks to * hook up to the standard feature unit control mechanism */ const struct snd_kcontrol_new *snd_usb_feature_unit_ctl = &usb_feature_unit_ctl; /* * build a feature control */ static size_t append_ctl_name(struct snd_kcontrol *kctl, const char *str) { return strlcat(kctl->id.name, str, sizeof(kctl->id.name)); } /* * A lot of headsets/headphones have a "Speaker" mixer. Make sure we * rename it to "Headphone". We determine if something is a headphone * similar to how udev determines form factor. */ static void check_no_speaker_on_headset(struct snd_kcontrol *kctl, struct snd_card *card) { static const char * const names_to_check[] = { "Headset", "headset", "Headphone", "headphone", NULL}; const char * const *s; bool found = false; if (strcmp("Speaker", kctl->id.name)) return; for (s = names_to_check; *s; s++) if (strstr(card->shortname, *s)) { found = true; break; } if (!found) return; snd_ctl_rename(card, kctl, "Headphone"); } static const struct usb_feature_control_info *get_feature_control_info(int control) { int i; for (i = 0; i < ARRAY_SIZE(audio_feature_info); ++i) { if (audio_feature_info[i].control == control) return &audio_feature_info[i]; } return NULL; } static void __build_feature_ctl(struct usb_mixer_interface *mixer, const struct usbmix_name_map *imap, unsigned int ctl_mask, int control, struct usb_audio_term *iterm, struct usb_audio_term *oterm, int unitid, int nameid, int readonly_mask) { const struct usb_feature_control_info *ctl_info; unsigned int len = 0; int mapped_name = 0; struct snd_kcontrol *kctl; struct usb_mixer_elem_info *cval; const struct usbmix_name_map *map; unsigned int range; if (control == UAC_FU_GRAPHIC_EQUALIZER) { /* FIXME: not supported yet */ return; } map = find_map(imap, unitid, control); if (check_ignored_ctl(map)) return; cval = kzalloc(sizeof(*cval), GFP_KERNEL); if (!cval) return; snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid); cval->control = control; cval->cmask = ctl_mask; ctl_info = get_feature_control_info(control); if (!ctl_info) { usb_mixer_elem_info_free(cval); return; } if (mixer->protocol == UAC_VERSION_1) cval->val_type = ctl_info->type; else /* UAC_VERSION_2 */ cval->val_type = ctl_info->type_uac2 >= 0 ? ctl_info->type_uac2 : ctl_info->type; if (ctl_mask == 0) { cval->channels = 1; /* master channel */ cval->master_readonly = readonly_mask; } else { int i, c = 0; for (i = 0; i < 16; i++) if (ctl_mask & (1 << i)) c++; cval->channels = c; cval->ch_readonly = readonly_mask; } /* * If all channels in the mask are marked read-only, make the control * read-only. snd_usb_set_cur_mix_value() will check the mask again and won't * issue write commands to read-only channels. */ if (cval->channels == readonly_mask) kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval); else kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval); if (!kctl) { usb_audio_err(mixer->chip, "cannot malloc kcontrol\n"); usb_mixer_elem_info_free(cval); return; } kctl->private_free = snd_usb_mixer_elem_free; len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name)); mapped_name = len != 0; if (!len && nameid) len = snd_usb_copy_string_desc(mixer->chip, nameid, kctl->id.name, sizeof(kctl->id.name)); switch (control) { case UAC_FU_MUTE: case UAC_FU_VOLUME: /* * determine the control name. the rule is: * - if a name id is given in descriptor, use it. * - if the connected input can be determined, then use the name * of terminal type. * - if the connected output can be determined, use it. * - otherwise, anonymous name. */ if (!len) { if (iterm) len = get_term_name(mixer->chip, iterm, kctl->id.name, sizeof(kctl->id.name), 1); if (!len && oterm) len = get_term_name(mixer->chip, oterm, kctl->id.name, sizeof(kctl->id.name), 1); if (!len) snprintf(kctl->id.name, sizeof(kctl->id.name), "Feature %d", unitid); } if (!mapped_name) check_no_speaker_on_headset(kctl, mixer->chip->card); /* * determine the stream direction: * if the connected output is USB stream, then it's likely a * capture stream. otherwise it should be playback (hopefully :) */ if (!mapped_name && oterm && !(oterm->type >> 16)) { if ((oterm->type & 0xff00) == 0x0100) append_ctl_name(kctl, " Capture"); else append_ctl_name(kctl, " Playback"); } append_ctl_name(kctl, control == UAC_FU_MUTE ? " Switch" : " Volume"); break; default: if (!len) strscpy(kctl->id.name, audio_feature_info[control-1].name, sizeof(kctl->id.name)); break; } /* get min/max values */ get_min_max_with_quirks(cval, 0, kctl); /* skip a bogus volume range */ if (cval->max <= cval->min) { usb_audio_dbg(mixer->chip, "[%d] FU [%s] skipped due to invalid volume\n", cval->head.id, kctl->id.name); snd_ctl_free_one(kctl); return; } if (control == UAC_FU_VOLUME) { check_mapped_dB(map, cval); if (cval->dBmin < cval->dBmax || !cval->initialized) { kctl->tlv.c = snd_usb_mixer_vol_tlv; kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ | SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; } } snd_usb_mixer_fu_apply_quirk(mixer, cval, unitid, kctl); range = (cval->max - cval->min) / cval->res; /* * Are there devices with volume range more than 255? I use a bit more * to be sure. 384 is a resolution magic number found on Logitech * devices. It will definitively catch all buggy Logitech devices. */ if (range > 384) { usb_audio_warn(mixer->chip, "Warning! Unlikely big volume range (=%u), cval->res is probably wrong.", range); usb_audio_warn(mixer->chip, "[%d] FU [%s] ch = %d, val = %d/%d/%d", cval->head.id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res); } usb_audio_dbg(mixer->chip, "[%d] FU [%s] ch = %d, val = %d/%d/%d\n", cval->head.id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res); snd_usb_mixer_add_control(&cval->head, kctl); } static void build_feature_ctl(struct mixer_build *state, void *raw_desc, unsigned int ctl_mask, int control, struct usb_audio_term *iterm, int unitid, int readonly_mask) { struct uac_feature_unit_descriptor *desc = raw_desc; int nameid = uac_feature_unit_iFeature(desc); __build_feature_ctl(state->mixer, state->map, ctl_mask, control, iterm, &state->oterm, unitid, nameid, readonly_mask); } static void build_feature_ctl_badd(struct usb_mixer_interface *mixer, unsigned int ctl_mask, int control, int unitid, const struct usbmix_name_map *badd_map) { __build_feature_ctl(mixer, badd_map, ctl_mask, control, NULL, NULL, unitid, 0, 0); } static void get_connector_control_name(struct usb_mixer_interface *mixer, struct usb_audio_term *term, bool is_input, char *name, int name_size) { int name_len = get_term_name(mixer->chip, term, name, name_size, 0); if (name_len == 0) strscpy(name, "Unknown", name_size); /* * sound/core/ctljack.c has a convention of naming jack controls * by ending in " Jack". Make it slightly more useful by * indicating Input or Output after the terminal name. */ if (is_input) strlcat(name, " - Input Jack", name_size); else strlcat(name, " - Output Jack", name_size); } /* get connector value to "wake up" the USB audio */ static int connector_mixer_resume(struct usb_mixer_elem_list *list) { struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list); get_connector_value(cval, NULL, NULL); return 0; } /* Build a mixer control for a UAC connector control (jack-detect) */ static void build_connector_control(struct usb_mixer_interface *mixer, const struct usbmix_name_map *imap, struct usb_audio_term *term, bool is_input) { struct snd_kcontrol *kctl; struct usb_mixer_elem_info *cval; const struct usbmix_name_map *map; map = find_map(imap, term->id, 0); if (check_ignored_ctl(map)) return; cval = kzalloc(sizeof(*cval), GFP_KERNEL); if (!cval) return; snd_usb_mixer_elem_init_std(&cval->head, mixer, term->id); /* set up a specific resume callback */ cval->head.resume = connector_mixer_resume; /* * UAC2: The first byte from reading the UAC2_TE_CONNECTOR control returns the * number of channels connected. * * UAC3: The first byte specifies size of bitmap for the inserted controls. The * following byte(s) specifies which connectors are inserted. * * This boolean ctl will simply report if any channels are connected * or not. */ if (mixer->protocol == UAC_VERSION_2) cval->control = UAC2_TE_CONNECTOR; else /* UAC_VERSION_3 */ cval->control = UAC3_TE_INSERTION; cval->val_type = USB_MIXER_BOOLEAN; cval->channels = 1; /* report true if any channel is connected */ cval->min = 0; cval->max = 1; kctl = snd_ctl_new1(&usb_connector_ctl_ro, cval); if (!kctl) { usb_audio_err(mixer->chip, "cannot malloc kcontrol\n"); usb_mixer_elem_info_free(cval); return; } if (check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name))) strlcat(kctl->id.name, " Jack", sizeof(kctl->id.name)); else get_connector_control_name(mixer, term, is_input, kctl->id.name, sizeof(kctl->id.name)); kctl->private_free = snd_usb_mixer_elem_free; snd_usb_mixer_add_control(&cval->head, kctl); } static int parse_clock_source_unit(struct mixer_build *state, int unitid, void *_ftr) { struct uac_clock_source_descriptor *hdr = _ftr; struct usb_mixer_elem_info *cval; struct snd_kcontrol *kctl; int ret; if (state->mixer->protocol != UAC_VERSION_2) return -EINVAL; /* * The only property of this unit we are interested in is the * clock source validity. If that isn't readable, just bail out. */ if (!uac_v2v3_control_is_readable(hdr->bmControls, UAC2_CS_CONTROL_CLOCK_VALID)) return 0; cval = kzalloc(sizeof(*cval), GFP_KERNEL); if (!cval) return -ENOMEM; snd_usb_mixer_elem_init_std(&cval->head, state->mixer, hdr->bClockID); cval->min = 0; cval->max = 1; cval->channels = 1; cval->val_type = USB_MIXER_BOOLEAN; cval->control = UAC2_CS_CONTROL_CLOCK_VALID; cval->master_readonly = 1; /* From UAC2 5.2.5.1.2 "Only the get request is supported." */ kctl = snd_ctl_new1(&usb_bool_master_control_ctl_ro, cval); if (!kctl) { usb_mixer_elem_info_free(cval); return -ENOMEM; } kctl->private_free = snd_usb_mixer_elem_free; ret = snd_usb_copy_string_desc(state->chip, hdr->iClockSource, kctl->id.name, sizeof(kctl->id.name)); if (ret > 0) append_ctl_name(kctl, " Validity"); else snprintf(kctl->id.name, sizeof(kctl->id.name), "Clock Source %d Validity", hdr->bClockID); return snd_usb_mixer_add_control(&cval->head, kctl); } /* * parse a feature unit * * most of controls are defined here. */ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void *_ftr) { int channels, i, j; struct usb_audio_term iterm; unsigned int master_bits; int err, csize; struct uac_feature_unit_descriptor *hdr = _ftr; __u8 *bmaControls; if (state->mixer->protocol == UAC_VERSION_1) { csize = hdr->bControlSize; channels = (hdr->bLength - 7) / csize - 1; bmaControls = hdr->bmaControls; } else if (state->mixer->protocol == UAC_VERSION_2) { struct uac2_feature_unit_descriptor *ftr = _ftr; csize = 4; channels = (hdr->bLength - 6) / 4 - 1; bmaControls = ftr->bmaControls; } else { /* UAC_VERSION_3 */ struct uac3_feature_unit_descriptor *ftr = _ftr; csize = 4; channels = (ftr->bLength - 7) / 4 - 1; bmaControls = ftr->bmaControls; } /* parse the source unit */ err = parse_audio_unit(state, hdr->bSourceID); if (err < 0) return err; /* determine the input source type and name */ err = check_input_term(state, hdr->bSourceID, &iterm); if (err < 0) return err; master_bits = snd_usb_combine_bytes(bmaControls, csize); /* master configuration quirks */ switch (state->chip->usb_id) { case USB_ID(0x08bb, 0x2702): usb_audio_info(state->chip, "usbmixer: master volume quirk for PCM2702 chip\n"); /* disable non-functional volume control */ master_bits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME); break; case USB_ID(0x1130, 0xf211): usb_audio_info(state->chip, "usbmixer: volume control quirk for Tenx TP6911 Audio Headset\n"); /* disable non-functional volume control */ channels = 0; break; } if (state->mixer->protocol == UAC_VERSION_1) { /* check all control types */ for (i = 0; i < 10; i++) { unsigned int ch_bits = 0; int control = audio_feature_info[i].control; for (j = 0; j < channels; j++) { unsigned int mask; mask = snd_usb_combine_bytes(bmaControls + csize * (j+1), csize); if (mask & (1 << i)) ch_bits |= (1 << j); } /* audio class v1 controls are never read-only */ /* * The first channel must be set * (for ease of programming). */ if (ch_bits & 1) build_feature_ctl(state, _ftr, ch_bits, control, &iterm, unitid, 0); if (master_bits & (1 << i)) build_feature_ctl(state, _ftr, 0, control, &iterm, unitid, 0); } } else { /* UAC_VERSION_2/3 */ for (i = 0; i < ARRAY_SIZE(audio_feature_info); i++) { unsigned int ch_bits = 0; unsigned int ch_read_only = 0; int control = audio_feature_info[i].control; for (j = 0; j < channels; j++) { unsigned int mask; mask = snd_usb_combine_bytes(bmaControls + csize * (j+1), csize); if (uac_v2v3_control_is_readable(mask, control)) { ch_bits |= (1 << j); if (!uac_v2v3_control_is_writeable(mask, control)) ch_read_only |= (1 << j); } } /* * NOTE: build_feature_ctl() will mark the control * read-only if all channels are marked read-only in * the descriptors. Otherwise, the control will be * reported as writeable, but the driver will not * actually issue a write command for read-only * channels. */ /* * The first channel must be set * (for ease of programming). */ if (ch_bits & 1) build_feature_ctl(state, _ftr, ch_bits, control, &iterm, unitid, ch_read_only); if (uac_v2v3_control_is_readable(master_bits, control)) build_feature_ctl(state, _ftr, 0, control, &iterm, unitid, !uac_v2v3_control_is_writeable(master_bits, control)); } } return 0; } /* * Mixer Unit */ /* check whether the given in/out overflows bmMixerControls matrix */ static bool mixer_bitmap_overflow(struct uac_mixer_unit_descriptor *desc, int protocol, int num_ins, int num_outs) { u8 *hdr = (u8 *)desc; u8 *c = uac_mixer_unit_bmControls(desc, protocol); size_t rest; /* remaining bytes after bmMixerControls */ switch (protocol) { case UAC_VERSION_1: default: rest = 1; /* iMixer */ break; case UAC_VERSION_2: rest = 2; /* bmControls + iMixer */ break; case UAC_VERSION_3: rest = 6; /* bmControls + wMixerDescrStr */ break; } /* overflow? */ return c + (num_ins * num_outs + 7) / 8 + rest > hdr + hdr[0]; } /* * build a mixer unit control * * the callbacks are identical with feature unit. * input channel number (zero based) is given in control field instead. */ static void build_mixer_unit_ctl(struct mixer_build *state, struct uac_mixer_unit_descriptor *desc, int in_pin, int in_ch, int num_outs, int unitid, struct usb_audio_term *iterm) { struct usb_mixer_elem_info *cval; unsigned int i, len; struct snd_kcontrol *kctl; const struct usbmix_name_map *map; map = find_map(state->map, unitid, 0); if (check_ignored_ctl(map)) return; cval = kzalloc(sizeof(*cval), GFP_KERNEL); if (!cval) return; snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid); cval->control = in_ch + 1; /* based on 1 */ cval->val_type = USB_MIXER_S16; for (i = 0; i < num_outs; i++) { __u8 *c = uac_mixer_unit_bmControls(desc, state->mixer->protocol); if (check_matrix_bitmap(c, in_ch, i, num_outs)) { cval->cmask |= (1 << i); cval->channels++; } } /* get min/max values */ get_min_max(cval, 0); kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval); if (!kctl) { usb_audio_err(state->chip, "cannot malloc kcontrol\n"); usb_mixer_elem_info_free(cval); return; } kctl->private_free = snd_usb_mixer_elem_free; len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name)); if (!len) len = get_term_name(state->chip, iterm, kctl->id.name, sizeof(kctl->id.name), 0); if (!len) len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1); append_ctl_name(kctl, " Volume"); usb_audio_dbg(state->chip, "[%d] MU [%s] ch = %d, val = %d/%d\n", cval->head.id, kctl->id.name, cval->channels, cval->min, cval->max); snd_usb_mixer_add_control(&cval->head, kctl); } static int parse_audio_input_terminal(struct mixer_build *state, int unitid, void *raw_desc) { struct usb_audio_term iterm; unsigned int control, bmctls, term_id; if (state->mixer->protocol == UAC_VERSION_2) { struct uac2_input_terminal_descriptor *d_v2 = raw_desc; control = UAC2_TE_CONNECTOR; term_id = d_v2->bTerminalID; bmctls = le16_to_cpu(d_v2->bmControls); } else if (state->mixer->protocol == UAC_VERSION_3) { struct uac3_input_terminal_descriptor *d_v3 = raw_desc; control = UAC3_TE_INSERTION; term_id = d_v3->bTerminalID; bmctls = le32_to_cpu(d_v3->bmControls); } else { return 0; /* UAC1. No Insertion control */ } check_input_term(state, term_id, &iterm); /* Check for jack detection. */ if ((iterm.type & 0xff00) != 0x0100 && uac_v2v3_control_is_readable(bmctls, control)) build_connector_control(state->mixer, state->map, &iterm, true); return 0; } /* * parse a mixer unit */ static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, void *raw_desc) { struct uac_mixer_unit_descriptor *desc = raw_desc; struct usb_audio_term iterm; int input_pins, num_ins, num_outs; int pin, ich, err; err = uac_mixer_unit_get_channels(state, desc); if (err < 0) { usb_audio_err(state->chip, "invalid MIXER UNIT descriptor %d\n", unitid); return err; } num_outs = err; input_pins = desc->bNrInPins; num_ins = 0; ich = 0; for (pin = 0; pin < input_pins; pin++) { err = parse_audio_unit(state, desc->baSourceID[pin]); if (err < 0) continue; /* no bmControls field (e.g. Maya44) -> ignore */ if (!num_outs) continue; err = check_input_term(state, desc->baSourceID[pin], &iterm); if (err < 0) return err; num_ins += iterm.channels; if (mixer_bitmap_overflow(desc, state->mixer->protocol, num_ins, num_outs)) break; for (; ich < num_ins; ich++) { int och, ich_has_controls = 0; for (och = 0; och < num_outs; och++) { __u8 *c = uac_mixer_unit_bmControls(desc, state->mixer->protocol); if (check_matrix_bitmap(c, ich, och, num_outs)) { ich_has_controls = 1; break; } } if (ich_has_controls) build_mixer_unit_ctl(state, desc, pin, ich, num_outs, unitid, &iterm); } } return 0; } /* * Processing Unit / Extension Unit */ /* get callback for processing/extension unit */ static int mixer_ctl_procunit_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; int err, val; err = get_cur_ctl_value(cval, cval->control << 8, &val); if (err < 0) { ucontrol->value.integer.value[0] = cval->min; return filter_error(cval, err); } val = get_relative_value(cval, val); ucontrol->value.integer.value[0] = val; return 0; } /* put callback for processing/extension unit */ static int mixer_ctl_procunit_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; int val, oval, err; err = get_cur_ctl_value(cval, cval->control << 8, &oval); if (err < 0) return filter_error(cval, err); val = ucontrol->value.integer.value[0]; val = get_abs_value(cval, val); if (val != oval) { set_cur_ctl_value(cval, cval->control << 8, val); return 1; } return 0; } /* alsa control interface for processing/extension unit */ static const struct snd_kcontrol_new mixer_procunit_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", /* will be filled later */ .info = mixer_ctl_feature_info, .get = mixer_ctl_procunit_get, .put = mixer_ctl_procunit_put, }; /* * predefined data for processing units */ struct procunit_value_info { int control; const char *suffix; int val_type; int min_value; }; struct procunit_info { int type; char *name; const struct procunit_value_info *values; }; static const struct procunit_value_info undefined_proc_info[] = { { 0x00, "Control Undefined", 0 }, { 0 } }; static const struct procunit_value_info updown_proc_info[] = { { UAC_UD_ENABLE, "Switch", USB_MIXER_BOOLEAN }, { UAC_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 }, { 0 } }; static const struct procunit_value_info prologic_proc_info[] = { { UAC_DP_ENABLE, "Switch", USB_MIXER_BOOLEAN }, { UAC_DP_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 }, { 0 } }; static const struct procunit_value_info threed_enh_proc_info[] = { { UAC_3D_ENABLE, "Switch", USB_MIXER_BOOLEAN }, { UAC_3D_SPACE, "Spaciousness", USB_MIXER_U8 }, { 0 } }; static const struct procunit_value_info reverb_proc_info[] = { { UAC_REVERB_ENABLE, "Switch", USB_MIXER_BOOLEAN }, { UAC_REVERB_LEVEL, "Level", USB_MIXER_U8 }, { UAC_REVERB_TIME, "Time", USB_MIXER_U16 }, { UAC_REVERB_FEEDBACK, "Feedback", USB_MIXER_U8 }, { 0 } }; static const struct procunit_value_info chorus_proc_info[] = { { UAC_CHORUS_ENABLE, "Switch", USB_MIXER_BOOLEAN }, { UAC_CHORUS_LEVEL, "Level", USB_MIXER_U8 }, { UAC_CHORUS_RATE, "Rate", USB_MIXER_U16 }, { UAC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 }, { 0 } }; static const struct procunit_value_info dcr_proc_info[] = { { UAC_DCR_ENABLE, "Switch", USB_MIXER_BOOLEAN }, { UAC_DCR_RATE, "Ratio", USB_MIXER_U16 }, { UAC_DCR_MAXAMPL, "Max Amp", USB_MIXER_S16 }, { UAC_DCR_THRESHOLD, "Threshold", USB_MIXER_S16 }, { UAC_DCR_ATTACK_TIME, "Attack Time", USB_MIXER_U16 }, { UAC_DCR_RELEASE_TIME, "Release Time", USB_MIXER_U16 }, { 0 } }; static const struct procunit_info procunits[] = { { UAC_PROCESS_UP_DOWNMIX, "Up Down", updown_proc_info }, { UAC_PROCESS_DOLBY_PROLOGIC, "Dolby Prologic", prologic_proc_info }, { UAC_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", threed_enh_proc_info }, { UAC_PROCESS_REVERB, "Reverb", reverb_proc_info }, { UAC_PROCESS_CHORUS, "Chorus", chorus_proc_info }, { UAC_PROCESS_DYN_RANGE_COMP, "DCR", dcr_proc_info }, { 0 }, }; static const struct procunit_value_info uac3_updown_proc_info[] = { { UAC3_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 }, { 0 } }; static const struct procunit_value_info uac3_stereo_ext_proc_info[] = { { UAC3_EXT_WIDTH_CONTROL, "Width Control", USB_MIXER_U8 }, { 0 } }; static const struct procunit_info uac3_procunits[] = { { UAC3_PROCESS_UP_DOWNMIX, "Up Down", uac3_updown_proc_info }, { UAC3_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", uac3_stereo_ext_proc_info }, { UAC3_PROCESS_MULTI_FUNCTION, "Multi-Function", undefined_proc_info }, { 0 }, }; /* * predefined data for extension units */ static const struct procunit_value_info clock_rate_xu_info[] = { { USB_XU_CLOCK_RATE_SELECTOR, "Selector", USB_MIXER_U8, 0 }, { 0 } }; static const struct procunit_value_info clock_source_xu_info[] = { { USB_XU_CLOCK_SOURCE_SELECTOR, "External", USB_MIXER_BOOLEAN }, { 0 } }; static const struct procunit_value_info spdif_format_xu_info[] = { { USB_XU_DIGITAL_FORMAT_SELECTOR, "SPDIF/AC3", USB_MIXER_BOOLEAN }, { 0 } }; static const struct procunit_value_info soft_limit_xu_info[] = { { USB_XU_SOFT_LIMIT_SELECTOR, " ", USB_MIXER_BOOLEAN }, { 0 } }; static const struct procunit_info extunits[] = { { USB_XU_CLOCK_RATE, "Clock rate", clock_rate_xu_info }, { USB_XU_CLOCK_SOURCE, "DigitalIn CLK source", clock_source_xu_info }, { USB_XU_DIGITAL_IO_STATUS, "DigitalOut format:", spdif_format_xu_info }, { USB_XU_DEVICE_OPTIONS, "AnalogueIn Soft Limit", soft_limit_xu_info }, { 0 } }; /* * build a processing/extension unit */ static int build_audio_procunit(struct mixer_build *state, int unitid, void *raw_desc, const struct procunit_info *list, bool extension_unit) { struct uac_processing_unit_descriptor *desc = raw_desc; int num_ins; struct usb_mixer_elem_info *cval; struct snd_kcontrol *kctl; int i, err, nameid, type, len, val; const struct procunit_info *info; const struct procunit_value_info *valinfo; const struct usbmix_name_map *map; static const struct procunit_value_info default_value_info[] = { { 0x01, "Switch", USB_MIXER_BOOLEAN }, { 0 } }; static const struct procunit_info default_info = { 0, NULL, default_value_info }; const char *name = extension_unit ? "Extension Unit" : "Processing Unit"; num_ins = desc->bNrInPins; for (i = 0; i < num_ins; i++) { err = parse_audio_unit(state, desc->baSourceID[i]); if (err < 0) return err; } type = le16_to_cpu(desc->wProcessType); for (info = list; info && info->type; info++) if (info->type == type) break; if (!info || !info->type) info = &default_info; for (valinfo = info->values; valinfo->control; valinfo++) { __u8 *controls = uac_processing_unit_bmControls(desc, state->mixer->protocol); if (state->mixer->protocol == UAC_VERSION_1) { if (!(controls[valinfo->control / 8] & (1 << ((valinfo->control % 8) - 1)))) continue; } else { /* UAC_VERSION_2/3 */ if (!uac_v2v3_control_is_readable(controls[valinfo->control / 8], valinfo->control)) continue; } map = find_map(state->map, unitid, valinfo->control); if (check_ignored_ctl(map)) continue; cval = kzalloc(sizeof(*cval), GFP_KERNEL); if (!cval) return -ENOMEM; snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid); cval->control = valinfo->control; cval->val_type = valinfo->val_type; cval->channels = 1; if (state->mixer->protocol > UAC_VERSION_1 && !uac_v2v3_control_is_writeable(controls[valinfo->control / 8], valinfo->control)) cval->master_readonly = 1; /* get min/max values */ switch (type) { case UAC_PROCESS_UP_DOWNMIX: { bool mode_sel = false; switch (state->mixer->protocol) { case UAC_VERSION_1: case UAC_VERSION_2: default: if (cval->control == UAC_UD_MODE_SELECT) mode_sel = true; break; case UAC_VERSION_3: if (cval->control == UAC3_UD_MODE_SELECT) mode_sel = true; break; } if (mode_sel) { __u8 *control_spec = uac_processing_unit_specific(desc, state->mixer->protocol); cval->min = 1; cval->max = control_spec[0]; cval->res = 1; cval->initialized = 1; break; } get_min_max(cval, valinfo->min_value); break; } case USB_XU_CLOCK_RATE: /* * E-Mu USB 0404/0202/TrackerPre/0204 * samplerate control quirk */ cval->min = 0; cval->max = 5; cval->res = 1; cval->initialized = 1; break; default: get_min_max(cval, valinfo->min_value); break; } err = get_cur_ctl_value(cval, cval->control << 8, &val); if (err < 0) { usb_mixer_elem_info_free(cval); return -EINVAL; } kctl = snd_ctl_new1(&mixer_procunit_ctl, cval); if (!kctl) { usb_mixer_elem_info_free(cval); return -ENOMEM; } kctl->private_free = snd_usb_mixer_elem_free; if (check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name))) { /* nothing */ ; } else if (info->name) { strscpy(kctl->id.name, info->name, sizeof(kctl->id.name)); } else { if (extension_unit) nameid = uac_extension_unit_iExtension(desc, state->mixer->protocol); else nameid = uac_processing_unit_iProcessing(desc, state->mixer->protocol); len = 0; if (nameid) len = snd_usb_copy_string_desc(state->chip, nameid, kctl->id.name, sizeof(kctl->id.name)); if (!len) strscpy(kctl->id.name, name, sizeof(kctl->id.name)); } append_ctl_name(kctl, " "); append_ctl_name(kctl, valinfo->suffix); usb_audio_dbg(state->chip, "[%d] PU [%s] ch = %d, val = %d/%d\n", cval->head.id, kctl->id.name, cval->channels, cval->min, cval->max); err = snd_usb_mixer_add_control(&cval->head, kctl); if (err < 0) return err; } return 0; } static int parse_audio_processing_unit(struct mixer_build *state, int unitid, void *raw_desc) { switch (state->mixer->protocol) { case UAC_VERSION_1: case UAC_VERSION_2: default: return build_audio_procunit(state, unitid, raw_desc, procunits, false); case UAC_VERSION_3: return build_audio_procunit(state, unitid, raw_desc, uac3_procunits, false); } } static int parse_audio_extension_unit(struct mixer_build *state, int unitid, void *raw_desc) { /* * Note that we parse extension units with processing unit descriptors. * That's ok as the layout is the same. */ return build_audio_procunit(state, unitid, raw_desc, extunits, true); } /* * Selector Unit */ /* * info callback for selector unit * use an enumerator type for routing */ static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *cval = kcontrol->private_data; const char **itemlist = (const char **)kcontrol->private_value; if (snd_BUG_ON(!itemlist)) return -EINVAL; return snd_ctl_enum_info(uinfo, 1, cval->max, itemlist); } /* get callback for selector unit */ static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; int val, err; err = get_cur_ctl_value(cval, cval->control << 8, &val); if (err < 0) { ucontrol->value.enumerated.item[0] = 0; return filter_error(cval, err); } val = get_relative_value(cval, val); ucontrol->value.enumerated.item[0] = val; return 0; } /* put callback for selector unit */ static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *cval = kcontrol->private_data; int val, oval, err; err = get_cur_ctl_value(cval, cval->control << 8, &oval); if (err < 0) return filter_error(cval, err); val = ucontrol->value.enumerated.item[0]; val = get_abs_value(cval, val); if (val != oval) { set_cur_ctl_value(cval, cval->control << 8, val); return 1; } return 0; } /* alsa control interface for selector unit */ static const struct snd_kcontrol_new mixer_selectunit_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", /* will be filled later */ .info = mixer_ctl_selector_info, .get = mixer_ctl_selector_get, .put = mixer_ctl_selector_put, }; /* * private free callback. * free both private_data and private_value */ static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl) { int i, num_ins = 0; if (kctl->private_data) { struct usb_mixer_elem_info *cval = kctl->private_data; num_ins = cval->max; usb_mixer_elem_info_free(cval); kctl->private_data = NULL; } if (kctl->private_value) { char **itemlist = (char **)kctl->private_value; for (i = 0; i < num_ins; i++) kfree(itemlist[i]); kfree(itemlist); kctl->private_value = 0; } } /* * parse a selector unit */ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void *raw_desc) { struct uac_selector_unit_descriptor *desc = raw_desc; unsigned int i, nameid, len; int err; struct usb_mixer_elem_info *cval; struct snd_kcontrol *kctl; const struct usbmix_name_map *map; char **namelist; for (i = 0; i < desc->bNrInPins; i++) { err = parse_audio_unit(state, desc->baSourceID[i]); if (err < 0) return err; } if (desc->bNrInPins == 1) /* only one ? nonsense! */ return 0; map = find_map(state->map, unitid, 0); if (check_ignored_ctl(map)) return 0; cval = kzalloc(sizeof(*cval), GFP_KERNEL); if (!cval) return -ENOMEM; snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid); cval->val_type = USB_MIXER_U8; cval->channels = 1; cval->min = 1; cval->max = desc->bNrInPins; cval->res = 1; cval->initialized = 1; switch (state->mixer->protocol) { case UAC_VERSION_1: default: cval->control = 0; break; case UAC_VERSION_2: case UAC_VERSION_3: if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR || desc->bDescriptorSubtype == UAC3_CLOCK_SELECTOR) cval->control = UAC2_CX_CLOCK_SELECTOR; else /* UAC2/3_SELECTOR_UNIT */ cval->control = UAC2_SU_SELECTOR; break; } namelist = kcalloc(desc->bNrInPins, sizeof(char *), GFP_KERNEL); if (!namelist) { err = -ENOMEM; goto error_cval; } #define MAX_ITEM_NAME_LEN 64 for (i = 0; i < desc->bNrInPins; i++) { struct usb_audio_term iterm; namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL); if (!namelist[i]) { err = -ENOMEM; goto error_name; } len = check_mapped_selector_name(state, unitid, i, namelist[i], MAX_ITEM_NAME_LEN); if (! len && check_input_term(state, desc->baSourceID[i], &iterm) >= 0) len = get_term_name(state->chip, &iterm, namelist[i], MAX_ITEM_NAME_LEN, 0); if (! len) sprintf(namelist[i], "Input %u", i); } kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval); if (! kctl) { usb_audio_err(state->chip, "cannot malloc kcontrol\n"); err = -ENOMEM; goto error_name; } kctl->private_value = (unsigned long)namelist; kctl->private_free = usb_mixer_selector_elem_free; /* check the static mapping table at first */ len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name)); if (!len) { /* no mapping ? */ switch (state->mixer->protocol) { case UAC_VERSION_1: case UAC_VERSION_2: default: /* if iSelector is given, use it */ nameid = uac_selector_unit_iSelector(desc); if (nameid) len = snd_usb_copy_string_desc(state->chip, nameid, kctl->id.name, sizeof(kctl->id.name)); break; case UAC_VERSION_3: /* TODO: Class-Specific strings not yet supported */ break; } /* ... or pick up the terminal name at next */ if (!len) len = get_term_name(state->chip, &state->oterm, kctl->id.name, sizeof(kctl->id.name), 0); /* ... or use the fixed string "USB" as the last resort */ if (!len) strscpy(kctl->id.name, "USB", sizeof(kctl->id.name)); /* and add the proper suffix */ if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR || desc->bDescriptorSubtype == UAC3_CLOCK_SELECTOR) append_ctl_name(kctl, " Clock Source"); else if ((state->oterm.type & 0xff00) == 0x0100) append_ctl_name(kctl, " Capture Source"); else append_ctl_name(kctl, " Playback Source"); } usb_audio_dbg(state->chip, "[%d] SU [%s] items = %d\n", cval->head.id, kctl->id.name, desc->bNrInPins); return snd_usb_mixer_add_control(&cval->head, kctl); error_name: for (i = 0; i < desc->bNrInPins; i++) kfree(namelist[i]); kfree(namelist); error_cval: usb_mixer_elem_info_free(cval); return err; } /* * parse an audio unit recursively */ static int parse_audio_unit(struct mixer_build *state, int unitid) { unsigned char *p1; int protocol = state->mixer->protocol; if (test_and_set_bit(unitid, state->unitbitmap)) return 0; /* the unit already visited */ p1 = find_audio_control_unit(state, unitid); if (!p1) { usb_audio_err(state->chip, "unit %d not found!\n", unitid); return -EINVAL; } if (!snd_usb_validate_audio_desc(p1, protocol)) { usb_audio_dbg(state->chip, "invalid unit %d\n", unitid); return 0; /* skip invalid unit */ } switch (PTYPE(protocol, p1[2])) { case PTYPE(UAC_VERSION_1, UAC_INPUT_TERMINAL): case PTYPE(UAC_VERSION_2, UAC_INPUT_TERMINAL): case PTYPE(UAC_VERSION_3, UAC_INPUT_TERMINAL): return parse_audio_input_terminal(state, unitid, p1); case PTYPE(UAC_VERSION_1, UAC_MIXER_UNIT): case PTYPE(UAC_VERSION_2, UAC_MIXER_UNIT): case PTYPE(UAC_VERSION_3, UAC3_MIXER_UNIT): return parse_audio_mixer_unit(state, unitid, p1); case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SOURCE): case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SOURCE): return parse_clock_source_unit(state, unitid, p1); case PTYPE(UAC_VERSION_1, UAC_SELECTOR_UNIT): case PTYPE(UAC_VERSION_2, UAC_SELECTOR_UNIT): case PTYPE(UAC_VERSION_3, UAC3_SELECTOR_UNIT): case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SELECTOR): case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SELECTOR): return parse_audio_selector_unit(state, unitid, p1); case PTYPE(UAC_VERSION_1, UAC_FEATURE_UNIT): case PTYPE(UAC_VERSION_2, UAC_FEATURE_UNIT): case PTYPE(UAC_VERSION_3, UAC3_FEATURE_UNIT): return parse_audio_feature_unit(state, unitid, p1); case PTYPE(UAC_VERSION_1, UAC1_PROCESSING_UNIT): case PTYPE(UAC_VERSION_2, UAC2_PROCESSING_UNIT_V2): case PTYPE(UAC_VERSION_3, UAC3_PROCESSING_UNIT): return parse_audio_processing_unit(state, unitid, p1); case PTYPE(UAC_VERSION_1, UAC1_EXTENSION_UNIT): case PTYPE(UAC_VERSION_2, UAC2_EXTENSION_UNIT_V2): case PTYPE(UAC_VERSION_3, UAC3_EXTENSION_UNIT): return parse_audio_extension_unit(state, unitid, p1); case PTYPE(UAC_VERSION_2, UAC2_EFFECT_UNIT): case PTYPE(UAC_VERSION_3, UAC3_EFFECT_UNIT): return 0; /* FIXME - effect units not implemented yet */ default: usb_audio_err(state->chip, "unit %u: unexpected type 0x%02x\n", unitid, p1[2]); return -EINVAL; } } static void snd_usb_mixer_free(struct usb_mixer_interface *mixer) { /* kill pending URBs */ snd_usb_mixer_disconnect(mixer); kfree(mixer->id_elems); if (mixer->urb) { kfree(mixer->urb->transfer_buffer); usb_free_urb(mixer->urb); } usb_free_urb(mixer->rc_urb); kfree(mixer->rc_setup_packet); kfree(mixer); } static int snd_usb_mixer_dev_free(struct snd_device *device) { struct usb_mixer_interface *mixer = device->device_data; snd_usb_mixer_free(mixer); return 0; } /* UAC3 predefined channels configuration */ struct uac3_badd_profile { int subclass; const char *name; int c_chmask; /* capture channels mask */ int p_chmask; /* playback channels mask */ int st_chmask; /* side tone mixing channel mask */ }; static const struct uac3_badd_profile uac3_badd_profiles[] = { { /* * BAIF, BAOF or combination of both * IN: Mono or Stereo cfg, Mono alt possible * OUT: Mono or Stereo cfg, Mono alt possible */ .subclass = UAC3_FUNCTION_SUBCLASS_GENERIC_IO, .name = "GENERIC IO", .c_chmask = -1, /* dynamic channels */ .p_chmask = -1, /* dynamic channels */ }, { /* BAOF; Stereo only cfg, Mono alt possible */ .subclass = UAC3_FUNCTION_SUBCLASS_HEADPHONE, .name = "HEADPHONE", .p_chmask = 3, }, { /* BAOF; Mono or Stereo cfg, Mono alt possible */ .subclass = UAC3_FUNCTION_SUBCLASS_SPEAKER, .name = "SPEAKER", .p_chmask = -1, /* dynamic channels */ }, { /* BAIF; Mono or Stereo cfg, Mono alt possible */ .subclass = UAC3_FUNCTION_SUBCLASS_MICROPHONE, .name = "MICROPHONE", .c_chmask = -1, /* dynamic channels */ }, { /* * BAIOF topology * IN: Mono only * OUT: Mono or Stereo cfg, Mono alt possible */ .subclass = UAC3_FUNCTION_SUBCLASS_HEADSET, .name = "HEADSET", .c_chmask = 1, .p_chmask = -1, /* dynamic channels */ .st_chmask = 1, }, { /* BAIOF; IN: Mono only; OUT: Stereo only, Mono alt possible */ .subclass = UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER, .name = "HEADSET ADAPTER", .c_chmask = 1, .p_chmask = 3, .st_chmask = 1, }, { /* BAIF + BAOF; IN: Mono only; OUT: Mono only */ .subclass = UAC3_FUNCTION_SUBCLASS_SPEAKERPHONE, .name = "SPEAKERPHONE", .c_chmask = 1, .p_chmask = 1, }, { 0 } /* terminator */ }; static bool uac3_badd_func_has_valid_channels(struct usb_mixer_interface *mixer, const struct uac3_badd_profile *f, int c_chmask, int p_chmask) { /* * If both playback/capture channels are dynamic, make sure * at least one channel is present */ if (f->c_chmask < 0 && f->p_chmask < 0) { if (!c_chmask && !p_chmask) { usb_audio_warn(mixer->chip, "BAAD %s: no channels?", f->name); return false; } return true; } if ((f->c_chmask < 0 && !c_chmask) || (f->c_chmask >= 0 && f->c_chmask != c_chmask)) { usb_audio_warn(mixer->chip, "BAAD %s c_chmask mismatch", f->name); return false; } if ((f->p_chmask < 0 && !p_chmask) || (f->p_chmask >= 0 && f->p_chmask != p_chmask)) { usb_audio_warn(mixer->chip, "BAAD %s p_chmask mismatch", f->name); return false; } return true; } /* * create mixer controls for UAC3 BADD profiles * * UAC3 BADD device doesn't contain CS descriptors thus we will guess everything * * BADD device may contain Mixer Unit, which doesn't have any controls, skip it */ static int snd_usb_mixer_controls_badd(struct usb_mixer_interface *mixer, int ctrlif) { struct usb_device *dev = mixer->chip->dev; struct usb_interface_assoc_descriptor *assoc; int badd_profile = mixer->chip->badd_profile; const struct uac3_badd_profile *f; const struct usbmix_ctl_map *map; int p_chmask = 0, c_chmask = 0, st_chmask = 0; int i; assoc = usb_ifnum_to_if(dev, ctrlif)->intf_assoc; /* Detect BADD capture/playback channels from AS EP descriptors */ for (i = 0; i < assoc->bInterfaceCount; i++) { int intf = assoc->bFirstInterface + i; struct usb_interface *iface; struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; unsigned int maxpacksize; char dir_in; int chmask, num; if (intf == ctrlif) continue; iface = usb_ifnum_to_if(dev, intf); if (!iface) continue; num = iface->num_altsetting; if (num < 2) return -EINVAL; /* * The number of Channels in an AudioStreaming interface * and the audio sample bit resolution (16 bits or 24 * bits) can be derived from the wMaxPacketSize field in * the Standard AS Audio Data Endpoint descriptor in * Alternate Setting 1 */ alts = &iface->altsetting[1]; altsd = get_iface_desc(alts); if (altsd->bNumEndpoints < 1) return -EINVAL; /* check direction */ dir_in = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN); maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); switch (maxpacksize) { default: usb_audio_err(mixer->chip, "incorrect wMaxPacketSize 0x%x for BADD profile\n", maxpacksize); return -EINVAL; case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16: case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16: case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24: case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24: chmask = 1; break; case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16: case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16: case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24: case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24: chmask = 3; break; } if (dir_in) c_chmask = chmask; else p_chmask = chmask; } usb_audio_dbg(mixer->chip, "UAC3 BADD profile 0x%x: detected c_chmask=%d p_chmask=%d\n", badd_profile, c_chmask, p_chmask); /* check the mapping table */ for (map = uac3_badd_usbmix_ctl_maps; map->id; map++) { if (map->id == badd_profile) break; } if (!map->id) return -EINVAL; for (f = uac3_badd_profiles; f->name; f++) { if (badd_profile == f->subclass) break; } if (!f->name) return -EINVAL; if (!uac3_badd_func_has_valid_channels(mixer, f, c_chmask, p_chmask)) return -EINVAL; st_chmask = f->st_chmask; /* Playback */ if (p_chmask) { /* Master channel, always writable */ build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE, UAC3_BADD_FU_ID2, map->map); /* Mono/Stereo volume channels, always writable */ build_feature_ctl_badd(mixer, p_chmask, UAC_FU_VOLUME, UAC3_BADD_FU_ID2, map->map); } /* Capture */ if (c_chmask) { /* Master channel, always writable */ build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE, UAC3_BADD_FU_ID5, map->map); /* Mono/Stereo volume channels, always writable */ build_feature_ctl_badd(mixer, c_chmask, UAC_FU_VOLUME, UAC3_BADD_FU_ID5, map->map); } /* Side tone-mixing */ if (st_chmask) { /* Master channel, always writable */ build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE, UAC3_BADD_FU_ID7, map->map); /* Mono volume channel, always writable */ build_feature_ctl_badd(mixer, 1, UAC_FU_VOLUME, UAC3_BADD_FU_ID7, map->map); } /* Insertion Control */ if (f->subclass == UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER) { struct usb_audio_term iterm, oterm; /* Input Term - Insertion control */ memset(&iterm, 0, sizeof(iterm)); iterm.id = UAC3_BADD_IT_ID4; iterm.type = UAC_BIDIR_TERMINAL_HEADSET; build_connector_control(mixer, map->map, &iterm, true); /* Output Term - Insertion control */ memset(&oterm, 0, sizeof(oterm)); oterm.id = UAC3_BADD_OT_ID3; oterm.type = UAC_BIDIR_TERMINAL_HEADSET; build_connector_control(mixer, map->map, &oterm, false); } return 0; } /* * create mixer controls * * walk through all UAC_OUTPUT_TERMINAL descriptors to search for mixers */ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer) { struct mixer_build state; int err; const struct usbmix_ctl_map *map; void *p; memset(&state, 0, sizeof(state)); state.chip = mixer->chip; state.mixer = mixer; state.buffer = mixer->hostif->extra; state.buflen = mixer->hostif->extralen; /* check the mapping table */ for (map = usbmix_ctl_maps; map->id; map++) { if (map->id == state.chip->usb_id) { state.map = map->map; state.selector_map = map->selector_map; mixer->connector_map = map->connector_map; break; } } p = NULL; while ((p = snd_usb_find_csint_desc(mixer->hostif->extra, mixer->hostif->extralen, p, UAC_OUTPUT_TERMINAL)) != NULL) { if (!snd_usb_validate_audio_desc(p, mixer->protocol)) continue; /* skip invalid descriptor */ if (mixer->protocol == UAC_VERSION_1) { struct uac1_output_terminal_descriptor *desc = p; /* mark terminal ID as visited */ set_bit(desc->bTerminalID, state.unitbitmap); state.oterm.id = desc->bTerminalID; state.oterm.type = le16_to_cpu(desc->wTerminalType); state.oterm.name = desc->iTerminal; err = parse_audio_unit(&state, desc->bSourceID); if (err < 0 && err != -EINVAL) return err; } else if (mixer->protocol == UAC_VERSION_2) { struct uac2_output_terminal_descriptor *desc = p; /* mark terminal ID as visited */ set_bit(desc->bTerminalID, state.unitbitmap); state.oterm.id = desc->bTerminalID; state.oterm.type = le16_to_cpu(desc->wTerminalType); state.oterm.name = desc->iTerminal; err = parse_audio_unit(&state, desc->bSourceID); if (err < 0 && err != -EINVAL) return err; /* * For UAC2, use the same approach to also add the * clock selectors */ err = parse_audio_unit(&state, desc->bCSourceID); if (err < 0 && err != -EINVAL) return err; if ((state.oterm.type & 0xff00) != 0x0100 && uac_v2v3_control_is_readable(le16_to_cpu(desc->bmControls), UAC2_TE_CONNECTOR)) { build_connector_control(state.mixer, state.map, &state.oterm, false); } } else { /* UAC_VERSION_3 */ struct uac3_output_terminal_descriptor *desc = p; /* mark terminal ID as visited */ set_bit(desc->bTerminalID, state.unitbitmap); state.oterm.id = desc->bTerminalID; state.oterm.type = le16_to_cpu(desc->wTerminalType); state.oterm.name = le16_to_cpu(desc->wTerminalDescrStr); err = parse_audio_unit(&state, desc->bSourceID); if (err < 0 && err != -EINVAL) return err; /* * For UAC3, use the same approach to also add the * clock selectors */ err = parse_audio_unit(&state, desc->bCSourceID); if (err < 0 && err != -EINVAL) return err; if ((state.oterm.type & 0xff00) != 0x0100 && uac_v2v3_control_is_readable(le32_to_cpu(desc->bmControls), UAC3_TE_INSERTION)) { build_connector_control(state.mixer, state.map, &state.oterm, false); } } } return 0; } static int delegate_notify(struct usb_mixer_interface *mixer, int unitid, u8 *control, u8 *channel) { const struct usbmix_connector_map *map = mixer->connector_map; if (!map) return unitid; for (; map->id; map++) { if (map->id == unitid) { if (control && map->control) *control = map->control; if (channel && map->channel) *channel = map->channel; return map->delegated_id; } } return unitid; } void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid) { struct usb_mixer_elem_list *list; unitid = delegate_notify(mixer, unitid, NULL, NULL); for_each_mixer_elem(list, mixer, unitid) { struct usb_mixer_elem_info *info; if (!list->is_std_info) continue; info = mixer_elem_list_to_info(list); /* invalidate cache, so the value is read from the device */ info->cached = 0; snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &list->kctl->id); } } static void snd_usb_mixer_dump_cval(struct snd_info_buffer *buffer, struct usb_mixer_elem_list *list) { struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list); static const char * const val_types[] = { [USB_MIXER_BOOLEAN] = "BOOLEAN", [USB_MIXER_INV_BOOLEAN] = "INV_BOOLEAN", [USB_MIXER_S8] = "S8", [USB_MIXER_U8] = "U8", [USB_MIXER_S16] = "S16", [USB_MIXER_U16] = "U16", [USB_MIXER_S32] = "S32", [USB_MIXER_U32] = "U32", [USB_MIXER_BESPOKEN] = "BESPOKEN", }; snd_iprintf(buffer, " Info: id=%i, control=%i, cmask=0x%x, " "channels=%i, type=\"%s\"\n", cval->head.id, cval->control, cval->cmask, cval->channels, val_types[cval->val_type]); snd_iprintf(buffer, " Volume: min=%i, max=%i, dBmin=%i, dBmax=%i\n", cval->min, cval->max, cval->dBmin, cval->dBmax); } static void snd_usb_mixer_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_usb_audio *chip = entry->private_data; struct usb_mixer_interface *mixer; struct usb_mixer_elem_list *list; int unitid; list_for_each_entry(mixer, &chip->mixer_list, list) { snd_iprintf(buffer, "USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n", chip->usb_id, mixer_ctrl_intf(mixer), mixer->ignore_ctl_error); snd_iprintf(buffer, "Card: %s\n", chip->card->longname); for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) { for_each_mixer_elem(list, mixer, unitid) { snd_iprintf(buffer, " Unit: %i\n", list->id); if (list->kctl) snd_iprintf(buffer, " Control: name=\"%s\", index=%i\n", list->kctl->id.name, list->kctl->id.index); if (list->dump) list->dump(buffer, list); } } } } static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer, int attribute, int value, int index) { struct usb_mixer_elem_list *list; __u8 unitid = (index >> 8) & 0xff; __u8 control = (value >> 8) & 0xff; __u8 channel = value & 0xff; unsigned int count = 0; if (channel >= MAX_CHANNELS) { usb_audio_dbg(mixer->chip, "%s(): bogus channel number %d\n", __func__, channel); return; } unitid = delegate_notify(mixer, unitid, &control, &channel); for_each_mixer_elem(list, mixer, unitid) count++; if (count == 0) return; for_each_mixer_elem(list, mixer, unitid) { struct usb_mixer_elem_info *info; if (!list->kctl) continue; if (!list->is_std_info) continue; info = mixer_elem_list_to_info(list); if (count > 1 && info->control != control) continue; switch (attribute) { case UAC2_CS_CUR: /* invalidate cache, so the value is read from the device */ if (channel) info->cached &= ~(1 << channel); else /* master channel */ info->cached = 0; snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &info->head.kctl->id); break; case UAC2_CS_RANGE: /* TODO */ break; case UAC2_CS_MEM: /* TODO */ break; default: usb_audio_dbg(mixer->chip, "unknown attribute %d in interrupt\n", attribute); break; } /* switch */ } } static void snd_usb_mixer_interrupt(struct urb *urb) { struct usb_mixer_interface *mixer = urb->context; int len = urb->actual_length; int ustatus = urb->status; if (ustatus != 0) goto requeue; if (mixer->protocol == UAC_VERSION_1) { struct uac1_status_word *status; for (status = urb->transfer_buffer; len >= sizeof(*status); len -= sizeof(*status), status++) { dev_dbg(&urb->dev->dev, "status interrupt: %02x %02x\n", status->bStatusType, status->bOriginator); /* ignore any notifications not from the control interface */ if ((status->bStatusType & UAC1_STATUS_TYPE_ORIG_MASK) != UAC1_STATUS_TYPE_ORIG_AUDIO_CONTROL_IF) continue; if (status->bStatusType & UAC1_STATUS_TYPE_MEM_CHANGED) snd_usb_mixer_rc_memory_change(mixer, status->bOriginator); else snd_usb_mixer_notify_id(mixer, status->bOriginator); } } else { /* UAC_VERSION_2 */ struct uac2_interrupt_data_msg *msg; for (msg = urb->transfer_buffer; len >= sizeof(*msg); len -= sizeof(*msg), msg++) { /* drop vendor specific and endpoint requests */ if ((msg->bInfo & UAC2_INTERRUPT_DATA_MSG_VENDOR) || (msg->bInfo & UAC2_INTERRUPT_DATA_MSG_EP)) continue; snd_usb_mixer_interrupt_v2(mixer, msg->bAttribute, le16_to_cpu(msg->wValue), le16_to_cpu(msg->wIndex)); } } requeue: if (ustatus != -ENOENT && ustatus != -ECONNRESET && ustatus != -ESHUTDOWN) { urb->dev = mixer->chip->dev; usb_submit_urb(urb, GFP_ATOMIC); } } /* create the handler for the optional status interrupt endpoint */ static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer) { struct usb_endpoint_descriptor *ep; void *transfer_buffer; int buffer_length; unsigned int epnum; /* we need one interrupt input endpoint */ if (get_iface_desc(mixer->hostif)->bNumEndpoints < 1) return 0; ep = get_endpoint(mixer->hostif, 0); if (!usb_endpoint_dir_in(ep) || !usb_endpoint_xfer_int(ep)) return 0; epnum = usb_endpoint_num(ep); buffer_length = le16_to_cpu(ep->wMaxPacketSize); transfer_buffer = kmalloc(buffer_length, GFP_KERNEL); if (!transfer_buffer) return -ENOMEM; mixer->urb = usb_alloc_urb(0, GFP_KERNEL); if (!mixer->urb) { kfree(transfer_buffer); return -ENOMEM; } usb_fill_int_urb(mixer->urb, mixer->chip->dev, usb_rcvintpipe(mixer->chip->dev, epnum), transfer_buffer, buffer_length, snd_usb_mixer_interrupt, mixer, ep->bInterval); usb_submit_urb(mixer->urb, GFP_KERNEL); return 0; } int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif) { static const struct snd_device_ops dev_ops = { .dev_free = snd_usb_mixer_dev_free }; struct usb_mixer_interface *mixer; int err; strcpy(chip->card->mixername, "USB Mixer"); mixer = kzalloc(sizeof(*mixer), GFP_KERNEL); if (!mixer) return -ENOMEM; mixer->chip = chip; mixer->ignore_ctl_error = !!(chip->quirk_flags & QUIRK_FLAG_IGNORE_CTL_ERROR); mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems), GFP_KERNEL); if (!mixer->id_elems) { kfree(mixer); return -ENOMEM; } mixer->hostif = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0]; switch (get_iface_desc(mixer->hostif)->bInterfaceProtocol) { case UAC_VERSION_1: default: mixer->protocol = UAC_VERSION_1; break; case UAC_VERSION_2: mixer->protocol = UAC_VERSION_2; break; case UAC_VERSION_3: mixer->protocol = UAC_VERSION_3; break; } if (mixer->protocol == UAC_VERSION_3 && chip->badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { err = snd_usb_mixer_controls_badd(mixer, ctrlif); if (err < 0) goto _error; } else { err = snd_usb_mixer_controls(mixer); if (err < 0) goto _error; } err = snd_usb_mixer_status_create(mixer); if (err < 0) goto _error; err = snd_usb_mixer_apply_create_quirk(mixer); if (err < 0) goto _error; err = snd_device_new(chip->card, SNDRV_DEV_CODEC, mixer, &dev_ops); if (err < 0) goto _error; if (list_empty(&chip->mixer_list)) snd_card_ro_proc_new(chip->card, "usbmixer", chip, snd_usb_mixer_proc_read); list_add(&mixer->list, &chip->mixer_list); return 0; _error: snd_usb_mixer_free(mixer); return err; } void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer) { if (mixer->disconnected) return; if (mixer->urb) usb_kill_urb(mixer->urb); if (mixer->rc_urb) usb_kill_urb(mixer->rc_urb); if (mixer->private_free) mixer->private_free(mixer); mixer->disconnected = true; } /* stop any bus activity of a mixer */ static void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer) { usb_kill_urb(mixer->urb); usb_kill_urb(mixer->rc_urb); } static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer) { int err; if (mixer->urb) { err = usb_submit_urb(mixer->urb, GFP_NOIO); if (err < 0) return err; } return 0; } int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer) { snd_usb_mixer_inactivate(mixer); if (mixer->private_suspend) mixer->private_suspend(mixer); return 0; } static int restore_mixer_value(struct usb_mixer_elem_list *list) { struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list); int c, err, idx; if (cval->val_type == USB_MIXER_BESPOKEN) return 0; if (cval->cmask) { idx = 0; for (c = 0; c < MAX_CHANNELS; c++) { if (!(cval->cmask & (1 << c))) continue; if (cval->cached & (1 << (c + 1))) { err = snd_usb_set_cur_mix_value(cval, c + 1, idx, cval->cache_val[idx]); if (err < 0) break; } idx++; } } else { /* master */ if (cval->cached) snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val); } return 0; } int snd_usb_mixer_resume(struct usb_mixer_interface *mixer) { struct usb_mixer_elem_list *list; int id, err; /* restore cached mixer values */ for (id = 0; id < MAX_ID_ELEMS; id++) { for_each_mixer_elem(list, mixer, id) { if (list->resume) { err = list->resume(list); if (err < 0) return err; } } } snd_usb_mixer_resume_quirk(mixer); return snd_usb_mixer_activate(mixer); } void snd_usb_mixer_elem_init_std(struct usb_mixer_elem_list *list, struct usb_mixer_interface *mixer, int unitid) { list->mixer = mixer; list->id = unitid; list->dump = snd_usb_mixer_dump_cval; list->resume = restore_mixer_value; }
linux-master
sound/usb/mixer.c
// SPDX-License-Identifier: GPL-2.0-or-later // // Validation of USB-audio class descriptors // #include <linux/init.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <linux/usb/audio-v3.h> #include <linux/usb/midi.h> #include "usbaudio.h" #include "helper.h" struct usb_desc_validator { unsigned char protocol; unsigned char type; bool (*func)(const void *p, const struct usb_desc_validator *v); size_t size; }; #define UAC_VERSION_ALL (unsigned char)(-1) /* UAC1 only */ static bool validate_uac1_header(const void *p, const struct usb_desc_validator *v) { const struct uac1_ac_header_descriptor *d = p; return d->bLength >= sizeof(*d) && d->bLength >= sizeof(*d) + d->bInCollection; } /* for mixer unit; covering all UACs */ static bool validate_mixer_unit(const void *p, const struct usb_desc_validator *v) { const struct uac_mixer_unit_descriptor *d = p; size_t len; if (d->bLength < sizeof(*d) || !d->bNrInPins) return false; len = sizeof(*d) + d->bNrInPins; /* We can't determine the bitmap size only from this unit descriptor, * so just check with the remaining length. * The actual bitmap is checked at mixer unit parser. */ switch (v->protocol) { case UAC_VERSION_1: default: len += 2 + 1; /* wChannelConfig, iChannelNames */ /* bmControls[n*m] */ len += 1; /* iMixer */ break; case UAC_VERSION_2: len += 4 + 1; /* bmChannelConfig, iChannelNames */ /* bmMixerControls[n*m] */ len += 1 + 1; /* bmControls, iMixer */ break; case UAC_VERSION_3: len += 2; /* wClusterDescrID */ /* bmMixerControls[n*m] */ break; } return d->bLength >= len; } /* both for processing and extension units; covering all UACs */ static bool validate_processing_unit(const void *p, const struct usb_desc_validator *v) { const struct uac_processing_unit_descriptor *d = p; const unsigned char *hdr = p; size_t len, m; if (d->bLength < sizeof(*d)) return false; len = sizeof(*d) + d->bNrInPins; if (d->bLength < len) return false; switch (v->protocol) { case UAC_VERSION_1: default: /* bNrChannels, wChannelConfig, iChannelNames */ len += 1 + 2 + 1; if (d->bLength < len + 1) /* bControlSize */ return false; m = hdr[len]; len += 1 + m + 1; /* bControlSize, bmControls, iProcessing */ break; case UAC_VERSION_2: /* bNrChannels, bmChannelConfig, iChannelNames */ len += 1 + 4 + 1; if (v->type == UAC2_PROCESSING_UNIT_V2) len += 2; /* bmControls -- 2 bytes for PU */ else len += 1; /* bmControls -- 1 byte for EU */ len += 1; /* iProcessing */ break; case UAC_VERSION_3: /* wProcessingDescrStr, bmControls */ len += 2 + 4; break; } if (d->bLength < len) return false; switch (v->protocol) { case UAC_VERSION_1: default: if (v->type == UAC1_EXTENSION_UNIT) return true; /* OK */ switch (le16_to_cpu(d->wProcessType)) { case UAC_PROCESS_UP_DOWNMIX: case UAC_PROCESS_DOLBY_PROLOGIC: if (d->bLength < len + 1) /* bNrModes */ return false; m = hdr[len]; len += 1 + m * 2; /* bNrModes, waModes(n) */ break; default: break; } break; case UAC_VERSION_2: if (v->type == UAC2_EXTENSION_UNIT_V2) return true; /* OK */ switch (le16_to_cpu(d->wProcessType)) { case UAC2_PROCESS_UP_DOWNMIX: case UAC2_PROCESS_DOLBY_PROLOCIC: /* SiC! */ if (d->bLength < len + 1) /* bNrModes */ return false; m = hdr[len]; len += 1 + m * 4; /* bNrModes, daModes(n) */ break; default: break; } break; case UAC_VERSION_3: if (v->type == UAC3_EXTENSION_UNIT) { len += 2; /* wClusterDescrID */ break; } switch (le16_to_cpu(d->wProcessType)) { case UAC3_PROCESS_UP_DOWNMIX: if (d->bLength < len + 1) /* bNrModes */ return false; m = hdr[len]; len += 1 + m * 2; /* bNrModes, waClusterDescrID(n) */ break; case UAC3_PROCESS_MULTI_FUNCTION: len += 2 + 4; /* wClusterDescrID, bmAlgorighms */ break; default: break; } break; } if (d->bLength < len) return false; return true; } /* both for selector and clock selector units; covering all UACs */ static bool validate_selector_unit(const void *p, const struct usb_desc_validator *v) { const struct uac_selector_unit_descriptor *d = p; size_t len; if (d->bLength < sizeof(*d)) return false; len = sizeof(*d) + d->bNrInPins; switch (v->protocol) { case UAC_VERSION_1: default: len += 1; /* iSelector */ break; case UAC_VERSION_2: len += 1 + 1; /* bmControls, iSelector */ break; case UAC_VERSION_3: len += 4 + 2; /* bmControls, wSelectorDescrStr */ break; } return d->bLength >= len; } static bool validate_uac1_feature_unit(const void *p, const struct usb_desc_validator *v) { const struct uac_feature_unit_descriptor *d = p; if (d->bLength < sizeof(*d) || !d->bControlSize) return false; /* at least bmaControls(0) for master channel + iFeature */ return d->bLength >= sizeof(*d) + d->bControlSize + 1; } static bool validate_uac2_feature_unit(const void *p, const struct usb_desc_validator *v) { const struct uac2_feature_unit_descriptor *d = p; if (d->bLength < sizeof(*d)) return false; /* at least bmaControls(0) for master channel + iFeature */ return d->bLength >= sizeof(*d) + 4 + 1; } static bool validate_uac3_feature_unit(const void *p, const struct usb_desc_validator *v) { const struct uac3_feature_unit_descriptor *d = p; if (d->bLength < sizeof(*d)) return false; /* at least bmaControls(0) for master channel + wFeatureDescrStr */ return d->bLength >= sizeof(*d) + 4 + 2; } static bool validate_midi_out_jack(const void *p, const struct usb_desc_validator *v) { const struct usb_midi_out_jack_descriptor *d = p; return d->bLength >= sizeof(*d) && d->bLength >= sizeof(*d) + d->bNrInputPins * 2; } #define FIXED(p, t, s) { .protocol = (p), .type = (t), .size = sizeof(s) } #define FUNC(p, t, f) { .protocol = (p), .type = (t), .func = (f) } static const struct usb_desc_validator audio_validators[] = { /* UAC1 */ FUNC(UAC_VERSION_1, UAC_HEADER, validate_uac1_header), FIXED(UAC_VERSION_1, UAC_INPUT_TERMINAL, struct uac_input_terminal_descriptor), FIXED(UAC_VERSION_1, UAC_OUTPUT_TERMINAL, struct uac1_output_terminal_descriptor), FUNC(UAC_VERSION_1, UAC_MIXER_UNIT, validate_mixer_unit), FUNC(UAC_VERSION_1, UAC_SELECTOR_UNIT, validate_selector_unit), FUNC(UAC_VERSION_1, UAC_FEATURE_UNIT, validate_uac1_feature_unit), FUNC(UAC_VERSION_1, UAC1_PROCESSING_UNIT, validate_processing_unit), FUNC(UAC_VERSION_1, UAC1_EXTENSION_UNIT, validate_processing_unit), /* UAC2 */ FIXED(UAC_VERSION_2, UAC_HEADER, struct uac2_ac_header_descriptor), FIXED(UAC_VERSION_2, UAC_INPUT_TERMINAL, struct uac2_input_terminal_descriptor), FIXED(UAC_VERSION_2, UAC_OUTPUT_TERMINAL, struct uac2_output_terminal_descriptor), FUNC(UAC_VERSION_2, UAC_MIXER_UNIT, validate_mixer_unit), FUNC(UAC_VERSION_2, UAC_SELECTOR_UNIT, validate_selector_unit), FUNC(UAC_VERSION_2, UAC_FEATURE_UNIT, validate_uac2_feature_unit), /* UAC_VERSION_2, UAC2_EFFECT_UNIT: not implemented yet */ FUNC(UAC_VERSION_2, UAC2_PROCESSING_UNIT_V2, validate_processing_unit), FUNC(UAC_VERSION_2, UAC2_EXTENSION_UNIT_V2, validate_processing_unit), FIXED(UAC_VERSION_2, UAC2_CLOCK_SOURCE, struct uac_clock_source_descriptor), FUNC(UAC_VERSION_2, UAC2_CLOCK_SELECTOR, validate_selector_unit), FIXED(UAC_VERSION_2, UAC2_CLOCK_MULTIPLIER, struct uac_clock_multiplier_descriptor), /* UAC_VERSION_2, UAC2_SAMPLE_RATE_CONVERTER: not implemented yet */ /* UAC3 */ FIXED(UAC_VERSION_2, UAC_HEADER, struct uac3_ac_header_descriptor), FIXED(UAC_VERSION_3, UAC_INPUT_TERMINAL, struct uac3_input_terminal_descriptor), FIXED(UAC_VERSION_3, UAC_OUTPUT_TERMINAL, struct uac3_output_terminal_descriptor), /* UAC_VERSION_3, UAC3_EXTENDED_TERMINAL: not implemented yet */ FUNC(UAC_VERSION_3, UAC3_MIXER_UNIT, validate_mixer_unit), FUNC(UAC_VERSION_3, UAC3_SELECTOR_UNIT, validate_selector_unit), FUNC(UAC_VERSION_3, UAC_FEATURE_UNIT, validate_uac3_feature_unit), /* UAC_VERSION_3, UAC3_EFFECT_UNIT: not implemented yet */ FUNC(UAC_VERSION_3, UAC3_PROCESSING_UNIT, validate_processing_unit), FUNC(UAC_VERSION_3, UAC3_EXTENSION_UNIT, validate_processing_unit), FIXED(UAC_VERSION_3, UAC3_CLOCK_SOURCE, struct uac3_clock_source_descriptor), FUNC(UAC_VERSION_3, UAC3_CLOCK_SELECTOR, validate_selector_unit), FIXED(UAC_VERSION_3, UAC3_CLOCK_MULTIPLIER, struct uac3_clock_multiplier_descriptor), /* UAC_VERSION_3, UAC3_SAMPLE_RATE_CONVERTER: not implemented yet */ /* UAC_VERSION_3, UAC3_CONNECTORS: not implemented yet */ { } /* terminator */ }; static const struct usb_desc_validator midi_validators[] = { FIXED(UAC_VERSION_ALL, USB_MS_HEADER, struct usb_ms_header_descriptor), FIXED(UAC_VERSION_ALL, USB_MS_MIDI_IN_JACK, struct usb_midi_in_jack_descriptor), FUNC(UAC_VERSION_ALL, USB_MS_MIDI_OUT_JACK, validate_midi_out_jack), { } /* terminator */ }; /* Validate the given unit descriptor, return true if it's OK */ static bool validate_desc(unsigned char *hdr, int protocol, const struct usb_desc_validator *v) { if (hdr[1] != USB_DT_CS_INTERFACE) return true; /* don't care */ for (; v->type; v++) { if (v->type == hdr[2] && (v->protocol == UAC_VERSION_ALL || v->protocol == protocol)) { if (v->func) return v->func(hdr, v); /* check for the fixed size */ return hdr[0] >= v->size; } } return true; /* not matching, skip validation */ } bool snd_usb_validate_audio_desc(void *p, int protocol) { unsigned char *c = p; bool valid; valid = validate_desc(p, protocol, audio_validators); if (!valid && snd_usb_skip_validation) { print_hex_dump(KERN_ERR, "USB-audio: buggy audio desc: ", DUMP_PREFIX_NONE, 16, 1, c, c[0], true); valid = true; } return valid; } bool snd_usb_validate_midi_desc(void *p) { unsigned char *c = p; bool valid; valid = validate_desc(p, UAC_VERSION_1, midi_validators); if (!valid && snd_usb_skip_validation) { print_hex_dump(KERN_ERR, "USB-audio: buggy midi desc: ", DUMP_PREFIX_NONE, 16, 1, c, c[0], true); valid = true; } return valid; }
linux-master
sound/usb/validate.c
// SPDX-License-Identifier: GPL-2.0-or-later /* */ #include <linux/init.h> #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <linux/usb/audio-v3.h> #include <sound/core.h> #include <sound/pcm.h> #include "usbaudio.h" #include "card.h" #include "quirks.h" #include "helper.h" #include "clock.h" #include "format.h" /* * parse the audio format type I descriptor * and returns the corresponding pcm format * * @dev: usb device * @fp: audioformat record * @format: the format tag (wFormatTag) * @fmt: the format type descriptor (v1/v2) or AudioStreaming descriptor (v3) */ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp, u64 format, void *_fmt) { int sample_width, sample_bytes; u64 pcm_formats = 0; switch (fp->protocol) { case UAC_VERSION_1: default: { struct uac_format_type_i_discrete_descriptor *fmt = _fmt; if (format >= 64) { usb_audio_info(chip, "%u:%d: invalid format type 0x%llx is detected, processed as PCM\n", fp->iface, fp->altsetting, format); format = UAC_FORMAT_TYPE_I_PCM; } sample_width = fmt->bBitResolution; sample_bytes = fmt->bSubframeSize; format = 1ULL << format; break; } case UAC_VERSION_2: { struct uac_format_type_i_ext_descriptor *fmt = _fmt; sample_width = fmt->bBitResolution; sample_bytes = fmt->bSubslotSize; if (format & UAC2_FORMAT_TYPE_I_RAW_DATA) { pcm_formats |= SNDRV_PCM_FMTBIT_SPECIAL; /* flag potentially raw DSD capable altsettings */ fp->dsd_raw = true; } format <<= 1; break; } case UAC_VERSION_3: { struct uac3_as_header_descriptor *as = _fmt; sample_width = as->bBitResolution; sample_bytes = as->bSubslotSize; if (format & UAC3_FORMAT_TYPE_I_RAW_DATA) pcm_formats |= SNDRV_PCM_FMTBIT_SPECIAL; format <<= 1; break; } } fp->fmt_bits = sample_width; if ((pcm_formats == 0) && (format == 0 || format == (1 << UAC_FORMAT_TYPE_I_UNDEFINED))) { /* some devices don't define this correctly... */ usb_audio_info(chip, "%u:%d : format type 0 is detected, processed as PCM\n", fp->iface, fp->altsetting); format = 1 << UAC_FORMAT_TYPE_I_PCM; } if (format & (1 << UAC_FORMAT_TYPE_I_PCM)) { if (((chip->usb_id == USB_ID(0x0582, 0x0016)) || /* Edirol SD-90 */ (chip->usb_id == USB_ID(0x0582, 0x000c))) && /* Roland SC-D70 */ sample_width == 24 && sample_bytes == 2) sample_bytes = 3; else if (sample_width > sample_bytes * 8) { usb_audio_info(chip, "%u:%d : sample bitwidth %d in over sample bytes %d\n", fp->iface, fp->altsetting, sample_width, sample_bytes); } /* check the format byte size */ switch (sample_bytes) { case 1: pcm_formats |= SNDRV_PCM_FMTBIT_S8; break; case 2: if (snd_usb_is_big_endian_format(chip, fp)) pcm_formats |= SNDRV_PCM_FMTBIT_S16_BE; /* grrr, big endian!! */ else pcm_formats |= SNDRV_PCM_FMTBIT_S16_LE; break; case 3: if (snd_usb_is_big_endian_format(chip, fp)) pcm_formats |= SNDRV_PCM_FMTBIT_S24_3BE; /* grrr, big endian!! */ else pcm_formats |= SNDRV_PCM_FMTBIT_S24_3LE; break; case 4: pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE; break; default: usb_audio_info(chip, "%u:%d : unsupported sample bitwidth %d in %d bytes\n", fp->iface, fp->altsetting, sample_width, sample_bytes); break; } } if (format & (1 << UAC_FORMAT_TYPE_I_PCM8)) { /* Dallas DS4201 workaround: it advertises U8 format, but really supports S8. */ if (chip->usb_id == USB_ID(0x04fa, 0x4201)) pcm_formats |= SNDRV_PCM_FMTBIT_S8; else pcm_formats |= SNDRV_PCM_FMTBIT_U8; } if (format & (1 << UAC_FORMAT_TYPE_I_IEEE_FLOAT)) { pcm_formats |= SNDRV_PCM_FMTBIT_FLOAT_LE; } if (format & (1 << UAC_FORMAT_TYPE_I_ALAW)) { pcm_formats |= SNDRV_PCM_FMTBIT_A_LAW; } if (format & (1 << UAC_FORMAT_TYPE_I_MULAW)) { pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW; } if (format & ~0x3f) { usb_audio_info(chip, "%u:%d : unsupported format bits %#llx\n", fp->iface, fp->altsetting, format); } pcm_formats |= snd_usb_interface_dsd_format_quirks(chip, fp, sample_bytes); return pcm_formats; } static int set_fixed_rate(struct audioformat *fp, int rate, int rate_bits) { kfree(fp->rate_table); fp->rate_table = kmalloc(sizeof(int), GFP_KERNEL); if (!fp->rate_table) return -ENOMEM; fp->nr_rates = 1; fp->rate_min = rate; fp->rate_max = rate; fp->rates = rate_bits; fp->rate_table[0] = rate; return 0; } /* set up rate_min, rate_max and rates from the rate table */ static void set_rate_table_min_max(struct audioformat *fp) { unsigned int rate; int i; fp->rate_min = INT_MAX; fp->rate_max = 0; fp->rates = 0; for (i = 0; i < fp->nr_rates; i++) { rate = fp->rate_table[i]; fp->rate_min = min(fp->rate_min, rate); fp->rate_max = max(fp->rate_max, rate); fp->rates |= snd_pcm_rate_to_rate_bit(rate); } } /* * parse the format descriptor and stores the possible sample rates * on the audioformat table (audio class v1). * * @dev: usb device * @fp: audioformat record * @fmt: the format descriptor * @offset: the start offset of descriptor pointing the rate type * (7 for type I and II, 8 for type II) */ static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp, unsigned char *fmt, int offset) { int nr_rates = fmt[offset]; if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) { usb_audio_err(chip, "%u:%d : invalid UAC_FORMAT_TYPE desc\n", fp->iface, fp->altsetting); return -EINVAL; } if (nr_rates) { /* * build the rate table and bitmap flags */ int r, idx; fp->rate_table = kmalloc_array(nr_rates, sizeof(int), GFP_KERNEL); if (fp->rate_table == NULL) return -ENOMEM; fp->nr_rates = 0; for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) { unsigned int rate = combine_triple(&fmt[idx]); if (!rate) continue; /* C-Media CM6501 mislabels its 96 kHz altsetting */ /* Terratec Aureon 7.1 USB C-Media 6206, too */ /* Ozone Z90 USB C-Media, too */ if (rate == 48000 && nr_rates == 1 && (chip->usb_id == USB_ID(0x0d8c, 0x0201) || chip->usb_id == USB_ID(0x0d8c, 0x0102) || chip->usb_id == USB_ID(0x0d8c, 0x0078) || chip->usb_id == USB_ID(0x0ccd, 0x00b1)) && fp->altsetting == 5 && fp->maxpacksize == 392) rate = 96000; /* Creative VF0420/VF0470 Live Cams report 16 kHz instead of 8kHz */ if (rate == 16000 && (chip->usb_id == USB_ID(0x041e, 0x4064) || chip->usb_id == USB_ID(0x041e, 0x4068))) rate = 8000; fp->rate_table[fp->nr_rates++] = rate; } if (!fp->nr_rates) { usb_audio_info(chip, "%u:%d: All rates were zero\n", fp->iface, fp->altsetting); return -EINVAL; } set_rate_table_min_max(fp); } else { /* continuous rates */ fp->rates = SNDRV_PCM_RATE_CONTINUOUS; fp->rate_min = combine_triple(&fmt[offset + 1]); fp->rate_max = combine_triple(&fmt[offset + 4]); } /* Jabra Evolve 65 headset */ if (chip->usb_id == USB_ID(0x0b0e, 0x030b)) { /* only 48kHz for playback while keeping 16kHz for capture */ if (fp->nr_rates != 1) return set_fixed_rate(fp, 48000, SNDRV_PCM_RATE_48000); } return 0; } /* * Presonus Studio 1810c supports a limited set of sampling * rates per altsetting but reports the full set each time. * If we don't filter out the unsupported rates and attempt * to configure the card, it will hang refusing to do any * further audio I/O until a hard reset is performed. * * The list of supported rates per altsetting (set of available * I/O channels) is described in the owner's manual, section 2.2. */ static bool s1810c_valid_sample_rate(struct audioformat *fp, unsigned int rate) { switch (fp->altsetting) { case 1: /* All ADAT ports available */ return rate <= 48000; case 2: /* Half of ADAT ports available */ return (rate == 88200 || rate == 96000); case 3: /* Analog I/O only (no S/PDIF nor ADAT) */ return rate >= 176400; default: return false; } return false; } /* * Many Focusrite devices supports a limited set of sampling rates per * altsetting. Maximum rate is exposed in the last 4 bytes of Format Type * descriptor which has a non-standard bLength = 10. */ static bool focusrite_valid_sample_rate(struct snd_usb_audio *chip, struct audioformat *fp, unsigned int rate) { struct usb_interface *iface; struct usb_host_interface *alts; unsigned char *fmt; unsigned int max_rate; iface = usb_ifnum_to_if(chip->dev, fp->iface); if (!iface) return true; alts = &iface->altsetting[fp->altset_idx]; fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE); if (!fmt) return true; if (fmt[0] == 10) { /* bLength */ max_rate = combine_quad(&fmt[6]); /* Validate max rate */ if (max_rate != 48000 && max_rate != 96000 && max_rate != 192000 && max_rate != 384000) { usb_audio_info(chip, "%u:%d : unexpected max rate: %u\n", fp->iface, fp->altsetting, max_rate); return true; } return rate <= max_rate; } return true; } /* * Helper function to walk the array of sample rate triplets reported by * the device. The problem is that we need to parse whole array first to * get to know how many sample rates we have to expect. * Then fp->rate_table can be allocated and filled. */ static int parse_uac2_sample_rate_range(struct snd_usb_audio *chip, struct audioformat *fp, int nr_triplets, const unsigned char *data) { int i, nr_rates = 0; for (i = 0; i < nr_triplets; i++) { int min = combine_quad(&data[2 + 12 * i]); int max = combine_quad(&data[6 + 12 * i]); int res = combine_quad(&data[10 + 12 * i]); unsigned int rate; if ((max < 0) || (min < 0) || (res < 0) || (max < min)) continue; /* * for ranges with res == 1, we announce a continuous sample * rate range, and this function should return 0 for no further * parsing. */ if (res == 1) { fp->rate_min = min; fp->rate_max = max; fp->rates = SNDRV_PCM_RATE_CONTINUOUS; return 0; } for (rate = min; rate <= max; rate += res) { /* Filter out invalid rates on Presonus Studio 1810c */ if (chip->usb_id == USB_ID(0x194f, 0x010c) && !s1810c_valid_sample_rate(fp, rate)) goto skip_rate; /* Filter out invalid rates on Focusrite devices */ if (USB_ID_VENDOR(chip->usb_id) == 0x1235 && !focusrite_valid_sample_rate(chip, fp, rate)) goto skip_rate; if (fp->rate_table) fp->rate_table[nr_rates] = rate; nr_rates++; if (nr_rates >= MAX_NR_RATES) { usb_audio_err(chip, "invalid uac2 rates\n"); break; } skip_rate: /* avoid endless loop */ if (res == 0) break; } } return nr_rates; } /* Line6 Helix series and the Rode Rodecaster Pro don't support the * UAC2_CS_RANGE usb function call. Return a static table of known * clock rates. */ static int line6_parse_audio_format_rates_quirk(struct snd_usb_audio *chip, struct audioformat *fp) { switch (chip->usb_id) { case USB_ID(0x0e41, 0x4241): /* Line6 Helix */ case USB_ID(0x0e41, 0x4242): /* Line6 Helix Rack */ case USB_ID(0x0e41, 0x4244): /* Line6 Helix LT */ case USB_ID(0x0e41, 0x4246): /* Line6 HX-Stomp */ case USB_ID(0x0e41, 0x4253): /* Line6 HX-Stomp XL */ case USB_ID(0x0e41, 0x4247): /* Line6 Pod Go */ case USB_ID(0x0e41, 0x4248): /* Line6 Helix >= fw 2.82 */ case USB_ID(0x0e41, 0x4249): /* Line6 Helix Rack >= fw 2.82 */ case USB_ID(0x0e41, 0x424a): /* Line6 Helix LT >= fw 2.82 */ case USB_ID(0x0e41, 0x424b): /* Line6 Pod Go */ case USB_ID(0x19f7, 0x0011): /* Rode Rodecaster Pro */ return set_fixed_rate(fp, 48000, SNDRV_PCM_RATE_48000); } return -ENODEV; } /* check whether the given altsetting is supported for the already set rate */ static bool check_valid_altsetting_v2v3(struct snd_usb_audio *chip, int iface, int altsetting) { struct usb_device *dev = chip->dev; __le64 raw_data = 0; u64 data; int err; /* we assume 64bit is enough for any altsettings */ if (snd_BUG_ON(altsetting >= 64 - 8)) return false; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR, USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, UAC2_AS_VAL_ALT_SETTINGS << 8, iface, &raw_data, sizeof(raw_data)); if (err < 0) return false; data = le64_to_cpu(raw_data); /* first byte contains the bitmap size */ if ((data & 0xff) * 8 < altsetting) return false; if (data & (1ULL << (altsetting + 8))) return true; return false; } /* * Validate each sample rate with the altsetting * Rebuild the rate table if only partial values are valid */ static int validate_sample_rate_table_v2v3(struct snd_usb_audio *chip, struct audioformat *fp, int clock) { struct usb_device *dev = chip->dev; unsigned int *table; unsigned int nr_rates; int i, err; /* performing the rate verification may lead to unexpected USB bus * behavior afterwards by some unknown reason. Do this only for the * known devices. */ if (!(chip->quirk_flags & QUIRK_FLAG_VALIDATE_RATES)) return 0; /* don't perform the validation as default */ table = kcalloc(fp->nr_rates, sizeof(*table), GFP_KERNEL); if (!table) return -ENOMEM; /* clear the interface altsetting at first */ usb_set_interface(dev, fp->iface, 0); nr_rates = 0; for (i = 0; i < fp->nr_rates; i++) { err = snd_usb_set_sample_rate_v2v3(chip, fp, clock, fp->rate_table[i]); if (err < 0) continue; if (check_valid_altsetting_v2v3(chip, fp->iface, fp->altsetting)) table[nr_rates++] = fp->rate_table[i]; } if (!nr_rates) { usb_audio_dbg(chip, "No valid sample rate available for %d:%d, assuming a firmware bug\n", fp->iface, fp->altsetting); nr_rates = fp->nr_rates; /* continue as is */ } if (fp->nr_rates == nr_rates) { kfree(table); return 0; } kfree(fp->rate_table); fp->rate_table = table; fp->nr_rates = nr_rates; return 0; } /* * parse the format descriptor and stores the possible sample rates * on the audioformat table (audio class v2 and v3). */ static int parse_audio_format_rates_v2v3(struct snd_usb_audio *chip, struct audioformat *fp) { struct usb_device *dev = chip->dev; unsigned char tmp[2], *data; int nr_triplets, data_size, ret = 0, ret_l6; int clock = snd_usb_clock_find_source(chip, fp, false); if (clock < 0) { dev_err(&dev->dev, "%s(): unable to find clock source (clock %d)\n", __func__, clock); goto err; } /* get the number of sample rates first by only fetching 2 bytes */ ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE, USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, UAC2_CS_CONTROL_SAM_FREQ << 8, snd_usb_ctrl_intf(chip) | (clock << 8), tmp, sizeof(tmp)); if (ret < 0) { /* line6 helix devices don't support UAC2_CS_CONTROL_SAM_FREQ call */ ret_l6 = line6_parse_audio_format_rates_quirk(chip, fp); if (ret_l6 == -ENODEV) { /* no line6 device found continue showing the error */ dev_err(&dev->dev, "%s(): unable to retrieve number of sample rates (clock %d)\n", __func__, clock); goto err; } if (ret_l6 == 0) { dev_info(&dev->dev, "%s(): unable to retrieve number of sample rates: set it to a predefined value (clock %d).\n", __func__, clock); return 0; } ret = ret_l6; goto err; } nr_triplets = (tmp[1] << 8) | tmp[0]; data_size = 2 + 12 * nr_triplets; data = kzalloc(data_size, GFP_KERNEL); if (!data) { ret = -ENOMEM; goto err; } /* now get the full information */ ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE, USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, UAC2_CS_CONTROL_SAM_FREQ << 8, snd_usb_ctrl_intf(chip) | (clock << 8), data, data_size); if (ret < 0) { dev_err(&dev->dev, "%s(): unable to retrieve sample rate range (clock %d)\n", __func__, clock); ret = -EINVAL; goto err_free; } /* Call the triplet parser, and make sure fp->rate_table is NULL. * We just use the return value to know how many sample rates we * will have to deal with. */ kfree(fp->rate_table); fp->rate_table = NULL; fp->nr_rates = parse_uac2_sample_rate_range(chip, fp, nr_triplets, data); if (fp->nr_rates == 0) { /* SNDRV_PCM_RATE_CONTINUOUS */ ret = 0; goto err_free; } fp->rate_table = kmalloc_array(fp->nr_rates, sizeof(int), GFP_KERNEL); if (!fp->rate_table) { ret = -ENOMEM; goto err_free; } /* Call the triplet parser again, but this time, fp->rate_table is * allocated, so the rates will be stored */ parse_uac2_sample_rate_range(chip, fp, nr_triplets, data); ret = validate_sample_rate_table_v2v3(chip, fp, clock); if (ret < 0) goto err_free; set_rate_table_min_max(fp); err_free: kfree(data); err: return ret; } /* * parse the format type I and III descriptors */ static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp, u64 format, void *_fmt) { snd_pcm_format_t pcm_format; unsigned int fmt_type; int ret; switch (fp->protocol) { default: case UAC_VERSION_1: case UAC_VERSION_2: { struct uac_format_type_i_continuous_descriptor *fmt = _fmt; fmt_type = fmt->bFormatType; break; } case UAC_VERSION_3: { /* fp->fmt_type is already set in this case */ fmt_type = fp->fmt_type; break; } } if (fmt_type == UAC_FORMAT_TYPE_III) { /* FIXME: the format type is really IECxxx * but we give normal PCM format to get the existing * apps working... */ switch (chip->usb_id) { case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ if (chip->setup == 0x00 && fp->altsetting == 6) pcm_format = SNDRV_PCM_FORMAT_S16_BE; else pcm_format = SNDRV_PCM_FORMAT_S16_LE; break; default: pcm_format = SNDRV_PCM_FORMAT_S16_LE; } fp->formats = pcm_format_to_bits(pcm_format); } else { fp->formats = parse_audio_format_i_type(chip, fp, format, _fmt); if (!fp->formats) return -EINVAL; } /* gather possible sample rates */ /* audio class v1 reports possible sample rates as part of the * proprietary class specific descriptor. * audio class v2 uses class specific EP0 range requests for that. */ switch (fp->protocol) { default: case UAC_VERSION_1: { struct uac_format_type_i_continuous_descriptor *fmt = _fmt; fp->channels = fmt->bNrChannels; ret = parse_audio_format_rates_v1(chip, fp, (unsigned char *) fmt, 7); break; } case UAC_VERSION_2: case UAC_VERSION_3: { /* fp->channels is already set in this case */ ret = parse_audio_format_rates_v2v3(chip, fp); break; } } if (fp->channels < 1) { usb_audio_err(chip, "%u:%d : invalid channels %d\n", fp->iface, fp->altsetting, fp->channels); return -EINVAL; } return ret; } /* * parse the format type II descriptor */ static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp, u64 format, void *_fmt) { int brate, framesize, ret; switch (format) { case UAC_FORMAT_TYPE_II_AC3: /* FIXME: there is no AC3 format defined yet */ // fp->formats = SNDRV_PCM_FMTBIT_AC3; fp->formats = SNDRV_PCM_FMTBIT_U8; /* temporary hack to receive byte streams */ break; case UAC_FORMAT_TYPE_II_MPEG: fp->formats = SNDRV_PCM_FMTBIT_MPEG; break; default: usb_audio_info(chip, "%u:%d : unknown format tag %#llx is detected. processed as MPEG.\n", fp->iface, fp->altsetting, format); fp->formats = SNDRV_PCM_FMTBIT_MPEG; break; } fp->channels = 1; switch (fp->protocol) { default: case UAC_VERSION_1: { struct uac_format_type_ii_discrete_descriptor *fmt = _fmt; brate = le16_to_cpu(fmt->wMaxBitRate); framesize = le16_to_cpu(fmt->wSamplesPerFrame); usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize); fp->frame_size = framesize; ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */ break; } case UAC_VERSION_2: { struct uac_format_type_ii_ext_descriptor *fmt = _fmt; brate = le16_to_cpu(fmt->wMaxBitRate); framesize = le16_to_cpu(fmt->wSamplesPerFrame); usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize); fp->frame_size = framesize; ret = parse_audio_format_rates_v2v3(chip, fp); break; } } return ret; } int snd_usb_parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp, u64 format, struct uac_format_type_i_continuous_descriptor *fmt, int stream) { int err; switch (fmt->bFormatType) { case UAC_FORMAT_TYPE_I: case UAC_FORMAT_TYPE_III: err = parse_audio_format_i(chip, fp, format, fmt); break; case UAC_FORMAT_TYPE_II: err = parse_audio_format_ii(chip, fp, format, fmt); break; default: usb_audio_info(chip, "%u:%d : format type %d is not supported yet\n", fp->iface, fp->altsetting, fmt->bFormatType); return -ENOTSUPP; } fp->fmt_type = fmt->bFormatType; if (err < 0) return err; #if 1 /* FIXME: temporary hack for extigy/audigy 2 nx/zs */ /* extigy apparently supports sample rates other than 48k * but not in ordinary way. so we enable only 48k atm. */ if (chip->usb_id == USB_ID(0x041e, 0x3000) || chip->usb_id == USB_ID(0x041e, 0x3020) || chip->usb_id == USB_ID(0x041e, 0x3061)) { if (fmt->bFormatType == UAC_FORMAT_TYPE_I && fp->rates != SNDRV_PCM_RATE_48000 && fp->rates != SNDRV_PCM_RATE_96000) return -ENOTSUPP; } #endif return 0; } int snd_usb_parse_audio_format_v3(struct snd_usb_audio *chip, struct audioformat *fp, struct uac3_as_header_descriptor *as, int stream) { u64 format = le64_to_cpu(as->bmFormats); int err; /* * Type I format bits are D0..D6 * This test works because type IV is not supported */ if (format & 0x7f) fp->fmt_type = UAC_FORMAT_TYPE_I; else fp->fmt_type = UAC_FORMAT_TYPE_III; err = parse_audio_format_i(chip, fp, format, as); if (err < 0) return err; return 0; }
linux-master
sound/usb/format.c
// SPDX-License-Identifier: GPL-2.0 /* * Presonus Studio 1810c driver for ALSA * Copyright (C) 2019 Nick Kossifidis <[email protected]> * * Based on reverse engineering of the communication protocol * between the windows driver / Univeral Control (UC) program * and the device, through usbmon. * * For now this bypasses the mixer, with all channels split, * so that the software can mix with greater flexibility. * It also adds controls for the 4 buttons on the front of * the device. */ #include <linux/usb.h> #include <linux/usb/audio-v2.h> #include <linux/slab.h> #include <sound/core.h> #include <sound/control.h> #include "usbaudio.h" #include "mixer.h" #include "mixer_quirks.h" #include "helper.h" #include "mixer_s1810c.h" #define SC1810C_CMD_REQ 160 #define SC1810C_CMD_REQTYPE \ (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT) #define SC1810C_CMD_F1 0x50617269 #define SC1810C_CMD_F2 0x14 /* * DISCLAIMER: These are just guesses based on the * dumps I got. * * It seems like a selects between * device (0), mixer (0x64) and output (0x65) * * For mixer (0x64): * * b selects an input channel (see below). * * c selects an output channel pair (see below). * * d selects left (0) or right (1) of that pair. * * e 0-> disconnect, 0x01000000-> connect, * 0x0109-> used for stereo-linking channels, * e is also used for setting volume levels * in which case b is also set so I guess * this way it is possible to set the volume * level from the specified input to the * specified output. * * IN Channels: * 0 - 7 Mic/Inst/Line (Analog inputs) * 8 - 9 S/PDIF * 10 - 17 ADAT * 18 - 35 DAW (Inputs from the host) * * OUT Channels (pairs): * 0 -> Main out * 1 -> Line1/2 * 2 -> Line3/4 * 3 -> S/PDIF * 4 -> ADAT? * * For device (0): * * b and c are not used, at least not on the * dumps I got. * * d sets the control id to be modified * (see below). * * e sets the setting for that control. * (so for the switches I was interested * in it's 0/1) * * For output (0x65): * * b is the output channel (see above). * * c is zero. * * e I guess the same as with mixer except 0x0109 * which I didn't see in my dumps. * * The two fixed fields have the same values for * mixer and output but a different set for device. */ struct s1810c_ctl_packet { u32 a; u32 b; u32 fixed1; u32 fixed2; u32 c; u32 d; u32 e; }; #define SC1810C_CTL_LINE_SW 0 #define SC1810C_CTL_MUTE_SW 1 #define SC1810C_CTL_AB_SW 3 #define SC1810C_CTL_48V_SW 4 #define SC1810C_SET_STATE_REQ 161 #define SC1810C_SET_STATE_REQTYPE SC1810C_CMD_REQTYPE #define SC1810C_SET_STATE_F1 0x64656D73 #define SC1810C_SET_STATE_F2 0xF4 #define SC1810C_GET_STATE_REQ 162 #define SC1810C_GET_STATE_REQTYPE \ (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN) #define SC1810C_GET_STATE_F1 SC1810C_SET_STATE_F1 #define SC1810C_GET_STATE_F2 SC1810C_SET_STATE_F2 #define SC1810C_STATE_F1_IDX 2 #define SC1810C_STATE_F2_IDX 3 /* * This packet includes mixer volumes and * various other fields, it's an extended * version of ctl_packet, with a and b * being zero and different f1/f2. */ struct s1810c_state_packet { u32 fields[63]; }; #define SC1810C_STATE_48V_SW 58 #define SC1810C_STATE_LINE_SW 59 #define SC1810C_STATE_MUTE_SW 60 #define SC1810C_STATE_AB_SW 62 struct s1810_mixer_state { uint16_t seqnum; struct mutex usb_mutex; struct mutex data_mutex; }; static int snd_s1810c_send_ctl_packet(struct usb_device *dev, u32 a, u32 b, u32 c, u32 d, u32 e) { struct s1810c_ctl_packet pkt = { 0 }; int ret = 0; pkt.fixed1 = SC1810C_CMD_F1; pkt.fixed2 = SC1810C_CMD_F2; pkt.a = a; pkt.b = b; pkt.c = c; pkt.d = d; /* * Value for settings 0/1 for this * output channel is always 0 (probably because * there is no ADAT output on 1810c) */ pkt.e = (c == 4) ? 0 : e; ret = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SC1810C_CMD_REQ, SC1810C_CMD_REQTYPE, 0, 0, &pkt, sizeof(pkt)); if (ret < 0) { dev_warn(&dev->dev, "could not send ctl packet\n"); return ret; } return 0; } /* * When opening Universal Control the program periodically * sends and receives state packets for syncinc state between * the device and the host. * * Note that if we send only the request to get data back we'll * get an error, we need to first send an empty state packet and * then ask to receive a filled. Their seqnumbers must also match. */ static int snd_sc1810c_get_status_field(struct usb_device *dev, u32 *field, int field_idx, uint16_t *seqnum) { struct s1810c_state_packet pkt_out = { { 0 } }; struct s1810c_state_packet pkt_in = { { 0 } }; int ret = 0; pkt_out.fields[SC1810C_STATE_F1_IDX] = SC1810C_SET_STATE_F1; pkt_out.fields[SC1810C_STATE_F2_IDX] = SC1810C_SET_STATE_F2; ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), SC1810C_SET_STATE_REQ, SC1810C_SET_STATE_REQTYPE, (*seqnum), 0, &pkt_out, sizeof(pkt_out)); if (ret < 0) { dev_warn(&dev->dev, "could not send state packet (%d)\n", ret); return ret; } ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), SC1810C_GET_STATE_REQ, SC1810C_GET_STATE_REQTYPE, (*seqnum), 0, &pkt_in, sizeof(pkt_in)); if (ret < 0) { dev_warn(&dev->dev, "could not get state field %u (%d)\n", field_idx, ret); return ret; } (*field) = pkt_in.fields[field_idx]; (*seqnum)++; return 0; } /* * This is what I got when bypassing the mixer with * all channels split. I'm not 100% sure of what's going * on, I could probably clean this up based on my observations * but I prefer to keep the same behavior as the windows driver. */ static int snd_s1810c_init_mixer_maps(struct snd_usb_audio *chip) { u32 a, b, c, e, n, off; struct usb_device *dev = chip->dev; /* Set initial volume levels ? */ a = 0x64; e = 0xbc; for (n = 0; n < 2; n++) { off = n * 18; for (b = off; b < 18 + off; b++) { /* This channel to all outputs ? */ for (c = 0; c <= 8; c++) { snd_s1810c_send_ctl_packet(dev, a, b, c, 0, e); snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e); } /* This channel to main output (again) */ snd_s1810c_send_ctl_packet(dev, a, b, 0, 0, e); snd_s1810c_send_ctl_packet(dev, a, b, 0, 1, e); } /* * I noticed on UC that DAW channels have different * initial volumes, so this makes sense. */ e = 0xb53bf0; } /* Connect analog outputs ? */ a = 0x65; e = 0x01000000; for (b = 1; b < 3; b++) { snd_s1810c_send_ctl_packet(dev, a, b, 0, 0, e); snd_s1810c_send_ctl_packet(dev, a, b, 0, 1, e); } snd_s1810c_send_ctl_packet(dev, a, 0, 0, 0, e); snd_s1810c_send_ctl_packet(dev, a, 0, 0, 1, e); /* Set initial volume levels for S/PDIF mappings ? */ a = 0x64; e = 0xbc; c = 3; for (n = 0; n < 2; n++) { off = n * 18; for (b = off; b < 18 + off; b++) { snd_s1810c_send_ctl_packet(dev, a, b, c, 0, e); snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e); } e = 0xb53bf0; } /* Connect S/PDIF output ? */ a = 0x65; e = 0x01000000; snd_s1810c_send_ctl_packet(dev, a, 3, 0, 0, e); snd_s1810c_send_ctl_packet(dev, a, 3, 0, 1, e); /* Connect all outputs (again) ? */ a = 0x65; e = 0x01000000; for (b = 0; b < 4; b++) { snd_s1810c_send_ctl_packet(dev, a, b, 0, 0, e); snd_s1810c_send_ctl_packet(dev, a, b, 0, 1, e); } /* Basic routing to get sound out of the device */ a = 0x64; e = 0x01000000; for (c = 0; c < 4; c++) { for (b = 0; b < 36; b++) { if ((c == 0 && b == 18) || /* DAW1/2 -> Main */ (c == 1 && b == 20) || /* DAW3/4 -> Line3/4 */ (c == 2 && b == 22) || /* DAW4/5 -> Line5/6 */ (c == 3 && b == 24)) { /* DAW5/6 -> S/PDIF */ /* Left */ snd_s1810c_send_ctl_packet(dev, a, b, c, 0, e); snd_s1810c_send_ctl_packet(dev, a, b, c, 1, 0); b++; /* Right */ snd_s1810c_send_ctl_packet(dev, a, b, c, 0, 0); snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e); } else { /* Leave the rest disconnected */ snd_s1810c_send_ctl_packet(dev, a, b, c, 0, 0); snd_s1810c_send_ctl_packet(dev, a, b, c, 1, 0); } } } /* Set initial volume levels for S/PDIF (again) ? */ a = 0x64; e = 0xbc; c = 3; for (n = 0; n < 2; n++) { off = n * 18; for (b = off; b < 18 + off; b++) { snd_s1810c_send_ctl_packet(dev, a, b, c, 0, e); snd_s1810c_send_ctl_packet(dev, a, b, c, 1, e); } e = 0xb53bf0; } /* Connect S/PDIF outputs (again) ? */ a = 0x65; e = 0x01000000; snd_s1810c_send_ctl_packet(dev, a, 3, 0, 0, e); snd_s1810c_send_ctl_packet(dev, a, 3, 0, 1, e); /* Again ? */ snd_s1810c_send_ctl_packet(dev, a, 3, 0, 0, e); snd_s1810c_send_ctl_packet(dev, a, 3, 0, 1, e); return 0; } /* * Sync state with the device and retrieve the requested field, * whose index is specified in (kctl->private_value & 0xFF), * from the received fields array. */ static int snd_s1810c_get_switch_state(struct usb_mixer_interface *mixer, struct snd_kcontrol *kctl, u32 *state) { struct snd_usb_audio *chip = mixer->chip; struct s1810_mixer_state *private = mixer->private_data; u32 field = 0; u32 ctl_idx = (u32) (kctl->private_value & 0xFF); int ret = 0; mutex_lock(&private->usb_mutex); ret = snd_sc1810c_get_status_field(chip->dev, &field, ctl_idx, &private->seqnum); if (ret < 0) goto unlock; *state = field; unlock: mutex_unlock(&private->usb_mutex); return ret ? ret : 0; } /* * Send a control packet to the device for the control id * specified in (kctl->private_value >> 8) with value * specified in (kctl->private_value >> 16). */ static int snd_s1810c_set_switch_state(struct usb_mixer_interface *mixer, struct snd_kcontrol *kctl) { struct snd_usb_audio *chip = mixer->chip; struct s1810_mixer_state *private = mixer->private_data; u32 pval = (u32) kctl->private_value; u32 ctl_id = (pval >> 8) & 0xFF; u32 ctl_val = (pval >> 16) & 0x1; int ret = 0; mutex_lock(&private->usb_mutex); ret = snd_s1810c_send_ctl_packet(chip->dev, 0, 0, 0, ctl_id, ctl_val); mutex_unlock(&private->usb_mutex); return ret; } /* Generic get/set/init functions for switch controls */ static int snd_s1810c_switch_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ctl_elem) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); struct usb_mixer_interface *mixer = list->mixer; struct s1810_mixer_state *private = mixer->private_data; u32 pval = (u32) kctl->private_value; u32 ctl_idx = pval & 0xFF; u32 state = 0; int ret = 0; mutex_lock(&private->data_mutex); ret = snd_s1810c_get_switch_state(mixer, kctl, &state); if (ret < 0) goto unlock; switch (ctl_idx) { case SC1810C_STATE_LINE_SW: case SC1810C_STATE_AB_SW: ctl_elem->value.enumerated.item[0] = (int)state; break; default: ctl_elem->value.integer.value[0] = (long)state; } unlock: mutex_unlock(&private->data_mutex); return (ret < 0) ? ret : 0; } static int snd_s1810c_switch_set(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ctl_elem) { struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl); struct usb_mixer_interface *mixer = list->mixer; struct s1810_mixer_state *private = mixer->private_data; u32 pval = (u32) kctl->private_value; u32 ctl_idx = pval & 0xFF; u32 curval = 0; u32 newval = 0; int ret = 0; mutex_lock(&private->data_mutex); ret = snd_s1810c_get_switch_state(mixer, kctl, &curval); if (ret < 0) goto unlock; switch (ctl_idx) { case SC1810C_STATE_LINE_SW: case SC1810C_STATE_AB_SW: newval = (u32) ctl_elem->value.enumerated.item[0]; break; default: newval = (u32) ctl_elem->value.integer.value[0]; } if (curval == newval) goto unlock; kctl->private_value &= ~(0x1 << 16); kctl->private_value |= (unsigned int)(newval & 0x1) << 16; ret = snd_s1810c_set_switch_state(mixer, kctl); unlock: mutex_unlock(&private->data_mutex); return (ret < 0) ? 0 : 1; } static int snd_s1810c_switch_init(struct usb_mixer_interface *mixer, const struct snd_kcontrol_new *new_kctl) { struct snd_kcontrol *kctl; struct usb_mixer_elem_info *elem; elem = kzalloc(sizeof(struct usb_mixer_elem_info), GFP_KERNEL); if (!elem) return -ENOMEM; elem->head.mixer = mixer; elem->control = 0; elem->head.id = 0; elem->channels = 1; kctl = snd_ctl_new1(new_kctl, elem); if (!kctl) { kfree(elem); return -ENOMEM; } kctl->private_free = snd_usb_mixer_elem_free; return snd_usb_mixer_add_control(&elem->head, kctl); } static int snd_s1810c_line_sw_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { static const char *const texts[2] = { "Preamp On (Mic/Inst)", "Preamp Off (Line in)" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); } static const struct snd_kcontrol_new snd_s1810c_line_sw = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line 1/2 Source Type", .info = snd_s1810c_line_sw_info, .get = snd_s1810c_switch_get, .put = snd_s1810c_switch_set, .private_value = (SC1810C_STATE_LINE_SW | SC1810C_CTL_LINE_SW << 8) }; static const struct snd_kcontrol_new snd_s1810c_mute_sw = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Mute Main Out Switch", .info = snd_ctl_boolean_mono_info, .get = snd_s1810c_switch_get, .put = snd_s1810c_switch_set, .private_value = (SC1810C_STATE_MUTE_SW | SC1810C_CTL_MUTE_SW << 8) }; static const struct snd_kcontrol_new snd_s1810c_48v_sw = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "48V Phantom Power On Mic Inputs Switch", .info = snd_ctl_boolean_mono_info, .get = snd_s1810c_switch_get, .put = snd_s1810c_switch_set, .private_value = (SC1810C_STATE_48V_SW | SC1810C_CTL_48V_SW << 8) }; static int snd_s1810c_ab_sw_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { static const char *const texts[2] = { "1/2", "3/4" }; return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); } static const struct snd_kcontrol_new snd_s1810c_ab_sw = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Headphone 1 Source Route", .info = snd_s1810c_ab_sw_info, .get = snd_s1810c_switch_get, .put = snd_s1810c_switch_set, .private_value = (SC1810C_STATE_AB_SW | SC1810C_CTL_AB_SW << 8) }; static void snd_sc1810_mixer_state_free(struct usb_mixer_interface *mixer) { struct s1810_mixer_state *private = mixer->private_data; kfree(private); mixer->private_data = NULL; } /* Entry point, called from mixer_quirks.c */ int snd_sc1810_init_mixer(struct usb_mixer_interface *mixer) { struct s1810_mixer_state *private = NULL; struct snd_usb_audio *chip = mixer->chip; struct usb_device *dev = chip->dev; int ret = 0; /* Run this only once */ if (!list_empty(&chip->mixer_list)) return 0; dev_info(&dev->dev, "Presonus Studio 1810c, device_setup: %u\n", chip->setup); if (chip->setup == 1) dev_info(&dev->dev, "(8out/18in @ 48kHz)\n"); else if (chip->setup == 2) dev_info(&dev->dev, "(6out/8in @ 192kHz)\n"); else dev_info(&dev->dev, "(8out/14in @ 96kHz)\n"); ret = snd_s1810c_init_mixer_maps(chip); if (ret < 0) return ret; private = kzalloc(sizeof(struct s1810_mixer_state), GFP_KERNEL); if (!private) return -ENOMEM; mutex_init(&private->usb_mutex); mutex_init(&private->data_mutex); mixer->private_data = private; mixer->private_free = snd_sc1810_mixer_state_free; private->seqnum = 1; ret = snd_s1810c_switch_init(mixer, &snd_s1810c_line_sw); if (ret < 0) return ret; ret = snd_s1810c_switch_init(mixer, &snd_s1810c_mute_sw); if (ret < 0) return ret; ret = snd_s1810c_switch_init(mixer, &snd_s1810c_48v_sw); if (ret < 0) return ret; ret = snd_s1810c_switch_init(mixer, &snd_s1810c_ab_sw); if (ret < 0) return ret; return ret; }
linux-master
sound/usb/mixer_s1810c.c
// SPDX-License-Identifier: GPL-2.0-or-later /* */ #include <linux/init.h> #include <linux/slab.h> #include <linux/bitrev.h> #include <linux/ratelimit.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "usbaudio.h" #include "card.h" #include "quirks.h" #include "endpoint.h" #include "helper.h" #include "pcm.h" #include "clock.h" #include "power.h" #include "media.h" #include "implicit.h" #define SUBSTREAM_FLAG_DATA_EP_STARTED 0 #define SUBSTREAM_FLAG_SYNC_EP_STARTED 1 /* return the estimated delay based on USB frame counters */ static snd_pcm_uframes_t snd_usb_pcm_delay(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime) { unsigned int current_frame_number; unsigned int frame_diff; int est_delay; int queued; if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) { queued = bytes_to_frames(runtime, subs->inflight_bytes); if (!queued) return 0; } else if (!subs->running) { return 0; } current_frame_number = usb_get_current_frame_number(subs->dev); /* * HCD implementations use different widths, use lower 8 bits. * The delay will be managed up to 256ms, which is more than * enough */ frame_diff = (current_frame_number - subs->last_frame_number) & 0xff; /* Approximation based on number of samples per USB frame (ms), some truncation for 44.1 but the estimate is good enough */ est_delay = frame_diff * runtime->rate / 1000; if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) { est_delay = queued - est_delay; if (est_delay < 0) est_delay = 0; } return est_delay; } /* * return the current pcm pointer. just based on the hwptr_done value. */ static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usb_substream *subs = runtime->private_data; unsigned int hwptr_done; if (atomic_read(&subs->stream->chip->shutdown)) return SNDRV_PCM_POS_XRUN; spin_lock(&subs->lock); hwptr_done = subs->hwptr_done; runtime->delay = snd_usb_pcm_delay(subs, runtime); spin_unlock(&subs->lock); return bytes_to_frames(runtime, hwptr_done); } /* * find a matching audio format */ static const struct audioformat * find_format(struct list_head *fmt_list_head, snd_pcm_format_t format, unsigned int rate, unsigned int channels, bool strict_match, struct snd_usb_substream *subs) { const struct audioformat *fp; const struct audioformat *found = NULL; int cur_attr = 0, attr; list_for_each_entry(fp, fmt_list_head, list) { if (strict_match) { if (!(fp->formats & pcm_format_to_bits(format))) continue; if (fp->channels != channels) continue; } if (rate < fp->rate_min || rate > fp->rate_max) continue; if (!(fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) { unsigned int i; for (i = 0; i < fp->nr_rates; i++) if (fp->rate_table[i] == rate) break; if (i >= fp->nr_rates) continue; } attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE; if (!found) { found = fp; cur_attr = attr; continue; } /* avoid async out and adaptive in if the other method * supports the same format. * this is a workaround for the case like * M-audio audiophile USB. */ if (subs && attr != cur_attr) { if ((attr == USB_ENDPOINT_SYNC_ASYNC && subs->direction == SNDRV_PCM_STREAM_PLAYBACK) || (attr == USB_ENDPOINT_SYNC_ADAPTIVE && subs->direction == SNDRV_PCM_STREAM_CAPTURE)) continue; if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC && subs->direction == SNDRV_PCM_STREAM_PLAYBACK) || (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE && subs->direction == SNDRV_PCM_STREAM_CAPTURE)) { found = fp; cur_attr = attr; continue; } } /* find the format with the largest max. packet size */ if (fp->maxpacksize > found->maxpacksize) { found = fp; cur_attr = attr; } } return found; } static const struct audioformat * find_substream_format(struct snd_usb_substream *subs, const struct snd_pcm_hw_params *params) { return find_format(&subs->fmt_list, params_format(params), params_rate(params), params_channels(params), true, subs); } bool snd_usb_pcm_has_fixed_rate(struct snd_usb_substream *subs) { const struct audioformat *fp; struct snd_usb_audio *chip; int rate = -1; if (!subs) return false; chip = subs->stream->chip; if (!(chip->quirk_flags & QUIRK_FLAG_FIXED_RATE)) return false; list_for_each_entry(fp, &subs->fmt_list, list) { if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) return false; if (fp->nr_rates < 1) continue; if (fp->nr_rates > 1) return false; if (rate < 0) { rate = fp->rate_table[0]; continue; } if (rate != fp->rate_table[0]) return false; } return true; } static int init_pitch_v1(struct snd_usb_audio *chip, int ep) { struct usb_device *dev = chip->dev; unsigned char data[1]; int err; data[0] = 1; err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT, UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep, data, sizeof(data)); return err; } static int init_pitch_v2(struct snd_usb_audio *chip, int ep) { struct usb_device *dev = chip->dev; unsigned char data[1]; int err; data[0] = 1; err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR, USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT, UAC2_EP_CS_PITCH << 8, 0, data, sizeof(data)); return err; } /* * initialize the pitch control and sample rate */ int snd_usb_init_pitch(struct snd_usb_audio *chip, const struct audioformat *fmt) { int err; /* if endpoint doesn't have pitch control, bail out */ if (!(fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL)) return 0; usb_audio_dbg(chip, "enable PITCH for EP 0x%x\n", fmt->endpoint); switch (fmt->protocol) { case UAC_VERSION_1: err = init_pitch_v1(chip, fmt->endpoint); break; case UAC_VERSION_2: err = init_pitch_v2(chip, fmt->endpoint); break; default: return 0; } if (err < 0) { usb_audio_err(chip, "failed to enable PITCH for EP 0x%x\n", fmt->endpoint); return err; } return 0; } static bool stop_endpoints(struct snd_usb_substream *subs, bool keep_pending) { bool stopped = 0; if (test_and_clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) { snd_usb_endpoint_stop(subs->sync_endpoint, keep_pending); stopped = true; } if (test_and_clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) { snd_usb_endpoint_stop(subs->data_endpoint, keep_pending); stopped = true; } return stopped; } static int start_endpoints(struct snd_usb_substream *subs) { int err; if (!subs->data_endpoint) return -EINVAL; if (!test_and_set_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) { err = snd_usb_endpoint_start(subs->data_endpoint); if (err < 0) { clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags); goto error; } } if (subs->sync_endpoint && !test_and_set_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) { err = snd_usb_endpoint_start(subs->sync_endpoint); if (err < 0) { clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags); goto error; } } return 0; error: stop_endpoints(subs, false); return err; } static void sync_pending_stops(struct snd_usb_substream *subs) { snd_usb_endpoint_sync_pending_stop(subs->sync_endpoint); snd_usb_endpoint_sync_pending_stop(subs->data_endpoint); } /* PCM sync_stop callback */ static int snd_usb_pcm_sync_stop(struct snd_pcm_substream *substream) { struct snd_usb_substream *subs = substream->runtime->private_data; sync_pending_stops(subs); return 0; } /* Set up sync endpoint */ int snd_usb_audioformat_set_sync_ep(struct snd_usb_audio *chip, struct audioformat *fmt) { struct usb_device *dev = chip->dev; struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; unsigned int ep, attr, sync_attr; bool is_playback; int err; if (fmt->sync_ep) return 0; /* already set up */ alts = snd_usb_get_host_interface(chip, fmt->iface, fmt->altsetting); if (!alts) return 0; altsd = get_iface_desc(alts); err = snd_usb_parse_implicit_fb_quirk(chip, fmt, alts); if (err > 0) return 0; /* matched */ /* * Generic sync EP handling */ if (fmt->ep_idx > 0 || altsd->bNumEndpoints < 2) return 0; is_playback = !(get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN); attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE; if ((is_playback && (attr == USB_ENDPOINT_SYNC_SYNC || attr == USB_ENDPOINT_SYNC_ADAPTIVE)) || (!is_playback && attr != USB_ENDPOINT_SYNC_ADAPTIVE)) return 0; sync_attr = get_endpoint(alts, 1)->bmAttributes; /* * In case of illegal SYNC_NONE for OUT endpoint, we keep going to see * if we don't find a sync endpoint, as on M-Audio Transit. In case of * error fall back to SYNC mode and don't create sync endpoint */ /* check sync-pipe endpoint */ /* ... and check descriptor size before accessing bSynchAddress because there is a version of the SB Audigy 2 NX firmware lacking the audio fields in the endpoint descriptors */ if ((sync_attr & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_ISOC || (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && get_endpoint(alts, 1)->bSynchAddress != 0)) { dev_err(&dev->dev, "%d:%d : invalid sync pipe. bmAttributes %02x, bLength %d, bSynchAddress %02x\n", fmt->iface, fmt->altsetting, get_endpoint(alts, 1)->bmAttributes, get_endpoint(alts, 1)->bLength, get_endpoint(alts, 1)->bSynchAddress); if (is_playback && attr == USB_ENDPOINT_SYNC_NONE) return 0; return -EINVAL; } ep = get_endpoint(alts, 1)->bEndpointAddress; if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && get_endpoint(alts, 0)->bSynchAddress != 0 && ((is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) || (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) { dev_err(&dev->dev, "%d:%d : invalid sync pipe. is_playback %d, ep %02x, bSynchAddress %02x\n", fmt->iface, fmt->altsetting, is_playback, ep, get_endpoint(alts, 0)->bSynchAddress); if (is_playback && attr == USB_ENDPOINT_SYNC_NONE) return 0; return -EINVAL; } fmt->sync_ep = ep; fmt->sync_iface = altsd->bInterfaceNumber; fmt->sync_altsetting = altsd->bAlternateSetting; fmt->sync_ep_idx = 1; if ((sync_attr & USB_ENDPOINT_USAGE_MASK) == USB_ENDPOINT_USAGE_IMPLICIT_FB) fmt->implicit_fb = 1; dev_dbg(&dev->dev, "%d:%d: found sync_ep=0x%x, iface=%d, alt=%d, implicit_fb=%d\n", fmt->iface, fmt->altsetting, fmt->sync_ep, fmt->sync_iface, fmt->sync_altsetting, fmt->implicit_fb); return 0; } static int snd_usb_pcm_change_state(struct snd_usb_substream *subs, int state) { int ret; if (!subs->str_pd) return 0; ret = snd_usb_power_domain_set(subs->stream->chip, subs->str_pd, state); if (ret < 0) { dev_err(&subs->dev->dev, "Cannot change Power Domain ID: %d to state: %d. Err: %d\n", subs->str_pd->pd_id, state, ret); return ret; } return 0; } int snd_usb_pcm_suspend(struct snd_usb_stream *as) { int ret; ret = snd_usb_pcm_change_state(&as->substream[0], UAC3_PD_STATE_D2); if (ret < 0) return ret; ret = snd_usb_pcm_change_state(&as->substream[1], UAC3_PD_STATE_D2); if (ret < 0) return ret; return 0; } int snd_usb_pcm_resume(struct snd_usb_stream *as) { int ret; ret = snd_usb_pcm_change_state(&as->substream[0], UAC3_PD_STATE_D1); if (ret < 0) return ret; ret = snd_usb_pcm_change_state(&as->substream[1], UAC3_PD_STATE_D1); if (ret < 0) return ret; return 0; } static void close_endpoints(struct snd_usb_audio *chip, struct snd_usb_substream *subs) { if (subs->data_endpoint) { snd_usb_endpoint_set_sync(chip, subs->data_endpoint, NULL); snd_usb_endpoint_close(chip, subs->data_endpoint); subs->data_endpoint = NULL; } if (subs->sync_endpoint) { snd_usb_endpoint_close(chip, subs->sync_endpoint); subs->sync_endpoint = NULL; } } /* * hw_params callback * * allocate a buffer and set the given audio format. * * so far we use a physically linear buffer although packetize transfer * doesn't need a continuous area. * if sg buffer is supported on the later version of alsa, we'll follow * that. */ static int snd_usb_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { struct snd_usb_substream *subs = substream->runtime->private_data; struct snd_usb_audio *chip = subs->stream->chip; const struct audioformat *fmt; const struct audioformat *sync_fmt; bool fixed_rate, sync_fixed_rate; int ret; ret = snd_media_start_pipeline(subs); if (ret) return ret; fixed_rate = snd_usb_pcm_has_fixed_rate(subs); fmt = find_substream_format(subs, hw_params); if (!fmt) { usb_audio_dbg(chip, "cannot find format: format=%s, rate=%d, channels=%d\n", snd_pcm_format_name(params_format(hw_params)), params_rate(hw_params), params_channels(hw_params)); ret = -EINVAL; goto stop_pipeline; } if (fmt->implicit_fb) { sync_fmt = snd_usb_find_implicit_fb_sync_format(chip, fmt, hw_params, !substream->stream, &sync_fixed_rate); if (!sync_fmt) { usb_audio_dbg(chip, "cannot find sync format: ep=0x%x, iface=%d:%d, format=%s, rate=%d, channels=%d\n", fmt->sync_ep, fmt->sync_iface, fmt->sync_altsetting, snd_pcm_format_name(params_format(hw_params)), params_rate(hw_params), params_channels(hw_params)); ret = -EINVAL; goto stop_pipeline; } } else { sync_fmt = fmt; sync_fixed_rate = fixed_rate; } ret = snd_usb_lock_shutdown(chip); if (ret < 0) goto stop_pipeline; ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0); if (ret < 0) goto unlock; if (subs->data_endpoint) { if (snd_usb_endpoint_compatible(chip, subs->data_endpoint, fmt, hw_params)) goto unlock; if (stop_endpoints(subs, false)) sync_pending_stops(subs); close_endpoints(chip, subs); } subs->data_endpoint = snd_usb_endpoint_open(chip, fmt, hw_params, false, fixed_rate); if (!subs->data_endpoint) { ret = -EINVAL; goto unlock; } if (fmt->sync_ep) { subs->sync_endpoint = snd_usb_endpoint_open(chip, sync_fmt, hw_params, fmt == sync_fmt, sync_fixed_rate); if (!subs->sync_endpoint) { ret = -EINVAL; goto unlock; } snd_usb_endpoint_set_sync(chip, subs->data_endpoint, subs->sync_endpoint); } mutex_lock(&chip->mutex); subs->cur_audiofmt = fmt; mutex_unlock(&chip->mutex); if (!subs->data_endpoint->need_setup) goto unlock; if (subs->sync_endpoint) { ret = snd_usb_endpoint_set_params(chip, subs->sync_endpoint); if (ret < 0) goto unlock; } ret = snd_usb_endpoint_set_params(chip, subs->data_endpoint); unlock: if (ret < 0) close_endpoints(chip, subs); snd_usb_unlock_shutdown(chip); stop_pipeline: if (ret < 0) snd_media_stop_pipeline(subs); return ret; } /* * hw_free callback * * reset the audio format and release the buffer */ static int snd_usb_hw_free(struct snd_pcm_substream *substream) { struct snd_usb_substream *subs = substream->runtime->private_data; struct snd_usb_audio *chip = subs->stream->chip; snd_media_stop_pipeline(subs); mutex_lock(&chip->mutex); subs->cur_audiofmt = NULL; mutex_unlock(&chip->mutex); if (!snd_usb_lock_shutdown(chip)) { if (stop_endpoints(subs, false)) sync_pending_stops(subs); close_endpoints(chip, subs); snd_usb_unlock_shutdown(chip); } return 0; } /* free-wheeling mode? (e.g. dmix) */ static int in_free_wheeling_mode(struct snd_pcm_runtime *runtime) { return runtime->stop_threshold > runtime->buffer_size; } /* check whether early start is needed for playback stream */ static int lowlatency_playback_available(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs) { struct snd_usb_audio *chip = subs->stream->chip; if (subs->direction == SNDRV_PCM_STREAM_CAPTURE) return false; /* disabled via module option? */ if (!chip->lowlatency) return false; if (in_free_wheeling_mode(runtime)) return false; /* implicit feedback mode has own operation mode */ if (snd_usb_endpoint_implicit_feedback_sink(subs->data_endpoint)) return false; return true; } /* * prepare callback * * only a few subtle things... */ static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usb_substream *subs = runtime->private_data; struct snd_usb_audio *chip = subs->stream->chip; int retry = 0; int ret; ret = snd_usb_lock_shutdown(chip); if (ret < 0) return ret; if (snd_BUG_ON(!subs->data_endpoint)) { ret = -EIO; goto unlock; } ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0); if (ret < 0) goto unlock; again: if (subs->sync_endpoint) { ret = snd_usb_endpoint_prepare(chip, subs->sync_endpoint); if (ret < 0) goto unlock; } ret = snd_usb_endpoint_prepare(chip, subs->data_endpoint); if (ret < 0) goto unlock; else if (ret > 0) snd_usb_set_format_quirk(subs, subs->cur_audiofmt); ret = 0; /* reset the pointer */ subs->buffer_bytes = frames_to_bytes(runtime, runtime->buffer_size); subs->inflight_bytes = 0; subs->hwptr_done = 0; subs->transfer_done = 0; subs->last_frame_number = 0; subs->period_elapsed_pending = 0; runtime->delay = 0; subs->lowlatency_playback = lowlatency_playback_available(runtime, subs); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !subs->lowlatency_playback) { ret = start_endpoints(subs); /* if XRUN happens at starting streams (possibly with implicit * fb case), restart again, but only try once. */ if (ret == -EPIPE && !retry++) { sync_pending_stops(subs); goto again; } } unlock: snd_usb_unlock_shutdown(chip); return ret; } /* * h/w constraints */ #ifdef HW_CONST_DEBUG #define hwc_debug(fmt, args...) pr_debug(fmt, ##args) #else #define hwc_debug(fmt, args...) do { } while(0) #endif static const struct snd_pcm_hardware snd_usb_hardware = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BATCH | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_PAUSE, .channels_min = 1, .channels_max = 256, .buffer_bytes_max = INT_MAX, /* limited by BUFFER_TIME later */ .period_bytes_min = 64, .period_bytes_max = INT_MAX, /* limited by PERIOD_TIME later */ .periods_min = 2, .periods_max = 1024, }; static int hw_check_valid_format(struct snd_usb_substream *subs, struct snd_pcm_hw_params *params, const struct audioformat *fp) { struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME); struct snd_mask check_fmts; unsigned int ptime; /* check the format */ snd_mask_none(&check_fmts); check_fmts.bits[0] = (u32)fp->formats; check_fmts.bits[1] = (u32)(fp->formats >> 32); snd_mask_intersect(&check_fmts, fmts); if (snd_mask_empty(&check_fmts)) { hwc_debug(" > check: no supported format 0x%llx\n", fp->formats); return 0; } /* check the channels */ if (fp->channels < ct->min || fp->channels > ct->max) { hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max); return 0; } /* check the rate is within the range */ if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) { hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max); return 0; } if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) { hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min); return 0; } /* check whether the period time is >= the data packet interval */ if (subs->speed != USB_SPEED_FULL) { ptime = 125 * (1 << fp->datainterval); if (ptime > pt->max || (ptime == pt->max && pt->openmax)) { hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max); return 0; } } return 1; } static int apply_hw_params_minmax(struct snd_interval *it, unsigned int rmin, unsigned int rmax) { int changed; if (rmin > rmax) { hwc_debug(" --> get empty\n"); it->empty = 1; return -EINVAL; } changed = 0; if (it->min < rmin) { it->min = rmin; it->openmin = 0; changed = 1; } if (it->max > rmax) { it->max = rmax; it->openmax = 0; changed = 1; } if (snd_interval_checkempty(it)) { it->empty = 1; return -EINVAL; } hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed); return changed; } /* get the specified endpoint object that is being used by other streams * (i.e. the parameter is locked) */ static const struct snd_usb_endpoint * get_endpoint_in_use(struct snd_usb_audio *chip, int endpoint, const struct snd_usb_endpoint *ref_ep) { const struct snd_usb_endpoint *ep; ep = snd_usb_get_endpoint(chip, endpoint); if (ep && ep->cur_audiofmt && (ep != ref_ep || ep->opened > 1)) return ep; return NULL; } static int hw_rule_rate(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_usb_substream *subs = rule->private; struct snd_usb_audio *chip = subs->stream->chip; const struct snd_usb_endpoint *ep; const struct audioformat *fp; struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); unsigned int rmin, rmax, r; int i; hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max); rmin = UINT_MAX; rmax = 0; list_for_each_entry(fp, &subs->fmt_list, list) { if (!hw_check_valid_format(subs, params, fp)) continue; ep = get_endpoint_in_use(chip, fp->endpoint, subs->data_endpoint); if (ep) { hwc_debug("rate limit %d for ep#%x\n", ep->cur_rate, fp->endpoint); rmin = min(rmin, ep->cur_rate); rmax = max(rmax, ep->cur_rate); continue; } if (fp->implicit_fb) { ep = get_endpoint_in_use(chip, fp->sync_ep, subs->sync_endpoint); if (ep) { hwc_debug("rate limit %d for sync_ep#%x\n", ep->cur_rate, fp->sync_ep); rmin = min(rmin, ep->cur_rate); rmax = max(rmax, ep->cur_rate); continue; } } r = snd_usb_endpoint_get_clock_rate(chip, fp->clock); if (r > 0) { if (!snd_interval_test(it, r)) continue; rmin = min(rmin, r); rmax = max(rmax, r); continue; } if (fp->rate_table && fp->nr_rates) { for (i = 0; i < fp->nr_rates; i++) { r = fp->rate_table[i]; if (!snd_interval_test(it, r)) continue; rmin = min(rmin, r); rmax = max(rmax, r); } } else { rmin = min(rmin, fp->rate_min); rmax = max(rmax, fp->rate_max); } } return apply_hw_params_minmax(it, rmin, rmax); } static int hw_rule_channels(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_usb_substream *subs = rule->private; const struct audioformat *fp; struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); unsigned int rmin, rmax; hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max); rmin = UINT_MAX; rmax = 0; list_for_each_entry(fp, &subs->fmt_list, list) { if (!hw_check_valid_format(subs, params, fp)) continue; rmin = min(rmin, fp->channels); rmax = max(rmax, fp->channels); } return apply_hw_params_minmax(it, rmin, rmax); } static int apply_hw_params_format_bits(struct snd_mask *fmt, u64 fbits) { u32 oldbits[2]; int changed; oldbits[0] = fmt->bits[0]; oldbits[1] = fmt->bits[1]; fmt->bits[0] &= (u32)fbits; fmt->bits[1] &= (u32)(fbits >> 32); if (!fmt->bits[0] && !fmt->bits[1]) { hwc_debug(" --> get empty\n"); return -EINVAL; } changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]); hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed); return changed; } static int hw_rule_format(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_usb_substream *subs = rule->private; struct snd_usb_audio *chip = subs->stream->chip; const struct snd_usb_endpoint *ep; const struct audioformat *fp; struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); u64 fbits; hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]); fbits = 0; list_for_each_entry(fp, &subs->fmt_list, list) { if (!hw_check_valid_format(subs, params, fp)) continue; ep = get_endpoint_in_use(chip, fp->endpoint, subs->data_endpoint); if (ep) { hwc_debug("format limit %d for ep#%x\n", ep->cur_format, fp->endpoint); fbits |= pcm_format_to_bits(ep->cur_format); continue; } if (fp->implicit_fb) { ep = get_endpoint_in_use(chip, fp->sync_ep, subs->sync_endpoint); if (ep) { hwc_debug("format limit %d for sync_ep#%x\n", ep->cur_format, fp->sync_ep); fbits |= pcm_format_to_bits(ep->cur_format); continue; } } fbits |= fp->formats; } return apply_hw_params_format_bits(fmt, fbits); } static int hw_rule_period_time(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_usb_substream *subs = rule->private; const struct audioformat *fp; struct snd_interval *it; unsigned char min_datainterval; unsigned int pmin; it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME); hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max); min_datainterval = 0xff; list_for_each_entry(fp, &subs->fmt_list, list) { if (!hw_check_valid_format(subs, params, fp)) continue; min_datainterval = min(min_datainterval, fp->datainterval); } if (min_datainterval == 0xff) { hwc_debug(" --> get empty\n"); it->empty = 1; return -EINVAL; } pmin = 125 * (1 << min_datainterval); return apply_hw_params_minmax(it, pmin, UINT_MAX); } /* additional hw constraints for implicit feedback mode */ static int hw_rule_period_size_implicit_fb(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_usb_substream *subs = rule->private; struct snd_usb_audio *chip = subs->stream->chip; const struct audioformat *fp; const struct snd_usb_endpoint *ep; struct snd_interval *it; unsigned int rmin, rmax; it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE); hwc_debug("hw_rule_period_size: (%u,%u)\n", it->min, it->max); rmin = UINT_MAX; rmax = 0; list_for_each_entry(fp, &subs->fmt_list, list) { if (!hw_check_valid_format(subs, params, fp)) continue; ep = get_endpoint_in_use(chip, fp->endpoint, subs->data_endpoint); if (ep) { hwc_debug("period size limit %d for ep#%x\n", ep->cur_period_frames, fp->endpoint); rmin = min(rmin, ep->cur_period_frames); rmax = max(rmax, ep->cur_period_frames); continue; } if (fp->implicit_fb) { ep = get_endpoint_in_use(chip, fp->sync_ep, subs->sync_endpoint); if (ep) { hwc_debug("period size limit %d for sync_ep#%x\n", ep->cur_period_frames, fp->sync_ep); rmin = min(rmin, ep->cur_period_frames); rmax = max(rmax, ep->cur_period_frames); continue; } } } if (!rmax) return 0; /* no limit by implicit fb */ return apply_hw_params_minmax(it, rmin, rmax); } static int hw_rule_periods_implicit_fb(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_usb_substream *subs = rule->private; struct snd_usb_audio *chip = subs->stream->chip; const struct audioformat *fp; const struct snd_usb_endpoint *ep; struct snd_interval *it; unsigned int rmin, rmax; it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIODS); hwc_debug("hw_rule_periods: (%u,%u)\n", it->min, it->max); rmin = UINT_MAX; rmax = 0; list_for_each_entry(fp, &subs->fmt_list, list) { if (!hw_check_valid_format(subs, params, fp)) continue; ep = get_endpoint_in_use(chip, fp->endpoint, subs->data_endpoint); if (ep) { hwc_debug("periods limit %d for ep#%x\n", ep->cur_buffer_periods, fp->endpoint); rmin = min(rmin, ep->cur_buffer_periods); rmax = max(rmax, ep->cur_buffer_periods); continue; } if (fp->implicit_fb) { ep = get_endpoint_in_use(chip, fp->sync_ep, subs->sync_endpoint); if (ep) { hwc_debug("periods limit %d for sync_ep#%x\n", ep->cur_buffer_periods, fp->sync_ep); rmin = min(rmin, ep->cur_buffer_periods); rmax = max(rmax, ep->cur_buffer_periods); continue; } } } if (!rmax) return 0; /* no limit by implicit fb */ return apply_hw_params_minmax(it, rmin, rmax); } /* * set up the runtime hardware information. */ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs) { const struct audioformat *fp; unsigned int pt, ptmin; int param_period_time_if_needed = -1; int err; runtime->hw.formats = subs->formats; runtime->hw.rate_min = 0x7fffffff; runtime->hw.rate_max = 0; runtime->hw.channels_min = 256; runtime->hw.channels_max = 0; runtime->hw.rates = 0; ptmin = UINT_MAX; /* check min/max rates and channels */ list_for_each_entry(fp, &subs->fmt_list, list) { runtime->hw.rates |= fp->rates; if (runtime->hw.rate_min > fp->rate_min) runtime->hw.rate_min = fp->rate_min; if (runtime->hw.rate_max < fp->rate_max) runtime->hw.rate_max = fp->rate_max; if (runtime->hw.channels_min > fp->channels) runtime->hw.channels_min = fp->channels; if (runtime->hw.channels_max < fp->channels) runtime->hw.channels_max = fp->channels; if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) { /* FIXME: there might be more than one audio formats... */ runtime->hw.period_bytes_min = runtime->hw.period_bytes_max = fp->frame_size; } pt = 125 * (1 << fp->datainterval); ptmin = min(ptmin, pt); } param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME; if (subs->speed == USB_SPEED_FULL) /* full speed devices have fixed data packet interval */ ptmin = 1000; if (ptmin == 1000) /* if period time doesn't go below 1 ms, no rules needed */ param_period_time_if_needed = -1; err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, ptmin, UINT_MAX); if (err < 0) return err; err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, hw_rule_rate, subs, SNDRV_PCM_HW_PARAM_RATE, SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_CHANNELS, param_period_time_if_needed, -1); if (err < 0) return err; err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, hw_rule_channels, subs, SNDRV_PCM_HW_PARAM_CHANNELS, SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_RATE, param_period_time_if_needed, -1); if (err < 0) return err; err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT, hw_rule_format, subs, SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_RATE, SNDRV_PCM_HW_PARAM_CHANNELS, param_period_time_if_needed, -1); if (err < 0) return err; if (param_period_time_if_needed >= 0) { err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_TIME, hw_rule_period_time, subs, SNDRV_PCM_HW_PARAM_FORMAT, SNDRV_PCM_HW_PARAM_CHANNELS, SNDRV_PCM_HW_PARAM_RATE, -1); if (err < 0) return err; } /* set max period and buffer sizes for 1 and 2 seconds, respectively */ err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 0, 1000000); if (err < 0) return err; err = snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_TIME, 0, 2000000); if (err < 0) return err; /* additional hw constraints for implicit fb */ err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, hw_rule_period_size_implicit_fb, subs, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1); if (err < 0) return err; err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS, hw_rule_periods_implicit_fb, subs, SNDRV_PCM_HW_PARAM_PERIODS, -1); if (err < 0) return err; list_for_each_entry(fp, &subs->fmt_list, list) { if (fp->implicit_fb) { runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX; break; } } return 0; } static int snd_usb_pcm_open(struct snd_pcm_substream *substream) { int direction = substream->stream; struct snd_usb_stream *as = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usb_substream *subs = &as->substream[direction]; int ret; runtime->hw = snd_usb_hardware; /* need an explicit sync to catch applptr update in low-latency mode */ if (direction == SNDRV_PCM_STREAM_PLAYBACK && as->chip->lowlatency) runtime->hw.info |= SNDRV_PCM_INFO_SYNC_APPLPTR; runtime->private_data = subs; subs->pcm_substream = substream; /* runtime PM is also done there */ /* initialize DSD/DOP context */ subs->dsd_dop.byte_idx = 0; subs->dsd_dop.channel = 0; subs->dsd_dop.marker = 1; ret = setup_hw_info(runtime, subs); if (ret < 0) return ret; ret = snd_usb_autoresume(subs->stream->chip); if (ret < 0) return ret; ret = snd_media_stream_init(subs, as->pcm, direction); if (ret < 0) snd_usb_autosuspend(subs->stream->chip); return ret; } static int snd_usb_pcm_close(struct snd_pcm_substream *substream) { int direction = substream->stream; struct snd_usb_stream *as = snd_pcm_substream_chip(substream); struct snd_usb_substream *subs = &as->substream[direction]; int ret; snd_media_stop_pipeline(subs); if (!snd_usb_lock_shutdown(subs->stream->chip)) { ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D1); snd_usb_unlock_shutdown(subs->stream->chip); if (ret < 0) return ret; } subs->pcm_substream = NULL; snd_usb_autosuspend(subs->stream->chip); return 0; } /* Since a URB can handle only a single linear buffer, we must use double * buffering when the data to be transferred overflows the buffer boundary. * To avoid inconsistencies when updating hwptr_done, we use double buffering * for all URBs. */ static void retire_capture_urb(struct snd_usb_substream *subs, struct urb *urb) { struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; unsigned int stride, frames, bytes, oldptr; int i, period_elapsed = 0; unsigned long flags; unsigned char *cp; int current_frame_number; /* read frame number here, update pointer in critical section */ current_frame_number = usb_get_current_frame_number(subs->dev); stride = runtime->frame_bits >> 3; for (i = 0; i < urb->number_of_packets; i++) { cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset + subs->pkt_offset_adj; if (urb->iso_frame_desc[i].status && printk_ratelimit()) { dev_dbg(&subs->dev->dev, "frame %d active: %d\n", i, urb->iso_frame_desc[i].status); // continue; } bytes = urb->iso_frame_desc[i].actual_length; if (subs->stream_offset_adj > 0) { unsigned int adj = min(subs->stream_offset_adj, bytes); cp += adj; bytes -= adj; subs->stream_offset_adj -= adj; } frames = bytes / stride; if (!subs->txfr_quirk) bytes = frames * stride; if (bytes % (runtime->sample_bits >> 3) != 0) { int oldbytes = bytes; bytes = frames * stride; dev_warn_ratelimited(&subs->dev->dev, "Corrected urb data len. %d->%d\n", oldbytes, bytes); } /* update the current pointer */ spin_lock_irqsave(&subs->lock, flags); oldptr = subs->hwptr_done; subs->hwptr_done += bytes; if (subs->hwptr_done >= subs->buffer_bytes) subs->hwptr_done -= subs->buffer_bytes; frames = (bytes + (oldptr % stride)) / stride; subs->transfer_done += frames; if (subs->transfer_done >= runtime->period_size) { subs->transfer_done -= runtime->period_size; period_elapsed = 1; } /* realign last_frame_number */ subs->last_frame_number = current_frame_number; spin_unlock_irqrestore(&subs->lock, flags); /* copy a data chunk */ if (oldptr + bytes > subs->buffer_bytes) { unsigned int bytes1 = subs->buffer_bytes - oldptr; memcpy(runtime->dma_area + oldptr, cp, bytes1); memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1); } else { memcpy(runtime->dma_area + oldptr, cp, bytes); } } if (period_elapsed) snd_pcm_period_elapsed(subs->pcm_substream); } static void urb_ctx_queue_advance(struct snd_usb_substream *subs, struct urb *urb, unsigned int bytes) { struct snd_urb_ctx *ctx = urb->context; ctx->queued += bytes; subs->inflight_bytes += bytes; subs->hwptr_done += bytes; if (subs->hwptr_done >= subs->buffer_bytes) subs->hwptr_done -= subs->buffer_bytes; } static inline void fill_playback_urb_dsd_dop(struct snd_usb_substream *subs, struct urb *urb, unsigned int bytes) { struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; unsigned int dst_idx = 0; unsigned int src_idx = subs->hwptr_done; unsigned int wrap = subs->buffer_bytes; u8 *dst = urb->transfer_buffer; u8 *src = runtime->dma_area; static const u8 marker[] = { 0x05, 0xfa }; unsigned int queued = 0; /* * The DSP DOP format defines a way to transport DSD samples over * normal PCM data endpoints. It requires stuffing of marker bytes * (0x05 and 0xfa, alternating per sample frame), and then expects * 2 additional bytes of actual payload. The whole frame is stored * LSB. * * Hence, for a stereo transport, the buffer layout looks like this, * where L refers to left channel samples and R to right. * * L1 L2 0x05 R1 R2 0x05 L3 L4 0xfa R3 R4 0xfa * L5 L6 0x05 R5 R6 0x05 L7 L8 0xfa R7 R8 0xfa * ..... * */ while (bytes--) { if (++subs->dsd_dop.byte_idx == 3) { /* frame boundary? */ dst[dst_idx++] = marker[subs->dsd_dop.marker]; src_idx += 2; subs->dsd_dop.byte_idx = 0; if (++subs->dsd_dop.channel % runtime->channels == 0) { /* alternate the marker */ subs->dsd_dop.marker++; subs->dsd_dop.marker %= ARRAY_SIZE(marker); subs->dsd_dop.channel = 0; } } else { /* stuff the DSD payload */ int idx = (src_idx + subs->dsd_dop.byte_idx - 1) % wrap; if (subs->cur_audiofmt->dsd_bitrev) dst[dst_idx++] = bitrev8(src[idx]); else dst[dst_idx++] = src[idx]; queued++; } } urb_ctx_queue_advance(subs, urb, queued); } /* copy bit-reversed bytes onto transfer buffer */ static void fill_playback_urb_dsd_bitrev(struct snd_usb_substream *subs, struct urb *urb, unsigned int bytes) { struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; const u8 *src = runtime->dma_area; u8 *buf = urb->transfer_buffer; int i, ofs = subs->hwptr_done; for (i = 0; i < bytes; i++) { *buf++ = bitrev8(src[ofs]); if (++ofs >= subs->buffer_bytes) ofs = 0; } urb_ctx_queue_advance(subs, urb, bytes); } static void copy_to_urb(struct snd_usb_substream *subs, struct urb *urb, int offset, int stride, unsigned int bytes) { struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; if (subs->hwptr_done + bytes > subs->buffer_bytes) { /* err, the transferred area goes over buffer boundary. */ unsigned int bytes1 = subs->buffer_bytes - subs->hwptr_done; memcpy(urb->transfer_buffer + offset, runtime->dma_area + subs->hwptr_done, bytes1); memcpy(urb->transfer_buffer + offset + bytes1, runtime->dma_area, bytes - bytes1); } else { memcpy(urb->transfer_buffer + offset, runtime->dma_area + subs->hwptr_done, bytes); } urb_ctx_queue_advance(subs, urb, bytes); } static unsigned int copy_to_urb_quirk(struct snd_usb_substream *subs, struct urb *urb, int stride, unsigned int bytes) { __le32 packet_length; int i; /* Put __le32 length descriptor at start of each packet. */ for (i = 0; i < urb->number_of_packets; i++) { unsigned int length = urb->iso_frame_desc[i].length; unsigned int offset = urb->iso_frame_desc[i].offset; packet_length = cpu_to_le32(length); offset += i * sizeof(packet_length); urb->iso_frame_desc[i].offset = offset; urb->iso_frame_desc[i].length += sizeof(packet_length); memcpy(urb->transfer_buffer + offset, &packet_length, sizeof(packet_length)); copy_to_urb(subs, urb, offset + sizeof(packet_length), stride, length); } /* Adjust transfer size accordingly. */ bytes += urb->number_of_packets * sizeof(packet_length); return bytes; } static int prepare_playback_urb(struct snd_usb_substream *subs, struct urb *urb, bool in_stream_lock) { struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; struct snd_usb_endpoint *ep = subs->data_endpoint; struct snd_urb_ctx *ctx = urb->context; unsigned int frames, bytes; int counts; unsigned int transfer_done, frame_limit, avail = 0; int i, stride, period_elapsed = 0; unsigned long flags; int err = 0; stride = ep->stride; frames = 0; ctx->queued = 0; urb->number_of_packets = 0; spin_lock_irqsave(&subs->lock, flags); frame_limit = subs->frame_limit + ep->max_urb_frames; transfer_done = subs->transfer_done; if (subs->lowlatency_playback && runtime->state != SNDRV_PCM_STATE_DRAINING) { unsigned int hwptr = subs->hwptr_done / stride; /* calculate the byte offset-in-buffer of the appl_ptr */ avail = (runtime->control->appl_ptr - runtime->hw_ptr_base) % runtime->buffer_size; if (avail <= hwptr) avail += runtime->buffer_size; avail -= hwptr; } for (i = 0; i < ctx->packets; i++) { counts = snd_usb_endpoint_next_packet_size(ep, ctx, i, avail); if (counts < 0) break; /* set up descriptor */ urb->iso_frame_desc[i].offset = frames * stride; urb->iso_frame_desc[i].length = counts * stride; frames += counts; avail -= counts; urb->number_of_packets++; transfer_done += counts; if (transfer_done >= runtime->period_size) { transfer_done -= runtime->period_size; frame_limit = 0; period_elapsed = 1; if (subs->fmt_type == UAC_FORMAT_TYPE_II) { if (transfer_done > 0) { /* FIXME: fill-max mode is not * supported yet */ frames -= transfer_done; counts -= transfer_done; urb->iso_frame_desc[i].length = counts * stride; transfer_done = 0; } i++; if (i < ctx->packets) { /* add a transfer delimiter */ urb->iso_frame_desc[i].offset = frames * stride; urb->iso_frame_desc[i].length = 0; urb->number_of_packets++; } break; } } /* finish at the period boundary or after enough frames */ if ((period_elapsed || transfer_done >= frame_limit) && !snd_usb_endpoint_implicit_feedback_sink(ep)) break; } if (!frames) { err = -EAGAIN; goto unlock; } bytes = frames * stride; subs->transfer_done = transfer_done; subs->frame_limit = frame_limit; if (unlikely(ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE && subs->cur_audiofmt->dsd_dop)) { fill_playback_urb_dsd_dop(subs, urb, bytes); } else if (unlikely(ep->cur_format == SNDRV_PCM_FORMAT_DSD_U8 && subs->cur_audiofmt->dsd_bitrev)) { fill_playback_urb_dsd_bitrev(subs, urb, bytes); } else { /* usual PCM */ if (!subs->tx_length_quirk) copy_to_urb(subs, urb, 0, stride, bytes); else bytes = copy_to_urb_quirk(subs, urb, stride, bytes); /* bytes is now amount of outgoing data */ } subs->last_frame_number = usb_get_current_frame_number(subs->dev); if (subs->trigger_tstamp_pending_update) { /* this is the first actual URB submitted, * update trigger timestamp to reflect actual start time */ snd_pcm_gettime(runtime, &runtime->trigger_tstamp); subs->trigger_tstamp_pending_update = false; } if (period_elapsed && !subs->running && subs->lowlatency_playback) { subs->period_elapsed_pending = 1; period_elapsed = 0; } unlock: spin_unlock_irqrestore(&subs->lock, flags); if (err < 0) return err; urb->transfer_buffer_length = bytes; if (period_elapsed) { if (in_stream_lock) snd_pcm_period_elapsed_under_stream_lock(subs->pcm_substream); else snd_pcm_period_elapsed(subs->pcm_substream); } return 0; } /* * process after playback data complete * - decrease the delay count again */ static void retire_playback_urb(struct snd_usb_substream *subs, struct urb *urb) { unsigned long flags; struct snd_urb_ctx *ctx = urb->context; bool period_elapsed = false; spin_lock_irqsave(&subs->lock, flags); if (ctx->queued) { if (subs->inflight_bytes >= ctx->queued) subs->inflight_bytes -= ctx->queued; else subs->inflight_bytes = 0; } subs->last_frame_number = usb_get_current_frame_number(subs->dev); if (subs->running) { period_elapsed = subs->period_elapsed_pending; subs->period_elapsed_pending = 0; } spin_unlock_irqrestore(&subs->lock, flags); if (period_elapsed) snd_pcm_period_elapsed(subs->pcm_substream); } /* PCM ack callback for the playback stream; * this plays a role only when the stream is running in low-latency mode. */ static int snd_usb_pcm_playback_ack(struct snd_pcm_substream *substream) { struct snd_usb_substream *subs = substream->runtime->private_data; struct snd_usb_endpoint *ep; if (!subs->lowlatency_playback || !subs->running) return 0; ep = subs->data_endpoint; if (!ep) return 0; /* When no more in-flight URBs available, try to process the pending * outputs here */ if (!ep->active_mask) return snd_usb_queue_pending_output_urbs(ep, true); return 0; } static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_usb_substream *subs = substream->runtime->private_data; int err; switch (cmd) { case SNDRV_PCM_TRIGGER_START: subs->trigger_tstamp_pending_update = true; fallthrough; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: snd_usb_endpoint_set_callback(subs->data_endpoint, prepare_playback_urb, retire_playback_urb, subs); if (subs->lowlatency_playback && cmd == SNDRV_PCM_TRIGGER_START) { if (in_free_wheeling_mode(substream->runtime)) subs->lowlatency_playback = false; err = start_endpoints(subs); if (err < 0) { snd_usb_endpoint_set_callback(subs->data_endpoint, NULL, NULL, NULL); return err; } } subs->running = 1; dev_dbg(&subs->dev->dev, "%d:%d Start Playback PCM\n", subs->cur_audiofmt->iface, subs->cur_audiofmt->altsetting); return 0; case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_STOP: stop_endpoints(subs, substream->runtime->state == SNDRV_PCM_STATE_DRAINING); snd_usb_endpoint_set_callback(subs->data_endpoint, NULL, NULL, NULL); subs->running = 0; dev_dbg(&subs->dev->dev, "%d:%d Stop Playback PCM\n", subs->cur_audiofmt->iface, subs->cur_audiofmt->altsetting); return 0; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* keep retire_data_urb for delay calculation */ snd_usb_endpoint_set_callback(subs->data_endpoint, NULL, retire_playback_urb, subs); subs->running = 0; dev_dbg(&subs->dev->dev, "%d:%d Pause Playback PCM\n", subs->cur_audiofmt->iface, subs->cur_audiofmt->altsetting); return 0; } return -EINVAL; } static int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd) { int err; struct snd_usb_substream *subs = substream->runtime->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: err = start_endpoints(subs); if (err < 0) return err; fallthrough; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: snd_usb_endpoint_set_callback(subs->data_endpoint, NULL, retire_capture_urb, subs); subs->last_frame_number = usb_get_current_frame_number(subs->dev); subs->running = 1; dev_dbg(&subs->dev->dev, "%d:%d Start Capture PCM\n", subs->cur_audiofmt->iface, subs->cur_audiofmt->altsetting); return 0; case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_STOP: stop_endpoints(subs, false); fallthrough; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: snd_usb_endpoint_set_callback(subs->data_endpoint, NULL, NULL, NULL); subs->running = 0; dev_dbg(&subs->dev->dev, "%d:%d Stop Capture PCM\n", subs->cur_audiofmt->iface, subs->cur_audiofmt->altsetting); return 0; } return -EINVAL; } static const struct snd_pcm_ops snd_usb_playback_ops = { .open = snd_usb_pcm_open, .close = snd_usb_pcm_close, .hw_params = snd_usb_hw_params, .hw_free = snd_usb_hw_free, .prepare = snd_usb_pcm_prepare, .trigger = snd_usb_substream_playback_trigger, .sync_stop = snd_usb_pcm_sync_stop, .pointer = snd_usb_pcm_pointer, .ack = snd_usb_pcm_playback_ack, }; static const struct snd_pcm_ops snd_usb_capture_ops = { .open = snd_usb_pcm_open, .close = snd_usb_pcm_close, .hw_params = snd_usb_hw_params, .hw_free = snd_usb_hw_free, .prepare = snd_usb_pcm_prepare, .trigger = snd_usb_substream_capture_trigger, .sync_stop = snd_usb_pcm_sync_stop, .pointer = snd_usb_pcm_pointer, }; void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream) { const struct snd_pcm_ops *ops; ops = stream == SNDRV_PCM_STREAM_PLAYBACK ? &snd_usb_playback_ops : &snd_usb_capture_ops; snd_pcm_set_ops(pcm, stream, ops); } void snd_usb_preallocate_buffer(struct snd_usb_substream *subs) { struct snd_pcm *pcm = subs->stream->pcm; struct snd_pcm_substream *s = pcm->streams[subs->direction].substream; struct device *dev = subs->dev->bus->sysdev; if (snd_usb_use_vmalloc) snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0); else snd_pcm_set_managed_buffer(s, SNDRV_DMA_TYPE_DEV_SG, dev, 64*1024, 512*1024); }
linux-master
sound/usb/pcm.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Clock domain and sample rate management functions */ #include <linux/bitops.h> #include <linux/init.h> #include <linux/string.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <linux/usb/audio-v3.h> #include <sound/core.h> #include <sound/info.h> #include <sound/pcm.h> #include "usbaudio.h" #include "card.h" #include "helper.h" #include "clock.h" #include "quirks.h" union uac23_clock_source_desc { struct uac_clock_source_descriptor v2; struct uac3_clock_source_descriptor v3; }; union uac23_clock_selector_desc { struct uac_clock_selector_descriptor v2; struct uac3_clock_selector_descriptor v3; }; union uac23_clock_multiplier_desc { struct uac_clock_multiplier_descriptor v2; struct uac_clock_multiplier_descriptor v3; }; #define GET_VAL(p, proto, field) \ ((proto) == UAC_VERSION_3 ? (p)->v3.field : (p)->v2.field) static void *find_uac_clock_desc(struct usb_host_interface *iface, int id, bool (*validator)(void *, int, int), u8 type, int proto) { void *cs = NULL; while ((cs = snd_usb_find_csint_desc(iface->extra, iface->extralen, cs, type))) { if (validator(cs, id, proto)) return cs; } return NULL; } static bool validate_clock_source(void *p, int id, int proto) { union uac23_clock_source_desc *cs = p; return GET_VAL(cs, proto, bClockID) == id; } static bool validate_clock_selector(void *p, int id, int proto) { union uac23_clock_selector_desc *cs = p; return GET_VAL(cs, proto, bClockID) == id; } static bool validate_clock_multiplier(void *p, int id, int proto) { union uac23_clock_multiplier_desc *cs = p; return GET_VAL(cs, proto, bClockID) == id; } #define DEFINE_FIND_HELPER(name, obj, validator, type2, type3) \ static obj *name(struct snd_usb_audio *chip, int id, int proto) \ { \ return find_uac_clock_desc(chip->ctrl_intf, id, validator, \ proto == UAC_VERSION_3 ? (type3) : (type2), \ proto); \ } DEFINE_FIND_HELPER(snd_usb_find_clock_source, union uac23_clock_source_desc, validate_clock_source, UAC2_CLOCK_SOURCE, UAC3_CLOCK_SOURCE); DEFINE_FIND_HELPER(snd_usb_find_clock_selector, union uac23_clock_selector_desc, validate_clock_selector, UAC2_CLOCK_SELECTOR, UAC3_CLOCK_SELECTOR); DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier, union uac23_clock_multiplier_desc, validate_clock_multiplier, UAC2_CLOCK_MULTIPLIER, UAC3_CLOCK_MULTIPLIER); static int uac_clock_selector_get_val(struct snd_usb_audio *chip, int selector_id) { unsigned char buf; int ret; ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, UAC2_CX_CLOCK_SELECTOR << 8, snd_usb_ctrl_intf(chip) | (selector_id << 8), &buf, sizeof(buf)); if (ret < 0) return ret; return buf; } static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_id, unsigned char pin) { int ret; ret = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC2_CS_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, UAC2_CX_CLOCK_SELECTOR << 8, snd_usb_ctrl_intf(chip) | (selector_id << 8), &pin, sizeof(pin)); if (ret < 0) return ret; if (ret != sizeof(pin)) { usb_audio_err(chip, "setting selector (id %d) unexpected length %d\n", selector_id, ret); return -EINVAL; } ret = uac_clock_selector_get_val(chip, selector_id); if (ret < 0) return ret; if (ret != pin) { usb_audio_err(chip, "setting selector (id %d) to %x failed (current: %d)\n", selector_id, pin, ret); return -EINVAL; } return ret; } static bool uac_clock_source_is_valid_quirk(struct snd_usb_audio *chip, const struct audioformat *fmt, int source_id) { bool ret = false; int count; unsigned char data; struct usb_device *dev = chip->dev; union uac23_clock_source_desc *cs_desc; cs_desc = snd_usb_find_clock_source(chip, source_id, fmt->protocol); if (!cs_desc) return false; if (fmt->protocol == UAC_VERSION_2) { /* * Assume the clock is valid if clock source supports only one * single sample rate, the terminal is connected directly to it * (there is no clock selector) and clock type is internal. * This is to deal with some Denon DJ controllers that always * reports that clock is invalid. */ if (fmt->nr_rates == 1 && (fmt->clock & 0xff) == cs_desc->v2.bClockID && (cs_desc->v2.bmAttributes & 0x3) != UAC_CLOCK_SOURCE_TYPE_EXT) return true; } /* * MOTU MicroBook IIc * Sample rate changes takes more than 2 seconds for this device. Clock * validity request returns false during that period. */ if (chip->usb_id == USB_ID(0x07fd, 0x0004)) { count = 0; while ((!ret) && (count < 50)) { int err; msleep(100); err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR, USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, UAC2_CS_CONTROL_CLOCK_VALID << 8, snd_usb_ctrl_intf(chip) | (source_id << 8), &data, sizeof(data)); if (err < 0) { dev_warn(&dev->dev, "%s(): cannot get clock validity for id %d\n", __func__, source_id); return false; } ret = !!data; count++; } } return ret; } static bool uac_clock_source_is_valid(struct snd_usb_audio *chip, const struct audioformat *fmt, int source_id) { int err; unsigned char data; struct usb_device *dev = chip->dev; u32 bmControls; union uac23_clock_source_desc *cs_desc; cs_desc = snd_usb_find_clock_source(chip, source_id, fmt->protocol); if (!cs_desc) return false; if (fmt->protocol == UAC_VERSION_3) bmControls = le32_to_cpu(cs_desc->v3.bmControls); else bmControls = cs_desc->v2.bmControls; /* If a clock source can't tell us whether it's valid, we assume it is */ if (!uac_v2v3_control_is_readable(bmControls, UAC2_CS_CONTROL_CLOCK_VALID)) return true; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR, USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, UAC2_CS_CONTROL_CLOCK_VALID << 8, snd_usb_ctrl_intf(chip) | (source_id << 8), &data, sizeof(data)); if (err < 0) { dev_warn(&dev->dev, "%s(): cannot get clock validity for id %d\n", __func__, source_id); return false; } if (data) return true; else return uac_clock_source_is_valid_quirk(chip, fmt, source_id); } static int __uac_clock_find_source(struct snd_usb_audio *chip, const struct audioformat *fmt, int entity_id, unsigned long *visited, bool validate) { union uac23_clock_source_desc *source; union uac23_clock_selector_desc *selector; union uac23_clock_multiplier_desc *multiplier; int ret, i, cur, err, pins, clock_id; const u8 *sources; int proto = fmt->protocol; entity_id &= 0xff; if (test_and_set_bit(entity_id, visited)) { usb_audio_warn(chip, "%s(): recursive clock topology detected, id %d.\n", __func__, entity_id); return -EINVAL; } /* first, see if the ID we're looking at is a clock source already */ source = snd_usb_find_clock_source(chip, entity_id, proto); if (source) { entity_id = GET_VAL(source, proto, bClockID); if (validate && !uac_clock_source_is_valid(chip, fmt, entity_id)) { usb_audio_err(chip, "clock source %d is not valid, cannot use\n", entity_id); return -ENXIO; } return entity_id; } selector = snd_usb_find_clock_selector(chip, entity_id, proto); if (selector) { pins = GET_VAL(selector, proto, bNrInPins); clock_id = GET_VAL(selector, proto, bClockID); sources = GET_VAL(selector, proto, baCSourceID); cur = 0; if (pins == 1) { ret = 1; goto find_source; } /* the entity ID we are looking at is a selector. * find out what it currently selects */ ret = uac_clock_selector_get_val(chip, clock_id); if (ret < 0) { if (!chip->autoclock) return ret; goto find_others; } /* Selector values are one-based */ if (ret > pins || ret < 1) { usb_audio_err(chip, "%s(): selector reported illegal value, id %d, ret %d\n", __func__, clock_id, ret); if (!chip->autoclock) return -EINVAL; goto find_others; } find_source: cur = ret; ret = __uac_clock_find_source(chip, fmt, sources[ret - 1], visited, validate); if (ret > 0) { /* Skip setting clock selector again for some devices */ if (chip->quirk_flags & QUIRK_FLAG_SKIP_CLOCK_SELECTOR) return ret; err = uac_clock_selector_set_val(chip, entity_id, cur); if (err < 0) return err; } if (!validate || ret > 0 || !chip->autoclock) return ret; find_others: /* The current clock source is invalid, try others. */ for (i = 1; i <= pins; i++) { if (i == cur) continue; ret = __uac_clock_find_source(chip, fmt, sources[i - 1], visited, true); if (ret < 0) continue; err = uac_clock_selector_set_val(chip, entity_id, i); if (err < 0) continue; usb_audio_info(chip, "found and selected valid clock source %d\n", ret); return ret; } return -ENXIO; } /* FIXME: multipliers only act as pass-thru element for now */ multiplier = snd_usb_find_clock_multiplier(chip, entity_id, proto); if (multiplier) return __uac_clock_find_source(chip, fmt, GET_VAL(multiplier, proto, bCSourceID), visited, validate); return -EINVAL; } /* * For all kinds of sample rate settings and other device queries, * the clock source (end-leaf) must be used. However, clock selectors, * clock multipliers and sample rate converters may be specified as * clock source input to terminal. This functions walks the clock path * to its end and tries to find the source. * * The 'visited' bitfield is used internally to detect recursive loops. * * Returns the clock source UnitID (>=0) on success, or an error. */ int snd_usb_clock_find_source(struct snd_usb_audio *chip, const struct audioformat *fmt, bool validate) { DECLARE_BITMAP(visited, 256); memset(visited, 0, sizeof(visited)); switch (fmt->protocol) { case UAC_VERSION_2: case UAC_VERSION_3: return __uac_clock_find_source(chip, fmt, fmt->clock, visited, validate); default: return -EINVAL; } } static int set_sample_rate_v1(struct snd_usb_audio *chip, const struct audioformat *fmt, int rate) { struct usb_device *dev = chip->dev; unsigned char data[3]; int err, crate; /* if endpoint doesn't have sampling rate control, bail out */ if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE)) return 0; data[0] = rate; data[1] = rate >> 8; data[2] = rate >> 16; err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT, UAC_EP_CS_ATTR_SAMPLE_RATE << 8, fmt->endpoint, data, sizeof(data)); if (err < 0) { dev_err(&dev->dev, "%d:%d: cannot set freq %d to ep %#x\n", fmt->iface, fmt->altsetting, rate, fmt->endpoint); return err; } /* Don't check the sample rate for devices which we know don't * support reading */ if (chip->quirk_flags & QUIRK_FLAG_GET_SAMPLE_RATE) return 0; /* the firmware is likely buggy, don't repeat to fail too many times */ if (chip->sample_rate_read_error > 2) return 0; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR, USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN, UAC_EP_CS_ATTR_SAMPLE_RATE << 8, fmt->endpoint, data, sizeof(data)); if (err < 0) { dev_err(&dev->dev, "%d:%d: cannot get freq at ep %#x\n", fmt->iface, fmt->altsetting, fmt->endpoint); chip->sample_rate_read_error++; return 0; /* some devices don't support reading */ } crate = data[0] | (data[1] << 8) | (data[2] << 16); if (!crate) { dev_info(&dev->dev, "failed to read current rate; disabling the check\n"); chip->sample_rate_read_error = 3; /* three strikes, see above */ return 0; } if (crate != rate) { dev_warn(&dev->dev, "current rate %d is different from the runtime rate %d\n", crate, rate); // runtime->rate = crate; } return 0; } static int get_sample_rate_v2v3(struct snd_usb_audio *chip, int iface, int altsetting, int clock) { struct usb_device *dev = chip->dev; __le32 data; int err; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR, USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, UAC2_CS_CONTROL_SAM_FREQ << 8, snd_usb_ctrl_intf(chip) | (clock << 8), &data, sizeof(data)); if (err < 0) { dev_warn(&dev->dev, "%d:%d: cannot get freq (v2/v3): err %d\n", iface, altsetting, err); return 0; } return le32_to_cpu(data); } /* * Try to set the given sample rate: * * Return 0 if the clock source is read-only, the actual rate on success, * or a negative error code. * * This function gets called from format.c to validate each sample rate, too. * Hence no message is shown upon error */ int snd_usb_set_sample_rate_v2v3(struct snd_usb_audio *chip, const struct audioformat *fmt, int clock, int rate) { bool writeable; u32 bmControls; __le32 data; int err; union uac23_clock_source_desc *cs_desc; cs_desc = snd_usb_find_clock_source(chip, clock, fmt->protocol); if (!cs_desc) return 0; if (fmt->protocol == UAC_VERSION_3) bmControls = le32_to_cpu(cs_desc->v3.bmControls); else bmControls = cs_desc->v2.bmControls; writeable = uac_v2v3_control_is_writeable(bmControls, UAC2_CS_CONTROL_SAM_FREQ); if (!writeable) return 0; data = cpu_to_le32(rate); err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC2_CS_CUR, USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, UAC2_CS_CONTROL_SAM_FREQ << 8, snd_usb_ctrl_intf(chip) | (clock << 8), &data, sizeof(data)); if (err < 0) return err; return get_sample_rate_v2v3(chip, fmt->iface, fmt->altsetting, clock); } static int set_sample_rate_v2v3(struct snd_usb_audio *chip, const struct audioformat *fmt, int rate) { int cur_rate, prev_rate; int clock; /* First, try to find a valid clock. This may trigger * automatic clock selection if the current clock is not * valid. */ clock = snd_usb_clock_find_source(chip, fmt, true); if (clock < 0) { /* We did not find a valid clock, but that might be * because the current sample rate does not match an * external clock source. Try again without validation * and we will do another validation after setting the * rate. */ clock = snd_usb_clock_find_source(chip, fmt, false); /* Hardcoded sample rates */ if (chip->quirk_flags & QUIRK_FLAG_IGNORE_CLOCK_SOURCE) return 0; if (clock < 0) return clock; } prev_rate = get_sample_rate_v2v3(chip, fmt->iface, fmt->altsetting, clock); if (prev_rate == rate) goto validation; cur_rate = snd_usb_set_sample_rate_v2v3(chip, fmt, clock, rate); if (cur_rate < 0) { usb_audio_err(chip, "%d:%d: cannot set freq %d (v2/v3): err %d\n", fmt->iface, fmt->altsetting, rate, cur_rate); return cur_rate; } if (!cur_rate) cur_rate = prev_rate; if (cur_rate != rate) { usb_audio_dbg(chip, "%d:%d: freq mismatch: req %d, clock runs @%d\n", fmt->iface, fmt->altsetting, rate, cur_rate); /* continue processing */ } /* FIXME - TEAC devices require the immediate interface setup */ if (USB_ID_VENDOR(chip->usb_id) == 0x0644) { bool cur_base_48k = (rate % 48000 == 0); bool prev_base_48k = (prev_rate % 48000 == 0); if (cur_base_48k != prev_base_48k) { usb_set_interface(chip->dev, fmt->iface, fmt->altsetting); if (chip->quirk_flags & QUIRK_FLAG_IFACE_DELAY) msleep(50); } } validation: /* validate clock after rate change */ if (!uac_clock_source_is_valid(chip, fmt, clock)) return -ENXIO; return 0; } int snd_usb_init_sample_rate(struct snd_usb_audio *chip, const struct audioformat *fmt, int rate) { usb_audio_dbg(chip, "%d:%d Set sample rate %d, clock %d\n", fmt->iface, fmt->altsetting, rate, fmt->clock); switch (fmt->protocol) { case UAC_VERSION_1: default: return set_sample_rate_v1(chip, fmt, rate); case UAC_VERSION_3: if (chip->badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { if (rate != UAC3_BADD_SAMPLING_RATE) return -ENXIO; else return 0; } fallthrough; case UAC_VERSION_2: return set_sample_rate_v2v3(chip, fmt, rate); } }
linux-master
sound/usb/clock.c
// SPDX-License-Identifier: GPL-2.0 /* * Focusrite Scarlett Gen 2/3 and Clarett+ Driver for ALSA * * Supported models: * - 6i6/18i8/18i20 Gen 2 * - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3 * - Clarett+ 8Pre * * Copyright (c) 2018-2022 by Geoffrey D. Bennett <g at b4.vu> * Copyright (c) 2020-2021 by Vladimir Sadovnikov <[email protected]> * Copyright (c) 2022 by Christian Colglazier <[email protected]> * * Based on the Scarlett (Gen 1) Driver for ALSA: * * Copyright (c) 2013 by Tobias Hoffmann * Copyright (c) 2013 by Robin Gareus <robin at gareus.org> * Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de> * Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com> * * Many codes borrowed from audio.c by * Alan Cox (alan at lxorguk.ukuu.org.uk) * Thomas Sailer (sailer at ife.ee.ethz.ch) * * Code cleanup: * David Henningsson <david.henningsson at canonical.com> */ /* The protocol was reverse engineered by looking at the communication * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20 * (firmware 1083) using usbmon in July-August 2018. * * Scarlett 18i8 support added in April 2019. * * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann * for providing usbmon output and testing). * * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6 * usbmon output and testing). * * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to * Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon * output, protocol traces and testing). * * Support for loading mixer volume and mux configuration from the * interface during driver initialisation added in May 2021 (thanks to * Vladimir Sadovnikov for figuring out how). * * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander * Vorona for 2i2 protocol traces). * * Support for phantom power, direct monitoring, speaker switching, * and talkback added in May-June 2021. * * Support for Clarett+ 8Pre added in Aug 2022 by Christian * Colglazier. * * This ALSA mixer gives access to (model-dependent): * - input, output, mixer-matrix muxes * - mixer-matrix gain stages * - gain/volume/mute controls * - level meters * - line/inst level, pad, and air controls * - phantom power, direct monitor, speaker switching, and talkback * controls * - disable/enable MSD mode * - disable/enable standalone mode * * <ditaa> * /--------------\ 18chn 20chn /--------------\ * | Hardware in +--+------\ /-------------+--+ ALSA PCM out | * \--------------/ | | | | \--------------/ * | | | /-----\ | * | | | | | | * | v v v | | * | +---------------+ | | * | \ Matrix Mux / | | * | +-----+-----+ | | * | | | | * | |18chn | | * | | | | * | | 10chn| | * | v | | * | +------------+ | | * | | Mixer | | | * | | Matrix | | | * | | | | | * | | 18x10 Gain | | | * | | stages | | | * | +-----+------+ | | * | | | | * |18chn |10chn | |20chn * | | | | * | +----------/ | * | | | * v v v * =========================== * +---------------+ +--—------------+ * \ Output Mux / \ Capture Mux / * +---+---+---+ +-----+-----+ * | | | * 10chn| | |18chn * | | | * /--------------\ | | | /--------------\ * | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in | * | Hardware out | | \--------------/ * \--------------/ | * v * +-------------+ Software gain per channel. * | Master Gain |<-- 18i20 only: Switch per channel * +------+------+ to select HW or SW gain control. * | * |10chn * /--------------\ | * | Analogue |<------/ * | Hardware out | * \--------------/ * </ditaa> * * Gen 3 devices have a Mass Storage Device (MSD) mode where a small * disk with registration and driver download information is presented * to the host. To access the full functionality of the device without * proprietary software, MSD mode can be disabled by: * - holding down the 48V button for five seconds while powering on * the device, or * - using this driver and alsamixer to change the "MSD Mode" setting * to Off and power-cycling the device */ #include <linux/slab.h> #include <linux/usb.h> #include <linux/moduleparam.h> #include <sound/control.h> #include <sound/tlv.h> #include "usbaudio.h" #include "mixer.h" #include "helper.h" #include "mixer_scarlett_gen2.h" /* device_setup value to enable */ #define SCARLETT2_ENABLE 0x01 /* device_setup value to allow turning MSD mode back on */ #define SCARLETT2_MSD_ENABLE 0x02 /* some gui mixers can't handle negative ctl values */ #define SCARLETT2_VOLUME_BIAS 127 /* mixer range from -80dB to +6dB in 0.5dB steps */ #define SCARLETT2_MIXER_MIN_DB -80 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2) #define SCARLETT2_MIXER_MAX_DB 6 #define SCARLETT2_MIXER_MAX_VALUE \ ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2) #define SCARLETT2_MIXER_VALUE_COUNT (SCARLETT2_MIXER_MAX_VALUE + 1) /* map from (dB + 80) * 2 to mixer value * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20))) */ static const u16 scarlett2_mixer_values[SCARLETT2_MIXER_VALUE_COUNT] = { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51, 54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115, 122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230, 244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460, 487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919, 973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634, 1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906, 3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168, 5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191, 9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430, 16345 }; /* Maximum number of analogue outputs */ #define SCARLETT2_ANALOGUE_MAX 10 /* Maximum number of level and pad switches */ #define SCARLETT2_LEVEL_SWITCH_MAX 2 #define SCARLETT2_PAD_SWITCH_MAX 8 #define SCARLETT2_AIR_SWITCH_MAX 8 #define SCARLETT2_PHANTOM_SWITCH_MAX 2 /* Maximum number of inputs to the mixer */ #define SCARLETT2_INPUT_MIX_MAX 25 /* Maximum number of outputs from the mixer */ #define SCARLETT2_OUTPUT_MIX_MAX 12 /* Maximum size of the data in the USB mux assignment message: * 20 inputs, 20 outputs, 25 matrix inputs, 12 spare */ #define SCARLETT2_MUX_MAX 77 /* Maximum number of meters (sum of output port counts) */ #define SCARLETT2_MAX_METERS 65 /* There are three different sets of configuration parameters across * the devices */ enum { SCARLETT2_CONFIG_SET_NO_MIXER = 0, SCARLETT2_CONFIG_SET_GEN_2 = 1, SCARLETT2_CONFIG_SET_GEN_3 = 2, SCARLETT2_CONFIG_SET_CLARETT = 3, SCARLETT2_CONFIG_SET_COUNT = 4 }; /* Hardware port types: * - None (no input to mux) * - Analogue I/O * - S/PDIF I/O * - ADAT I/O * - Mixer I/O * - PCM I/O */ enum { SCARLETT2_PORT_TYPE_NONE = 0, SCARLETT2_PORT_TYPE_ANALOGUE = 1, SCARLETT2_PORT_TYPE_SPDIF = 2, SCARLETT2_PORT_TYPE_ADAT = 3, SCARLETT2_PORT_TYPE_MIX = 4, SCARLETT2_PORT_TYPE_PCM = 5, SCARLETT2_PORT_TYPE_COUNT = 6, }; /* I/O count of each port type kept in struct scarlett2_ports */ enum { SCARLETT2_PORT_IN = 0, SCARLETT2_PORT_OUT = 1, SCARLETT2_PORT_DIRNS = 2, }; /* Dim/Mute buttons on the 18i20 */ enum { SCARLETT2_BUTTON_MUTE = 0, SCARLETT2_BUTTON_DIM = 1, SCARLETT2_DIM_MUTE_COUNT = 2, }; static const char *const scarlett2_dim_mute_names[SCARLETT2_DIM_MUTE_COUNT] = { "Mute Playback Switch", "Dim Playback Switch" }; /* Description of each hardware port type: * - id: hardware ID of this port type * - src_descr: printf format string for mux input selections * - src_num_offset: added to channel number for the fprintf * - dst_descr: printf format string for mixer controls */ struct scarlett2_port { u16 id; const char * const src_descr; int src_num_offset; const char * const dst_descr; }; static const struct scarlett2_port scarlett2_ports[SCARLETT2_PORT_TYPE_COUNT] = { [SCARLETT2_PORT_TYPE_NONE] = { .id = 0x000, .src_descr = "Off" }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { .id = 0x080, .src_descr = "Analogue %d", .src_num_offset = 1, .dst_descr = "Analogue Output %02d Playback" }, [SCARLETT2_PORT_TYPE_SPDIF] = { .id = 0x180, .src_descr = "S/PDIF %d", .src_num_offset = 1, .dst_descr = "S/PDIF Output %d Playback" }, [SCARLETT2_PORT_TYPE_ADAT] = { .id = 0x200, .src_descr = "ADAT %d", .src_num_offset = 1, .dst_descr = "ADAT Output %d Playback" }, [SCARLETT2_PORT_TYPE_MIX] = { .id = 0x300, .src_descr = "Mix %c", .src_num_offset = 'A', .dst_descr = "Mixer Input %02d Capture" }, [SCARLETT2_PORT_TYPE_PCM] = { .id = 0x600, .src_descr = "PCM %d", .src_num_offset = 1, .dst_descr = "PCM %02d Capture" }, }; /* Number of mux tables: one for each band of sample rates * (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz) */ #define SCARLETT2_MUX_TABLES 3 /* Maximum number of entries in a mux table */ #define SCARLETT2_MAX_MUX_ENTRIES 10 /* One entry within mux_assignment defines the port type and range of * ports to add to the set_mux message. The end of the list is marked * with count == 0. */ struct scarlett2_mux_entry { u8 port_type; u8 start; u8 count; }; struct scarlett2_device_info { u32 usb_id; /* USB device identifier */ /* Gen 3 devices have an internal MSD mode switch that needs * to be disabled in order to access the full functionality of * the device. */ u8 has_msd_mode; /* which set of configuration parameters the device uses */ u8 config_set; /* line out hw volume is sw controlled */ u8 line_out_hw_vol; /* support for main/alt speaker switching */ u8 has_speaker_switching; /* support for talkback microphone */ u8 has_talkback; /* the number of analogue inputs with a software switchable * level control that can be set to line or instrument */ u8 level_input_count; /* the first input with a level control (0-based) */ u8 level_input_first; /* the number of analogue inputs with a software switchable * 10dB pad control */ u8 pad_input_count; /* the number of analogue inputs with a software switchable * "air" control */ u8 air_input_count; /* the number of phantom (48V) software switchable controls */ u8 phantom_count; /* the number of inputs each phantom switch controls */ u8 inputs_per_phantom; /* the number of direct monitor options * (0 = none, 1 = mono only, 2 = mono/stereo) */ u8 direct_monitor; /* remap analogue outputs; 18i8 Gen 3 has "line 3/4" connected * internally to the analogue 7/8 outputs */ u8 line_out_remap_enable; u8 line_out_remap[SCARLETT2_ANALOGUE_MAX]; /* additional description for the line out volume controls */ const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX]; /* number of sources/destinations of each port type */ const int port_count[SCARLETT2_PORT_TYPE_COUNT][SCARLETT2_PORT_DIRNS]; /* layout/order of the entries in the set_mux message */ struct scarlett2_mux_entry mux_assignment[SCARLETT2_MUX_TABLES] [SCARLETT2_MAX_MUX_ENTRIES]; }; struct scarlett2_data { struct usb_mixer_interface *mixer; struct mutex usb_mutex; /* prevent sending concurrent USB requests */ struct mutex data_mutex; /* lock access to this data */ struct delayed_work work; const struct scarlett2_device_info *info; __u8 bInterfaceNumber; __u8 bEndpointAddress; __u16 wMaxPacketSize; __u8 bInterval; int num_mux_srcs; int num_mux_dsts; u16 scarlett2_seq; u8 sync_updated; u8 vol_updated; u8 input_other_updated; u8 monitor_other_updated; u8 mux_updated; u8 speaker_switching_switched; u8 sync; u8 master_vol; u8 vol[SCARLETT2_ANALOGUE_MAX]; u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX]; u8 mute_switch[SCARLETT2_ANALOGUE_MAX]; u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX]; u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX]; u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT]; u8 air_switch[SCARLETT2_AIR_SWITCH_MAX]; u8 phantom_switch[SCARLETT2_PHANTOM_SWITCH_MAX]; u8 phantom_persistence; u8 direct_monitor_switch; u8 speaker_switching_switch; u8 talkback_switch; u8 talkback_map[SCARLETT2_OUTPUT_MIX_MAX]; u8 msd_switch; u8 standalone_switch; struct snd_kcontrol *sync_ctl; struct snd_kcontrol *master_vol_ctl; struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX]; struct snd_kcontrol *sw_hw_ctls[SCARLETT2_ANALOGUE_MAX]; struct snd_kcontrol *mute_ctls[SCARLETT2_ANALOGUE_MAX]; struct snd_kcontrol *dim_mute_ctls[SCARLETT2_DIM_MUTE_COUNT]; struct snd_kcontrol *level_ctls[SCARLETT2_LEVEL_SWITCH_MAX]; struct snd_kcontrol *pad_ctls[SCARLETT2_PAD_SWITCH_MAX]; struct snd_kcontrol *air_ctls[SCARLETT2_AIR_SWITCH_MAX]; struct snd_kcontrol *phantom_ctls[SCARLETT2_PHANTOM_SWITCH_MAX]; struct snd_kcontrol *mux_ctls[SCARLETT2_MUX_MAX]; struct snd_kcontrol *direct_monitor_ctl; struct snd_kcontrol *speaker_switching_ctl; struct snd_kcontrol *talkback_ctl; u8 mux[SCARLETT2_MUX_MAX]; u8 mix[SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX]; }; /*** Model-specific data ***/ static const struct scarlett2_device_info s6i6_gen2_info = { .usb_id = USB_ID(0x1235, 0x8203), .config_set = SCARLETT2_CONFIG_SET_GEN_2, .level_input_count = 2, .pad_input_count = 2, .line_out_descrs = { "Headphones 1 L", "Headphones 1 R", "Headphones 2 L", "Headphones 2 R", }, .port_count = { [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 }, [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, [SCARLETT2_PORT_TYPE_PCM] = { 6, 6 }, }, .mux_assignment = { { { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, } }, }; static const struct scarlett2_device_info s18i8_gen2_info = { .usb_id = USB_ID(0x1235, 0x8204), .config_set = SCARLETT2_CONFIG_SET_GEN_2, .level_input_count = 2, .pad_input_count = 4, .line_out_descrs = { "Monitor L", "Monitor R", "Headphones 1 L", "Headphones 1 R", "Headphones 2 L", "Headphones 2 R", }, .port_count = { [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 }, [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 }, [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, [SCARLETT2_PORT_TYPE_PCM] = { 8, 18 }, }, .mux_assignment = { { { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 4 }, { 0, 0, 0 }, } }, }; static const struct scarlett2_device_info s18i20_gen2_info = { .usb_id = USB_ID(0x1235, 0x8201), .config_set = SCARLETT2_CONFIG_SET_GEN_2, .line_out_hw_vol = 1, .line_out_descrs = { "Monitor L", "Monitor R", NULL, NULL, NULL, NULL, "Headphones 1 L", "Headphones 1 R", "Headphones 2 L", "Headphones 2 R", }, .port_count = { [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 }, [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, [SCARLETT2_PORT_TYPE_PCM] = { 20, 18 }, }, .mux_assignment = { { { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_ADAT, 0, 4 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 6 }, { 0, 0, 0 }, } }, }; static const struct scarlett2_device_info solo_gen3_info = { .usb_id = USB_ID(0x1235, 0x8211), .has_msd_mode = 1, .config_set = SCARLETT2_CONFIG_SET_NO_MIXER, .level_input_count = 1, .level_input_first = 1, .air_input_count = 1, .phantom_count = 1, .inputs_per_phantom = 1, .direct_monitor = 1, }; static const struct scarlett2_device_info s2i2_gen3_info = { .usb_id = USB_ID(0x1235, 0x8210), .has_msd_mode = 1, .config_set = SCARLETT2_CONFIG_SET_NO_MIXER, .level_input_count = 2, .air_input_count = 2, .phantom_count = 1, .inputs_per_phantom = 2, .direct_monitor = 2, }; static const struct scarlett2_device_info s4i4_gen3_info = { .usb_id = USB_ID(0x1235, 0x8212), .has_msd_mode = 1, .config_set = SCARLETT2_CONFIG_SET_GEN_3, .level_input_count = 2, .pad_input_count = 2, .air_input_count = 2, .phantom_count = 1, .inputs_per_phantom = 2, .line_out_descrs = { "Monitor L", "Monitor R", "Headphones L", "Headphones R", }, .port_count = { [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 }, [SCARLETT2_PORT_TYPE_MIX] = { 6, 8 }, [SCARLETT2_PORT_TYPE_PCM] = { 4, 6 }, }, .mux_assignment = { { { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, { 0, 0, 0 }, } }, }; static const struct scarlett2_device_info s8i6_gen3_info = { .usb_id = USB_ID(0x1235, 0x8213), .has_msd_mode = 1, .config_set = SCARLETT2_CONFIG_SET_GEN_3, .level_input_count = 2, .pad_input_count = 2, .air_input_count = 2, .phantom_count = 1, .inputs_per_phantom = 2, .line_out_descrs = { "Headphones 1 L", "Headphones 1 R", "Headphones 2 L", "Headphones 2 R", }, .port_count = { [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { 6, 4 }, [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, [SCARLETT2_PORT_TYPE_MIX] = { 8, 8 }, [SCARLETT2_PORT_TYPE_PCM] = { 6, 10 }, }, .mux_assignment = { { { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, { 0, 0, 0 }, } }, }; static const struct scarlett2_device_info s18i8_gen3_info = { .usb_id = USB_ID(0x1235, 0x8214), .has_msd_mode = 1, .config_set = SCARLETT2_CONFIG_SET_GEN_3, .line_out_hw_vol = 1, .has_speaker_switching = 1, .level_input_count = 2, .pad_input_count = 4, .air_input_count = 4, .phantom_count = 2, .inputs_per_phantom = 2, .line_out_remap_enable = 1, .line_out_remap = { 0, 1, 6, 7, 2, 3, 4, 5 }, .line_out_descrs = { "Monitor L", "Monitor R", "Alt Monitor L", "Alt Monitor R", "Headphones 1 L", "Headphones 1 R", "Headphones 2 L", "Headphones 2 R", }, .port_count = { [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 8 }, [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 }, [SCARLETT2_PORT_TYPE_MIX] = { 10, 20 }, [SCARLETT2_PORT_TYPE_PCM] = { 8, 20 }, }, .mux_assignment = { { { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, { SCARLETT2_PORT_TYPE_PCM, 12, 8 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_PCM, 10, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, { SCARLETT2_PORT_TYPE_PCM, 12, 4 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_PCM, 10, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, { 0, 0, 0 }, } }, }; static const struct scarlett2_device_info s18i20_gen3_info = { .usb_id = USB_ID(0x1235, 0x8215), .has_msd_mode = 1, .config_set = SCARLETT2_CONFIG_SET_GEN_3, .line_out_hw_vol = 1, .has_speaker_switching = 1, .has_talkback = 1, .level_input_count = 2, .pad_input_count = 8, .air_input_count = 8, .phantom_count = 2, .inputs_per_phantom = 4, .line_out_descrs = { "Monitor 1 L", "Monitor 1 R", "Monitor 2 L", "Monitor 2 R", NULL, NULL, "Headphones 1 L", "Headphones 1 R", "Headphones 2 L", "Headphones 2 R", }, .port_count = { [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { 9, 10 }, [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, [SCARLETT2_PORT_TYPE_MIX] = { 12, 25 }, [SCARLETT2_PORT_TYPE_PCM] = { 20, 20 }, }, .mux_assignment = { { { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, { SCARLETT2_PORT_TYPE_PCM, 10, 10 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 25 }, { SCARLETT2_PORT_TYPE_NONE, 0, 12 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, { SCARLETT2_PORT_TYPE_PCM, 10, 8 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, { SCARLETT2_PORT_TYPE_MIX, 0, 25 }, { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_NONE, 0, 24 }, { 0, 0, 0 }, } }, }; static const struct scarlett2_device_info clarett_8pre_info = { .usb_id = USB_ID(0x1235, 0x820c), .config_set = SCARLETT2_CONFIG_SET_CLARETT, .line_out_hw_vol = 1, .level_input_count = 2, .air_input_count = 8, .line_out_descrs = { "Monitor L", "Monitor R", NULL, NULL, NULL, NULL, "Headphones 1 L", "Headphones 1 R", "Headphones 2 L", "Headphones 2 R", }, .port_count = { [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 }, [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, [SCARLETT2_PORT_TYPE_PCM] = { 20, 18 }, }, .mux_assignment = { { { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_ADAT, 0, 4 }, { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, { 0, 0, 0 }, }, { { SCARLETT2_PORT_TYPE_PCM, 0, 12 }, { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, { SCARLETT2_PORT_TYPE_NONE, 0, 22 }, { 0, 0, 0 }, } }, }; static const struct scarlett2_device_info *scarlett2_devices[] = { /* Supported Gen 2 devices */ &s6i6_gen2_info, &s18i8_gen2_info, &s18i20_gen2_info, /* Supported Gen 3 devices */ &solo_gen3_info, &s2i2_gen3_info, &s4i4_gen3_info, &s8i6_gen3_info, &s18i8_gen3_info, &s18i20_gen3_info, /* Supported Clarett+ devices */ &clarett_8pre_info, /* End of list */ NULL }; /* get the starting port index number for a given port type/direction */ static int scarlett2_get_port_start_num( const int port_count[][SCARLETT2_PORT_DIRNS], int direction, int port_type) { int i, num = 0; for (i = 0; i < port_type; i++) num += port_count[i][direction]; return num; } /*** USB Interactions ***/ /* Notifications from the interface */ #define SCARLETT2_USB_NOTIFY_SYNC 0x00000008 #define SCARLETT2_USB_NOTIFY_DIM_MUTE 0x00200000 #define SCARLETT2_USB_NOTIFY_MONITOR 0x00400000 #define SCARLETT2_USB_NOTIFY_INPUT_OTHER 0x00800000 #define SCARLETT2_USB_NOTIFY_MONITOR_OTHER 0x01000000 /* Commands for sending/receiving requests/responses */ #define SCARLETT2_USB_CMD_INIT 0 #define SCARLETT2_USB_CMD_REQ 2 #define SCARLETT2_USB_CMD_RESP 3 #define SCARLETT2_USB_INIT_1 0x00000000 #define SCARLETT2_USB_INIT_2 0x00000002 #define SCARLETT2_USB_GET_METER 0x00001001 #define SCARLETT2_USB_GET_MIX 0x00002001 #define SCARLETT2_USB_SET_MIX 0x00002002 #define SCARLETT2_USB_GET_MUX 0x00003001 #define SCARLETT2_USB_SET_MUX 0x00003002 #define SCARLETT2_USB_GET_SYNC 0x00006004 #define SCARLETT2_USB_GET_DATA 0x00800000 #define SCARLETT2_USB_SET_DATA 0x00800001 #define SCARLETT2_USB_DATA_CMD 0x00800002 #define SCARLETT2_USB_CONFIG_SAVE 6 #define SCARLETT2_USB_VOLUME_STATUS_OFFSET 0x31 #define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1 /* volume status is read together (matches scarlett2_config_items[1]) */ struct scarlett2_usb_volume_status { /* dim/mute buttons */ u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT]; u8 pad1; /* software volume setting */ s16 sw_vol[SCARLETT2_ANALOGUE_MAX]; /* actual volume of output inc. dim (-18dB) */ s16 hw_vol[SCARLETT2_ANALOGUE_MAX]; /* internal mute buttons */ u8 mute_switch[SCARLETT2_ANALOGUE_MAX]; /* sw (0) or hw (1) controlled */ u8 sw_hw_switch[SCARLETT2_ANALOGUE_MAX]; u8 pad3[6]; /* front panel volume knob */ s16 master_vol; } __packed; /* Configuration parameters that can be read and written */ enum { SCARLETT2_CONFIG_DIM_MUTE = 0, SCARLETT2_CONFIG_LINE_OUT_VOLUME = 1, SCARLETT2_CONFIG_MUTE_SWITCH = 2, SCARLETT2_CONFIG_SW_HW_SWITCH = 3, SCARLETT2_CONFIG_LEVEL_SWITCH = 4, SCARLETT2_CONFIG_PAD_SWITCH = 5, SCARLETT2_CONFIG_MSD_SWITCH = 6, SCARLETT2_CONFIG_AIR_SWITCH = 7, SCARLETT2_CONFIG_STANDALONE_SWITCH = 8, SCARLETT2_CONFIG_PHANTOM_SWITCH = 9, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE = 10, SCARLETT2_CONFIG_DIRECT_MONITOR = 11, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH = 12, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE = 13, SCARLETT2_CONFIG_TALKBACK_MAP = 14, SCARLETT2_CONFIG_COUNT = 15 }; /* Location, size, and activation command number for the configuration * parameters. Size is in bits and may be 1, 8, or 16. */ struct scarlett2_config { u8 offset; u8 size; u8 activate; }; static const struct scarlett2_config scarlett2_config_items[SCARLETT2_CONFIG_SET_COUNT] [SCARLETT2_CONFIG_COUNT] = /* Devices without a mixer (Gen 3 Solo and 2i2) */ { { [SCARLETT2_CONFIG_MSD_SWITCH] = { .offset = 0x04, .size = 8, .activate = 6 }, [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = { .offset = 0x05, .size = 8, .activate = 6 }, [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { .offset = 0x06, .size = 8, .activate = 3 }, [SCARLETT2_CONFIG_DIRECT_MONITOR] = { .offset = 0x07, .size = 8, .activate = 4 }, [SCARLETT2_CONFIG_LEVEL_SWITCH] = { .offset = 0x08, .size = 1, .activate = 7 }, [SCARLETT2_CONFIG_AIR_SWITCH] = { .offset = 0x09, .size = 1, .activate = 8 }, /* Gen 2 devices: 6i6, 18i8, 18i20 */ }, { [SCARLETT2_CONFIG_DIM_MUTE] = { .offset = 0x31, .size = 8, .activate = 2 }, [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { .offset = 0x34, .size = 16, .activate = 1 }, [SCARLETT2_CONFIG_MUTE_SWITCH] = { .offset = 0x5c, .size = 8, .activate = 1 }, [SCARLETT2_CONFIG_SW_HW_SWITCH] = { .offset = 0x66, .size = 8, .activate = 3 }, [SCARLETT2_CONFIG_LEVEL_SWITCH] = { .offset = 0x7c, .size = 8, .activate = 7 }, [SCARLETT2_CONFIG_PAD_SWITCH] = { .offset = 0x84, .size = 8, .activate = 8 }, [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { .offset = 0x8d, .size = 8, .activate = 6 }, /* Gen 3 devices: 4i4, 8i6, 18i8, 18i20 */ }, { [SCARLETT2_CONFIG_DIM_MUTE] = { .offset = 0x31, .size = 8, .activate = 2 }, [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { .offset = 0x34, .size = 16, .activate = 1 }, [SCARLETT2_CONFIG_MUTE_SWITCH] = { .offset = 0x5c, .size = 8, .activate = 1 }, [SCARLETT2_CONFIG_SW_HW_SWITCH] = { .offset = 0x66, .size = 8, .activate = 3 }, [SCARLETT2_CONFIG_LEVEL_SWITCH] = { .offset = 0x7c, .size = 8, .activate = 7 }, [SCARLETT2_CONFIG_PAD_SWITCH] = { .offset = 0x84, .size = 8, .activate = 8 }, [SCARLETT2_CONFIG_AIR_SWITCH] = { .offset = 0x8c, .size = 8, .activate = 8 }, [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { .offset = 0x95, .size = 8, .activate = 6 }, [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { .offset = 0x9c, .size = 1, .activate = 8 }, [SCARLETT2_CONFIG_MSD_SWITCH] = { .offset = 0x9d, .size = 8, .activate = 6 }, [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = { .offset = 0x9e, .size = 8, .activate = 6 }, [SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH] = { .offset = 0x9f, .size = 1, .activate = 10 }, [SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE] = { .offset = 0xa0, .size = 1, .activate = 10 }, [SCARLETT2_CONFIG_TALKBACK_MAP] = { .offset = 0xb0, .size = 16, .activate = 10 }, /* Clarett+ 8Pre */ }, { [SCARLETT2_CONFIG_DIM_MUTE] = { .offset = 0x31, .size = 8, .activate = 2 }, [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { .offset = 0x34, .size = 16, .activate = 1 }, [SCARLETT2_CONFIG_MUTE_SWITCH] = { .offset = 0x5c, .size = 8, .activate = 1 }, [SCARLETT2_CONFIG_SW_HW_SWITCH] = { .offset = 0x66, .size = 8, .activate = 3 }, [SCARLETT2_CONFIG_LEVEL_SWITCH] = { .offset = 0x7c, .size = 8, .activate = 7 }, [SCARLETT2_CONFIG_AIR_SWITCH] = { .offset = 0x95, .size = 8, .activate = 8 }, [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { .offset = 0x8d, .size = 8, .activate = 6 }, } }; /* proprietary request/response format */ struct scarlett2_usb_packet { __le32 cmd; __le16 size; __le16 seq; __le32 error; __le32 pad; u8 data[]; }; static void scarlett2_fill_request_header(struct scarlett2_data *private, struct scarlett2_usb_packet *req, u32 cmd, u16 req_size) { /* sequence must go up by 1 for each request */ u16 seq = private->scarlett2_seq++; req->cmd = cpu_to_le32(cmd); req->size = cpu_to_le16(req_size); req->seq = cpu_to_le16(seq); req->error = 0; req->pad = 0; } static int scarlett2_usb_tx(struct usb_device *dev, int interface, void *buf, u16 size) { return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SCARLETT2_USB_CMD_REQ, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 0, interface, buf, size); } static int scarlett2_usb_rx(struct usb_device *dev, int interface, u32 usb_req, void *buf, u16 size) { return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), usb_req, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 0, interface, buf, size); } /* Send a proprietary format request to the Scarlett interface */ static int scarlett2_usb( struct usb_mixer_interface *mixer, u32 cmd, void *req_data, u16 req_size, void *resp_data, u16 resp_size) { struct scarlett2_data *private = mixer->private_data; struct usb_device *dev = mixer->chip->dev; struct scarlett2_usb_packet *req, *resp = NULL; size_t req_buf_size = struct_size(req, data, req_size); size_t resp_buf_size = struct_size(resp, data, resp_size); int err; req = kmalloc(req_buf_size, GFP_KERNEL); if (!req) { err = -ENOMEM; goto error; } resp = kmalloc(resp_buf_size, GFP_KERNEL); if (!resp) { err = -ENOMEM; goto error; } mutex_lock(&private->usb_mutex); /* build request message and send it */ scarlett2_fill_request_header(private, req, cmd, req_size); if (req_size) memcpy(req->data, req_data, req_size); err = scarlett2_usb_tx(dev, private->bInterfaceNumber, req, req_buf_size); if (err != req_buf_size) { usb_audio_err( mixer->chip, "Scarlett Gen 2/3 USB request result cmd %x was %d\n", cmd, err); err = -EINVAL; goto unlock; } /* send a second message to get the response */ err = scarlett2_usb_rx(dev, private->bInterfaceNumber, SCARLETT2_USB_CMD_RESP, resp, resp_buf_size); /* validate the response */ if (err != resp_buf_size) { usb_audio_err( mixer->chip, "Scarlett Gen 2/3 USB response result cmd %x was %d " "expected %zu\n", cmd, err, resp_buf_size); err = -EINVAL; goto unlock; } /* cmd/seq/size should match except when initialising * seq sent = 1, response = 0 */ if (resp->cmd != req->cmd || (resp->seq != req->seq && (le16_to_cpu(req->seq) != 1 || resp->seq != 0)) || resp_size != le16_to_cpu(resp->size) || resp->error || resp->pad) { usb_audio_err( mixer->chip, "Scarlett Gen 2/3 USB invalid response; " "cmd tx/rx %d/%d seq %d/%d size %d/%d " "error %d pad %d\n", le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd), le16_to_cpu(req->seq), le16_to_cpu(resp->seq), resp_size, le16_to_cpu(resp->size), le32_to_cpu(resp->error), le32_to_cpu(resp->pad)); err = -EINVAL; goto unlock; } if (resp_data && resp_size > 0) memcpy(resp_data, resp->data, resp_size); unlock: mutex_unlock(&private->usb_mutex); error: kfree(req); kfree(resp); return err; } /* Send a USB message to get data; result placed in *buf */ static int scarlett2_usb_get( struct usb_mixer_interface *mixer, int offset, void *buf, int size) { struct { __le32 offset; __le32 size; } __packed req; req.offset = cpu_to_le32(offset); req.size = cpu_to_le32(size); return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA, &req, sizeof(req), buf, size); } /* Send a USB message to get configuration parameters; result placed in *buf */ static int scarlett2_usb_get_config( struct usb_mixer_interface *mixer, int config_item_num, int count, void *buf) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const struct scarlett2_config *config_item = &scarlett2_config_items[info->config_set][config_item_num]; int size, err, i; u8 *buf_8; u8 value; /* For byte-sized parameters, retrieve directly into buf */ if (config_item->size >= 8) { size = config_item->size / 8 * count; err = scarlett2_usb_get(mixer, config_item->offset, buf, size); if (err < 0) return err; if (size == 2) { u16 *buf_16 = buf; for (i = 0; i < count; i++, buf_16++) *buf_16 = le16_to_cpu(*(__le16 *)buf_16); } return 0; } /* For bit-sized parameters, retrieve into value */ err = scarlett2_usb_get(mixer, config_item->offset, &value, 1); if (err < 0) return err; /* then unpack from value into buf[] */ buf_8 = buf; for (i = 0; i < 8 && i < count; i++, value >>= 1) *buf_8++ = value & 1; return 0; } /* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */ static void scarlett2_config_save(struct usb_mixer_interface *mixer) { __le32 req = cpu_to_le32(SCARLETT2_USB_CONFIG_SAVE); scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD, &req, sizeof(u32), NULL, 0); } /* Delayed work to save config */ static void scarlett2_config_save_work(struct work_struct *work) { struct scarlett2_data *private = container_of(work, struct scarlett2_data, work.work); scarlett2_config_save(private->mixer); } /* Send a USB message to set a SCARLETT2_CONFIG_* parameter */ static int scarlett2_usb_set_config( struct usb_mixer_interface *mixer, int config_item_num, int index, int value) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const struct scarlett2_config *config_item = &scarlett2_config_items[info->config_set][config_item_num]; struct { __le32 offset; __le32 bytes; __le32 value; } __packed req; __le32 req2; int offset, size; int err; /* Cancel any pending NVRAM save */ cancel_delayed_work_sync(&private->work); /* Convert config_item->size in bits to size in bytes and * calculate offset */ if (config_item->size >= 8) { size = config_item->size / 8; offset = config_item->offset + index * size; /* If updating a bit, retrieve the old value, set/clear the * bit as needed, and update value */ } else { u8 tmp; size = 1; offset = config_item->offset; scarlett2_usb_get(mixer, offset, &tmp, 1); if (value) tmp |= (1 << index); else tmp &= ~(1 << index); value = tmp; } /* Send the configuration parameter data */ req.offset = cpu_to_le32(offset); req.bytes = cpu_to_le32(size); req.value = cpu_to_le32(value); err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA, &req, sizeof(u32) * 2 + size, NULL, 0); if (err < 0) return err; /* Activate the change */ req2 = cpu_to_le32(config_item->activate); err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD, &req2, sizeof(req2), NULL, 0); if (err < 0) return err; /* Schedule the change to be written to NVRAM */ if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE) schedule_delayed_work(&private->work, msecs_to_jiffies(2000)); return 0; } /* Send a USB message to get sync status; result placed in *sync */ static int scarlett2_usb_get_sync_status( struct usb_mixer_interface *mixer, u8 *sync) { __le32 data; int err; err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC, NULL, 0, &data, sizeof(data)); if (err < 0) return err; *sync = !!data; return 0; } /* Send a USB message to get volume status; result placed in *buf */ static int scarlett2_usb_get_volume_status( struct usb_mixer_interface *mixer, struct scarlett2_usb_volume_status *buf) { return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET, buf, sizeof(*buf)); } /* Send a USB message to get the volumes for all inputs of one mix * and put the values into private->mix[] */ static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer, int mix_num) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; int num_mixer_in = info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT]; int err, i, j, k; struct { __le16 mix_num; __le16 count; } __packed req; __le16 data[SCARLETT2_INPUT_MIX_MAX]; req.mix_num = cpu_to_le16(mix_num); req.count = cpu_to_le16(num_mixer_in); err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX, &req, sizeof(req), data, num_mixer_in * sizeof(u16)); if (err < 0) return err; for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) { u16 mixer_value = le16_to_cpu(data[i]); for (k = 0; k < SCARLETT2_MIXER_VALUE_COUNT; k++) if (scarlett2_mixer_values[k] >= mixer_value) break; if (k == SCARLETT2_MIXER_VALUE_COUNT) k = SCARLETT2_MIXER_MAX_VALUE; private->mix[j] = k; } return 0; } /* Send a USB message to set the volumes for all inputs of one mix * (values obtained from private->mix[]) */ static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer, int mix_num) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; struct { __le16 mix_num; __le16 data[SCARLETT2_INPUT_MIX_MAX]; } __packed req; int i, j; int num_mixer_in = info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT]; req.mix_num = cpu_to_le16(mix_num); for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) req.data[i] = cpu_to_le16( scarlett2_mixer_values[private->mix[j]] ); return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX, &req, (num_mixer_in + 1) * sizeof(u16), NULL, 0); } /* Convert a port number index (per info->port_count) to a hardware ID */ static u32 scarlett2_mux_src_num_to_id( const int port_count[][SCARLETT2_PORT_DIRNS], int num) { int port_type; for (port_type = 0; port_type < SCARLETT2_PORT_TYPE_COUNT; port_type++) { if (num < port_count[port_type][SCARLETT2_PORT_IN]) return scarlett2_ports[port_type].id | num; num -= port_count[port_type][SCARLETT2_PORT_IN]; } /* Oops */ return 0; } /* Convert a hardware ID to a port number index */ static u32 scarlett2_mux_id_to_num( const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id) { int port_type; int port_num = 0; for (port_type = 0; port_type < SCARLETT2_PORT_TYPE_COUNT; port_type++) { int base = scarlett2_ports[port_type].id; int count = port_count[port_type][direction]; if (id >= base && id < base + count) return port_num + id - base; port_num += count; } /* Oops */ return -1; } /* Convert one mux entry from the interface and load into private->mux[] */ static void scarlett2_usb_populate_mux(struct scarlett2_data *private, u32 mux_entry) { const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int dst_idx, src_idx; dst_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_OUT, mux_entry & 0xFFF); if (dst_idx < 0) return; if (dst_idx >= private->num_mux_dsts) { usb_audio_err(private->mixer->chip, "BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d", mux_entry, dst_idx, private->num_mux_dsts); return; } src_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_IN, mux_entry >> 12); if (src_idx < 0) return; if (src_idx >= private->num_mux_srcs) { usb_audio_err(private->mixer->chip, "BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d", mux_entry, src_idx, private->num_mux_srcs); return; } private->mux[dst_idx] = src_idx; } /* Send USB message to get mux inputs and then populate private->mux[] */ static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; int count = private->num_mux_dsts; int err, i; struct { __le16 num; __le16 count; } __packed req; __le32 data[SCARLETT2_MUX_MAX]; private->mux_updated = 0; req.num = 0; req.count = cpu_to_le16(count); err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX, &req, sizeof(req), data, count * sizeof(u32)); if (err < 0) return err; for (i = 0; i < count; i++) scarlett2_usb_populate_mux(private, le32_to_cpu(data[i])); return 0; } /* Send USB messages to set mux inputs */ static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int table; struct { __le16 pad; __le16 num; __le32 data[SCARLETT2_MUX_MAX]; } __packed req; req.pad = 0; /* set mux settings for each rate */ for (table = 0; table < SCARLETT2_MUX_TABLES; table++) { const struct scarlett2_mux_entry *entry; /* i counts over the output array */ int i = 0, err; req.num = cpu_to_le16(table); /* loop through each entry */ for (entry = info->mux_assignment[table]; entry->count; entry++) { int j; int port_type = entry->port_type; int port_idx = entry->start; int mux_idx = scarlett2_get_port_start_num(port_count, SCARLETT2_PORT_OUT, port_type) + port_idx; int dst_id = scarlett2_ports[port_type].id + port_idx; /* Empty slots */ if (!dst_id) { for (j = 0; j < entry->count; j++) req.data[i++] = 0; continue; } /* Non-empty mux slots use the lower 12 bits * for the destination and next 12 bits for * the source */ for (j = 0; j < entry->count; j++) { int src_id = scarlett2_mux_src_num_to_id( port_count, private->mux[mux_idx++]); req.data[i++] = cpu_to_le32(dst_id | src_id << 12); dst_id++; } } err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX, &req, (i + 1) * sizeof(u32), NULL, 0); if (err < 0) return err; } return 0; } /* Send USB message to get meter levels */ static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer, u16 num_meters, u16 *levels) { struct { __le16 pad; __le16 num_meters; __le32 magic; } __packed req; u32 resp[SCARLETT2_MAX_METERS]; int i, err; req.pad = 0; req.num_meters = cpu_to_le16(num_meters); req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC); err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER, &req, sizeof(req), resp, num_meters * sizeof(u32)); if (err < 0) return err; /* copy, convert to u16 */ for (i = 0; i < num_meters; i++) levels[i] = resp[i]; return 0; } /*** Control Functions ***/ /* helper function to create a new control */ static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer, const struct snd_kcontrol_new *ncontrol, int index, int channels, const char *name, struct snd_kcontrol **kctl_return) { struct snd_kcontrol *kctl; struct usb_mixer_elem_info *elem; int err; elem = kzalloc(sizeof(*elem), GFP_KERNEL); if (!elem) return -ENOMEM; /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code * ignores them for resume and other operations. * Also, the head.id field is set to 0, as we don't use this field. */ elem->head.mixer = mixer; elem->control = index; elem->head.id = 0; elem->channels = channels; elem->val_type = USB_MIXER_BESPOKEN; kctl = snd_ctl_new1(ncontrol, elem); if (!kctl) { kfree(elem); return -ENOMEM; } kctl->private_free = snd_usb_mixer_elem_free; strscpy(kctl->id.name, name, sizeof(kctl->id.name)); err = snd_usb_mixer_add_control(&elem->head, kctl); if (err < 0) return err; if (kctl_return) *kctl_return = kctl; return 0; } /*** Sync Control ***/ /* Update sync control after receiving notification that the status * has changed */ static int scarlett2_update_sync(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; private->sync_updated = 0; return scarlett2_usb_get_sync_status(mixer, &private->sync); } static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { static const char *texts[2] = { "Unlocked", "Locked" }; return snd_ctl_enum_info(uinfo, 1, 2, texts); } static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; mutex_lock(&private->data_mutex); if (private->sync_updated) scarlett2_update_sync(mixer); ucontrol->value.enumerated.item[0] = private->sync; mutex_unlock(&private->data_mutex); return 0; } static const struct snd_kcontrol_new scarlett2_sync_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READ, .name = "", .info = scarlett2_sync_ctl_info, .get = scarlett2_sync_ctl_get }; static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; /* devices without a mixer also don't support reporting sync status */ if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER) return 0; return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl, 0, 1, "Sync Status", &private->sync_ctl); } /*** Analogue Line Out Volume Controls ***/ /* Update hardware volume controls after receiving notification that * they have changed */ static int scarlett2_update_volumes(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; struct scarlett2_usb_volume_status volume_status; int num_line_out = port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; int err, i; int mute; private->vol_updated = 0; err = scarlett2_usb_get_volume_status(mixer, &volume_status); if (err < 0) return err; private->master_vol = clamp( volume_status.master_vol + SCARLETT2_VOLUME_BIAS, 0, SCARLETT2_VOLUME_BIAS); if (info->line_out_hw_vol) for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) private->dim_mute[i] = !!volume_status.dim_mute[i]; mute = private->dim_mute[SCARLETT2_BUTTON_MUTE]; for (i = 0; i < num_line_out; i++) if (private->vol_sw_hw_switch[i]) { private->vol[i] = private->master_vol; private->mute_switch[i] = mute; } return 0; } static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *elem = kctl->private_data; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = elem->channels; uinfo->value.integer.min = 0; uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS; uinfo->value.integer.step = 1; return 0; } static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; mutex_lock(&private->data_mutex); if (private->vol_updated) scarlett2_update_volumes(mixer); mutex_unlock(&private->data_mutex); ucontrol->value.integer.value[0] = private->master_vol; return 0; } static int line_out_remap(struct scarlett2_data *private, int index) { const struct scarlett2_device_info *info = private->info; if (!info->line_out_remap_enable) return index; return info->line_out_remap[index]; } static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = line_out_remap(private, elem->control); mutex_lock(&private->data_mutex); if (private->vol_updated) scarlett2_update_volumes(mixer); mutex_unlock(&private->data_mutex); ucontrol->value.integer.value[0] = private->vol[index]; return 0; } static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = line_out_remap(private, elem->control); int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->vol[index]; val = ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->vol[index] = val; err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME, index, val - SCARLETT2_VOLUME_BIAS); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const DECLARE_TLV_DB_MINMAX( db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0 ); static const struct snd_kcontrol_new scarlett2_master_volume_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .name = "", .info = scarlett2_volume_ctl_info, .get = scarlett2_master_volume_ctl_get, .private_value = 0, /* max value */ .tlv = { .p = db_scale_scarlett2_gain } }; static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .name = "", .info = scarlett2_volume_ctl_info, .get = scarlett2_volume_ctl_get, .put = scarlett2_volume_ctl_put, .private_value = 0, /* max value */ .tlv = { .p = db_scale_scarlett2_gain } }; /*** Mute Switch Controls ***/ static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = line_out_remap(private, elem->control); mutex_lock(&private->data_mutex); if (private->vol_updated) scarlett2_update_volumes(mixer); mutex_unlock(&private->data_mutex); ucontrol->value.integer.value[0] = private->mute_switch[index]; return 0; } static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = line_out_remap(private, elem->control); int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->mute_switch[index]; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->mute_switch[index] = val; /* Send mute change to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH, index, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_mute_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_mute_ctl_get, .put = scarlett2_mute_ctl_put, }; /*** HW/SW Volume Switch Controls ***/ static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index) { private->sw_hw_ctls[index]->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE; } static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index) { private->sw_hw_ctls[index]->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE; } static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { static const char *const values[2] = { "SW", "HW" }; return snd_ctl_enum_info(uinfo, 1, 2, values); } static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett2_data *private = elem->head.mixer->private_data; int index = line_out_remap(private, elem->control); ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index]; return 0; } static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer, int index, int value) { struct scarlett2_data *private = mixer->private_data; struct snd_card *card = mixer->chip->card; /* Set/Clear write bits */ if (value) { private->vol_ctls[index]->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE; private->mute_ctls[index]->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE; } else { private->vol_ctls[index]->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE; private->mute_ctls[index]->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE; } /* Notify of write bit and possible value change */ snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, &private->vol_ctls[index]->id); snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, &private->mute_ctls[index]->id); } static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer, int ctl_index, int val) { struct scarlett2_data *private = mixer->private_data; int index = line_out_remap(private, ctl_index); int err; private->vol_sw_hw_switch[index] = val; /* Change access mode to RO (hardware controlled volume) * or RW (software controlled volume) */ scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val); /* Reset volume/mute to master volume/mute */ private->vol[index] = private->master_vol; private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE]; /* Set SW volume to current HW volume */ err = scarlett2_usb_set_config( mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME, index, private->master_vol - SCARLETT2_VOLUME_BIAS); if (err < 0) return err; /* Set SW mute to current HW mute */ err = scarlett2_usb_set_config( mixer, SCARLETT2_CONFIG_MUTE_SWITCH, index, private->dim_mute[SCARLETT2_BUTTON_MUTE]); if (err < 0) return err; /* Send SW/HW switch change to the device */ return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH, index, val); } static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int ctl_index = elem->control; int index = line_out_remap(private, ctl_index); int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->vol_sw_hw_switch[index]; val = !!ucontrol->value.enumerated.item[0]; if (oval == val) goto unlock; err = scarlett2_sw_hw_change(mixer, ctl_index, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett2_sw_hw_enum_ctl_info, .get = scarlett2_sw_hw_enum_ctl_get, .put = scarlett2_sw_hw_enum_ctl_put, }; /*** Line Level/Instrument Level Switch Controls ***/ static int scarlett2_update_input_other(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; private->input_other_updated = 0; if (info->level_input_count) { int err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_LEVEL_SWITCH, info->level_input_count + info->level_input_first, private->level_switch); if (err < 0) return err; } if (info->pad_input_count) { int err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_PAD_SWITCH, info->pad_input_count, private->pad_switch); if (err < 0) return err; } if (info->air_input_count) { int err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_AIR_SWITCH, info->air_input_count, private->air_switch); if (err < 0) return err; } if (info->phantom_count) { int err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH, info->phantom_count, private->phantom_switch); if (err < 0) return err; err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, 1, &private->phantom_persistence); if (err < 0) return err; } return 0; } static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { static const char *const values[2] = { "Line", "Inst" }; return snd_ctl_enum_info(uinfo, 1, 2, values); } static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; int index = elem->control + info->level_input_first; mutex_lock(&private->data_mutex); if (private->input_other_updated) scarlett2_update_input_other(mixer); ucontrol->value.enumerated.item[0] = private->level_switch[index]; mutex_unlock(&private->data_mutex); return 0; } static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; int index = elem->control + info->level_input_first; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->level_switch[index]; val = !!ucontrol->value.enumerated.item[0]; if (oval == val) goto unlock; private->level_switch[index] = val; /* Send switch change to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH, index, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_level_enum_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett2_level_enum_ctl_info, .get = scarlett2_level_enum_ctl_get, .put = scarlett2_level_enum_ctl_put, }; /*** Pad Switch Controls ***/ static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; mutex_lock(&private->data_mutex); if (private->input_other_updated) scarlett2_update_input_other(mixer); ucontrol->value.integer.value[0] = private->pad_switch[elem->control]; mutex_unlock(&private->data_mutex); return 0; } static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = elem->control; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->pad_switch[index]; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->pad_switch[index] = val; /* Send switch change to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH, index, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_pad_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_pad_ctl_get, .put = scarlett2_pad_ctl_put, }; /*** Air Switch Controls ***/ static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; mutex_lock(&private->data_mutex); if (private->input_other_updated) scarlett2_update_input_other(mixer); ucontrol->value.integer.value[0] = private->air_switch[elem->control]; mutex_unlock(&private->data_mutex); return 0; } static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = elem->control; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->air_switch[index]; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->air_switch[index] = val; /* Send switch change to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH, index, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_air_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_air_ctl_get, .put = scarlett2_air_ctl_put, }; /*** Phantom Switch Controls ***/ static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; mutex_lock(&private->data_mutex); if (private->input_other_updated) scarlett2_update_input_other(mixer); ucontrol->value.integer.value[0] = private->phantom_switch[elem->control]; mutex_unlock(&private->data_mutex); return 0; } static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = elem->control; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->phantom_switch[index]; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->phantom_switch[index] = val; /* Send switch change to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH, index, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_phantom_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_phantom_ctl_get, .put = scarlett2_phantom_ctl_put, }; /*** Phantom Persistence Control ***/ static int scarlett2_phantom_persistence_ctl_get( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett2_data *private = elem->head.mixer->private_data; ucontrol->value.integer.value[0] = private->phantom_persistence; return 0; } static int scarlett2_phantom_persistence_ctl_put( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = elem->control; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->phantom_persistence; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->phantom_persistence = val; /* Send switch change to the device */ err = scarlett2_usb_set_config( mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_phantom_persistence_ctl_get, .put = scarlett2_phantom_persistence_ctl_put, }; /*** Direct Monitor Control ***/ static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; int err; /* monitor_other_enable[0] enables speaker switching * monitor_other_enable[1] enables talkback */ u8 monitor_other_enable[2]; /* monitor_other_switch[0] activates the alternate speakers * monitor_other_switch[1] activates talkback */ u8 monitor_other_switch[2]; private->monitor_other_updated = 0; if (info->direct_monitor) return scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, 1, &private->direct_monitor_switch); /* if it doesn't do speaker switching then it also doesn't do * talkback */ if (!info->has_speaker_switching) return 0; err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 2, monitor_other_enable); if (err < 0) return err; err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 2, monitor_other_switch); if (err < 0) return err; if (!monitor_other_enable[0]) private->speaker_switching_switch = 0; else private->speaker_switching_switch = monitor_other_switch[0] + 1; if (info->has_talkback) { const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; u16 bitmap; int i; if (!monitor_other_enable[1]) private->talkback_switch = 0; else private->talkback_switch = monitor_other_switch[1] + 1; err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP, 1, &bitmap); if (err < 0) return err; for (i = 0; i < num_mixes; i++, bitmap >>= 1) private->talkback_map[i] = bitmap & 1; } return 0; } static int scarlett2_direct_monitor_ctl_get( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = elem->head.mixer->private_data; mutex_lock(&private->data_mutex); if (private->monitor_other_updated) scarlett2_update_monitor_other(mixer); ucontrol->value.enumerated.item[0] = private->direct_monitor_switch; mutex_unlock(&private->data_mutex); return 0; } static int scarlett2_direct_monitor_ctl_put( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = elem->control; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->direct_monitor_switch; val = min(ucontrol->value.enumerated.item[0], 2U); if (oval == val) goto unlock; private->direct_monitor_switch = val; /* Send switch change to the device */ err = scarlett2_usb_set_config( mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static int scarlett2_direct_monitor_stereo_enum_ctl_info( struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { static const char *const values[3] = { "Off", "Mono", "Stereo" }; return snd_ctl_enum_info(uinfo, 1, 3, values); } /* Direct Monitor for Solo is mono-only and only needs a boolean control * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo */ static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_direct_monitor_ctl_get, .put = scarlett2_direct_monitor_ctl_put, }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett2_direct_monitor_stereo_enum_ctl_info, .get = scarlett2_direct_monitor_ctl_get, .put = scarlett2_direct_monitor_ctl_put, } }; static int scarlett2_add_direct_monitor_ctl(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const char *s; if (!info->direct_monitor) return 0; s = info->direct_monitor == 1 ? "Direct Monitor Playback Switch" : "Direct Monitor Playback Enum"; return scarlett2_add_new_ctl( mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1], 0, 1, s, &private->direct_monitor_ctl); } /*** Speaker Switching Control ***/ static int scarlett2_speaker_switch_enum_ctl_info( struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { static const char *const values[3] = { "Off", "Main", "Alt" }; return snd_ctl_enum_info(uinfo, 1, 3, values); } static int scarlett2_speaker_switch_enum_ctl_get( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; mutex_lock(&private->data_mutex); if (private->monitor_other_updated) scarlett2_update_monitor_other(mixer); ucontrol->value.enumerated.item[0] = private->speaker_switching_switch; mutex_unlock(&private->data_mutex); return 0; } /* when speaker switching gets enabled, switch the main/alt speakers * to HW volume and disable those controls */ static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer) { struct snd_card *card = mixer->chip->card; struct scarlett2_data *private = mixer->private_data; int i, err; for (i = 0; i < 4; i++) { int index = line_out_remap(private, i); /* switch the main/alt speakers to HW volume */ if (!private->vol_sw_hw_switch[index]) { err = scarlett2_sw_hw_change(private->mixer, i, 1); if (err < 0) return err; } /* disable the line out SW/HW switch */ scarlett2_sw_hw_ctl_ro(private, i); snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, &private->sw_hw_ctls[i]->id); } /* when the next monitor-other notify comes in, update the mux * configuration */ private->speaker_switching_switched = 1; return 0; } /* when speaker switching gets disabled, reenable the hw/sw controls * and invalidate the routing */ static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer) { struct snd_card *card = mixer->chip->card; struct scarlett2_data *private = mixer->private_data; int i; /* enable the line out SW/HW switch */ for (i = 0; i < 4; i++) { scarlett2_sw_hw_ctl_rw(private, i); snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, &private->sw_hw_ctls[i]->id); } /* when the next monitor-other notify comes in, update the mux * configuration */ private->speaker_switching_switched = 1; } static int scarlett2_speaker_switch_enum_ctl_put( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->speaker_switching_switch; val = min(ucontrol->value.enumerated.item[0], 2U); if (oval == val) goto unlock; private->speaker_switching_switch = val; /* enable/disable speaker switching */ err = scarlett2_usb_set_config( mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 0, !!val); if (err < 0) goto unlock; /* if speaker switching is enabled, select main or alt */ err = scarlett2_usb_set_config( mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 0, val == 2); if (err < 0) goto unlock; /* update controls if speaker switching gets enabled or disabled */ if (!oval && val) err = scarlett2_speaker_switch_enable(mixer); else if (oval && !val) scarlett2_speaker_switch_disable(mixer); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett2_speaker_switch_enum_ctl_info, .get = scarlett2_speaker_switch_enum_ctl_get, .put = scarlett2_speaker_switch_enum_ctl_put, }; static int scarlett2_add_speaker_switch_ctl( struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; if (!info->has_speaker_switching) return 0; return scarlett2_add_new_ctl( mixer, &scarlett2_speaker_switch_enum_ctl, 0, 1, "Speaker Switching Playback Enum", &private->speaker_switching_ctl); } /*** Talkback and Talkback Map Controls ***/ static int scarlett2_talkback_enum_ctl_info( struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { static const char *const values[3] = { "Disabled", "Off", "On" }; return snd_ctl_enum_info(uinfo, 1, 3, values); } static int scarlett2_talkback_enum_ctl_get( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; mutex_lock(&private->data_mutex); if (private->monitor_other_updated) scarlett2_update_monitor_other(mixer); ucontrol->value.enumerated.item[0] = private->talkback_switch; mutex_unlock(&private->data_mutex); return 0; } static int scarlett2_talkback_enum_ctl_put( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->talkback_switch; val = min(ucontrol->value.enumerated.item[0], 2U); if (oval == val) goto unlock; private->talkback_switch = val; /* enable/disable talkback */ err = scarlett2_usb_set_config( mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 1, !!val); if (err < 0) goto unlock; /* if talkback is enabled, select main or alt */ err = scarlett2_usb_set_config( mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 1, val == 2); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett2_talkback_enum_ctl_info, .get = scarlett2_talkback_enum_ctl_get, .put = scarlett2_talkback_enum_ctl_put, }; static int scarlett2_talkback_map_ctl_get( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int index = elem->control; ucontrol->value.integer.value[0] = private->talkback_map[index]; return 0; } static int scarlett2_talkback_map_ctl_put( struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; const int (*port_count)[SCARLETT2_PORT_DIRNS] = private->info->port_count; int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; int index = elem->control; int oval, val, err = 0, i; u16 bitmap = 0; mutex_lock(&private->data_mutex); oval = private->talkback_map[index]; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->talkback_map[index] = val; for (i = 0; i < num_mixes; i++) bitmap |= private->talkback_map[i] << i; /* Send updated bitmap to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP, 0, bitmap); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_talkback_map_ctl_get, .put = scarlett2_talkback_map_ctl_put, }; static int scarlett2_add_talkback_ctls( struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; int err, i; char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; if (!info->has_talkback) return 0; err = scarlett2_add_new_ctl( mixer, &scarlett2_talkback_enum_ctl, 0, 1, "Talkback Playback Enum", &private->talkback_ctl); if (err < 0) return err; for (i = 0; i < num_mixes; i++) { snprintf(s, sizeof(s), "Talkback Mix %c Playback Switch", i + 'A'); err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl, i, 1, s, NULL); if (err < 0) return err; } return 0; } /*** Dim/Mute Controls ***/ static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; mutex_lock(&private->data_mutex); if (private->vol_updated) scarlett2_update_volumes(mixer); mutex_unlock(&private->data_mutex); ucontrol->value.integer.value[0] = private->dim_mute[elem->control]; return 0; } static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int num_line_out = port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; int index = elem->control; int oval, val, err = 0, i; mutex_lock(&private->data_mutex); oval = private->dim_mute[index]; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->dim_mute[index] = val; /* Send switch change to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE, index, val); if (err == 0) err = 1; if (index == SCARLETT2_BUTTON_MUTE) for (i = 0; i < num_line_out; i++) { int line_index = line_out_remap(private, i); if (private->vol_sw_hw_switch[line_index]) { private->mute_switch[line_index] = val; snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &private->mute_ctls[i]->id); } } unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_dim_mute_ctl_get, .put = scarlett2_dim_mute_ctl_put }; /*** Create the analogue output controls ***/ static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int num_line_out = port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; int err, i; char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* Add R/O HW volume control */ if (info->line_out_hw_vol) { snprintf(s, sizeof(s), "Master HW Playback Volume"); err = scarlett2_add_new_ctl(mixer, &scarlett2_master_volume_ctl, 0, 1, s, &private->master_vol_ctl); if (err < 0) return err; } /* Add volume controls */ for (i = 0; i < num_line_out; i++) { int index = line_out_remap(private, i); /* Fader */ if (info->line_out_descrs[i]) snprintf(s, sizeof(s), "Line %02d (%s) Playback Volume", i + 1, info->line_out_descrs[i]); else snprintf(s, sizeof(s), "Line %02d Playback Volume", i + 1); err = scarlett2_add_new_ctl(mixer, &scarlett2_line_out_volume_ctl, i, 1, s, &private->vol_ctls[i]); if (err < 0) return err; /* Mute Switch */ snprintf(s, sizeof(s), "Line %02d Mute Playback Switch", i + 1); err = scarlett2_add_new_ctl(mixer, &scarlett2_mute_ctl, i, 1, s, &private->mute_ctls[i]); if (err < 0) return err; /* Make the fader and mute controls read-only if the * SW/HW switch is set to HW */ if (private->vol_sw_hw_switch[index]) scarlett2_vol_ctl_set_writable(mixer, i, 0); /* SW/HW Switch */ if (info->line_out_hw_vol) { snprintf(s, sizeof(s), "Line Out %02d Volume Control Playback Enum", i + 1); err = scarlett2_add_new_ctl(mixer, &scarlett2_sw_hw_enum_ctl, i, 1, s, &private->sw_hw_ctls[i]); if (err < 0) return err; /* Make the switch read-only if the line is * involved in speaker switching */ if (private->speaker_switching_switch && i < 4) scarlett2_sw_hw_ctl_ro(private, i); } } /* Add dim/mute controls */ if (info->line_out_hw_vol) for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) { err = scarlett2_add_new_ctl( mixer, &scarlett2_dim_mute_ctl, i, 1, scarlett2_dim_mute_names[i], &private->dim_mute_ctls[i]); if (err < 0) return err; } return 0; } /*** Create the analogue input controls ***/ static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; int err, i; char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; const char *fmt = "Line In %d %s Capture %s"; const char *fmt2 = "Line In %d-%d %s Capture %s"; /* Add input level (line/inst) controls */ for (i = 0; i < info->level_input_count; i++) { snprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first, "Level", "Enum"); err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl, i, 1, s, &private->level_ctls[i]); if (err < 0) return err; } /* Add input pad controls */ for (i = 0; i < info->pad_input_count; i++) { snprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch"); err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl, i, 1, s, &private->pad_ctls[i]); if (err < 0) return err; } /* Add input air controls */ for (i = 0; i < info->air_input_count; i++) { snprintf(s, sizeof(s), fmt, i + 1, "Air", "Switch"); err = scarlett2_add_new_ctl(mixer, &scarlett2_air_ctl, i, 1, s, &private->air_ctls[i]); if (err < 0) return err; } /* Add input phantom controls */ if (info->inputs_per_phantom == 1) { for (i = 0; i < info->phantom_count; i++) { scnprintf(s, sizeof(s), fmt, i + 1, "Phantom Power", "Switch"); err = scarlett2_add_new_ctl( mixer, &scarlett2_phantom_ctl, i, 1, s, &private->phantom_ctls[i]); if (err < 0) return err; } } else if (info->inputs_per_phantom > 1) { for (i = 0; i < info->phantom_count; i++) { int from = i * info->inputs_per_phantom + 1; int to = (i + 1) * info->inputs_per_phantom; scnprintf(s, sizeof(s), fmt2, from, to, "Phantom Power", "Switch"); err = scarlett2_add_new_ctl( mixer, &scarlett2_phantom_ctl, i, 1, s, &private->phantom_ctls[i]); if (err < 0) return err; } } if (info->phantom_count) { err = scarlett2_add_new_ctl( mixer, &scarlett2_phantom_persistence_ctl, 0, 1, "Phantom Power Persistence Capture Switch", NULL); if (err < 0) return err; } return 0; } /*** Mixer Volume Controls ***/ static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *elem = kctl->private_data; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = elem->channels; uinfo->value.integer.min = 0; uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE; uinfo->value.integer.step = 1; return 0; } static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett2_data *private = elem->head.mixer->private_data; ucontrol->value.integer.value[0] = private->mix[elem->control]; return 0; } static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int oval, val, num_mixer_in, mix_num, err = 0; int index = elem->control; mutex_lock(&private->data_mutex); oval = private->mix[index]; val = ucontrol->value.integer.value[0]; num_mixer_in = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT]; mix_num = index / num_mixer_in; if (oval == val) goto unlock; private->mix[index] = val; err = scarlett2_usb_set_mix(mixer, mix_num); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const DECLARE_TLV_DB_MINMAX( db_scale_scarlett2_mixer, SCARLETT2_MIXER_MIN_DB * 100, SCARLETT2_MIXER_MAX_DB * 100 ); static const struct snd_kcontrol_new scarlett2_mixer_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .name = "", .info = scarlett2_mixer_ctl_info, .get = scarlett2_mixer_ctl_get, .put = scarlett2_mixer_ctl_put, .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */ .tlv = { .p = db_scale_scarlett2_mixer } }; static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int err, i, j; int index; char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; int num_inputs = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT]; int num_outputs = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; for (i = 0, index = 0; i < num_outputs; i++) for (j = 0; j < num_inputs; j++, index++) { snprintf(s, sizeof(s), "Mix %c Input %02d Playback Volume", 'A' + i, j + 1); err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl, index, 1, s, NULL); if (err < 0) return err; } return 0; } /*** Mux Source Selection Controls ***/ static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett2_data *private = elem->head.mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; unsigned int item = uinfo->value.enumerated.item; int items = private->num_mux_srcs; int port_type; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = elem->channels; uinfo->value.enumerated.items = items; if (item >= items) item = uinfo->value.enumerated.item = items - 1; for (port_type = 0; port_type < SCARLETT2_PORT_TYPE_COUNT; port_type++) { if (item < port_count[port_type][SCARLETT2_PORT_IN]) { const struct scarlett2_port *port = &scarlett2_ports[port_type]; sprintf(uinfo->value.enumerated.name, port->src_descr, item + port->src_num_offset); return 0; } item -= port_count[port_type][SCARLETT2_PORT_IN]; } return -EINVAL; } static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int line_out_count = port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; int index = elem->control; if (index < line_out_count) index = line_out_remap(private, index); mutex_lock(&private->data_mutex); if (private->mux_updated) scarlett2_usb_get_mux(mixer); ucontrol->value.enumerated.item[0] = private->mux[index]; mutex_unlock(&private->data_mutex); return 0; } static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int line_out_count = port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; int index = elem->control; int oval, val, err = 0; if (index < line_out_count) index = line_out_remap(private, index); mutex_lock(&private->data_mutex); oval = private->mux[index]; val = min(ucontrol->value.enumerated.item[0], private->num_mux_srcs - 1U); if (oval == val) goto unlock; private->mux[index] = val; err = scarlett2_usb_set_mux(mixer); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett2_mux_src_enum_ctl_info, .get = scarlett2_mux_src_enum_ctl_get, .put = scarlett2_mux_src_enum_ctl_put, }; static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int port_type, channel, i; for (i = 0, port_type = 0; port_type < SCARLETT2_PORT_TYPE_COUNT; port_type++) { for (channel = 0; channel < port_count[port_type][SCARLETT2_PORT_OUT]; channel++, i++) { int err; char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; const char *const descr = scarlett2_ports[port_type].dst_descr; snprintf(s, sizeof(s) - 5, descr, channel + 1); strcat(s, " Enum"); err = scarlett2_add_new_ctl(mixer, &scarlett2_mux_src_enum_ctl, i, 1, s, &private->mux_ctls[i]); if (err < 0) return err; } } return 0; } /*** Meter Controls ***/ static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *elem = kctl->private_data; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = elem->channels; uinfo->value.integer.min = 0; uinfo->value.integer.max = 4095; uinfo->value.integer.step = 1; return 0; } static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; u16 meter_levels[SCARLETT2_MAX_METERS]; int i, err; err = scarlett2_usb_get_meter_levels(elem->head.mixer, elem->channels, meter_levels); if (err < 0) return err; for (i = 0; i < elem->channels; i++) ucontrol->value.integer.value[i] = meter_levels[i]; return 0; } static const struct snd_kcontrol_new scarlett2_meter_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .name = "", .info = scarlett2_meter_ctl_info, .get = scarlett2_meter_ctl_get }; static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; /* devices without a mixer also don't support reporting levels */ if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER) return 0; return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl, 0, private->num_mux_dsts, "Level Meter", NULL); } /*** MSD Controls ***/ static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett2_data *private = elem->head.mixer->private_data; ucontrol->value.integer.value[0] = private->msd_switch; return 0; } static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->msd_switch; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->msd_switch = val; /* Send switch change to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH, 0, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_msd_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_msd_ctl_get, .put = scarlett2_msd_ctl_put, }; static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; if (!info->has_msd_mode) return 0; /* If MSD mode is off, hide the switch by default */ if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE)) return 0; /* Add MSD control */ return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl, 0, 1, "MSD Mode Switch", NULL); } /*** Standalone Control ***/ static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett2_data *private = elem->head.mixer->private_data; ucontrol->value.integer.value[0] = private->standalone_switch; return 0; } static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct usb_mixer_interface *mixer = elem->head.mixer; struct scarlett2_data *private = mixer->private_data; int oval, val, err = 0; mutex_lock(&private->data_mutex); oval = private->standalone_switch; val = !!ucontrol->value.integer.value[0]; if (oval == val) goto unlock; private->standalone_switch = val; /* Send switch change to the device */ err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH, 0, val); if (err == 0) err = 1; unlock: mutex_unlock(&private->data_mutex); return err; } static const struct snd_kcontrol_new scarlett2_standalone_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = snd_ctl_boolean_mono_info, .get = scarlett2_standalone_ctl_get, .put = scarlett2_standalone_ctl_put, }; static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER) return 0; /* Add standalone control */ return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl, 0, 1, "Standalone Switch", NULL); } /*** Cleanup/Suspend Callbacks ***/ static void scarlett2_private_free(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; cancel_delayed_work_sync(&private->work); kfree(private); mixer->private_data = NULL; } static void scarlett2_private_suspend(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; if (cancel_delayed_work_sync(&private->work)) scarlett2_config_save(private->mixer); } /*** Initialisation ***/ static void scarlett2_count_mux_io(struct scarlett2_data *private) { const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int port_type, srcs = 0, dsts = 0; for (port_type = 0; port_type < SCARLETT2_PORT_TYPE_COUNT; port_type++) { srcs += port_count[port_type][SCARLETT2_PORT_IN]; dsts += port_count[port_type][SCARLETT2_PORT_OUT]; } private->num_mux_srcs = srcs; private->num_mux_dsts = dsts; } /* Look through the interface descriptors for the Focusrite Control * interface (bInterfaceClass = 255 Vendor Specific Class) and set * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval * in private */ static int scarlett2_find_fc_interface(struct usb_device *dev, struct scarlett2_data *private) { struct usb_host_config *config = dev->actconfig; int i; for (i = 0; i < config->desc.bNumInterfaces; i++) { struct usb_interface *intf = config->interface[i]; struct usb_interface_descriptor *desc = &intf->altsetting[0].desc; struct usb_endpoint_descriptor *epd; if (desc->bInterfaceClass != 255) continue; epd = get_endpoint(intf->altsetting, 0); private->bInterfaceNumber = desc->bInterfaceNumber; private->bEndpointAddress = epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize); private->bInterval = epd->bInterval; return 0; } return -EINVAL; } /* Initialise private data */ static int scarlett2_init_private(struct usb_mixer_interface *mixer, const struct scarlett2_device_info *info) { struct scarlett2_data *private = kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL); if (!private) return -ENOMEM; mutex_init(&private->usb_mutex); mutex_init(&private->data_mutex); INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work); mixer->private_data = private; mixer->private_free = scarlett2_private_free; mixer->private_suspend = scarlett2_private_suspend; private->info = info; scarlett2_count_mux_io(private); private->scarlett2_seq = 0; private->mixer = mixer; return scarlett2_find_fc_interface(mixer->chip->dev, private); } /* Cargo cult proprietary initialisation sequence */ static int scarlett2_usb_init(struct usb_mixer_interface *mixer) { struct usb_device *dev = mixer->chip->dev; struct scarlett2_data *private = mixer->private_data; u8 buf[24]; int err; if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0))) return -EINVAL; /* step 0 */ err = scarlett2_usb_rx(dev, private->bInterfaceNumber, SCARLETT2_USB_CMD_INIT, buf, sizeof(buf)); if (err < 0) return err; /* step 1 */ private->scarlett2_seq = 1; err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0); if (err < 0) return err; /* step 2 */ private->scarlett2_seq = 1; return scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, NULL, 0, NULL, 84); } /* Read configuration from the interface on start */ static int scarlett2_read_configs(struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int num_line_out = port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; int num_mixer_out = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; struct scarlett2_usb_volume_status volume_status; int err, i; if (info->has_msd_mode) { err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_MSD_SWITCH, 1, &private->msd_switch); if (err < 0) return err; /* no other controls are created if MSD mode is on */ if (private->msd_switch) return 0; } err = scarlett2_update_input_other(mixer); if (err < 0) return err; err = scarlett2_update_monitor_other(mixer); if (err < 0) return err; /* the rest of the configuration is for devices with a mixer */ if (info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER) return 0; err = scarlett2_usb_get_config( mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH, 1, &private->standalone_switch); if (err < 0) return err; err = scarlett2_update_sync(mixer); if (err < 0) return err; err = scarlett2_usb_get_volume_status(mixer, &volume_status); if (err < 0) return err; if (info->line_out_hw_vol) for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) private->dim_mute[i] = !!volume_status.dim_mute[i]; private->master_vol = clamp( volume_status.master_vol + SCARLETT2_VOLUME_BIAS, 0, SCARLETT2_VOLUME_BIAS); for (i = 0; i < num_line_out; i++) { int volume, mute; private->vol_sw_hw_switch[i] = info->line_out_hw_vol && volume_status.sw_hw_switch[i]; volume = private->vol_sw_hw_switch[i] ? volume_status.master_vol : volume_status.sw_vol[i]; volume = clamp(volume + SCARLETT2_VOLUME_BIAS, 0, SCARLETT2_VOLUME_BIAS); private->vol[i] = volume; mute = private->vol_sw_hw_switch[i] ? private->dim_mute[SCARLETT2_BUTTON_MUTE] : volume_status.mute_switch[i]; private->mute_switch[i] = mute; } for (i = 0; i < num_mixer_out; i++) { err = scarlett2_usb_get_mix(mixer, i); if (err < 0) return err; } return scarlett2_usb_get_mux(mixer); } /* Notify on sync change */ static void scarlett2_notify_sync( struct usb_mixer_interface *mixer) { struct scarlett2_data *private = mixer->private_data; private->sync_updated = 1; snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &private->sync_ctl->id); } /* Notify on monitor change */ static void scarlett2_notify_monitor( struct usb_mixer_interface *mixer) { struct snd_card *card = mixer->chip->card; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int num_line_out = port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; int i; /* if line_out_hw_vol is 0, there are no controls to update */ if (!info->line_out_hw_vol) return; private->vol_updated = 1; snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &private->master_vol_ctl->id); for (i = 0; i < num_line_out; i++) if (private->vol_sw_hw_switch[line_out_remap(private, i)]) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->vol_ctls[i]->id); } /* Notify on dim/mute change */ static void scarlett2_notify_dim_mute( struct usb_mixer_interface *mixer) { struct snd_card *card = mixer->chip->card; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; int num_line_out = port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; int i; private->vol_updated = 1; if (!info->line_out_hw_vol) return; for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->dim_mute_ctls[i]->id); for (i = 0; i < num_line_out; i++) if (private->vol_sw_hw_switch[line_out_remap(private, i)]) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->mute_ctls[i]->id); } /* Notify on "input other" change (level/pad/air) */ static void scarlett2_notify_input_other( struct usb_mixer_interface *mixer) { struct snd_card *card = mixer->chip->card; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; int i; private->input_other_updated = 1; for (i = 0; i < info->level_input_count; i++) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->level_ctls[i]->id); for (i = 0; i < info->pad_input_count; i++) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->pad_ctls[i]->id); for (i = 0; i < info->air_input_count; i++) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->air_ctls[i]->id); for (i = 0; i < info->phantom_count; i++) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->phantom_ctls[i]->id); } /* Notify on "monitor other" change (direct monitor, speaker * switching, talkback) */ static void scarlett2_notify_monitor_other( struct usb_mixer_interface *mixer) { struct snd_card *card = mixer->chip->card; struct scarlett2_data *private = mixer->private_data; const struct scarlett2_device_info *info = private->info; private->monitor_other_updated = 1; if (info->direct_monitor) { snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->direct_monitor_ctl->id); return; } if (info->has_speaker_switching) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->speaker_switching_ctl->id); if (info->has_talkback) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->talkback_ctl->id); /* if speaker switching was recently enabled or disabled, * invalidate the dim/mute and mux enum controls */ if (private->speaker_switching_switched) { int i; scarlett2_notify_dim_mute(mixer); private->speaker_switching_switched = 0; private->mux_updated = 1; for (i = 0; i < private->num_mux_dsts; i++) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &private->mux_ctls[i]->id); } } /* Interrupt callback */ static void scarlett2_notify(struct urb *urb) { struct usb_mixer_interface *mixer = urb->context; int len = urb->actual_length; int ustatus = urb->status; u32 data; if (ustatus != 0 || len != 8) goto requeue; data = le32_to_cpu(*(__le32 *)urb->transfer_buffer); if (data & SCARLETT2_USB_NOTIFY_SYNC) scarlett2_notify_sync(mixer); if (data & SCARLETT2_USB_NOTIFY_MONITOR) scarlett2_notify_monitor(mixer); if (data & SCARLETT2_USB_NOTIFY_DIM_MUTE) scarlett2_notify_dim_mute(mixer); if (data & SCARLETT2_USB_NOTIFY_INPUT_OTHER) scarlett2_notify_input_other(mixer); if (data & SCARLETT2_USB_NOTIFY_MONITOR_OTHER) scarlett2_notify_monitor_other(mixer); requeue: if (ustatus != -ENOENT && ustatus != -ECONNRESET && ustatus != -ESHUTDOWN) { urb->dev = mixer->chip->dev; usb_submit_urb(urb, GFP_ATOMIC); } } static int scarlett2_init_notify(struct usb_mixer_interface *mixer) { struct usb_device *dev = mixer->chip->dev; struct scarlett2_data *private = mixer->private_data; unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress); void *transfer_buffer; if (mixer->urb) { usb_audio_err(mixer->chip, "%s: mixer urb already in use!\n", __func__); return 0; } if (usb_pipe_type_check(dev, pipe)) return -EINVAL; mixer->urb = usb_alloc_urb(0, GFP_KERNEL); if (!mixer->urb) return -ENOMEM; transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL); if (!transfer_buffer) return -ENOMEM; usb_fill_int_urb(mixer->urb, dev, pipe, transfer_buffer, private->wMaxPacketSize, scarlett2_notify, mixer, private->bInterval); return usb_submit_urb(mixer->urb, GFP_KERNEL); } static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer) { const struct scarlett2_device_info **info = scarlett2_devices; int err; /* Find device in scarlett2_devices */ while (*info && (*info)->usb_id != mixer->chip->usb_id) info++; if (!*info) return -EINVAL; /* Initialise private data */ err = scarlett2_init_private(mixer, *info); if (err < 0) return err; /* Send proprietary USB initialisation sequence */ err = scarlett2_usb_init(mixer); if (err < 0) return err; /* Read volume levels and controls from the interface */ err = scarlett2_read_configs(mixer); if (err < 0) return err; /* Create the MSD control */ err = scarlett2_add_msd_ctl(mixer); if (err < 0) return err; /* If MSD mode is enabled, don't create any other controls */ if (((struct scarlett2_data *)mixer->private_data)->msd_switch) return 0; /* Create the analogue output controls */ err = scarlett2_add_line_out_ctls(mixer); if (err < 0) return err; /* Create the analogue input controls */ err = scarlett2_add_line_in_ctls(mixer); if (err < 0) return err; /* Create the input, output, and mixer mux input selections */ err = scarlett2_add_mux_enums(mixer); if (err < 0) return err; /* Create the matrix mixer controls */ err = scarlett2_add_mixer_ctls(mixer); if (err < 0) return err; /* Create the level meter controls */ err = scarlett2_add_meter_ctl(mixer); if (err < 0) return err; /* Create the sync control */ err = scarlett2_add_sync_ctl(mixer); if (err < 0) return err; /* Create the direct monitor control */ err = scarlett2_add_direct_monitor_ctl(mixer); if (err < 0) return err; /* Create the speaker switching control */ err = scarlett2_add_speaker_switch_ctl(mixer); if (err < 0) return err; /* Create the talkback controls */ err = scarlett2_add_talkback_ctls(mixer); if (err < 0) return err; /* Create the standalone control */ err = scarlett2_add_standalone_ctl(mixer); if (err < 0) return err; /* Set up the interrupt polling */ err = scarlett2_init_notify(mixer); if (err < 0) return err; return 0; } int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer) { struct snd_usb_audio *chip = mixer->chip; int err; /* only use UAC_VERSION_2 */ if (!mixer->protocol) return 0; if (!(chip->setup & SCARLETT2_ENABLE)) { usb_audio_info(chip, "Focusrite Scarlett Gen 2/3 Mixer Driver disabled; " "use options snd_usb_audio vid=0x%04x pid=0x%04x " "device_setup=1 to enable and report any issues " "to [email protected]", USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id)); return 0; } usb_audio_info(chip, "Focusrite Scarlett Gen 2/3 Mixer Driver enabled pid=0x%04x", USB_ID_PRODUCT(chip->usb_id)); err = snd_scarlett_gen2_controls_create(mixer); if (err < 0) usb_audio_err(mixer->chip, "Error initialising Scarlett Mixer Driver: %d", err); return err; }
linux-master
sound/usb/mixer_scarlett_gen2.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Scarlett Driver for ALSA * * Copyright (c) 2013 by Tobias Hoffmann * Copyright (c) 2013 by Robin Gareus <robin at gareus.org> * Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de> * Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com> * * Many codes borrowed from audio.c by * Alan Cox (alan at lxorguk.ukuu.org.uk) * Thomas Sailer (sailer at ife.ee.ethz.ch) * * Code cleanup: * David Henningsson <david.henningsson at canonical.com> */ /* * Rewritten and extended to support more models, e.g. Scarlett 18i8. * * Auto-detection via UAC2 is not feasible to properly discover the vast * majority of features. It's related to both Linux/ALSA's UAC2 as well as * Focusrite's implementation of it. Eventually quirks may be sufficient but * right now it's a major headache to work around these things. * * NB. Neither the OSX nor the win driver provided by Focusrite performs * discovery, they seem to operate the same as this driver. */ /* Mixer Interface for the Focusrite Scarlett 18i6 audio interface. * * The protocol was reverse engineered by looking at communication between * Scarlett MixControl (v 1.2.128.0) and the Focusrite(R) Scarlett 18i6 * (firmware v305) using wireshark and usbmon in January 2013. * Extended in July 2013. * * this mixer gives complete access to all features of the device: * - change Impedance of inputs (Line-in, Mic / Instrument, Hi-Z) * - select clock source * - dynamic input to mixer-matrix assignment * - 18 x 6 mixer-matrix gain stages * - bus routing & volume control * - automatic re-initialization on connect if device was power-cycled * * USB URB commands overview (bRequest = 0x01 = UAC2_CS_CUR) * wIndex * 0x01 Analog Input line/instrument impedance switch, wValue=0x0901 + * channel, data=Line/Inst (2bytes) * pad (-10dB) switch, wValue=0x0b01 + channel, data=Off/On (2bytes) * ?? wValue=0x0803/04, ?? (2bytes) * 0x0a Master Volume, wValue=0x0200+bus[0:all + only 1..4?] data(2bytes) * Bus Mute/Unmute wValue=0x0100+bus[0:all + only 1..4?], data(2bytes) * 0x28 Clock source, wValue=0x0100, data={1:int,2:spdif,3:adat} (1byte) * 0x29 Set Sample-rate, wValue=0x0100, data=sample-rate(4bytes) * 0x32 Mixer mux, wValue=0x0600 + mixer-channel, data=input-to-connect(2bytes) * 0x33 Output mux, wValue=bus, data=input-to-connect(2bytes) * 0x34 Capture mux, wValue=0...18, data=input-to-connect(2bytes) * 0x3c Matrix Mixer gains, wValue=mixer-node data=gain(2bytes) * ?? [sometimes](4bytes, e.g 0x000003be 0x000003bf ...03ff) * * USB reads: (i.e. actually issued by original software) * 0x01 wValue=0x0901+channel (1byte!!), wValue=0x0b01+channed (1byte!!) * 0x29 wValue=0x0100 sample-rate(4bytes) * wValue=0x0200 ?? 1byte (only once) * 0x2a wValue=0x0100 ?? 4bytes, sample-rate2 ?? * * USB reads with bRequest = 0x03 = UAC2_CS_MEM * 0x3c wValue=0x0002 1byte: sync status (locked=1) * wValue=0x0000 18*2byte: peak meter (inputs) * wValue=0x0001 8(?)*2byte: peak meter (mix) * wValue=0x0003 6*2byte: peak meter (pcm/daw) * * USB write with bRequest = 0x03 * 0x3c Save settings to hardware: wValue=0x005a, data=0xa5 * * * <ditaa> * /--------------\ 18chn 6chn /--------------\ * | Hardware in +--+-------\ /------+--+ ALSA PCM out | * \--------------/ | | | | \--------------/ * | | | | * | v v | * | +---------------+ | * | \ Matrix Mux / | * | +-----+-----+ | * | | | * | | 18chn | * | v | * | +-----------+ | * | | Mixer | | * | | Matrix | | * | | | | * | | 18x6 Gain | | * | | stages | | * | +-----+-----+ | * | | | * | | | * | 18chn | 6chn | 6chn * v v v * ========================= * +---------------+ +--—------------+ * \ Output Mux / \ Capture Mux / * +-----+-----+ +-----+-----+ * | | * | 6chn | * v | * +-------------+ | * | Master Gain | | * +------+------+ | * | | * | 6chn | 18chn * | (3 stereo pairs) | * /--------------\ | | /--------------\ * | Hardware out |<--/ \-->| ALSA PCM in | * \--------------/ \--------------/ * </ditaa> * */ #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio-v2.h> #include <sound/core.h> #include <sound/control.h> #include <sound/tlv.h> #include "usbaudio.h" #include "mixer.h" #include "helper.h" #include "power.h" #include "mixer_scarlett.h" /* some gui mixers can't handle negative ctl values */ #define SND_SCARLETT_LEVEL_BIAS 128 #define SND_SCARLETT_MATRIX_IN_MAX 18 #define SND_SCARLETT_CONTROLS_MAX 10 #define SND_SCARLETT_OFFSETS_MAX 5 enum { SCARLETT_OUTPUTS, SCARLETT_SWITCH_IMPEDANCE, SCARLETT_SWITCH_PAD, SCARLETT_SWITCH_GAIN, }; enum { SCARLETT_OFFSET_PCM = 0, SCARLETT_OFFSET_ANALOG = 1, SCARLETT_OFFSET_SPDIF = 2, SCARLETT_OFFSET_ADAT = 3, SCARLETT_OFFSET_MIX = 4, }; struct scarlett_mixer_elem_enum_info { int start; int len; int offsets[SND_SCARLETT_OFFSETS_MAX]; char const * const *names; }; struct scarlett_mixer_control { unsigned char num; unsigned char type; const char *name; }; struct scarlett_device_info { int matrix_in; int matrix_out; int input_len; int output_len; struct scarlett_mixer_elem_enum_info opt_master; struct scarlett_mixer_elem_enum_info opt_matrix; /* initial values for matrix mux */ int matrix_mux_init[SND_SCARLETT_MATRIX_IN_MAX]; int num_controls; /* number of items in controls */ const struct scarlett_mixer_control controls[SND_SCARLETT_CONTROLS_MAX]; }; /********************** Enum Strings *************************/ static const struct scarlett_mixer_elem_enum_info opt_pad = { .start = 0, .len = 2, .offsets = {}, .names = (char const * const []){ "0dB", "-10dB" } }; static const struct scarlett_mixer_elem_enum_info opt_gain = { .start = 0, .len = 2, .offsets = {}, .names = (char const * const []){ "Lo", "Hi" } }; static const struct scarlett_mixer_elem_enum_info opt_impedance = { .start = 0, .len = 2, .offsets = {}, .names = (char const * const []){ "Line", "Hi-Z" } }; static const struct scarlett_mixer_elem_enum_info opt_clock = { .start = 1, .len = 3, .offsets = {}, .names = (char const * const []){ "Internal", "SPDIF", "ADAT" } }; static const struct scarlett_mixer_elem_enum_info opt_sync = { .start = 0, .len = 2, .offsets = {}, .names = (char const * const []){ "No Lock", "Locked" } }; static int scarlett_ctl_switch_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *elem = kctl->private_data; uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->count = elem->channels; uinfo->value.integer.min = 0; uinfo->value.integer.max = 1; return 0; } static int scarlett_ctl_switch_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; int i, err, val; for (i = 0; i < elem->channels; i++) { err = snd_usb_get_cur_mix_value(elem, i, i, &val); if (err < 0) return err; val = !val; /* invert mute logic for mixer */ ucontrol->value.integer.value[i] = val; } return 0; } static int scarlett_ctl_switch_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; int i, changed = 0; int err, oval, val; for (i = 0; i < elem->channels; i++) { err = snd_usb_get_cur_mix_value(elem, i, i, &oval); if (err < 0) return err; val = ucontrol->value.integer.value[i]; val = !val; if (oval != val) { err = snd_usb_set_cur_mix_value(elem, i, i, val); if (err < 0) return err; changed = 1; } } return changed; } static int scarlett_ctl_resume(struct usb_mixer_elem_list *list) { struct usb_mixer_elem_info *elem = mixer_elem_list_to_info(list); int i; for (i = 0; i < elem->channels; i++) if (elem->cached & (1 << i)) snd_usb_set_cur_mix_value(elem, i, i, elem->cache_val[i]); return 0; } static int scarlett_ctl_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *elem = kctl->private_data; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = elem->channels; uinfo->value.integer.min = 0; uinfo->value.integer.max = (int)kctl->private_value + SND_SCARLETT_LEVEL_BIAS; uinfo->value.integer.step = 1; return 0; } static int scarlett_ctl_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; int i, err, val; for (i = 0; i < elem->channels; i++) { err = snd_usb_get_cur_mix_value(elem, i, i, &val); if (err < 0) return err; val = clamp(val / 256, -128, (int)kctl->private_value) + SND_SCARLETT_LEVEL_BIAS; ucontrol->value.integer.value[i] = val; } return 0; } static int scarlett_ctl_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; int i, changed = 0; int err, oval, val; for (i = 0; i < elem->channels; i++) { err = snd_usb_get_cur_mix_value(elem, i, i, &oval); if (err < 0) return err; val = ucontrol->value.integer.value[i] - SND_SCARLETT_LEVEL_BIAS; val = val * 256; if (oval != val) { err = snd_usb_set_cur_mix_value(elem, i, i, val); if (err < 0) return err; changed = 1; } } return changed; } static void scarlett_generate_name(int i, char *dst, int offsets[]) { if (i > offsets[SCARLETT_OFFSET_MIX]) sprintf(dst, "Mix %c", 'A'+(i - offsets[SCARLETT_OFFSET_MIX] - 1)); else if (i > offsets[SCARLETT_OFFSET_ADAT]) sprintf(dst, "ADAT %d", i - offsets[SCARLETT_OFFSET_ADAT]); else if (i > offsets[SCARLETT_OFFSET_SPDIF]) sprintf(dst, "SPDIF %d", i - offsets[SCARLETT_OFFSET_SPDIF]); else if (i > offsets[SCARLETT_OFFSET_ANALOG]) sprintf(dst, "Analog %d", i - offsets[SCARLETT_OFFSET_ANALOG]); else if (i > offsets[SCARLETT_OFFSET_PCM]) sprintf(dst, "PCM %d", i - offsets[SCARLETT_OFFSET_PCM]); else sprintf(dst, "Off"); } static int scarlett_ctl_enum_dynamic_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett_mixer_elem_enum_info *opt = elem->private_data; unsigned int items = opt->len; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = elem->channels; uinfo->value.enumerated.items = items; if (uinfo->value.enumerated.item >= items) uinfo->value.enumerated.item = items - 1; /* generate name dynamically based on item number and offset info */ scarlett_generate_name(uinfo->value.enumerated.item, uinfo->value.enumerated.name, opt->offsets); return 0; } static int scarlett_ctl_enum_info(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett_mixer_elem_enum_info *opt = elem->private_data; return snd_ctl_enum_info(uinfo, elem->channels, opt->len, (const char * const *)opt->names); } static int scarlett_ctl_enum_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett_mixer_elem_enum_info *opt = elem->private_data; int err, val; err = snd_usb_get_cur_mix_value(elem, 0, 0, &val); if (err < 0) return err; val = clamp(val - opt->start, 0, opt->len-1); ucontrol->value.enumerated.item[0] = val; return 0; } static int scarlett_ctl_enum_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct scarlett_mixer_elem_enum_info *opt = elem->private_data; int err, oval, val; err = snd_usb_get_cur_mix_value(elem, 0, 0, &oval); if (err < 0) return err; val = ucontrol->value.integer.value[0]; val = val + opt->start; if (val != oval) { snd_usb_set_cur_mix_value(elem, 0, 0, val); return 1; } return 0; } static int scarlett_ctl_enum_resume(struct usb_mixer_elem_list *list) { struct usb_mixer_elem_info *elem = mixer_elem_list_to_info(list); if (elem->cached) snd_usb_set_cur_mix_value(elem, 0, 0, *elem->cache_val); return 0; } static int scarlett_ctl_meter_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kctl->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; unsigned char buf[2 * MAX_CHANNELS] = {0, }; int wValue = (elem->control << 8) | elem->idx_off; int idx = snd_usb_ctrl_intf(chip) | (elem->head.id << 8); int err; err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_MEM, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, wValue, idx, buf, elem->channels); if (err < 0) return err; ucontrol->value.enumerated.item[0] = clamp((int)buf[0], 0, 1); return 0; } static const struct snd_kcontrol_new usb_scarlett_ctl_switch = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett_ctl_switch_info, .get = scarlett_ctl_switch_get, .put = scarlett_ctl_switch_put, }; static const DECLARE_TLV_DB_SCALE(db_scale_scarlett_gain, -12800, 100, 0); static const struct snd_kcontrol_new usb_scarlett_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .name = "", .info = scarlett_ctl_info, .get = scarlett_ctl_get, .put = scarlett_ctl_put, .private_value = 6, /* max value */ .tlv = { .p = db_scale_scarlett_gain } }; static const struct snd_kcontrol_new usb_scarlett_ctl_master = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .name = "", .info = scarlett_ctl_info, .get = scarlett_ctl_get, .put = scarlett_ctl_put, .private_value = 6, /* max value */ .tlv = { .p = db_scale_scarlett_gain } }; static const struct snd_kcontrol_new usb_scarlett_ctl_enum = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett_ctl_enum_info, .get = scarlett_ctl_enum_get, .put = scarlett_ctl_enum_put, }; static const struct snd_kcontrol_new usb_scarlett_ctl_dynamic_enum = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "", .info = scarlett_ctl_enum_dynamic_info, .get = scarlett_ctl_enum_get, .put = scarlett_ctl_enum_put, }; static const struct snd_kcontrol_new usb_scarlett_ctl_sync = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, .name = "", .info = scarlett_ctl_enum_info, .get = scarlett_ctl_meter_get, }; static int add_new_ctl(struct usb_mixer_interface *mixer, const struct snd_kcontrol_new *ncontrol, usb_mixer_elem_resume_func_t resume, int index, int offset, int num, int val_type, int channels, const char *name, const struct scarlett_mixer_elem_enum_info *opt, struct usb_mixer_elem_info **elem_ret ) { struct snd_kcontrol *kctl; struct usb_mixer_elem_info *elem; int err; elem = kzalloc(sizeof(*elem), GFP_KERNEL); if (!elem) return -ENOMEM; elem->head.mixer = mixer; elem->head.resume = resume; elem->control = offset; elem->idx_off = num; elem->head.id = index; elem->val_type = val_type; elem->channels = channels; /* add scarlett_mixer_elem_enum_info struct */ elem->private_data = (void *)opt; kctl = snd_ctl_new1(ncontrol, elem); if (!kctl) { kfree(elem); return -ENOMEM; } kctl->private_free = snd_usb_mixer_elem_free; strscpy(kctl->id.name, name, sizeof(kctl->id.name)); err = snd_usb_mixer_add_control(&elem->head, kctl); if (err < 0) return err; if (elem_ret) *elem_ret = elem; return 0; } static int add_output_ctls(struct usb_mixer_interface *mixer, int index, const char *name, const struct scarlett_device_info *info) { int err; char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; struct usb_mixer_elem_info *elem; /* Add mute switch */ snprintf(mx, sizeof(mx), "Master %d (%s) Playback Switch", index + 1, name); err = add_new_ctl(mixer, &usb_scarlett_ctl_switch, scarlett_ctl_resume, 0x0a, 0x01, 2*index+1, USB_MIXER_S16, 2, mx, NULL, &elem); if (err < 0) return err; /* Add volume control and initialize to 0 */ snprintf(mx, sizeof(mx), "Master %d (%s) Playback Volume", index + 1, name); err = add_new_ctl(mixer, &usb_scarlett_ctl_master, scarlett_ctl_resume, 0x0a, 0x02, 2*index+1, USB_MIXER_S16, 2, mx, NULL, &elem); if (err < 0) return err; /* Add L channel source playback enumeration */ snprintf(mx, sizeof(mx), "Master %dL (%s) Source Playback Enum", index + 1, name); err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum, scarlett_ctl_enum_resume, 0x33, 0x00, 2*index, USB_MIXER_S16, 1, mx, &info->opt_master, &elem); if (err < 0) return err; /* Add R channel source playback enumeration */ snprintf(mx, sizeof(mx), "Master %dR (%s) Source Playback Enum", index + 1, name); err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum, scarlett_ctl_enum_resume, 0x33, 0x00, 2*index+1, USB_MIXER_S16, 1, mx, &info->opt_master, &elem); if (err < 0) return err; return 0; } /********************** device-specific config *************************/ /* untested... */ static const struct scarlett_device_info s6i6_info = { .matrix_in = 18, .matrix_out = 8, .input_len = 6, .output_len = 6, .opt_master = { .start = -1, .len = 27, .offsets = {0, 12, 16, 18, 18}, .names = NULL }, .opt_matrix = { .start = -1, .len = 19, .offsets = {0, 12, 16, 18, 18}, .names = NULL }, .num_controls = 9, .controls = { { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" }, { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" }, { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" }, { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 3, .type = SCARLETT_SWITCH_GAIN, .name = NULL}, { .num = 4, .type = SCARLETT_SWITCH_GAIN, .name = NULL}, }, .matrix_mux_init = { 12, 13, 14, 15, /* Analog -> 1..4 */ 16, 17, /* SPDIF -> 5,6 */ 0, 1, 2, 3, 4, 5, 6, 7, /* PCM[1..12] -> 7..18 */ 8, 9, 10, 11 } }; /* untested... */ static const struct scarlett_device_info s8i6_info = { .matrix_in = 18, .matrix_out = 6, .input_len = 8, .output_len = 6, .opt_master = { .start = -1, .len = 25, .offsets = {0, 12, 16, 18, 18}, .names = NULL }, .opt_matrix = { .start = -1, .len = 19, .offsets = {0, 12, 16, 18, 18}, .names = NULL }, .num_controls = 7, .controls = { { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" }, { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" }, { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" }, { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL}, }, .matrix_mux_init = { 12, 13, 14, 15, /* Analog -> 1..4 */ 16, 17, /* SPDIF -> 5,6 */ 0, 1, 2, 3, 4, 5, 6, 7, /* PCM[1..12] -> 7..18 */ 8, 9, 10, 11 } }; static const struct scarlett_device_info s18i6_info = { .matrix_in = 18, .matrix_out = 6, .input_len = 18, .output_len = 6, .opt_master = { .start = -1, .len = 31, .offsets = {0, 6, 14, 16, 24}, .names = NULL, }, .opt_matrix = { .start = -1, .len = 25, .offsets = {0, 6, 14, 16, 24}, .names = NULL, }, .num_controls = 5, .controls = { { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" }, { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" }, { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" }, { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, }, .matrix_mux_init = { 6, 7, 8, 9, 10, 11, 12, 13, /* Analog -> 1..8 */ 16, 17, 18, 19, 20, 21, /* ADAT[1..6] -> 9..14 */ 14, 15, /* SPDIF -> 15,16 */ 0, 1 /* PCM[1,2] -> 17,18 */ } }; static const struct scarlett_device_info s18i8_info = { .matrix_in = 18, .matrix_out = 8, .input_len = 18, .output_len = 8, .opt_master = { .start = -1, .len = 35, .offsets = {0, 8, 16, 18, 26}, .names = NULL }, .opt_matrix = { .start = -1, .len = 27, .offsets = {0, 8, 16, 18, 26}, .names = NULL }, .num_controls = 10, .controls = { { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" }, { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone 1" }, { .num = 2, .type = SCARLETT_OUTPUTS, .name = "Headphone 2" }, { .num = 3, .type = SCARLETT_OUTPUTS, .name = "SPDIF" }, { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL}, }, .matrix_mux_init = { 8, 9, 10, 11, 12, 13, 14, 15, /* Analog -> 1..8 */ 18, 19, 20, 21, 22, 23, /* ADAT[1..6] -> 9..14 */ 16, 17, /* SPDIF -> 15,16 */ 0, 1 /* PCM[1,2] -> 17,18 */ } }; static const struct scarlett_device_info s18i20_info = { .matrix_in = 18, .matrix_out = 8, .input_len = 18, .output_len = 20, .opt_master = { .start = -1, .len = 47, .offsets = {0, 20, 28, 30, 38}, .names = NULL }, .opt_matrix = { .start = -1, .len = 39, .offsets = {0, 20, 28, 30, 38}, .names = NULL }, .num_controls = 10, .controls = { { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" }, { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Line 3/4" }, { .num = 2, .type = SCARLETT_OUTPUTS, .name = "Line 5/6" }, { .num = 3, .type = SCARLETT_OUTPUTS, .name = "Line 7/8" }, { .num = 4, .type = SCARLETT_OUTPUTS, .name = "Line 9/10" }, { .num = 5, .type = SCARLETT_OUTPUTS, .name = "SPDIF" }, { .num = 6, .type = SCARLETT_OUTPUTS, .name = "ADAT 1/2" }, { .num = 7, .type = SCARLETT_OUTPUTS, .name = "ADAT 3/4" }, { .num = 8, .type = SCARLETT_OUTPUTS, .name = "ADAT 5/6" }, { .num = 9, .type = SCARLETT_OUTPUTS, .name = "ADAT 7/8" }, /*{ .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL}, { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL}, { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},*/ }, .matrix_mux_init = { 20, 21, 22, 23, 24, 25, 26, 27, /* Analog -> 1..8 */ 30, 31, 32, 33, 34, 35, /* ADAT[1..6] -> 9..14 */ 28, 29, /* SPDIF -> 15,16 */ 0, 1 /* PCM[1,2] -> 17,18 */ } }; static int scarlett_controls_create_generic(struct usb_mixer_interface *mixer, const struct scarlett_device_info *info) { int i, err; char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; const struct scarlett_mixer_control *ctl; struct usb_mixer_elem_info *elem; /* create master switch and playback volume */ err = add_new_ctl(mixer, &usb_scarlett_ctl_switch, scarlett_ctl_resume, 0x0a, 0x01, 0, USB_MIXER_S16, 1, "Master Playback Switch", NULL, &elem); if (err < 0) return err; err = add_new_ctl(mixer, &usb_scarlett_ctl_master, scarlett_ctl_resume, 0x0a, 0x02, 0, USB_MIXER_S16, 1, "Master Playback Volume", NULL, &elem); if (err < 0) return err; /* iterate through controls in info struct and create each one */ for (i = 0; i < info->num_controls; i++) { ctl = &info->controls[i]; switch (ctl->type) { case SCARLETT_OUTPUTS: err = add_output_ctls(mixer, ctl->num, ctl->name, info); if (err < 0) return err; break; case SCARLETT_SWITCH_IMPEDANCE: sprintf(mx, "Input %d Impedance Switch", ctl->num); err = add_new_ctl(mixer, &usb_scarlett_ctl_enum, scarlett_ctl_enum_resume, 0x01, 0x09, ctl->num, USB_MIXER_S16, 1, mx, &opt_impedance, &elem); if (err < 0) return err; break; case SCARLETT_SWITCH_PAD: sprintf(mx, "Input %d Pad Switch", ctl->num); err = add_new_ctl(mixer, &usb_scarlett_ctl_enum, scarlett_ctl_enum_resume, 0x01, 0x0b, ctl->num, USB_MIXER_S16, 1, mx, &opt_pad, &elem); if (err < 0) return err; break; case SCARLETT_SWITCH_GAIN: sprintf(mx, "Input %d Gain Switch", ctl->num); err = add_new_ctl(mixer, &usb_scarlett_ctl_enum, scarlett_ctl_enum_resume, 0x01, 0x08, ctl->num, USB_MIXER_S16, 1, mx, &opt_gain, &elem); if (err < 0) return err; break; } } return 0; } /* * Create and initialize a mixer for the Focusrite(R) Scarlett */ int snd_scarlett_controls_create(struct usb_mixer_interface *mixer) { int err, i, o; char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; const struct scarlett_device_info *info; struct usb_mixer_elem_info *elem; static char sample_rate_buffer[4] = { '\x80', '\xbb', '\x00', '\x00' }; /* only use UAC_VERSION_2 */ if (!mixer->protocol) return 0; switch (mixer->chip->usb_id) { case USB_ID(0x1235, 0x8012): info = &s6i6_info; break; case USB_ID(0x1235, 0x8002): info = &s8i6_info; break; case USB_ID(0x1235, 0x8004): info = &s18i6_info; break; case USB_ID(0x1235, 0x8014): info = &s18i8_info; break; case USB_ID(0x1235, 0x800c): info = &s18i20_info; break; default: /* device not (yet) supported */ return -EINVAL; } /* generic function to create controls */ err = scarlett_controls_create_generic(mixer, info); if (err < 0) return err; /* setup matrix controls */ for (i = 0; i < info->matrix_in; i++) { snprintf(mx, sizeof(mx), "Matrix %02d Input Playback Route", i+1); err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum, scarlett_ctl_enum_resume, 0x32, 0x06, i, USB_MIXER_S16, 1, mx, &info->opt_matrix, &elem); if (err < 0) return err; for (o = 0; o < info->matrix_out; o++) { sprintf(mx, "Matrix %02d Mix %c Playback Volume", i+1, o+'A'); err = add_new_ctl(mixer, &usb_scarlett_ctl, scarlett_ctl_resume, 0x3c, 0x00, (i << 3) + (o & 0x07), USB_MIXER_S16, 1, mx, NULL, &elem); if (err < 0) return err; } } for (i = 0; i < info->input_len; i++) { snprintf(mx, sizeof(mx), "Input Source %02d Capture Route", i+1); err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum, scarlett_ctl_enum_resume, 0x34, 0x00, i, USB_MIXER_S16, 1, mx, &info->opt_master, &elem); if (err < 0) return err; } /* val_len == 1 needed here */ err = add_new_ctl(mixer, &usb_scarlett_ctl_enum, scarlett_ctl_enum_resume, 0x28, 0x01, 0, USB_MIXER_U8, 1, "Sample Clock Source", &opt_clock, &elem); if (err < 0) return err; /* val_len == 1 and UAC2_CS_MEM */ err = add_new_ctl(mixer, &usb_scarlett_ctl_sync, NULL, 0x3c, 0x00, 2, USB_MIXER_U8, 1, "Sample Clock Sync Status", &opt_sync, &elem); if (err < 0) return err; /* initialize sampling rate to 48000 */ err = snd_usb_ctl_msg(mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0), UAC2_CS_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 0x0100, snd_usb_ctrl_intf(mixer->chip) | (0x29 << 8), sample_rate_buffer, 4); if (err < 0) return err; return err; }
linux-master
sound/usb/mixer_scarlett.c
// SPDX-License-Identifier: GPL-2.0 /* * UAC3 Power Domain state management functions */ #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <linux/usb/audio-v3.h> #include "usbaudio.h" #include "helper.h" #include "power.h" struct snd_usb_power_domain * snd_usb_find_power_domain(struct usb_host_interface *ctrl_iface, unsigned char id) { struct snd_usb_power_domain *pd; void *p; pd = kzalloc(sizeof(*pd), GFP_KERNEL); if (!pd) return NULL; p = NULL; while ((p = snd_usb_find_csint_desc(ctrl_iface->extra, ctrl_iface->extralen, p, UAC3_POWER_DOMAIN)) != NULL) { struct uac3_power_domain_descriptor *pd_desc = p; int i; if (!snd_usb_validate_audio_desc(p, UAC_VERSION_3)) continue; for (i = 0; i < pd_desc->bNrEntities; i++) { if (pd_desc->baEntityID[i] == id) { pd->pd_id = pd_desc->bPowerDomainID; pd->pd_d1d0_rec = le16_to_cpu(pd_desc->waRecoveryTime1); pd->pd_d2d0_rec = le16_to_cpu(pd_desc->waRecoveryTime2); return pd; } } } kfree(pd); return NULL; } int snd_usb_power_domain_set(struct snd_usb_audio *chip, struct snd_usb_power_domain *pd, unsigned char state) { struct usb_device *dev = chip->dev; unsigned char current_state; int err, idx; idx = snd_usb_ctrl_intf(chip) | (pd->pd_id << 8); err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, UAC3_AC_POWER_DOMAIN_CONTROL << 8, idx, &current_state, sizeof(current_state)); if (err < 0) { dev_err(&dev->dev, "Can't get UAC3 power state for id %d\n", pd->pd_id); return err; } if (current_state == state) { dev_dbg(&dev->dev, "UAC3 power domain id %d already in state %d\n", pd->pd_id, state); return 0; } err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC2_CS_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, UAC3_AC_POWER_DOMAIN_CONTROL << 8, idx, &state, sizeof(state)); if (err < 0) { dev_err(&dev->dev, "Can't set UAC3 power state to %d for id %d\n", state, pd->pd_id); return err; } if (state == UAC3_PD_STATE_D0) { switch (current_state) { case UAC3_PD_STATE_D2: udelay(pd->pd_d2d0_rec * 50); break; case UAC3_PD_STATE_D1: udelay(pd->pd_d1d0_rec * 50); break; default: return -EINVAL; } } dev_dbg(&dev->dev, "UAC3 power domain id %d change to state %d\n", pd->pd_id, state); return 0; }
linux-master
sound/usb/power.c
// SPDX-License-Identifier: GPL-2.0-or-later /* */ #include <linux/init.h> #include <linux/slab.h> #include <linux/usb.h> #include "usbaudio.h" #include "helper.h" #include "quirks.h" /* * combine bytes and get an integer value */ unsigned int snd_usb_combine_bytes(unsigned char *bytes, int size) { switch (size) { case 1: return *bytes; case 2: return combine_word(bytes); case 3: return combine_triple(bytes); case 4: return combine_quad(bytes); default: return 0; } } /* * parse descriptor buffer and return the pointer starting the given * descriptor type. */ void *snd_usb_find_desc(void *descstart, int desclen, void *after, u8 dtype) { u8 *p, *end, *next; p = descstart; end = p + desclen; for (; p < end;) { if (p[0] < 2) return NULL; next = p + p[0]; if (next > end) return NULL; if (p[1] == dtype && (!after || (void *)p > after)) { return p; } p = next; } return NULL; } /* * find a class-specified interface descriptor with the given subtype. */ void *snd_usb_find_csint_desc(void *buffer, int buflen, void *after, u8 dsubtype) { unsigned char *p = after; while ((p = snd_usb_find_desc(buffer, buflen, p, USB_DT_CS_INTERFACE)) != NULL) { if (p[0] >= 3 && p[2] == dsubtype) return p; } return NULL; } /* * Wrapper for usb_control_msg(). * Allocates a temp buffer to prevent dmaing from/to the stack. */ int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype, __u16 value, __u16 index, void *data, __u16 size) { int err; void *buf = NULL; int timeout; if (usb_pipe_type_check(dev, pipe)) return -EINVAL; if (size > 0) { buf = kmemdup(data, size, GFP_KERNEL); if (!buf) return -ENOMEM; } if (requesttype & USB_DIR_IN) timeout = USB_CTRL_GET_TIMEOUT; else timeout = USB_CTRL_SET_TIMEOUT; err = usb_control_msg(dev, pipe, request, requesttype, value, index, buf, size, timeout); if (size > 0) { memcpy(data, buf, size); kfree(buf); } snd_usb_ctl_msg_quirk(dev, pipe, request, requesttype, value, index, data, size); return err; } unsigned char snd_usb_parse_datainterval(struct snd_usb_audio *chip, struct usb_host_interface *alts) { switch (snd_usb_get_speed(chip->dev)) { case USB_SPEED_HIGH: case USB_SPEED_SUPER: case USB_SPEED_SUPER_PLUS: if (get_endpoint(alts, 0)->bInterval >= 1 && get_endpoint(alts, 0)->bInterval <= 4) return get_endpoint(alts, 0)->bInterval - 1; break; default: break; } return 0; } struct usb_host_interface * snd_usb_get_host_interface(struct snd_usb_audio *chip, int ifnum, int altsetting) { struct usb_interface *iface; iface = usb_ifnum_to_if(chip->dev, ifnum); if (!iface) return NULL; return usb_altnum_to_altsetting(iface, altsetting); }
linux-master
sound/usb/helper.c
// SPDX-License-Identifier: GPL-2.0-or-later /* */ #include <linux/gfp.h> #include <linux/init.h> #include <linux/ratelimit.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/slab.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "usbaudio.h" #include "helper.h" #include "card.h" #include "endpoint.h" #include "pcm.h" #include "clock.h" #include "quirks.h" enum { EP_STATE_STOPPED, EP_STATE_RUNNING, EP_STATE_STOPPING, }; /* interface refcounting */ struct snd_usb_iface_ref { unsigned char iface; bool need_setup; int opened; int altset; struct list_head list; }; /* clock refcounting */ struct snd_usb_clock_ref { unsigned char clock; atomic_t locked; int opened; int rate; bool need_setup; struct list_head list; }; /* * snd_usb_endpoint is a model that abstracts everything related to an * USB endpoint and its streaming. * * There are functions to activate and deactivate the streaming URBs and * optional callbacks to let the pcm logic handle the actual content of the * packets for playback and record. Thus, the bus streaming and the audio * handlers are fully decoupled. * * There are two different types of endpoints in audio applications. * * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both * inbound and outbound traffic. * * SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and * expect the payload to carry Q10.14 / Q16.16 formatted sync information * (3 or 4 bytes). * * Each endpoint has to be configured prior to being used by calling * snd_usb_endpoint_set_params(). * * The model incorporates a reference counting, so that multiple users * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and * only the first user will effectively start the URBs, and only the last * one to stop it will tear the URBs down again. */ /* * convert a sampling rate into our full speed format (fs/1000 in Q16.16) * this will overflow at approx 524 kHz */ static inline unsigned get_usb_full_speed_rate(unsigned int rate) { return ((rate << 13) + 62) / 125; } /* * convert a sampling rate into USB high speed format (fs/8000 in Q16.16) * this will overflow at approx 4 MHz */ static inline unsigned get_usb_high_speed_rate(unsigned int rate) { return ((rate << 10) + 62) / 125; } /* * release a urb data */ static void release_urb_ctx(struct snd_urb_ctx *u) { if (u->urb && u->buffer_size) usb_free_coherent(u->ep->chip->dev, u->buffer_size, u->urb->transfer_buffer, u->urb->transfer_dma); usb_free_urb(u->urb); u->urb = NULL; u->buffer_size = 0; } static const char *usb_error_string(int err) { switch (err) { case -ENODEV: return "no device"; case -ENOENT: return "endpoint not enabled"; case -EPIPE: return "endpoint stalled"; case -ENOSPC: return "not enough bandwidth"; case -ESHUTDOWN: return "device disabled"; case -EHOSTUNREACH: return "device suspended"; case -EINVAL: case -EAGAIN: case -EFBIG: case -EMSGSIZE: return "internal error"; default: return "unknown error"; } } static inline bool ep_state_running(struct snd_usb_endpoint *ep) { return atomic_read(&ep->state) == EP_STATE_RUNNING; } static inline bool ep_state_update(struct snd_usb_endpoint *ep, int old, int new) { return atomic_try_cmpxchg(&ep->state, &old, new); } /** * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type * * @ep: The snd_usb_endpoint * * Determine whether an endpoint is driven by an implicit feedback * data endpoint source. */ int snd_usb_endpoint_implicit_feedback_sink(struct snd_usb_endpoint *ep) { return ep->implicit_fb_sync && usb_pipeout(ep->pipe); } /* * Return the number of samples to be sent in the next packet * for streaming based on information derived from sync endpoints * * This won't be used for implicit feedback which takes the packet size * returned from the sync source */ static int slave_next_packet_size(struct snd_usb_endpoint *ep, unsigned int avail) { unsigned long flags; unsigned int phase; int ret; if (ep->fill_max) return ep->maxframesize; spin_lock_irqsave(&ep->lock, flags); phase = (ep->phase & 0xffff) + (ep->freqm << ep->datainterval); ret = min(phase >> 16, ep->maxframesize); if (avail && ret >= avail) ret = -EAGAIN; else ep->phase = phase; spin_unlock_irqrestore(&ep->lock, flags); return ret; } /* * Return the number of samples to be sent in the next packet * for adaptive and synchronous endpoints */ static int next_packet_size(struct snd_usb_endpoint *ep, unsigned int avail) { unsigned int sample_accum; int ret; if (ep->fill_max) return ep->maxframesize; sample_accum = ep->sample_accum + ep->sample_rem; if (sample_accum >= ep->pps) { sample_accum -= ep->pps; ret = ep->packsize[1]; } else { ret = ep->packsize[0]; } if (avail && ret >= avail) ret = -EAGAIN; else ep->sample_accum = sample_accum; return ret; } /* * snd_usb_endpoint_next_packet_size: Return the number of samples to be sent * in the next packet * * If the size is equal or exceeds @avail, don't proceed but return -EAGAIN * Exception: @avail = 0 for skipping the check. */ int snd_usb_endpoint_next_packet_size(struct snd_usb_endpoint *ep, struct snd_urb_ctx *ctx, int idx, unsigned int avail) { unsigned int packet; packet = ctx->packet_size[idx]; if (packet) { if (avail && packet >= avail) return -EAGAIN; return packet; } if (ep->sync_source) return slave_next_packet_size(ep, avail); else return next_packet_size(ep, avail); } static void call_retire_callback(struct snd_usb_endpoint *ep, struct urb *urb) { struct snd_usb_substream *data_subs; data_subs = READ_ONCE(ep->data_subs); if (data_subs && ep->retire_data_urb) ep->retire_data_urb(data_subs, urb); } static void retire_outbound_urb(struct snd_usb_endpoint *ep, struct snd_urb_ctx *urb_ctx) { call_retire_callback(ep, urb_ctx->urb); } static void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep, struct snd_usb_endpoint *sender, const struct urb *urb); static void retire_inbound_urb(struct snd_usb_endpoint *ep, struct snd_urb_ctx *urb_ctx) { struct urb *urb = urb_ctx->urb; struct snd_usb_endpoint *sync_sink; if (unlikely(ep->skip_packets > 0)) { ep->skip_packets--; return; } sync_sink = READ_ONCE(ep->sync_sink); if (sync_sink) snd_usb_handle_sync_urb(sync_sink, ep, urb); call_retire_callback(ep, urb); } static inline bool has_tx_length_quirk(struct snd_usb_audio *chip) { return chip->quirk_flags & QUIRK_FLAG_TX_LENGTH; } static void prepare_silent_urb(struct snd_usb_endpoint *ep, struct snd_urb_ctx *ctx) { struct urb *urb = ctx->urb; unsigned int offs = 0; unsigned int extra = 0; __le32 packet_length; int i; /* For tx_length_quirk, put packet length at start of packet */ if (has_tx_length_quirk(ep->chip)) extra = sizeof(packet_length); for (i = 0; i < ctx->packets; ++i) { unsigned int offset; unsigned int length; int counts; counts = snd_usb_endpoint_next_packet_size(ep, ctx, i, 0); length = counts * ep->stride; /* number of silent bytes */ offset = offs * ep->stride + extra * i; urb->iso_frame_desc[i].offset = offset; urb->iso_frame_desc[i].length = length + extra; if (extra) { packet_length = cpu_to_le32(length); memcpy(urb->transfer_buffer + offset, &packet_length, sizeof(packet_length)); } memset(urb->transfer_buffer + offset + extra, ep->silence_value, length); offs += counts; } urb->number_of_packets = ctx->packets; urb->transfer_buffer_length = offs * ep->stride + ctx->packets * extra; ctx->queued = 0; } /* * Prepare a PLAYBACK urb for submission to the bus. */ static int prepare_outbound_urb(struct snd_usb_endpoint *ep, struct snd_urb_ctx *ctx, bool in_stream_lock) { struct urb *urb = ctx->urb; unsigned char *cp = urb->transfer_buffer; struct snd_usb_substream *data_subs; urb->dev = ep->chip->dev; /* we need to set this at each time */ switch (ep->type) { case SND_USB_ENDPOINT_TYPE_DATA: data_subs = READ_ONCE(ep->data_subs); if (data_subs && ep->prepare_data_urb) return ep->prepare_data_urb(data_subs, urb, in_stream_lock); /* no data provider, so send silence */ prepare_silent_urb(ep, ctx); break; case SND_USB_ENDPOINT_TYPE_SYNC: if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) { /* * fill the length and offset of each urb descriptor. * the fixed 12.13 frequency is passed as 16.16 through the pipe. */ urb->iso_frame_desc[0].length = 4; urb->iso_frame_desc[0].offset = 0; cp[0] = ep->freqn; cp[1] = ep->freqn >> 8; cp[2] = ep->freqn >> 16; cp[3] = ep->freqn >> 24; } else { /* * fill the length and offset of each urb descriptor. * the fixed 10.14 frequency is passed through the pipe. */ urb->iso_frame_desc[0].length = 3; urb->iso_frame_desc[0].offset = 0; cp[0] = ep->freqn >> 2; cp[1] = ep->freqn >> 10; cp[2] = ep->freqn >> 18; } break; } return 0; } /* * Prepare a CAPTURE or SYNC urb for submission to the bus. */ static int prepare_inbound_urb(struct snd_usb_endpoint *ep, struct snd_urb_ctx *urb_ctx) { int i, offs; struct urb *urb = urb_ctx->urb; urb->dev = ep->chip->dev; /* we need to set this at each time */ switch (ep->type) { case SND_USB_ENDPOINT_TYPE_DATA: offs = 0; for (i = 0; i < urb_ctx->packets; i++) { urb->iso_frame_desc[i].offset = offs; urb->iso_frame_desc[i].length = ep->curpacksize; offs += ep->curpacksize; } urb->transfer_buffer_length = offs; urb->number_of_packets = urb_ctx->packets; break; case SND_USB_ENDPOINT_TYPE_SYNC: urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize); urb->iso_frame_desc[0].offset = 0; break; } return 0; } /* notify an error as XRUN to the assigned PCM data substream */ static void notify_xrun(struct snd_usb_endpoint *ep) { struct snd_usb_substream *data_subs; data_subs = READ_ONCE(ep->data_subs); if (data_subs && data_subs->pcm_substream) snd_pcm_stop_xrun(data_subs->pcm_substream); } static struct snd_usb_packet_info * next_packet_fifo_enqueue(struct snd_usb_endpoint *ep) { struct snd_usb_packet_info *p; p = ep->next_packet + (ep->next_packet_head + ep->next_packet_queued) % ARRAY_SIZE(ep->next_packet); ep->next_packet_queued++; return p; } static struct snd_usb_packet_info * next_packet_fifo_dequeue(struct snd_usb_endpoint *ep) { struct snd_usb_packet_info *p; p = ep->next_packet + ep->next_packet_head; ep->next_packet_head++; ep->next_packet_head %= ARRAY_SIZE(ep->next_packet); ep->next_packet_queued--; return p; } static void push_back_to_ready_list(struct snd_usb_endpoint *ep, struct snd_urb_ctx *ctx) { unsigned long flags; spin_lock_irqsave(&ep->lock, flags); list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs); spin_unlock_irqrestore(&ep->lock, flags); } /* * Send output urbs that have been prepared previously. URBs are dequeued * from ep->ready_playback_urbs and in case there aren't any available * or there are no packets that have been prepared, this function does * nothing. * * The reason why the functionality of sending and preparing URBs is separated * is that host controllers don't guarantee the order in which they return * inbound and outbound packets to their submitters. * * This function is used both for implicit feedback endpoints and in low- * latency playback mode. */ int snd_usb_queue_pending_output_urbs(struct snd_usb_endpoint *ep, bool in_stream_lock) { bool implicit_fb = snd_usb_endpoint_implicit_feedback_sink(ep); while (ep_state_running(ep)) { unsigned long flags; struct snd_usb_packet_info *packet; struct snd_urb_ctx *ctx = NULL; int err, i; spin_lock_irqsave(&ep->lock, flags); if ((!implicit_fb || ep->next_packet_queued > 0) && !list_empty(&ep->ready_playback_urbs)) { /* take URB out of FIFO */ ctx = list_first_entry(&ep->ready_playback_urbs, struct snd_urb_ctx, ready_list); list_del_init(&ctx->ready_list); if (implicit_fb) packet = next_packet_fifo_dequeue(ep); } spin_unlock_irqrestore(&ep->lock, flags); if (ctx == NULL) break; /* copy over the length information */ if (implicit_fb) { for (i = 0; i < packet->packets; i++) ctx->packet_size[i] = packet->packet_size[i]; } /* call the data handler to fill in playback data */ err = prepare_outbound_urb(ep, ctx, in_stream_lock); /* can be stopped during prepare callback */ if (unlikely(!ep_state_running(ep))) break; if (err < 0) { /* push back to ready list again for -EAGAIN */ if (err == -EAGAIN) { push_back_to_ready_list(ep, ctx); break; } if (!in_stream_lock) notify_xrun(ep); return -EPIPE; } if (!atomic_read(&ep->chip->shutdown)) err = usb_submit_urb(ctx->urb, GFP_ATOMIC); else err = -ENODEV; if (err < 0) { if (!atomic_read(&ep->chip->shutdown)) { usb_audio_err(ep->chip, "Unable to submit urb #%d: %d at %s\n", ctx->index, err, __func__); if (!in_stream_lock) notify_xrun(ep); } return -EPIPE; } set_bit(ctx->index, &ep->active_mask); atomic_inc(&ep->submitted_urbs); } return 0; } /* * complete callback for urbs */ static void snd_complete_urb(struct urb *urb) { struct snd_urb_ctx *ctx = urb->context; struct snd_usb_endpoint *ep = ctx->ep; int err; if (unlikely(urb->status == -ENOENT || /* unlinked */ urb->status == -ENODEV || /* device removed */ urb->status == -ECONNRESET || /* unlinked */ urb->status == -ESHUTDOWN)) /* device disabled */ goto exit_clear; /* device disconnected */ if (unlikely(atomic_read(&ep->chip->shutdown))) goto exit_clear; if (unlikely(!ep_state_running(ep))) goto exit_clear; if (usb_pipeout(ep->pipe)) { retire_outbound_urb(ep, ctx); /* can be stopped during retire callback */ if (unlikely(!ep_state_running(ep))) goto exit_clear; /* in low-latency and implicit-feedback modes, push back the * URB to ready list at first, then process as much as possible */ if (ep->lowlatency_playback || snd_usb_endpoint_implicit_feedback_sink(ep)) { push_back_to_ready_list(ep, ctx); clear_bit(ctx->index, &ep->active_mask); snd_usb_queue_pending_output_urbs(ep, false); atomic_dec(&ep->submitted_urbs); /* decrement at last */ return; } /* in non-lowlatency mode, no error handling for prepare */ prepare_outbound_urb(ep, ctx, false); /* can be stopped during prepare callback */ if (unlikely(!ep_state_running(ep))) goto exit_clear; } else { retire_inbound_urb(ep, ctx); /* can be stopped during retire callback */ if (unlikely(!ep_state_running(ep))) goto exit_clear; prepare_inbound_urb(ep, ctx); } if (!atomic_read(&ep->chip->shutdown)) err = usb_submit_urb(urb, GFP_ATOMIC); else err = -ENODEV; if (err == 0) return; if (!atomic_read(&ep->chip->shutdown)) { usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err); notify_xrun(ep); } exit_clear: clear_bit(ctx->index, &ep->active_mask); atomic_dec(&ep->submitted_urbs); } /* * Find or create a refcount object for the given interface * * The objects are released altogether in snd_usb_endpoint_free_all() */ static struct snd_usb_iface_ref * iface_ref_find(struct snd_usb_audio *chip, int iface) { struct snd_usb_iface_ref *ip; list_for_each_entry(ip, &chip->iface_ref_list, list) if (ip->iface == iface) return ip; ip = kzalloc(sizeof(*ip), GFP_KERNEL); if (!ip) return NULL; ip->iface = iface; list_add_tail(&ip->list, &chip->iface_ref_list); return ip; } /* Similarly, a refcount object for clock */ static struct snd_usb_clock_ref * clock_ref_find(struct snd_usb_audio *chip, int clock) { struct snd_usb_clock_ref *ref; list_for_each_entry(ref, &chip->clock_ref_list, list) if (ref->clock == clock) return ref; ref = kzalloc(sizeof(*ref), GFP_KERNEL); if (!ref) return NULL; ref->clock = clock; atomic_set(&ref->locked, 0); list_add_tail(&ref->list, &chip->clock_ref_list); return ref; } /* * Get the existing endpoint object corresponding EP * Returns NULL if not present. */ struct snd_usb_endpoint * snd_usb_get_endpoint(struct snd_usb_audio *chip, int ep_num) { struct snd_usb_endpoint *ep; list_for_each_entry(ep, &chip->ep_list, list) { if (ep->ep_num == ep_num) return ep; } return NULL; } #define ep_type_name(type) \ (type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync") /** * snd_usb_add_endpoint: Add an endpoint to an USB audio chip * * @chip: The chip * @ep_num: The number of the endpoint to use * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC * * If the requested endpoint has not been added to the given chip before, * a new instance is created. * * Returns zero on success or a negative error code. * * New endpoints will be added to chip->ep_list and freed by * calling snd_usb_endpoint_free_all(). * * For SND_USB_ENDPOINT_TYPE_SYNC, the caller needs to guarantee that * bNumEndpoints > 1 beforehand. */ int snd_usb_add_endpoint(struct snd_usb_audio *chip, int ep_num, int type) { struct snd_usb_endpoint *ep; bool is_playback; ep = snd_usb_get_endpoint(chip, ep_num); if (ep) return 0; usb_audio_dbg(chip, "Creating new %s endpoint #%x\n", ep_type_name(type), ep_num); ep = kzalloc(sizeof(*ep), GFP_KERNEL); if (!ep) return -ENOMEM; ep->chip = chip; spin_lock_init(&ep->lock); ep->type = type; ep->ep_num = ep_num; INIT_LIST_HEAD(&ep->ready_playback_urbs); atomic_set(&ep->submitted_urbs, 0); is_playback = ((ep_num & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT); ep_num &= USB_ENDPOINT_NUMBER_MASK; if (is_playback) ep->pipe = usb_sndisocpipe(chip->dev, ep_num); else ep->pipe = usb_rcvisocpipe(chip->dev, ep_num); list_add_tail(&ep->list, &chip->ep_list); return 0; } /* Set up syncinterval and maxsyncsize for a sync EP */ static void endpoint_set_syncinterval(struct snd_usb_audio *chip, struct snd_usb_endpoint *ep) { struct usb_host_interface *alts; struct usb_endpoint_descriptor *desc; alts = snd_usb_get_host_interface(chip, ep->iface, ep->altsetting); if (!alts) return; desc = get_endpoint(alts, ep->ep_idx); if (desc->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && desc->bRefresh >= 1 && desc->bRefresh <= 9) ep->syncinterval = desc->bRefresh; else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL) ep->syncinterval = 1; else if (desc->bInterval >= 1 && desc->bInterval <= 16) ep->syncinterval = desc->bInterval - 1; else ep->syncinterval = 3; ep->syncmaxsize = le16_to_cpu(desc->wMaxPacketSize); } static bool endpoint_compatible(struct snd_usb_endpoint *ep, const struct audioformat *fp, const struct snd_pcm_hw_params *params) { if (!ep->opened) return false; if (ep->cur_audiofmt != fp) return false; if (ep->cur_rate != params_rate(params) || ep->cur_format != params_format(params) || ep->cur_period_frames != params_period_size(params) || ep->cur_buffer_periods != params_periods(params)) return false; return true; } /* * Check whether the given fp and hw params are compatible with the current * setup of the target EP for implicit feedback sync */ bool snd_usb_endpoint_compatible(struct snd_usb_audio *chip, struct snd_usb_endpoint *ep, const struct audioformat *fp, const struct snd_pcm_hw_params *params) { bool ret; mutex_lock(&chip->mutex); ret = endpoint_compatible(ep, fp, params); mutex_unlock(&chip->mutex); return ret; } /* * snd_usb_endpoint_open: Open the endpoint * * Called from hw_params to assign the endpoint to the substream. * It's reference-counted, and only the first opener is allowed to set up * arbitrary parameters. The later opener must be compatible with the * former opened parameters. * The endpoint needs to be closed via snd_usb_endpoint_close() later. * * Note that this function doesn't configure the endpoint. The substream * needs to set it up later via snd_usb_endpoint_set_params() and * snd_usb_endpoint_prepare(). */ struct snd_usb_endpoint * snd_usb_endpoint_open(struct snd_usb_audio *chip, const struct audioformat *fp, const struct snd_pcm_hw_params *params, bool is_sync_ep, bool fixed_rate) { struct snd_usb_endpoint *ep; int ep_num = is_sync_ep ? fp->sync_ep : fp->endpoint; mutex_lock(&chip->mutex); ep = snd_usb_get_endpoint(chip, ep_num); if (!ep) { usb_audio_err(chip, "Cannot find EP 0x%x to open\n", ep_num); goto unlock; } if (!ep->opened) { if (is_sync_ep) { ep->iface = fp->sync_iface; ep->altsetting = fp->sync_altsetting; ep->ep_idx = fp->sync_ep_idx; } else { ep->iface = fp->iface; ep->altsetting = fp->altsetting; ep->ep_idx = fp->ep_idx; } usb_audio_dbg(chip, "Open EP 0x%x, iface=%d:%d, idx=%d\n", ep_num, ep->iface, ep->altsetting, ep->ep_idx); ep->iface_ref = iface_ref_find(chip, ep->iface); if (!ep->iface_ref) { ep = NULL; goto unlock; } if (fp->protocol != UAC_VERSION_1) { ep->clock_ref = clock_ref_find(chip, fp->clock); if (!ep->clock_ref) { ep = NULL; goto unlock; } ep->clock_ref->opened++; } ep->cur_audiofmt = fp; ep->cur_channels = fp->channels; ep->cur_rate = params_rate(params); ep->cur_format = params_format(params); ep->cur_frame_bytes = snd_pcm_format_physical_width(ep->cur_format) * ep->cur_channels / 8; ep->cur_period_frames = params_period_size(params); ep->cur_period_bytes = ep->cur_period_frames * ep->cur_frame_bytes; ep->cur_buffer_periods = params_periods(params); if (ep->type == SND_USB_ENDPOINT_TYPE_SYNC) endpoint_set_syncinterval(chip, ep); ep->implicit_fb_sync = fp->implicit_fb; ep->need_setup = true; ep->need_prepare = true; ep->fixed_rate = fixed_rate; usb_audio_dbg(chip, " channels=%d, rate=%d, format=%s, period_bytes=%d, periods=%d, implicit_fb=%d\n", ep->cur_channels, ep->cur_rate, snd_pcm_format_name(ep->cur_format), ep->cur_period_bytes, ep->cur_buffer_periods, ep->implicit_fb_sync); } else { if (WARN_ON(!ep->iface_ref)) { ep = NULL; goto unlock; } if (!endpoint_compatible(ep, fp, params)) { usb_audio_err(chip, "Incompatible EP setup for 0x%x\n", ep_num); ep = NULL; goto unlock; } usb_audio_dbg(chip, "Reopened EP 0x%x (count %d)\n", ep_num, ep->opened); } if (!ep->iface_ref->opened++) ep->iface_ref->need_setup = true; ep->opened++; unlock: mutex_unlock(&chip->mutex); return ep; } /* * snd_usb_endpoint_set_sync: Link data and sync endpoints * * Pass NULL to sync_ep to unlink again */ void snd_usb_endpoint_set_sync(struct snd_usb_audio *chip, struct snd_usb_endpoint *data_ep, struct snd_usb_endpoint *sync_ep) { data_ep->sync_source = sync_ep; } /* * Set data endpoint callbacks and the assigned data stream * * Called at PCM trigger and cleanups. * Pass NULL to deactivate each callback. */ void snd_usb_endpoint_set_callback(struct snd_usb_endpoint *ep, int (*prepare)(struct snd_usb_substream *subs, struct urb *urb, bool in_stream_lock), void (*retire)(struct snd_usb_substream *subs, struct urb *urb), struct snd_usb_substream *data_subs) { ep->prepare_data_urb = prepare; ep->retire_data_urb = retire; if (data_subs) ep->lowlatency_playback = data_subs->lowlatency_playback; else ep->lowlatency_playback = false; WRITE_ONCE(ep->data_subs, data_subs); } static int endpoint_set_interface(struct snd_usb_audio *chip, struct snd_usb_endpoint *ep, bool set) { int altset = set ? ep->altsetting : 0; int err; if (ep->iface_ref->altset == altset) return 0; usb_audio_dbg(chip, "Setting usb interface %d:%d for EP 0x%x\n", ep->iface, altset, ep->ep_num); err = usb_set_interface(chip->dev, ep->iface, altset); if (err < 0) { usb_audio_err_ratelimited( chip, "%d:%d: usb_set_interface failed (%d)\n", ep->iface, altset, err); return err; } if (chip->quirk_flags & QUIRK_FLAG_IFACE_DELAY) msleep(50); ep->iface_ref->altset = altset; return 0; } /* * snd_usb_endpoint_close: Close the endpoint * * Unreference the already opened endpoint via snd_usb_endpoint_open(). */ void snd_usb_endpoint_close(struct snd_usb_audio *chip, struct snd_usb_endpoint *ep) { mutex_lock(&chip->mutex); usb_audio_dbg(chip, "Closing EP 0x%x (count %d)\n", ep->ep_num, ep->opened); if (!--ep->iface_ref->opened && !(chip->quirk_flags & QUIRK_FLAG_IFACE_SKIP_CLOSE)) endpoint_set_interface(chip, ep, false); if (!--ep->opened) { if (ep->clock_ref) { if (!--ep->clock_ref->opened) ep->clock_ref->rate = 0; } ep->iface = 0; ep->altsetting = 0; ep->cur_audiofmt = NULL; ep->cur_rate = 0; ep->iface_ref = NULL; ep->clock_ref = NULL; usb_audio_dbg(chip, "EP 0x%x closed\n", ep->ep_num); } mutex_unlock(&chip->mutex); } /* Prepare for suspening EP, called from the main suspend handler */ void snd_usb_endpoint_suspend(struct snd_usb_endpoint *ep) { ep->need_prepare = true; if (ep->iface_ref) ep->iface_ref->need_setup = true; if (ep->clock_ref) ep->clock_ref->rate = 0; } /* * wait until all urbs are processed. */ static int wait_clear_urbs(struct snd_usb_endpoint *ep) { unsigned long end_time = jiffies + msecs_to_jiffies(1000); int alive; if (atomic_read(&ep->state) != EP_STATE_STOPPING) return 0; do { alive = atomic_read(&ep->submitted_urbs); if (!alive) break; schedule_timeout_uninterruptible(1); } while (time_before(jiffies, end_time)); if (alive) usb_audio_err(ep->chip, "timeout: still %d active urbs on EP #%x\n", alive, ep->ep_num); if (ep_state_update(ep, EP_STATE_STOPPING, EP_STATE_STOPPED)) { ep->sync_sink = NULL; snd_usb_endpoint_set_callback(ep, NULL, NULL, NULL); } return 0; } /* sync the pending stop operation; * this function itself doesn't trigger the stop operation */ void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep) { if (ep) wait_clear_urbs(ep); } /* * Stop active urbs * * This function moves the EP to STOPPING state if it's being RUNNING. */ static int stop_urbs(struct snd_usb_endpoint *ep, bool force, bool keep_pending) { unsigned int i; unsigned long flags; if (!force && atomic_read(&ep->running)) return -EBUSY; if (!ep_state_update(ep, EP_STATE_RUNNING, EP_STATE_STOPPING)) return 0; spin_lock_irqsave(&ep->lock, flags); INIT_LIST_HEAD(&ep->ready_playback_urbs); ep->next_packet_head = 0; ep->next_packet_queued = 0; spin_unlock_irqrestore(&ep->lock, flags); if (keep_pending) return 0; for (i = 0; i < ep->nurbs; i++) { if (test_bit(i, &ep->active_mask)) { if (!test_and_set_bit(i, &ep->unlink_mask)) { struct urb *u = ep->urb[i].urb; usb_unlink_urb(u); } } } return 0; } /* * release an endpoint's urbs */ static int release_urbs(struct snd_usb_endpoint *ep, bool force) { int i, err; /* route incoming urbs to nirvana */ snd_usb_endpoint_set_callback(ep, NULL, NULL, NULL); /* stop and unlink urbs */ err = stop_urbs(ep, force, false); if (err) return err; wait_clear_urbs(ep); for (i = 0; i < ep->nurbs; i++) release_urb_ctx(&ep->urb[i]); usb_free_coherent(ep->chip->dev, SYNC_URBS * 4, ep->syncbuf, ep->sync_dma); ep->syncbuf = NULL; ep->nurbs = 0; return 0; } /* * configure a data endpoint */ static int data_ep_set_params(struct snd_usb_endpoint *ep) { struct snd_usb_audio *chip = ep->chip; unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb; unsigned int max_packs_per_period, urbs_per_period, urb_packs; unsigned int max_urbs, i; const struct audioformat *fmt = ep->cur_audiofmt; int frame_bits = ep->cur_frame_bytes * 8; int tx_length_quirk = (has_tx_length_quirk(chip) && usb_pipeout(ep->pipe)); usb_audio_dbg(chip, "Setting params for data EP 0x%x, pipe 0x%x\n", ep->ep_num, ep->pipe); if (ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) { /* * When operating in DSD DOP mode, the size of a sample frame * in hardware differs from the actual physical format width * because we need to make room for the DOP markers. */ frame_bits += ep->cur_channels << 3; } ep->datainterval = fmt->datainterval; ep->stride = frame_bits >> 3; switch (ep->cur_format) { case SNDRV_PCM_FORMAT_U8: ep->silence_value = 0x80; break; case SNDRV_PCM_FORMAT_DSD_U8: case SNDRV_PCM_FORMAT_DSD_U16_LE: case SNDRV_PCM_FORMAT_DSD_U32_LE: case SNDRV_PCM_FORMAT_DSD_U16_BE: case SNDRV_PCM_FORMAT_DSD_U32_BE: ep->silence_value = 0x69; break; default: ep->silence_value = 0; } /* assume max. frequency is 50% higher than nominal */ ep->freqmax = ep->freqn + (ep->freqn >> 1); /* Round up freqmax to nearest integer in order to calculate maximum * packet size, which must represent a whole number of frames. * This is accomplished by adding 0x0.ffff before converting the * Q16.16 format into integer. * In order to accurately calculate the maximum packet size when * the data interval is more than 1 (i.e. ep->datainterval > 0), * multiply by the data interval prior to rounding. For instance, * a freqmax of 41 kHz will result in a max packet size of 6 (5.125) * frames with a data interval of 1, but 11 (10.25) frames with a * data interval of 2. * (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the * maximum datainterval value of 3, at USB full speed, higher for * USB high speed, noting that ep->freqmax is in units of * frames per packet in Q16.16 format.) */ maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) * (frame_bits >> 3); if (tx_length_quirk) maxsize += sizeof(__le32); /* Space for length descriptor */ /* but wMaxPacketSize might reduce this */ if (ep->maxpacksize && ep->maxpacksize < maxsize) { /* whatever fits into a max. size packet */ unsigned int data_maxsize = maxsize = ep->maxpacksize; if (tx_length_quirk) /* Need to remove the length descriptor to calc freq */ data_maxsize -= sizeof(__le32); ep->freqmax = (data_maxsize / (frame_bits >> 3)) << (16 - ep->datainterval); } if (ep->fill_max) ep->curpacksize = ep->maxpacksize; else ep->curpacksize = maxsize; if (snd_usb_get_speed(chip->dev) != USB_SPEED_FULL) { packs_per_ms = 8 >> ep->datainterval; max_packs_per_urb = MAX_PACKS_HS; } else { packs_per_ms = 1; max_packs_per_urb = MAX_PACKS; } if (ep->sync_source && !ep->implicit_fb_sync) max_packs_per_urb = min(max_packs_per_urb, 1U << ep->sync_source->syncinterval); max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval); /* * Capture endpoints need to use small URBs because there's no way * to tell in advance where the next period will end, and we don't * want the next URB to complete much after the period ends. * * Playback endpoints with implicit sync much use the same parameters * as their corresponding capture endpoint. */ if (usb_pipein(ep->pipe) || ep->implicit_fb_sync) { /* make capture URBs <= 1 ms and smaller than a period */ urb_packs = min(max_packs_per_urb, packs_per_ms); while (urb_packs > 1 && urb_packs * maxsize >= ep->cur_period_bytes) urb_packs >>= 1; ep->nurbs = MAX_URBS; /* * Playback endpoints without implicit sync are adjusted so that * a period fits as evenly as possible in the smallest number of * URBs. The total number of URBs is adjusted to the size of the * ALSA buffer, subject to the MAX_URBS and MAX_QUEUE limits. */ } else { /* determine how small a packet can be */ minsize = (ep->freqn >> (16 - ep->datainterval)) * (frame_bits >> 3); /* with sync from device, assume it can be 12% lower */ if (ep->sync_source) minsize -= minsize >> 3; minsize = max(minsize, 1u); /* how many packets will contain an entire ALSA period? */ max_packs_per_period = DIV_ROUND_UP(ep->cur_period_bytes, minsize); /* how many URBs will contain a period? */ urbs_per_period = DIV_ROUND_UP(max_packs_per_period, max_packs_per_urb); /* how many packets are needed in each URB? */ urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period); /* limit the number of frames in a single URB */ ep->max_urb_frames = DIV_ROUND_UP(ep->cur_period_frames, urbs_per_period); /* try to use enough URBs to contain an entire ALSA buffer */ max_urbs = min((unsigned) MAX_URBS, MAX_QUEUE * packs_per_ms / urb_packs); ep->nurbs = min(max_urbs, urbs_per_period * ep->cur_buffer_periods); } /* allocate and initialize data urbs */ for (i = 0; i < ep->nurbs; i++) { struct snd_urb_ctx *u = &ep->urb[i]; u->index = i; u->ep = ep; u->packets = urb_packs; u->buffer_size = maxsize * u->packets; if (fmt->fmt_type == UAC_FORMAT_TYPE_II) u->packets++; /* for transfer delimiter */ u->urb = usb_alloc_urb(u->packets, GFP_KERNEL); if (!u->urb) goto out_of_memory; u->urb->transfer_buffer = usb_alloc_coherent(chip->dev, u->buffer_size, GFP_KERNEL, &u->urb->transfer_dma); if (!u->urb->transfer_buffer) goto out_of_memory; u->urb->pipe = ep->pipe; u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; u->urb->interval = 1 << ep->datainterval; u->urb->context = u; u->urb->complete = snd_complete_urb; INIT_LIST_HEAD(&u->ready_list); } return 0; out_of_memory: release_urbs(ep, false); return -ENOMEM; } /* * configure a sync endpoint */ static int sync_ep_set_params(struct snd_usb_endpoint *ep) { struct snd_usb_audio *chip = ep->chip; int i; usb_audio_dbg(chip, "Setting params for sync EP 0x%x, pipe 0x%x\n", ep->ep_num, ep->pipe); ep->syncbuf = usb_alloc_coherent(chip->dev, SYNC_URBS * 4, GFP_KERNEL, &ep->sync_dma); if (!ep->syncbuf) return -ENOMEM; ep->nurbs = SYNC_URBS; for (i = 0; i < SYNC_URBS; i++) { struct snd_urb_ctx *u = &ep->urb[i]; u->index = i; u->ep = ep; u->packets = 1; u->urb = usb_alloc_urb(1, GFP_KERNEL); if (!u->urb) goto out_of_memory; u->urb->transfer_buffer = ep->syncbuf + i * 4; u->urb->transfer_dma = ep->sync_dma + i * 4; u->urb->transfer_buffer_length = 4; u->urb->pipe = ep->pipe; u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; u->urb->number_of_packets = 1; u->urb->interval = 1 << ep->syncinterval; u->urb->context = u; u->urb->complete = snd_complete_urb; } return 0; out_of_memory: release_urbs(ep, false); return -ENOMEM; } /* update the rate of the referred clock; return the actual rate */ static int update_clock_ref_rate(struct snd_usb_audio *chip, struct snd_usb_endpoint *ep) { struct snd_usb_clock_ref *clock = ep->clock_ref; int rate = ep->cur_rate; if (!clock || clock->rate == rate) return rate; if (clock->rate) { if (atomic_read(&clock->locked)) return clock->rate; if (clock->rate != rate) { usb_audio_err(chip, "Mismatched sample rate %d vs %d for EP 0x%x\n", clock->rate, rate, ep->ep_num); return clock->rate; } } clock->rate = rate; clock->need_setup = true; return rate; } /* * snd_usb_endpoint_set_params: configure an snd_usb_endpoint * * It's called either from hw_params callback. * Determine the number of URBs to be used on this endpoint. * An endpoint must be configured before it can be started. * An endpoint that is already running can not be reconfigured. */ int snd_usb_endpoint_set_params(struct snd_usb_audio *chip, struct snd_usb_endpoint *ep) { const struct audioformat *fmt = ep->cur_audiofmt; int err = 0; mutex_lock(&chip->mutex); if (!ep->need_setup) goto unlock; /* release old buffers, if any */ err = release_urbs(ep, false); if (err < 0) goto unlock; ep->datainterval = fmt->datainterval; ep->maxpacksize = fmt->maxpacksize; ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX); if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL) { ep->freqn = get_usb_full_speed_rate(ep->cur_rate); ep->pps = 1000 >> ep->datainterval; } else { ep->freqn = get_usb_high_speed_rate(ep->cur_rate); ep->pps = 8000 >> ep->datainterval; } ep->sample_rem = ep->cur_rate % ep->pps; ep->packsize[0] = ep->cur_rate / ep->pps; ep->packsize[1] = (ep->cur_rate + (ep->pps - 1)) / ep->pps; /* calculate the frequency in 16.16 format */ ep->freqm = ep->freqn; ep->freqshift = INT_MIN; ep->phase = 0; switch (ep->type) { case SND_USB_ENDPOINT_TYPE_DATA: err = data_ep_set_params(ep); break; case SND_USB_ENDPOINT_TYPE_SYNC: err = sync_ep_set_params(ep); break; default: err = -EINVAL; } usb_audio_dbg(chip, "Set up %d URBS, ret=%d\n", ep->nurbs, err); if (err < 0) goto unlock; /* some unit conversions in runtime */ ep->maxframesize = ep->maxpacksize / ep->cur_frame_bytes; ep->curframesize = ep->curpacksize / ep->cur_frame_bytes; err = update_clock_ref_rate(chip, ep); if (err >= 0) { ep->need_setup = false; err = 0; } unlock: mutex_unlock(&chip->mutex); return err; } static int init_sample_rate(struct snd_usb_audio *chip, struct snd_usb_endpoint *ep) { struct snd_usb_clock_ref *clock = ep->clock_ref; int rate, err; rate = update_clock_ref_rate(chip, ep); if (rate < 0) return rate; if (clock && !clock->need_setup) return 0; if (!ep->fixed_rate) { err = snd_usb_init_sample_rate(chip, ep->cur_audiofmt, rate); if (err < 0) { if (clock) clock->rate = 0; /* reset rate */ return err; } } if (clock) clock->need_setup = false; return 0; } /* * snd_usb_endpoint_prepare: Prepare the endpoint * * This function sets up the EP to be fully usable state. * It's called either from prepare callback. * The function checks need_setup flag, and performs nothing unless needed, * so it's safe to call this multiple times. * * This returns zero if unchanged, 1 if the configuration has changed, * or a negative error code. */ int snd_usb_endpoint_prepare(struct snd_usb_audio *chip, struct snd_usb_endpoint *ep) { bool iface_first; int err = 0; mutex_lock(&chip->mutex); if (WARN_ON(!ep->iface_ref)) goto unlock; if (!ep->need_prepare) goto unlock; /* If the interface has been already set up, just set EP parameters */ if (!ep->iface_ref->need_setup) { /* sample rate setup of UAC1 is per endpoint, and we need * to update at each EP configuration */ if (ep->cur_audiofmt->protocol == UAC_VERSION_1) { err = init_sample_rate(chip, ep); if (err < 0) goto unlock; } goto done; } /* Need to deselect altsetting at first */ endpoint_set_interface(chip, ep, false); /* Some UAC1 devices (e.g. Yamaha THR10) need the host interface * to be set up before parameter setups */ iface_first = ep->cur_audiofmt->protocol == UAC_VERSION_1; /* Workaround for devices that require the interface setup at first like UAC1 */ if (chip->quirk_flags & QUIRK_FLAG_SET_IFACE_FIRST) iface_first = true; if (iface_first) { err = endpoint_set_interface(chip, ep, true); if (err < 0) goto unlock; } err = snd_usb_init_pitch(chip, ep->cur_audiofmt); if (err < 0) goto unlock; err = init_sample_rate(chip, ep); if (err < 0) goto unlock; err = snd_usb_select_mode_quirk(chip, ep->cur_audiofmt); if (err < 0) goto unlock; /* for UAC2/3, enable the interface altset here at last */ if (!iface_first) { err = endpoint_set_interface(chip, ep, true); if (err < 0) goto unlock; } ep->iface_ref->need_setup = false; done: ep->need_prepare = false; err = 1; unlock: mutex_unlock(&chip->mutex); return err; } /* get the current rate set to the given clock by any endpoint */ int snd_usb_endpoint_get_clock_rate(struct snd_usb_audio *chip, int clock) { struct snd_usb_clock_ref *ref; int rate = 0; if (!clock) return 0; mutex_lock(&chip->mutex); list_for_each_entry(ref, &chip->clock_ref_list, list) { if (ref->clock == clock) { rate = ref->rate; break; } } mutex_unlock(&chip->mutex); return rate; } /** * snd_usb_endpoint_start: start an snd_usb_endpoint * * @ep: the endpoint to start * * A call to this function will increment the running count of the endpoint. * In case it is not already running, the URBs for this endpoint will be * submitted. Otherwise, this function does nothing. * * Must be balanced to calls of snd_usb_endpoint_stop(). * * Returns an error if the URB submission failed, 0 in all other cases. */ int snd_usb_endpoint_start(struct snd_usb_endpoint *ep) { bool is_playback = usb_pipeout(ep->pipe); int err; unsigned int i; if (atomic_read(&ep->chip->shutdown)) return -EBADFD; if (ep->sync_source) WRITE_ONCE(ep->sync_source->sync_sink, ep); usb_audio_dbg(ep->chip, "Starting %s EP 0x%x (running %d)\n", ep_type_name(ep->type), ep->ep_num, atomic_read(&ep->running)); /* already running? */ if (atomic_inc_return(&ep->running) != 1) return 0; if (ep->clock_ref) atomic_inc(&ep->clock_ref->locked); ep->active_mask = 0; ep->unlink_mask = 0; ep->phase = 0; ep->sample_accum = 0; snd_usb_endpoint_start_quirk(ep); /* * If this endpoint has a data endpoint as implicit feedback source, * don't start the urbs here. Instead, mark them all as available, * wait for the record urbs to return and queue the playback urbs * from that context. */ if (!ep_state_update(ep, EP_STATE_STOPPED, EP_STATE_RUNNING)) goto __error; if (snd_usb_endpoint_implicit_feedback_sink(ep) && !(ep->chip->quirk_flags & QUIRK_FLAG_PLAYBACK_FIRST)) { usb_audio_dbg(ep->chip, "No URB submission due to implicit fb sync\n"); i = 0; goto fill_rest; } for (i = 0; i < ep->nurbs; i++) { struct urb *urb = ep->urb[i].urb; if (snd_BUG_ON(!urb)) goto __error; if (is_playback) err = prepare_outbound_urb(ep, urb->context, true); else err = prepare_inbound_urb(ep, urb->context); if (err < 0) { /* stop filling at applptr */ if (err == -EAGAIN) break; usb_audio_dbg(ep->chip, "EP 0x%x: failed to prepare urb: %d\n", ep->ep_num, err); goto __error; } if (!atomic_read(&ep->chip->shutdown)) err = usb_submit_urb(urb, GFP_ATOMIC); else err = -ENODEV; if (err < 0) { if (!atomic_read(&ep->chip->shutdown)) usb_audio_err(ep->chip, "cannot submit urb %d, error %d: %s\n", i, err, usb_error_string(err)); goto __error; } set_bit(i, &ep->active_mask); atomic_inc(&ep->submitted_urbs); } if (!i) { usb_audio_dbg(ep->chip, "XRUN at starting EP 0x%x\n", ep->ep_num); goto __error; } usb_audio_dbg(ep->chip, "%d URBs submitted for EP 0x%x\n", i, ep->ep_num); fill_rest: /* put the remaining URBs to ready list */ if (is_playback) { for (; i < ep->nurbs; i++) push_back_to_ready_list(ep, ep->urb + i); } return 0; __error: snd_usb_endpoint_stop(ep, false); return -EPIPE; } /** * snd_usb_endpoint_stop: stop an snd_usb_endpoint * * @ep: the endpoint to stop (may be NULL) * @keep_pending: keep in-flight URBs * * A call to this function will decrement the running count of the endpoint. * In case the last user has requested the endpoint stop, the URBs will * actually be deactivated. * * Must be balanced to calls of snd_usb_endpoint_start(). * * The caller needs to synchronize the pending stop operation via * snd_usb_endpoint_sync_pending_stop(). */ void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep, bool keep_pending) { if (!ep) return; usb_audio_dbg(ep->chip, "Stopping %s EP 0x%x (running %d)\n", ep_type_name(ep->type), ep->ep_num, atomic_read(&ep->running)); if (snd_BUG_ON(!atomic_read(&ep->running))) return; if (!atomic_dec_return(&ep->running)) { if (ep->sync_source) WRITE_ONCE(ep->sync_source->sync_sink, NULL); stop_urbs(ep, false, keep_pending); if (ep->clock_ref) atomic_dec(&ep->clock_ref->locked); if (ep->chip->quirk_flags & QUIRK_FLAG_FORCE_IFACE_RESET && usb_pipeout(ep->pipe)) { ep->need_prepare = true; if (ep->iface_ref) ep->iface_ref->need_setup = true; } } } /** * snd_usb_endpoint_release: Tear down an snd_usb_endpoint * * @ep: the endpoint to release * * This function does not care for the endpoint's running count but will tear * down all the streaming URBs immediately. */ void snd_usb_endpoint_release(struct snd_usb_endpoint *ep) { release_urbs(ep, true); } /** * snd_usb_endpoint_free_all: Free the resources of an snd_usb_endpoint * @chip: The chip * * This free all endpoints and those resources */ void snd_usb_endpoint_free_all(struct snd_usb_audio *chip) { struct snd_usb_endpoint *ep, *en; struct snd_usb_iface_ref *ip, *in; struct snd_usb_clock_ref *cp, *cn; list_for_each_entry_safe(ep, en, &chip->ep_list, list) kfree(ep); list_for_each_entry_safe(ip, in, &chip->iface_ref_list, list) kfree(ip); list_for_each_entry_safe(cp, cn, &chip->clock_ref_list, list) kfree(cp); } /* * snd_usb_handle_sync_urb: parse an USB sync packet * * @ep: the endpoint to handle the packet * @sender: the sending endpoint * @urb: the received packet * * This function is called from the context of an endpoint that received * the packet and is used to let another endpoint object handle the payload. */ static void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep, struct snd_usb_endpoint *sender, const struct urb *urb) { int shift; unsigned int f; unsigned long flags; snd_BUG_ON(ep == sender); /* * In case the endpoint is operating in implicit feedback mode, prepare * a new outbound URB that has the same layout as the received packet * and add it to the list of pending urbs. queue_pending_output_urbs() * will take care of them later. */ if (snd_usb_endpoint_implicit_feedback_sink(ep) && atomic_read(&ep->running)) { /* implicit feedback case */ int i, bytes = 0; struct snd_urb_ctx *in_ctx; struct snd_usb_packet_info *out_packet; in_ctx = urb->context; /* Count overall packet size */ for (i = 0; i < in_ctx->packets; i++) if (urb->iso_frame_desc[i].status == 0) bytes += urb->iso_frame_desc[i].actual_length; /* * skip empty packets. At least M-Audio's Fast Track Ultra stops * streaming once it received a 0-byte OUT URB */ if (bytes == 0) return; spin_lock_irqsave(&ep->lock, flags); if (ep->next_packet_queued >= ARRAY_SIZE(ep->next_packet)) { spin_unlock_irqrestore(&ep->lock, flags); usb_audio_err(ep->chip, "next package FIFO overflow EP 0x%x\n", ep->ep_num); notify_xrun(ep); return; } out_packet = next_packet_fifo_enqueue(ep); /* * Iterate through the inbound packet and prepare the lengths * for the output packet. The OUT packet we are about to send * will have the same amount of payload bytes per stride as the * IN packet we just received. Since the actual size is scaled * by the stride, use the sender stride to calculate the length * in case the number of channels differ between the implicitly * fed-back endpoint and the synchronizing endpoint. */ out_packet->packets = in_ctx->packets; for (i = 0; i < in_ctx->packets; i++) { if (urb->iso_frame_desc[i].status == 0) out_packet->packet_size[i] = urb->iso_frame_desc[i].actual_length / sender->stride; else out_packet->packet_size[i] = 0; } spin_unlock_irqrestore(&ep->lock, flags); snd_usb_queue_pending_output_urbs(ep, false); return; } /* * process after playback sync complete * * Full speed devices report feedback values in 10.14 format as samples * per frame, high speed devices in 16.16 format as samples per * microframe. * * Because the Audio Class 1 spec was written before USB 2.0, many high * speed devices use a wrong interpretation, some others use an * entirely different format. * * Therefore, we cannot predict what format any particular device uses * and must detect it automatically. */ if (urb->iso_frame_desc[0].status != 0 || urb->iso_frame_desc[0].actual_length < 3) return; f = le32_to_cpup(urb->transfer_buffer); if (urb->iso_frame_desc[0].actual_length == 3) f &= 0x00ffffff; else f &= 0x0fffffff; if (f == 0) return; if (unlikely(sender->tenor_fb_quirk)) { /* * Devices based on Tenor 8802 chipsets (TEAC UD-H01 * and others) sometimes change the feedback value * by +/- 0x1.0000. */ if (f < ep->freqn - 0x8000) f += 0xf000; else if (f > ep->freqn + 0x8000) f -= 0xf000; } else if (unlikely(ep->freqshift == INT_MIN)) { /* * The first time we see a feedback value, determine its format * by shifting it left or right until it matches the nominal * frequency value. This assumes that the feedback does not * differ from the nominal value more than +50% or -25%. */ shift = 0; while (f < ep->freqn - ep->freqn / 4) { f <<= 1; shift++; } while (f > ep->freqn + ep->freqn / 2) { f >>= 1; shift--; } ep->freqshift = shift; } else if (ep->freqshift >= 0) f <<= ep->freqshift; else f >>= -ep->freqshift; if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) { /* * If the frequency looks valid, set it. * This value is referred to in prepare_playback_urb(). */ spin_lock_irqsave(&ep->lock, flags); ep->freqm = f; spin_unlock_irqrestore(&ep->lock, flags); } else { /* * Out of range; maybe the shift value is wrong. * Reset it so that we autodetect again the next time. */ ep->freqshift = INT_MIN; } }
linux-master
sound/usb/endpoint.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * (Tentative) USB Audio Driver for ALSA * * Copyright (c) 2002 by Takashi Iwai <[email protected]> * * Many codes borrowed from audio.c by * Alan Cox ([email protected]) * Thomas Sailer ([email protected]) * * Audio Class 3.0 support by Ruslan Bilovol <[email protected]> * * NOTES: * * - the linked URBs would be preferred but not used so far because of * the instability of unlinking. * - type II is not supported properly. there is no device which supports * this type *correctly*. SB extigy looks as if it supports, but it's * indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream). */ #include <linux/bitops.h> #include <linux/init.h> #include <linux/list.h> #include <linux/slab.h> #include <linux/string.h> #include <linux/ctype.h> #include <linux/usb.h> #include <linux/moduleparam.h> #include <linux/mutex.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <linux/usb/audio-v3.h> #include <linux/module.h> #include <sound/control.h> #include <sound/core.h> #include <sound/info.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include <sound/initval.h> #include "usbaudio.h" #include "card.h" #include "midi.h" #include "midi2.h" #include "mixer.h" #include "proc.h" #include "quirks.h" #include "endpoint.h" #include "helper.h" #include "pcm.h" #include "format.h" #include "power.h" #include "stream.h" #include "media.h" MODULE_AUTHOR("Takashi Iwai <[email protected]>"); MODULE_DESCRIPTION("USB Audio"); MODULE_LICENSE("GPL"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */ /* Vendor/product IDs for this card */ static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; static int device_setup[SNDRV_CARDS]; /* device parameter for this card */ static bool ignore_ctl_error; static bool autoclock = true; static bool lowlatency = true; static char *quirk_alias[SNDRV_CARDS]; static char *delayed_register[SNDRV_CARDS]; static bool implicit_fb[SNDRV_CARDS]; static unsigned int quirk_flags[SNDRV_CARDS]; bool snd_usb_use_vmalloc = true; bool snd_usb_skip_validation; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for the USB audio adapter."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for the USB audio adapter."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable USB audio adapter."); module_param_array(vid, int, NULL, 0444); MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device."); module_param_array(pid, int, NULL, 0444); MODULE_PARM_DESC(pid, "Product ID for the USB audio device."); module_param_array(device_setup, int, NULL, 0444); MODULE_PARM_DESC(device_setup, "Specific device setup (if needed)."); module_param(ignore_ctl_error, bool, 0444); MODULE_PARM_DESC(ignore_ctl_error, "Ignore errors from USB controller for mixer interfaces."); module_param(autoclock, bool, 0444); MODULE_PARM_DESC(autoclock, "Enable auto-clock selection for UAC2 devices (default: yes)."); module_param(lowlatency, bool, 0444); MODULE_PARM_DESC(lowlatency, "Enable low latency playback (default: yes)."); module_param_array(quirk_alias, charp, NULL, 0444); MODULE_PARM_DESC(quirk_alias, "Quirk aliases, e.g. 0123abcd:5678beef."); module_param_array(delayed_register, charp, NULL, 0444); MODULE_PARM_DESC(delayed_register, "Quirk for delayed registration, given by id:iface, e.g. 0123abcd:4."); module_param_array(implicit_fb, bool, NULL, 0444); MODULE_PARM_DESC(implicit_fb, "Apply generic implicit feedback sync mode."); module_param_array(quirk_flags, uint, NULL, 0444); MODULE_PARM_DESC(quirk_flags, "Driver quirk bit flags."); module_param_named(use_vmalloc, snd_usb_use_vmalloc, bool, 0444); MODULE_PARM_DESC(use_vmalloc, "Use vmalloc for PCM intermediate buffers (default: yes)."); module_param_named(skip_validation, snd_usb_skip_validation, bool, 0444); MODULE_PARM_DESC(skip_validation, "Skip unit descriptor validation (default: no)."); /* * we keep the snd_usb_audio_t instances by ourselves for merging * the all interfaces on the same card as one sound device. */ static DEFINE_MUTEX(register_mutex); static struct snd_usb_audio *usb_chip[SNDRV_CARDS]; static struct usb_driver usb_audio_driver; /* * disconnect streams * called from usb_audio_disconnect() */ static void snd_usb_stream_disconnect(struct snd_usb_stream *as) { int idx; struct snd_usb_substream *subs; for (idx = 0; idx < 2; idx++) { subs = &as->substream[idx]; if (!subs->num_formats) continue; subs->data_endpoint = NULL; subs->sync_endpoint = NULL; } } static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int interface) { struct usb_device *dev = chip->dev; struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; struct usb_interface *iface = usb_ifnum_to_if(dev, interface); if (!iface) { dev_err(&dev->dev, "%u:%d : does not exist\n", ctrlif, interface); return -EINVAL; } alts = &iface->altsetting[0]; altsd = get_iface_desc(alts); /* * Android with both accessory and audio interfaces enabled gets the * interface numbers wrong. */ if ((chip->usb_id == USB_ID(0x18d1, 0x2d04) || chip->usb_id == USB_ID(0x18d1, 0x2d05)) && interface == 0 && altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC && altsd->bInterfaceSubClass == USB_SUBCLASS_VENDOR_SPEC) { interface = 2; iface = usb_ifnum_to_if(dev, interface); if (!iface) return -EINVAL; alts = &iface->altsetting[0]; altsd = get_iface_desc(alts); } if (usb_interface_claimed(iface)) { dev_dbg(&dev->dev, "%d:%d: skipping, already claimed\n", ctrlif, interface); return -EINVAL; } if ((altsd->bInterfaceClass == USB_CLASS_AUDIO || altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) && altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) { int err = snd_usb_midi_v2_create(chip, iface, NULL, chip->usb_id); if (err < 0) { dev_err(&dev->dev, "%u:%d: cannot create sequencer device\n", ctrlif, interface); return -EINVAL; } return usb_driver_claim_interface(&usb_audio_driver, iface, USB_AUDIO_IFACE_UNUSED); } if ((altsd->bInterfaceClass != USB_CLASS_AUDIO && altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) { dev_dbg(&dev->dev, "%u:%d: skipping non-supported interface %d\n", ctrlif, interface, altsd->bInterfaceClass); /* skip non-supported classes */ return -EINVAL; } if (snd_usb_get_speed(dev) == USB_SPEED_LOW) { dev_err(&dev->dev, "low speed audio streaming not supported\n"); return -EINVAL; } if (! snd_usb_parse_audio_interface(chip, interface)) { usb_set_interface(dev, interface, 0); /* reset the current interface */ return usb_driver_claim_interface(&usb_audio_driver, iface, USB_AUDIO_IFACE_UNUSED); } return 0; } /* * parse audio control descriptor and create pcm/midi streams */ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) { struct usb_device *dev = chip->dev; struct usb_host_interface *host_iface; struct usb_interface_descriptor *altsd; int i, protocol; /* find audiocontrol interface */ host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0]; altsd = get_iface_desc(host_iface); protocol = altsd->bInterfaceProtocol; switch (protocol) { default: dev_warn(&dev->dev, "unknown interface protocol %#02x, assuming v1\n", protocol); fallthrough; case UAC_VERSION_1: { struct uac1_ac_header_descriptor *h1; int rest_bytes; h1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, UAC_HEADER); if (!h1 || h1->bLength < sizeof(*h1)) { dev_err(&dev->dev, "cannot find UAC_HEADER\n"); return -EINVAL; } rest_bytes = (void *)(host_iface->extra + host_iface->extralen) - (void *)h1; /* just to be sure -- this shouldn't hit at all */ if (rest_bytes <= 0) { dev_err(&dev->dev, "invalid control header\n"); return -EINVAL; } if (rest_bytes < sizeof(*h1)) { dev_err(&dev->dev, "too short v1 buffer descriptor\n"); return -EINVAL; } if (!h1->bInCollection) { dev_info(&dev->dev, "skipping empty audio interface (v1)\n"); return -EINVAL; } if (rest_bytes < h1->bLength) { dev_err(&dev->dev, "invalid buffer length (v1)\n"); return -EINVAL; } if (h1->bLength < sizeof(*h1) + h1->bInCollection) { dev_err(&dev->dev, "invalid UAC_HEADER (v1)\n"); return -EINVAL; } for (i = 0; i < h1->bInCollection; i++) snd_usb_create_stream(chip, ctrlif, h1->baInterfaceNr[i]); break; } case UAC_VERSION_2: case UAC_VERSION_3: { struct usb_interface_assoc_descriptor *assoc = usb_ifnum_to_if(dev, ctrlif)->intf_assoc; if (!assoc) { /* * Firmware writers cannot count to three. So to find * the IAD on the NuForce UDH-100, also check the next * interface. */ struct usb_interface *iface = usb_ifnum_to_if(dev, ctrlif + 1); if (iface && iface->intf_assoc && iface->intf_assoc->bFunctionClass == USB_CLASS_AUDIO && iface->intf_assoc->bFunctionProtocol == UAC_VERSION_2) assoc = iface->intf_assoc; } if (!assoc) { dev_err(&dev->dev, "Audio class v2/v3 interfaces need an interface association\n"); return -EINVAL; } if (protocol == UAC_VERSION_3) { int badd = assoc->bFunctionSubClass; if (badd != UAC3_FUNCTION_SUBCLASS_FULL_ADC_3_0 && (badd < UAC3_FUNCTION_SUBCLASS_GENERIC_IO || badd > UAC3_FUNCTION_SUBCLASS_SPEAKERPHONE)) { dev_err(&dev->dev, "Unsupported UAC3 BADD profile\n"); return -EINVAL; } chip->badd_profile = badd; } for (i = 0; i < assoc->bInterfaceCount; i++) { int intf = assoc->bFirstInterface + i; if (intf != ctrlif) snd_usb_create_stream(chip, ctrlif, intf); } break; } } return 0; } /* * Profile name preset table */ struct usb_audio_device_name { u32 id; const char *vendor_name; const char *product_name; const char *profile_name; /* override card->longname */ }; #define PROFILE_NAME(vid, pid, vendor, product, profile) \ { .id = USB_ID(vid, pid), .vendor_name = (vendor), \ .product_name = (product), .profile_name = (profile) } #define DEVICE_NAME(vid, pid, vendor, product) \ PROFILE_NAME(vid, pid, vendor, product, NULL) /* vendor/product and profile name presets, sorted in device id order */ static const struct usb_audio_device_name usb_audio_names[] = { /* HP Thunderbolt Dock Audio Headset */ PROFILE_NAME(0x03f0, 0x0269, "HP", "Thunderbolt Dock Audio Headset", "HP-Thunderbolt-Dock-Audio-Headset"), /* HP Thunderbolt Dock Audio Module */ PROFILE_NAME(0x03f0, 0x0567, "HP", "Thunderbolt Dock Audio Module", "HP-Thunderbolt-Dock-Audio-Module"), /* Two entries for Gigabyte TRX40 Aorus Master: * TRX40 Aorus Master has two USB-audio devices, one for the front * headphone with ESS SABRE9218 DAC chip, while another for the rest * I/O (the rear panel and the front mic) with Realtek ALC1220-VB. * Here we provide two distinct names for making UCM profiles easier. */ PROFILE_NAME(0x0414, 0xa000, "Gigabyte", "Aorus Master Front Headphone", "Gigabyte-Aorus-Master-Front-Headphone"), PROFILE_NAME(0x0414, 0xa001, "Gigabyte", "Aorus Master Main Audio", "Gigabyte-Aorus-Master-Main-Audio"), /* Gigabyte TRX40 Aorus Pro WiFi */ PROFILE_NAME(0x0414, 0xa002, "Realtek", "ALC1220-VB-DT", "Realtek-ALC1220-VB-Desktop"), /* Creative/E-Mu devices */ DEVICE_NAME(0x041e, 0x3010, "Creative Labs", "Sound Blaster MP3+"), /* Creative/Toshiba Multimedia Center SB-0500 */ DEVICE_NAME(0x041e, 0x3048, "Toshiba", "SB-0500"), DEVICE_NAME(0x046d, 0x0990, "Logitech, Inc.", "QuickCam Pro 9000"), DEVICE_NAME(0x05e1, 0x0408, "Syntek", "STK1160"), DEVICE_NAME(0x05e1, 0x0480, "Hauppauge", "Woodbury"), /* ASUS ROG Zenith II: this machine has also two devices, one for * the front headphone and another for the rest */ PROFILE_NAME(0x0b05, 0x1915, "ASUS", "Zenith II Front Headphone", "Zenith-II-Front-Headphone"), PROFILE_NAME(0x0b05, 0x1916, "ASUS", "Zenith II Main Audio", "Zenith-II-Main-Audio"), /* ASUS ROG Strix */ PROFILE_NAME(0x0b05, 0x1917, "Realtek", "ALC1220-VB-DT", "Realtek-ALC1220-VB-Desktop"), /* ASUS PRIME TRX40 PRO-S */ PROFILE_NAME(0x0b05, 0x1918, "Realtek", "ALC1220-VB-DT", "Realtek-ALC1220-VB-Desktop"), /* Dell WD15 Dock */ PROFILE_NAME(0x0bda, 0x4014, "Dell", "WD15 Dock", "Dell-WD15-Dock"), /* Dell WD19 Dock */ PROFILE_NAME(0x0bda, 0x402e, "Dell", "WD19 Dock", "Dell-WD15-Dock"), DEVICE_NAME(0x0ccd, 0x0028, "TerraTec", "Aureon5.1MkII"), /* * The original product_name is "USB Sound Device", however this name * is also used by the CM106 based cards, so make it unique. */ DEVICE_NAME(0x0d8c, 0x0102, NULL, "ICUSBAUDIO7D"), DEVICE_NAME(0x0d8c, 0x0103, NULL, "Audio Advantage MicroII"), /* MSI TRX40 Creator */ PROFILE_NAME(0x0db0, 0x0d64, "Realtek", "ALC1220-VB-DT", "Realtek-ALC1220-VB-Desktop"), /* MSI TRX40 */ PROFILE_NAME(0x0db0, 0x543d, "Realtek", "ALC1220-VB-DT", "Realtek-ALC1220-VB-Desktop"), DEVICE_NAME(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"), /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */ DEVICE_NAME(0x103d, 0x0100, "Stanton", "ScratchAmp"), DEVICE_NAME(0x103d, 0x0101, "Stanton", "ScratchAmp"), /* aka. Serato Scratch Live DJ Box */ DEVICE_NAME(0x13e5, 0x0001, "Rane", "SL-1"), /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */ PROFILE_NAME(0x17aa, 0x1046, "Lenovo", "ThinkStation P620 Rear", "Lenovo-ThinkStation-P620-Rear"), /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */ PROFILE_NAME(0x17aa, 0x104d, "Lenovo", "ThinkStation P620 Main", "Lenovo-ThinkStation-P620-Main"), /* Asrock TRX40 Creator */ PROFILE_NAME(0x26ce, 0x0a01, "Realtek", "ALC1220-VB-DT", "Realtek-ALC1220-VB-Desktop"), DEVICE_NAME(0x2040, 0x7200, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"), DEVICE_NAME(0x2040, 0x7210, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"), DEVICE_NAME(0x2040, 0x7213, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x7217, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x721b, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x721e, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x721f, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x7240, "Hauppauge", "HVR-850"), DEVICE_NAME(0x2040, 0x7260, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x7270, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x7280, "Hauppauge", "HVR-950Q"), DEVICE_NAME(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"), DEVICE_NAME(0x2040, 0x8200, "Hauppauge", "Woodbury"), { } /* terminator */ }; static const struct usb_audio_device_name * lookup_device_name(u32 id) { static const struct usb_audio_device_name *p; for (p = usb_audio_names; p->id; p++) if (p->id == id) return p; return NULL; } /* * free the chip instance * * here we have to do not much, since pcm and controls are already freed * */ static void snd_usb_audio_free(struct snd_card *card) { struct snd_usb_audio *chip = card->private_data; snd_usb_endpoint_free_all(chip); snd_usb_midi_v2_free_all(chip); mutex_destroy(&chip->mutex); if (!atomic_read(&chip->shutdown)) dev_set_drvdata(&chip->dev->dev, NULL); } static void usb_audio_make_shortname(struct usb_device *dev, struct snd_usb_audio *chip, const struct snd_usb_audio_quirk *quirk) { struct snd_card *card = chip->card; const struct usb_audio_device_name *preset; const char *s = NULL; preset = lookup_device_name(chip->usb_id); if (preset && preset->product_name) s = preset->product_name; else if (quirk && quirk->product_name) s = quirk->product_name; if (s && *s) { strscpy(card->shortname, s, sizeof(card->shortname)); return; } /* retrieve the device string as shortname */ if (!dev->descriptor.iProduct || usb_string(dev, dev->descriptor.iProduct, card->shortname, sizeof(card->shortname)) <= 0) { /* no name available from anywhere, so use ID */ sprintf(card->shortname, "USB Device %#04x:%#04x", USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id)); } strim(card->shortname); } static void usb_audio_make_longname(struct usb_device *dev, struct snd_usb_audio *chip, const struct snd_usb_audio_quirk *quirk) { struct snd_card *card = chip->card; const struct usb_audio_device_name *preset; const char *s = NULL; int len; preset = lookup_device_name(chip->usb_id); /* shortcut - if any pre-defined string is given, use it */ if (preset && preset->profile_name) s = preset->profile_name; if (s && *s) { strscpy(card->longname, s, sizeof(card->longname)); return; } if (preset && preset->vendor_name) s = preset->vendor_name; else if (quirk && quirk->vendor_name) s = quirk->vendor_name; *card->longname = 0; if (s && *s) { strscpy(card->longname, s, sizeof(card->longname)); } else { /* retrieve the vendor and device strings as longname */ if (dev->descriptor.iManufacturer) usb_string(dev, dev->descriptor.iManufacturer, card->longname, sizeof(card->longname)); /* we don't really care if there isn't any vendor string */ } if (*card->longname) { strim(card->longname); if (*card->longname) strlcat(card->longname, " ", sizeof(card->longname)); } strlcat(card->longname, card->shortname, sizeof(card->longname)); len = strlcat(card->longname, " at ", sizeof(card->longname)); if (len < sizeof(card->longname)) usb_make_path(dev, card->longname + len, sizeof(card->longname) - len); switch (snd_usb_get_speed(dev)) { case USB_SPEED_LOW: strlcat(card->longname, ", low speed", sizeof(card->longname)); break; case USB_SPEED_FULL: strlcat(card->longname, ", full speed", sizeof(card->longname)); break; case USB_SPEED_HIGH: strlcat(card->longname, ", high speed", sizeof(card->longname)); break; case USB_SPEED_SUPER: strlcat(card->longname, ", super speed", sizeof(card->longname)); break; case USB_SPEED_SUPER_PLUS: strlcat(card->longname, ", super speed plus", sizeof(card->longname)); break; default: break; } } /* * create a chip instance and set its names. */ static int snd_usb_audio_create(struct usb_interface *intf, struct usb_device *dev, int idx, const struct snd_usb_audio_quirk *quirk, unsigned int usb_id, struct snd_usb_audio **rchip) { struct snd_card *card; struct snd_usb_audio *chip; int err; char component[14]; *rchip = NULL; switch (snd_usb_get_speed(dev)) { case USB_SPEED_LOW: case USB_SPEED_FULL: case USB_SPEED_HIGH: case USB_SPEED_SUPER: case USB_SPEED_SUPER_PLUS: break; default: dev_err(&dev->dev, "unknown device speed %d\n", snd_usb_get_speed(dev)); return -ENXIO; } err = snd_card_new(&intf->dev, index[idx], id[idx], THIS_MODULE, sizeof(*chip), &card); if (err < 0) { dev_err(&dev->dev, "cannot create card instance %d\n", idx); return err; } chip = card->private_data; mutex_init(&chip->mutex); init_waitqueue_head(&chip->shutdown_wait); chip->index = idx; chip->dev = dev; chip->card = card; chip->setup = device_setup[idx]; chip->generic_implicit_fb = implicit_fb[idx]; chip->autoclock = autoclock; chip->lowlatency = lowlatency; atomic_set(&chip->active, 1); /* avoid autopm during probing */ atomic_set(&chip->usage_count, 0); atomic_set(&chip->shutdown, 0); chip->usb_id = usb_id; INIT_LIST_HEAD(&chip->pcm_list); INIT_LIST_HEAD(&chip->ep_list); INIT_LIST_HEAD(&chip->iface_ref_list); INIT_LIST_HEAD(&chip->clock_ref_list); INIT_LIST_HEAD(&chip->midi_list); INIT_LIST_HEAD(&chip->midi_v2_list); INIT_LIST_HEAD(&chip->mixer_list); if (quirk_flags[idx]) chip->quirk_flags = quirk_flags[idx]; else snd_usb_init_quirk_flags(chip); card->private_free = snd_usb_audio_free; strcpy(card->driver, "USB-Audio"); sprintf(component, "USB%04x:%04x", USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id)); snd_component_add(card, component); usb_audio_make_shortname(dev, chip, quirk); usb_audio_make_longname(dev, chip, quirk); snd_usb_audio_create_proc(chip); *rchip = chip; return 0; } /* look for a matching quirk alias id */ static bool get_alias_id(struct usb_device *dev, unsigned int *id) { int i; unsigned int src, dst; for (i = 0; i < ARRAY_SIZE(quirk_alias); i++) { if (!quirk_alias[i] || sscanf(quirk_alias[i], "%x:%x", &src, &dst) != 2 || src != *id) continue; dev_info(&dev->dev, "device (%04x:%04x): applying quirk alias %04x:%04x\n", USB_ID_VENDOR(*id), USB_ID_PRODUCT(*id), USB_ID_VENDOR(dst), USB_ID_PRODUCT(dst)); *id = dst; return true; } return false; } static int check_delayed_register_option(struct snd_usb_audio *chip) { int i; unsigned int id, inum; for (i = 0; i < ARRAY_SIZE(delayed_register); i++) { if (delayed_register[i] && sscanf(delayed_register[i], "%x:%x", &id, &inum) == 2 && id == chip->usb_id) return inum; } return -1; } static const struct usb_device_id usb_audio_ids[]; /* defined below */ /* look for the last interface that matches with our ids and remember it */ static void find_last_interface(struct snd_usb_audio *chip) { struct usb_host_config *config = chip->dev->actconfig; struct usb_interface *intf; int i; if (!config) return; for (i = 0; i < config->desc.bNumInterfaces; i++) { intf = config->interface[i]; if (usb_match_id(intf, usb_audio_ids)) chip->last_iface = intf->altsetting[0].desc.bInterfaceNumber; } usb_audio_dbg(chip, "Found last interface = %d\n", chip->last_iface); } /* look for the corresponding quirk */ static const struct snd_usb_audio_quirk * get_alias_quirk(struct usb_device *dev, unsigned int id) { const struct usb_device_id *p; for (p = usb_audio_ids; p->match_flags; p++) { /* FIXME: this checks only vendor:product pair in the list */ if ((p->match_flags & USB_DEVICE_ID_MATCH_DEVICE) == USB_DEVICE_ID_MATCH_DEVICE && p->idVendor == USB_ID_VENDOR(id) && p->idProduct == USB_ID_PRODUCT(id)) return (const struct snd_usb_audio_quirk *)p->driver_info; } return NULL; } /* register card if we reach to the last interface or to the specified * one given via option */ static int try_to_register_card(struct snd_usb_audio *chip, int ifnum) { if (check_delayed_register_option(chip) == ifnum || chip->last_iface == ifnum || usb_interface_claimed(usb_ifnum_to_if(chip->dev, chip->last_iface))) return snd_card_register(chip->card); return 0; } /* * probe the active usb device * * note that this can be called multiple times per a device, when it * includes multiple audio control interfaces. * * thus we check the usb device pointer and creates the card instance * only at the first time. the successive calls of this function will * append the pcm interface to the corresponding card. */ static int usb_audio_probe(struct usb_interface *intf, const struct usb_device_id *usb_id) { struct usb_device *dev = interface_to_usbdev(intf); const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info; struct snd_usb_audio *chip; int i, err; struct usb_host_interface *alts; int ifnum; u32 id; alts = &intf->altsetting[0]; ifnum = get_iface_desc(alts)->bInterfaceNumber; id = USB_ID(le16_to_cpu(dev->descriptor.idVendor), le16_to_cpu(dev->descriptor.idProduct)); if (get_alias_id(dev, &id)) quirk = get_alias_quirk(dev, id); if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum) return -ENXIO; if (quirk && quirk->ifnum == QUIRK_NODEV_INTERFACE) return -ENODEV; err = snd_usb_apply_boot_quirk(dev, intf, quirk, id); if (err < 0) return err; /* * found a config. now register to ALSA */ /* check whether it's already registered */ chip = NULL; mutex_lock(&register_mutex); for (i = 0; i < SNDRV_CARDS; i++) { if (usb_chip[i] && usb_chip[i]->dev == dev) { if (atomic_read(&usb_chip[i]->shutdown)) { dev_err(&dev->dev, "USB device is in the shutdown state, cannot create a card instance\n"); err = -EIO; goto __error; } chip = usb_chip[i]; atomic_inc(&chip->active); /* avoid autopm */ break; } } if (! chip) { err = snd_usb_apply_boot_quirk_once(dev, intf, quirk, id); if (err < 0) goto __error; /* it's a fresh one. * now look for an empty slot and create a new card instance */ for (i = 0; i < SNDRV_CARDS; i++) if (!usb_chip[i] && (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) && (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) { if (enable[i]) { err = snd_usb_audio_create(intf, dev, i, quirk, id, &chip); if (err < 0) goto __error; break; } else if (vid[i] != -1 || pid[i] != -1) { dev_info(&dev->dev, "device (%04x:%04x) is disabled\n", USB_ID_VENDOR(id), USB_ID_PRODUCT(id)); err = -ENOENT; goto __error; } } if (!chip) { dev_err(&dev->dev, "no available usb audio device\n"); err = -ENODEV; goto __error; } find_last_interface(chip); } if (chip->num_interfaces >= MAX_CARD_INTERFACES) { dev_info(&dev->dev, "Too many interfaces assigned to the single USB-audio card\n"); err = -EINVAL; goto __error; } dev_set_drvdata(&dev->dev, chip); if (ignore_ctl_error) chip->quirk_flags |= QUIRK_FLAG_IGNORE_CTL_ERROR; if (chip->quirk_flags & QUIRK_FLAG_DISABLE_AUTOSUSPEND) usb_disable_autosuspend(interface_to_usbdev(intf)); /* * For devices with more than one control interface, we assume the * first contains the audio controls. We might need a more specific * check here in the future. */ if (!chip->ctrl_intf) chip->ctrl_intf = alts; err = 1; /* continue */ if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) { /* need some special handlings */ err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk); if (err < 0) goto __error; } if (err > 0) { /* create normal USB audio interfaces */ err = snd_usb_create_streams(chip, ifnum); if (err < 0) goto __error; err = snd_usb_create_mixer(chip, ifnum); if (err < 0) goto __error; } if (chip->need_delayed_register) { dev_info(&dev->dev, "Found post-registration device assignment: %08x:%02x\n", chip->usb_id, ifnum); chip->need_delayed_register = false; /* clear again */ } err = try_to_register_card(chip, ifnum); if (err < 0) goto __error_no_register; if (chip->quirk_flags & QUIRK_FLAG_SHARE_MEDIA_DEVICE) { /* don't want to fail when snd_media_device_create() fails */ snd_media_device_create(chip, intf); } if (quirk) chip->quirk_type = quirk->type; usb_chip[chip->index] = chip; chip->intf[chip->num_interfaces] = intf; chip->num_interfaces++; usb_set_intfdata(intf, chip); atomic_dec(&chip->active); mutex_unlock(&register_mutex); return 0; __error: /* in the case of error in secondary interface, still try to register */ if (chip) try_to_register_card(chip, ifnum); __error_no_register: if (chip) { /* chip->active is inside the chip->card object, * decrement before memory is possibly returned. */ atomic_dec(&chip->active); if (!chip->num_interfaces) snd_card_free(chip->card); } mutex_unlock(&register_mutex); return err; } /* * we need to take care of counter, since disconnection can be called also * many times as well as usb_audio_probe(). */ static void usb_audio_disconnect(struct usb_interface *intf) { struct snd_usb_audio *chip = usb_get_intfdata(intf); struct snd_card *card; struct list_head *p; if (chip == USB_AUDIO_IFACE_UNUSED) return; card = chip->card; mutex_lock(&register_mutex); if (atomic_inc_return(&chip->shutdown) == 1) { struct snd_usb_stream *as; struct snd_usb_endpoint *ep; struct usb_mixer_interface *mixer; /* wait until all pending tasks done; * they are protected by snd_usb_lock_shutdown() */ wait_event(chip->shutdown_wait, !atomic_read(&chip->usage_count)); snd_card_disconnect(card); /* release the pcm resources */ list_for_each_entry(as, &chip->pcm_list, list) { snd_usb_stream_disconnect(as); } /* release the endpoint resources */ list_for_each_entry(ep, &chip->ep_list, list) { snd_usb_endpoint_release(ep); } /* release the midi resources */ list_for_each(p, &chip->midi_list) { snd_usbmidi_disconnect(p); } snd_usb_midi_v2_disconnect_all(chip); /* * Nice to check quirk && quirk->shares_media_device and * then call the snd_media_device_delete(). Don't have * access to the quirk here. snd_media_device_delete() * accesses mixer_list */ snd_media_device_delete(chip); /* release mixer resources */ list_for_each_entry(mixer, &chip->mixer_list, list) { snd_usb_mixer_disconnect(mixer); } } if (chip->quirk_flags & QUIRK_FLAG_DISABLE_AUTOSUSPEND) usb_enable_autosuspend(interface_to_usbdev(intf)); chip->num_interfaces--; if (chip->num_interfaces <= 0) { usb_chip[chip->index] = NULL; mutex_unlock(&register_mutex); snd_card_free_when_closed(card); } else { mutex_unlock(&register_mutex); } } /* lock the shutdown (disconnect) task and autoresume */ int snd_usb_lock_shutdown(struct snd_usb_audio *chip) { int err; atomic_inc(&chip->usage_count); if (atomic_read(&chip->shutdown)) { err = -EIO; goto error; } err = snd_usb_autoresume(chip); if (err < 0) goto error; return 0; error: if (atomic_dec_and_test(&chip->usage_count)) wake_up(&chip->shutdown_wait); return err; } /* autosuspend and unlock the shutdown */ void snd_usb_unlock_shutdown(struct snd_usb_audio *chip) { snd_usb_autosuspend(chip); if (atomic_dec_and_test(&chip->usage_count)) wake_up(&chip->shutdown_wait); } int snd_usb_autoresume(struct snd_usb_audio *chip) { int i, err; if (atomic_read(&chip->shutdown)) return -EIO; if (atomic_inc_return(&chip->active) != 1) return 0; for (i = 0; i < chip->num_interfaces; i++) { err = usb_autopm_get_interface(chip->intf[i]); if (err < 0) { /* rollback */ while (--i >= 0) usb_autopm_put_interface(chip->intf[i]); atomic_dec(&chip->active); return err; } } return 0; } void snd_usb_autosuspend(struct snd_usb_audio *chip) { int i; if (atomic_read(&chip->shutdown)) return; if (!atomic_dec_and_test(&chip->active)) return; for (i = 0; i < chip->num_interfaces; i++) usb_autopm_put_interface(chip->intf[i]); } static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message) { struct snd_usb_audio *chip = usb_get_intfdata(intf); struct snd_usb_stream *as; struct snd_usb_endpoint *ep; struct usb_mixer_interface *mixer; struct list_head *p; if (chip == USB_AUDIO_IFACE_UNUSED) return 0; if (!chip->num_suspended_intf++) { list_for_each_entry(as, &chip->pcm_list, list) snd_usb_pcm_suspend(as); list_for_each_entry(ep, &chip->ep_list, list) snd_usb_endpoint_suspend(ep); list_for_each(p, &chip->midi_list) snd_usbmidi_suspend(p); list_for_each_entry(mixer, &chip->mixer_list, list) snd_usb_mixer_suspend(mixer); snd_usb_midi_v2_suspend_all(chip); } if (!PMSG_IS_AUTO(message) && !chip->system_suspend) { snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot); chip->system_suspend = chip->num_suspended_intf; } return 0; } static int usb_audio_resume(struct usb_interface *intf) { struct snd_usb_audio *chip = usb_get_intfdata(intf); struct snd_usb_stream *as; struct usb_mixer_interface *mixer; struct list_head *p; int err = 0; if (chip == USB_AUDIO_IFACE_UNUSED) return 0; atomic_inc(&chip->active); /* avoid autopm */ if (chip->num_suspended_intf > 1) goto out; list_for_each_entry(as, &chip->pcm_list, list) { err = snd_usb_pcm_resume(as); if (err < 0) goto err_out; } /* * ALSA leaves material resumption to user space * we just notify and restart the mixers */ list_for_each_entry(mixer, &chip->mixer_list, list) { err = snd_usb_mixer_resume(mixer); if (err < 0) goto err_out; } list_for_each(p, &chip->midi_list) { snd_usbmidi_resume(p); } snd_usb_midi_v2_resume_all(chip); out: if (chip->num_suspended_intf == chip->system_suspend) { snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0); chip->system_suspend = 0; } chip->num_suspended_intf--; err_out: atomic_dec(&chip->active); /* allow autopm after this point */ return err; } static const struct usb_device_id usb_audio_ids [] = { #include "quirks-table.h" { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS), .bInterfaceClass = USB_CLASS_AUDIO, .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL }, { } /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, usb_audio_ids); /* * entry point for linux usb interface */ static struct usb_driver usb_audio_driver = { .name = "snd-usb-audio", .probe = usb_audio_probe, .disconnect = usb_audio_disconnect, .suspend = usb_audio_suspend, .resume = usb_audio_resume, .reset_resume = usb_audio_resume, .id_table = usb_audio_ids, .supports_autosuspend = 1, }; module_usb_driver(usb_audio_driver);
linux-master
sound/usb/card.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Additional mixer mapping * * Copyright (c) 2002 by Takashi Iwai <[email protected]> */ struct usbmix_dB_map { int min; int max; bool min_mute; }; struct usbmix_name_map { int id; const char *name; int control; const struct usbmix_dB_map *dB; }; struct usbmix_selector_map { int id; int count; const char **names; }; struct usbmix_ctl_map { u32 id; const struct usbmix_name_map *map; const struct usbmix_selector_map *selector_map; const struct usbmix_connector_map *connector_map; }; /* * USB control mappers for SB Exitigy */ /* * Topology of SB Extigy (see on the wide screen :) USB_IN[1] --->FU[2]------------------------------+->MU[16]-->PU[17]-+->FU[18]--+->EU[27]--+->EU[21]-->FU[22]--+->FU[23] > Dig_OUT[24] ^ | | | | USB_IN[3] -+->SU[5]-->FU[6]--+->MU[14] ->PU[15]->+ | | | +->FU[25] > Dig_OUT[26] ^ ^ | | | | Dig_IN[4] -+ | | | | +->FU[28]---------------------> Spk_OUT[19] | | | | Lin-IN[7] -+-->FU[8]---------+ | | +----------------------------------------> Hph_OUT[20] | | | Mic-IN[9] --+->FU[10]----------------------------+ | || | || +----------------------------------------------------+ VV V ++--+->SU[11]-->FU[12] --------------------------------------------------------------------------------------> USB_OUT[13] */ static const struct usbmix_name_map extigy_map[] = { /* 1: IT pcm */ { 2, "PCM Playback" }, /* FU */ /* 3: IT pcm */ /* 4: IT digital in */ { 5, NULL }, /* DISABLED: this seems to be bogus on some firmware */ { 6, "Digital In" }, /* FU */ /* 7: IT line */ { 8, "Line Playback" }, /* FU */ /* 9: IT mic */ { 10, "Mic Playback" }, /* FU */ { 11, "Capture Source" }, /* SU */ { 12, "Capture" }, /* FU */ /* 13: OT pcm capture */ /* 14: MU (w/o controls) */ /* 15: PU (3D enh) */ /* 16: MU (w/o controls) */ { 17, NULL, 1 }, /* DISABLED: PU-switch (any effect?) */ { 17, "Channel Routing", 2 }, /* PU: mode select */ { 18, "Tone Control - Bass", UAC_FU_BASS }, /* FU */ { 18, "Tone Control - Treble", UAC_FU_TREBLE }, /* FU */ { 18, "Master Playback" }, /* FU; others */ /* 19: OT speaker */ /* 20: OT headphone */ { 21, NULL }, /* DISABLED: EU (for what?) */ { 22, "Digital Out Playback" }, /* FU */ { 23, "Digital Out1 Playback" }, /* FU */ /* FIXME: corresponds to 24 */ /* 24: OT digital out */ { 25, "IEC958 Optical Playback" }, /* FU */ { 26, "IEC958 Optical Playback" }, /* OT */ { 27, NULL }, /* DISABLED: EU (for what?) */ /* 28: FU speaker (mute) */ { 29, NULL }, /* Digital Input Playback Source? */ { 0 } /* terminator */ }; /* Sound Blaster MP3+ controls mapping * The default mixer channels have totally misleading names, * e.g. no Master and fake PCM volume * Pavel Mihaylov <[email protected]> */ static const struct usbmix_dB_map mp3plus_dB_1 = {.min = -4781, .max = 0}; /* just guess */ static const struct usbmix_dB_map mp3plus_dB_2 = {.min = -1781, .max = 618}; /* just guess */ static const struct usbmix_name_map mp3plus_map[] = { /* 1: IT pcm */ /* 2: IT mic */ /* 3: IT line */ /* 4: IT digital in */ /* 5: OT digital out */ /* 6: OT speaker */ /* 7: OT pcm capture */ { 8, "Capture Source" }, /* FU, default PCM Capture Source */ /* (Mic, Input 1 = Line input, Input 2 = Optical input) */ { 9, "Master Playback" }, /* FU, default Speaker 1 */ /* { 10, "Mic Capture", 1 }, */ /* FU, Mic Capture */ { 10, /* "Mic Capture", */ NULL, 2, .dB = &mp3plus_dB_2 }, /* FU, Mic Capture */ { 10, "Mic Boost", 7 }, /* FU, default Auto Gain Input */ { 11, "Line Capture", .dB = &mp3plus_dB_2 }, /* FU, default PCM Capture */ { 12, "Digital In Playback" }, /* FU, default PCM 1 */ { 13, /* "Mic Playback", */ .dB = &mp3plus_dB_1 }, /* FU, default Mic Playback */ { 14, "Line Playback", .dB = &mp3plus_dB_1 }, /* FU, default Speaker */ /* 15: MU */ { 0 } /* terminator */ }; /* Topology of SB Audigy 2 NX +----------------------------->EU[27]--+ | v | +----------------------------------->SU[29]---->FU[22]-->Dig_OUT[24] | | ^ USB_IN[1]-+------------+ +->EU[17]->+->FU[11]-+ | v | v | Dig_IN[4]---+->FU[6]-->MU[16]->FU[18]-+->EU[21]->SU[31]----->FU[30]->Hph_OUT[20] | ^ | | Lin_IN[7]-+--->FU[8]---+ +->EU[23]->FU[28]------------->Spk_OUT[19] | | v +--->FU[12]------------------------------------->SU[14]--->USB_OUT[15] | ^ +->FU[13]--------------------------------------+ */ static const struct usbmix_name_map audigy2nx_map[] = { /* 1: IT pcm playback */ /* 4: IT digital in */ { 6, "Digital In Playback" }, /* FU */ /* 7: IT line in */ { 8, "Line Playback" }, /* FU */ { 11, "What-U-Hear Capture" }, /* FU */ { 12, "Line Capture" }, /* FU */ { 13, "Digital In Capture" }, /* FU */ { 14, "Capture Source" }, /* SU */ /* 15: OT pcm capture */ /* 16: MU w/o controls */ { 17, NULL }, /* DISABLED: EU (for what?) */ { 18, "Master Playback" }, /* FU */ /* 19: OT speaker */ /* 20: OT headphone */ { 21, NULL }, /* DISABLED: EU (for what?) */ { 22, "Digital Out Playback" }, /* FU */ { 23, NULL }, /* DISABLED: EU (for what?) */ /* 24: OT digital out */ { 27, NULL }, /* DISABLED: EU (for what?) */ { 28, "Speaker Playback" }, /* FU */ { 29, "Digital Out Source" }, /* SU */ { 30, "Headphone Playback" }, /* FU */ { 31, "Headphone Source" }, /* SU */ { 0 } /* terminator */ }; static const struct usbmix_name_map mbox1_map[] = { { 1, "Clock" }, { 0 } /* terminator */ }; static const struct usbmix_selector_map c400_selectors[] = { { .id = 0x80, .count = 2, .names = (const char*[]) {"Internal", "SPDIF"} }, { 0 } /* terminator */ }; static const struct usbmix_selector_map audigy2nx_selectors[] = { { .id = 14, /* Capture Source */ .count = 3, .names = (const char*[]) {"Line", "Digital In", "What-U-Hear"} }, { .id = 29, /* Digital Out Source */ .count = 3, .names = (const char*[]) {"Front", "PCM", "Digital In"} }, { .id = 31, /* Headphone Source */ .count = 2, .names = (const char*[]) {"Front", "Side"} }, { 0 } /* terminator */ }; /* Creative SoundBlaster Live! 24-bit External */ static const struct usbmix_name_map live24ext_map[] = { /* 2: PCM Playback Volume */ { 5, "Mic Capture" }, /* FU, default PCM Capture Volume */ { 0 } /* terminator */ }; /* LineX FM Transmitter entry - needed to bypass controls bug */ static const struct usbmix_name_map linex_map[] = { /* 1: IT pcm */ /* 2: OT Speaker */ { 3, "Master" }, /* FU: master volume - left / right / mute */ { 0 } /* terminator */ }; static const struct usbmix_name_map maya44_map[] = { /* 1: IT line */ { 2, "Line Playback" }, /* FU */ /* 3: IT line */ { 4, "Line Playback" }, /* FU */ /* 5: IT pcm playback */ /* 6: MU */ { 7, "Master Playback" }, /* FU */ /* 8: OT speaker */ /* 9: IT line */ { 10, "Line Capture" }, /* FU */ /* 11: MU */ /* 12: OT pcm capture */ { } }; /* Section "justlink_map" below added by James Courtier-Dutton <[email protected]> * sourced from Maplin Electronics (https://www.maplin.co.uk), part number A56AK * Part has 2 connectors that act as a single output. (TOSLINK Optical for digital out, and 3.5mm Jack for Analogue out.) * The USB Mixer publishes a Microphone and extra Volume controls for it, but none exist on the device, * so this map removes all unwanted sliders from alsamixer */ static const struct usbmix_name_map justlink_map[] = { /* 1: IT pcm playback */ /* 2: Not present */ { 3, NULL}, /* IT mic (No mic input on device) */ /* 4: Not present */ /* 5: OT speacker */ /* 6: OT pcm capture */ { 7, "Master Playback" }, /* Mute/volume for speaker */ { 8, NULL }, /* Capture Switch (No capture inputs on device) */ { 9, NULL }, /* Capture Mute/volume (No capture inputs on device */ /* 0xa: Not present */ /* 0xb: MU (w/o controls) */ { 0xc, NULL }, /* Mic feedback Mute/volume (No capture inputs on device) */ { 0 } /* terminator */ }; /* TerraTec Aureon 5.1 MkII USB */ static const struct usbmix_name_map aureon_51_2_map[] = { /* 1: IT USB */ /* 2: IT Mic */ /* 3: IT Line */ /* 4: IT SPDIF */ /* 5: OT SPDIF */ /* 6: OT Speaker */ /* 7: OT USB */ { 8, "Capture Source" }, /* SU */ { 9, "Master Playback" }, /* FU */ { 10, "Mic Capture" }, /* FU */ { 11, "Line Capture" }, /* FU */ { 12, "IEC958 In Capture" }, /* FU */ { 13, "Mic Playback" }, /* FU */ { 14, "Line Playback" }, /* FU */ /* 15: MU */ {} /* terminator */ }; static const struct usbmix_name_map scratch_live_map[] = { /* 1: IT Line 1 (USB streaming) */ /* 2: OT Line 1 (Speaker) */ /* 3: IT Line 1 (Line connector) */ { 4, "Line 1 In" }, /* FU */ /* 5: OT Line 1 (USB streaming) */ /* 6: IT Line 2 (USB streaming) */ /* 7: OT Line 2 (Speaker) */ /* 8: IT Line 2 (Line connector) */ { 9, "Line 2 In" }, /* FU */ /* 10: OT Line 2 (USB streaming) */ /* 11: IT Mic (Line connector) */ /* 12: OT Mic (USB streaming) */ { 0 } /* terminator */ }; static const struct usbmix_name_map ebox44_map[] = { { 4, NULL }, /* FU */ { 6, NULL }, /* MU */ { 7, NULL }, /* FU */ { 10, NULL }, /* FU */ { 11, NULL }, /* MU */ { 0 } }; /* "Gamesurround Muse Pocket LT" looks same like "Sound Blaster MP3+" * most importand difference is SU[8], it should be set to "Capture Source" * to make alsamixer and PA working properly. * FIXME: or mp3plus_map should use "Capture Source" too, * so this maps can be merget */ static const struct usbmix_name_map hercules_usb51_map[] = { { 8, "Capture Source" }, /* SU, default "PCM Capture Source" */ { 9, "Master Playback" }, /* FU, default "Speaker Playback" */ { 10, "Mic Boost", 7 }, /* FU, default "Auto Gain Input" */ { 11, "Line Capture" }, /* FU, default "PCM Capture" */ { 13, "Mic Bypass Playback" }, /* FU, default "Mic Playback" */ { 14, "Line Bypass Playback" }, /* FU, default "Line Playback" */ { 0 } /* terminator */ }; /* Plantronics Gamecom 780 has a broken volume control, better to disable it */ static const struct usbmix_name_map gamecom780_map[] = { { 9, NULL }, /* FU, speaker out */ {} }; /* some (all?) SCMS USB3318 devices are affected by a firmware lock up * when anything attempts to access FU 10 (control) */ static const struct usbmix_name_map scms_usb3318_map[] = { { 10, NULL }, { 0 } }; /* Bose companion 5, the dB conversion factor is 16 instead of 256 */ static const struct usbmix_dB_map bose_companion5_dB = {-5006, -6}; static const struct usbmix_name_map bose_companion5_map[] = { { 3, NULL, .dB = &bose_companion5_dB }, { 0 } /* terminator */ }; /* Bose Revolve+ SoundLink, correction of dB maps */ static const struct usbmix_dB_map bose_soundlink_dB = {-8283, -0, true}; static const struct usbmix_name_map bose_soundlink_map[] = { { 2, NULL, .dB = &bose_soundlink_dB }, { 0 } /* terminator */ }; /* Sennheiser Communications Headset [PC 8], the dB value is reported as -6 negative maximum */ static const struct usbmix_dB_map sennheiser_pc8_dB = {-9500, 0}; static const struct usbmix_name_map sennheiser_pc8_map[] = { { 9, NULL, .dB = &sennheiser_pc8_dB }, { 0 } /* terminator */ }; /* * Dell usb dock with ALC4020 codec had a firmware problem where it got * screwed up when zero volume is passed; just skip it as a workaround * * Also the extension unit gives an access error, so skip it as well. */ static const struct usbmix_name_map dell_alc4020_map[] = { { 4, NULL }, /* extension unit */ { 16, NULL }, { 19, NULL }, { 0 } }; /* * Corsair Virtuoso calls everything "Headset" without this, leading to * applications moving the sidetone control instead of the main one. */ static const struct usbmix_name_map corsair_virtuoso_map[] = { { 3, "Mic Capture" }, { 6, "Sidetone Playback" }, { 0 } }; /* Microsoft USB Link headset */ /* a guess work: raw playback volume values are from 2 to 129 */ static const struct usbmix_dB_map ms_usb_link_dB = { -3225, 0, true }; static const struct usbmix_name_map ms_usb_link_map[] = { { 9, NULL, .dB = &ms_usb_link_dB }, { 10, NULL }, /* Headset Capture volume; seems non-working, disabled */ { 0 } /* terminator */ }; /* ASUS ROG Zenith II with Realtek ALC1220-VB */ static const struct usbmix_name_map asus_zenith_ii_map[] = { { 19, NULL, 12 }, /* FU, Input Gain Pad - broken response, disabled */ { 16, "Speaker" }, /* OT */ { 22, "Speaker Playback" }, /* FU */ { 7, "Line" }, /* IT */ { 19, "Line Capture" }, /* FU */ { 8, "Mic" }, /* IT */ { 20, "Mic Capture" }, /* FU */ { 9, "Front Mic" }, /* IT */ { 21, "Front Mic Capture" }, /* FU */ { 17, "IEC958" }, /* OT */ { 23, "IEC958 Playback" }, /* FU */ {} }; static const struct usbmix_connector_map asus_zenith_ii_connector_map[] = { { 10, 16 }, /* (Back) Speaker */ { 11, 17 }, /* SPDIF */ { 13, 7 }, /* Line */ { 14, 8 }, /* Mic */ { 15, 9 }, /* Front Mic */ {} }; static const struct usbmix_name_map lenovo_p620_rear_map[] = { { 19, NULL, 12 }, /* FU, Input Gain Pad */ {} }; /* TRX40 mobos with Realtek ALC1220-VB */ static const struct usbmix_name_map trx40_mobo_map[] = { { 18, NULL }, /* OT, IEC958 - broken response, disabled */ { 19, NULL, 12 }, /* FU, Input Gain Pad - broken response, disabled */ { 16, "Speaker" }, /* OT */ { 22, "Speaker Playback" }, /* FU */ { 7, "Line" }, /* IT */ { 19, "Line Capture" }, /* FU */ { 17, "Front Headphone" }, /* OT */ { 23, "Front Headphone Playback" }, /* FU */ { 8, "Mic" }, /* IT */ { 20, "Mic Capture" }, /* FU */ { 9, "Front Mic" }, /* IT */ { 21, "Front Mic Capture" }, /* FU */ { 24, "IEC958 Playback" }, /* FU */ {} }; static const struct usbmix_connector_map trx40_mobo_connector_map[] = { { 10, 16 }, /* (Back) Speaker */ { 11, 17 }, /* Front Headphone */ { 13, 7 }, /* Line */ { 14, 8 }, /* Mic */ { 15, 9 }, /* Front Mic */ {} }; /* Rear panel + front mic on Gigabyte TRX40 Aorus Master with ALC1220-VB */ static const struct usbmix_name_map aorus_master_alc1220vb_map[] = { { 17, NULL }, /* OT, IEC958?, disabled */ { 19, NULL, 12 }, /* FU, Input Gain Pad - broken response, disabled */ { 16, "Line Out" }, /* OT */ { 22, "Line Out Playback" }, /* FU */ { 7, "Line" }, /* IT */ { 19, "Line Capture" }, /* FU */ { 8, "Mic" }, /* IT */ { 20, "Mic Capture" }, /* FU */ { 9, "Front Mic" }, /* IT */ { 21, "Front Mic Capture" }, /* FU */ {} }; /* MSI MPG X570S Carbon Max Wifi with ALC4080 */ static const struct usbmix_name_map msi_mpg_x570s_carbon_max_wifi_alc4080_map[] = { { 29, "Speaker Playback" }, { 30, "Front Headphone Playback" }, { 32, "IEC958 Playback" }, {} }; /* Gigabyte B450/550 Mobo */ static const struct usbmix_name_map gigabyte_b450_map[] = { { 24, NULL }, /* OT, IEC958?, disabled */ { 21, "Speaker" }, /* OT */ { 29, "Speaker Playback" }, /* FU */ { 22, "Headphone" }, /* OT */ { 30, "Headphone Playback" }, /* FU */ { 11, "Line" }, /* IT */ { 27, "Line Capture" }, /* FU */ { 12, "Mic" }, /* IT */ { 28, "Mic Capture" }, /* FU */ { 9, "Front Mic" }, /* IT */ { 25, "Front Mic Capture" }, /* FU */ {} }; static const struct usbmix_connector_map gigabyte_b450_connector_map[] = { { 13, 21 }, /* Speaker */ { 14, 22 }, /* Headphone */ { 19, 11 }, /* Line */ { 20, 12 }, /* Mic */ { 17, 9 }, /* Front Mic */ {} }; /* * Control map entries */ static const struct usbmix_ctl_map usbmix_ctl_maps[] = { { .id = USB_ID(0x041e, 0x3000), .map = extigy_map, }, { .id = USB_ID(0x041e, 0x3010), .map = mp3plus_map, }, { .id = USB_ID(0x041e, 0x3020), .map = audigy2nx_map, .selector_map = audigy2nx_selectors, }, { .id = USB_ID(0x041e, 0x3040), .map = live24ext_map, }, { .id = USB_ID(0x041e, 0x3048), .map = audigy2nx_map, .selector_map = audigy2nx_selectors, }, { /* Plantronics GameCom 780 */ .id = USB_ID(0x047f, 0xc010), .map = gamecom780_map, }, { /* Hercules Gamesurround Muse Pocket LT * (USB 5.1 Channel Audio Adapter) */ .id = USB_ID(0x06f8, 0xc000), .map = hercules_usb51_map, }, { .id = USB_ID(0x0763, 0x2030), .selector_map = c400_selectors, }, { .id = USB_ID(0x0763, 0x2031), .selector_map = c400_selectors, }, { .id = USB_ID(0x08bb, 0x2702), .map = linex_map, }, { .id = USB_ID(0x0a92, 0x0091), .map = maya44_map, }, { .id = USB_ID(0x0c45, 0x1158), .map = justlink_map, }, { .id = USB_ID(0x0ccd, 0x0028), .map = aureon_51_2_map, }, { .id = USB_ID(0x0bda, 0x4014), .map = dell_alc4020_map, }, { .id = USB_ID(0x0dba, 0x1000), .map = mbox1_map, }, { .id = USB_ID(0x13e5, 0x0001), .map = scratch_live_map, }, { .id = USB_ID(0x200c, 0x1018), .map = ebox44_map, }, { /* MAYA44 USB+ */ .id = USB_ID(0x2573, 0x0008), .map = maya44_map, }, { /* KEF X300A */ .id = USB_ID(0x27ac, 0x1000), .map = scms_usb3318_map, }, { /* Arcam rPAC */ .id = USB_ID(0x25c4, 0x0003), .map = scms_usb3318_map, }, { /* Bose Companion 5 */ .id = USB_ID(0x05a7, 0x1020), .map = bose_companion5_map, }, { /* Bose Revolve+ SoundLink */ .id = USB_ID(0x05a7, 0x40fa), .map = bose_soundlink_map, }, { /* Corsair Virtuoso SE Latest (wired mode) */ .id = USB_ID(0x1b1c, 0x0a3f), .map = corsair_virtuoso_map, }, { /* Corsair Virtuoso SE Latest (wireless mode) */ .id = USB_ID(0x1b1c, 0x0a40), .map = corsair_virtuoso_map, }, { /* Corsair Virtuoso SE (wired mode) */ .id = USB_ID(0x1b1c, 0x0a3d), .map = corsair_virtuoso_map, }, { /* Corsair Virtuoso SE (wireless mode) */ .id = USB_ID(0x1b1c, 0x0a3e), .map = corsair_virtuoso_map, }, { /* Corsair Virtuoso (wired mode) */ .id = USB_ID(0x1b1c, 0x0a41), .map = corsair_virtuoso_map, }, { /* Corsair Virtuoso (wireless mode) */ .id = USB_ID(0x1b1c, 0x0a42), .map = corsair_virtuoso_map, }, { /* Gigabyte TRX40 Aorus Master (rear panel + front mic) */ .id = USB_ID(0x0414, 0xa001), .map = aorus_master_alc1220vb_map, }, { /* Gigabyte TRX40 Aorus Pro WiFi */ .id = USB_ID(0x0414, 0xa002), .map = trx40_mobo_map, .connector_map = trx40_mobo_connector_map, }, { /* Gigabyte B450/550 Mobo */ .id = USB_ID(0x0414, 0xa00d), .map = gigabyte_b450_map, .connector_map = gigabyte_b450_connector_map, }, { /* ASUS ROG Zenith II (main audio) */ .id = USB_ID(0x0b05, 0x1916), .map = asus_zenith_ii_map, .connector_map = asus_zenith_ii_connector_map, }, { /* ASUS ROG Strix */ .id = USB_ID(0x0b05, 0x1917), .map = trx40_mobo_map, .connector_map = trx40_mobo_connector_map, }, { /* MSI TRX40 Creator */ .id = USB_ID(0x0db0, 0x0d64), .map = trx40_mobo_map, .connector_map = trx40_mobo_connector_map, }, { /* MSI MPG X570S Carbon Max Wifi */ .id = USB_ID(0x0db0, 0x419c), .map = msi_mpg_x570s_carbon_max_wifi_alc4080_map, }, { /* MSI MAG X570S Torpedo Max */ .id = USB_ID(0x0db0, 0xa073), .map = msi_mpg_x570s_carbon_max_wifi_alc4080_map, }, { /* MSI TRX40 */ .id = USB_ID(0x0db0, 0x543d), .map = trx40_mobo_map, .connector_map = trx40_mobo_connector_map, }, { /* Asrock TRX40 Creator */ .id = USB_ID(0x26ce, 0x0a01), .map = trx40_mobo_map, .connector_map = trx40_mobo_connector_map, }, { /* Lenovo ThinkStation P620 Rear */ .id = USB_ID(0x17aa, 0x1046), .map = lenovo_p620_rear_map, }, { /* Sennheiser Communications Headset [PC 8] */ .id = USB_ID(0x1395, 0x0025), .map = sennheiser_pc8_map, }, { /* Microsoft USB Link headset */ .id = USB_ID(0x045e, 0x083c), .map = ms_usb_link_map, }, { 0 } /* terminator */ }; /* * Control map entries for UAC3 BADD profiles */ static const struct usbmix_name_map uac3_badd_generic_io_map[] = { { UAC3_BADD_FU_ID2, "Generic Out Playback" }, { UAC3_BADD_FU_ID5, "Generic In Capture" }, { 0 } /* terminator */ }; static const struct usbmix_name_map uac3_badd_headphone_map[] = { { UAC3_BADD_FU_ID2, "Headphone Playback" }, { 0 } /* terminator */ }; static const struct usbmix_name_map uac3_badd_speaker_map[] = { { UAC3_BADD_FU_ID2, "Speaker Playback" }, { 0 } /* terminator */ }; static const struct usbmix_name_map uac3_badd_microphone_map[] = { { UAC3_BADD_FU_ID5, "Mic Capture" }, { 0 } /* terminator */ }; /* Covers also 'headset adapter' profile */ static const struct usbmix_name_map uac3_badd_headset_map[] = { { UAC3_BADD_FU_ID2, "Headset Playback" }, { UAC3_BADD_FU_ID5, "Headset Capture" }, { UAC3_BADD_FU_ID7, "Sidetone Mixing" }, { 0 } /* terminator */ }; static const struct usbmix_name_map uac3_badd_speakerphone_map[] = { { UAC3_BADD_FU_ID2, "Speaker Playback" }, { UAC3_BADD_FU_ID5, "Mic Capture" }, { 0 } /* terminator */ }; static const struct usbmix_ctl_map uac3_badd_usbmix_ctl_maps[] = { { .id = UAC3_FUNCTION_SUBCLASS_GENERIC_IO, .map = uac3_badd_generic_io_map, }, { .id = UAC3_FUNCTION_SUBCLASS_HEADPHONE, .map = uac3_badd_headphone_map, }, { .id = UAC3_FUNCTION_SUBCLASS_SPEAKER, .map = uac3_badd_speaker_map, }, { .id = UAC3_FUNCTION_SUBCLASS_MICROPHONE, .map = uac3_badd_microphone_map, }, { .id = UAC3_FUNCTION_SUBCLASS_HEADSET, .map = uac3_badd_headset_map, }, { .id = UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER, .map = uac3_badd_headset_map, }, { .id = UAC3_FUNCTION_SUBCLASS_SPEAKERPHONE, .map = uac3_badd_speakerphone_map, }, { 0 } /* terminator */ };
linux-master
sound/usb/mixer_maps.c
/* * usbmidi.c - ALSA USB MIDI driver * * Copyright (c) 2002-2009 Clemens Ladisch * All rights reserved. * * Based on the OSS usb-midi driver by NAGANO Daisuke, * NetBSD's umidi driver by Takuya SHIOZAKI, * the "USB Device Class Definition for MIDI Devices" by Roland * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions, and the following disclaimer, * without modification. * 2. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * Alternatively, this software may be distributed and/or modified 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 SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include <linux/kernel.h> #include <linux/types.h> #include <linux/bitops.h> #include <linux/interrupt.h> #include <linux/spinlock.h> #include <linux/string.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/timer.h> #include <linux/usb.h> #include <linux/wait.h> #include <linux/usb/audio.h> #include <linux/usb/midi.h> #include <linux/module.h> #include <sound/core.h> #include <sound/control.h> #include <sound/rawmidi.h> #include <sound/asequencer.h> #include "usbaudio.h" #include "midi.h" #include "power.h" #include "helper.h" /* * define this to log all USB packets */ /* #define DUMP_PACKETS */ /* * how long to wait after some USB errors, so that hub_wq can disconnect() us * without too many spurious errors */ #define ERROR_DELAY_JIFFIES (HZ / 10) #define OUTPUT_URBS 7 #define INPUT_URBS 7 MODULE_AUTHOR("Clemens Ladisch <[email protected]>"); MODULE_DESCRIPTION("USB Audio/MIDI helper module"); MODULE_LICENSE("Dual BSD/GPL"); struct snd_usb_midi_in_endpoint; struct snd_usb_midi_out_endpoint; struct snd_usb_midi_endpoint; struct usb_protocol_ops { void (*input)(struct snd_usb_midi_in_endpoint*, uint8_t*, int); void (*output)(struct snd_usb_midi_out_endpoint *ep, struct urb *urb); void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t); void (*init_out_endpoint)(struct snd_usb_midi_out_endpoint *); void (*finish_out_endpoint)(struct snd_usb_midi_out_endpoint *); }; struct snd_usb_midi { struct usb_device *dev; struct snd_card *card; struct usb_interface *iface; const struct snd_usb_audio_quirk *quirk; struct snd_rawmidi *rmidi; const struct usb_protocol_ops *usb_protocol_ops; struct list_head list; struct timer_list error_timer; spinlock_t disc_lock; struct rw_semaphore disc_rwsem; struct mutex mutex; u32 usb_id; int next_midi_device; struct snd_usb_midi_endpoint { struct snd_usb_midi_out_endpoint *out; struct snd_usb_midi_in_endpoint *in; } endpoints[MIDI_MAX_ENDPOINTS]; unsigned long input_triggered; unsigned int opened[2]; unsigned char disconnected; unsigned char input_running; struct snd_kcontrol *roland_load_ctl; }; struct snd_usb_midi_out_endpoint { struct snd_usb_midi *umidi; struct out_urb_context { struct urb *urb; struct snd_usb_midi_out_endpoint *ep; } urbs[OUTPUT_URBS]; unsigned int active_urbs; unsigned int drain_urbs; int max_transfer; /* size of urb buffer */ struct work_struct work; unsigned int next_urb; spinlock_t buffer_lock; struct usbmidi_out_port { struct snd_usb_midi_out_endpoint *ep; struct snd_rawmidi_substream *substream; int active; uint8_t cable; /* cable number << 4 */ uint8_t state; #define STATE_UNKNOWN 0 #define STATE_1PARAM 1 #define STATE_2PARAM_1 2 #define STATE_2PARAM_2 3 #define STATE_SYSEX_0 4 #define STATE_SYSEX_1 5 #define STATE_SYSEX_2 6 uint8_t data[2]; } ports[0x10]; int current_port; wait_queue_head_t drain_wait; }; struct snd_usb_midi_in_endpoint { struct snd_usb_midi *umidi; struct urb *urbs[INPUT_URBS]; struct usbmidi_in_port { struct snd_rawmidi_substream *substream; u8 running_status_length; } ports[0x10]; u8 seen_f5; bool in_sysex; u8 last_cin; u8 error_resubmit; int current_port; }; static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint *ep); static const uint8_t snd_usbmidi_cin_length[] = { 0, 0, 2, 3, 3, 1, 2, 3, 3, 3, 3, 3, 2, 2, 3, 1 }; /* * Submits the URB, with error handling. */ static int snd_usbmidi_submit_urb(struct urb *urb, gfp_t flags) { int err = usb_submit_urb(urb, flags); if (err < 0 && err != -ENODEV) dev_err(&urb->dev->dev, "usb_submit_urb: %d\n", err); return err; } /* * Error handling for URB completion functions. */ static int snd_usbmidi_urb_error(const struct urb *urb) { switch (urb->status) { /* manually unlinked, or device gone */ case -ENOENT: case -ECONNRESET: case -ESHUTDOWN: case -ENODEV: return -ENODEV; /* errors that might occur during unplugging */ case -EPROTO: case -ETIME: case -EILSEQ: return -EIO; default: dev_err(&urb->dev->dev, "urb status %d\n", urb->status); return 0; /* continue */ } } /* * Receives a chunk of MIDI data. */ static void snd_usbmidi_input_data(struct snd_usb_midi_in_endpoint *ep, int portidx, uint8_t *data, int length) { struct usbmidi_in_port *port = &ep->ports[portidx]; if (!port->substream) { dev_dbg(&ep->umidi->dev->dev, "unexpected port %d!\n", portidx); return; } if (!test_bit(port->substream->number, &ep->umidi->input_triggered)) return; snd_rawmidi_receive(port->substream, data, length); } #ifdef DUMP_PACKETS static void dump_urb(const char *type, const u8 *data, int length) { snd_printk(KERN_DEBUG "%s packet: [", type); for (; length > 0; ++data, --length) printk(KERN_CONT " %02x", *data); printk(KERN_CONT " ]\n"); } #else #define dump_urb(type, data, length) /* nothing */ #endif /* * Processes the data read from the device. */ static void snd_usbmidi_in_urb_complete(struct urb *urb) { struct snd_usb_midi_in_endpoint *ep = urb->context; if (urb->status == 0) { dump_urb("received", urb->transfer_buffer, urb->actual_length); ep->umidi->usb_protocol_ops->input(ep, urb->transfer_buffer, urb->actual_length); } else { int err = snd_usbmidi_urb_error(urb); if (err < 0) { if (err != -ENODEV) { ep->error_resubmit = 1; mod_timer(&ep->umidi->error_timer, jiffies + ERROR_DELAY_JIFFIES); } return; } } urb->dev = ep->umidi->dev; snd_usbmidi_submit_urb(urb, GFP_ATOMIC); } static void snd_usbmidi_out_urb_complete(struct urb *urb) { struct out_urb_context *context = urb->context; struct snd_usb_midi_out_endpoint *ep = context->ep; unsigned int urb_index; unsigned long flags; spin_lock_irqsave(&ep->buffer_lock, flags); urb_index = context - ep->urbs; ep->active_urbs &= ~(1 << urb_index); if (unlikely(ep->drain_urbs)) { ep->drain_urbs &= ~(1 << urb_index); wake_up(&ep->drain_wait); } spin_unlock_irqrestore(&ep->buffer_lock, flags); if (urb->status < 0) { int err = snd_usbmidi_urb_error(urb); if (err < 0) { if (err != -ENODEV) mod_timer(&ep->umidi->error_timer, jiffies + ERROR_DELAY_JIFFIES); return; } } snd_usbmidi_do_output(ep); } /* * This is called when some data should be transferred to the device * (from one or more substreams). */ static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint *ep) { unsigned int urb_index; struct urb *urb; unsigned long flags; spin_lock_irqsave(&ep->buffer_lock, flags); if (ep->umidi->disconnected) { spin_unlock_irqrestore(&ep->buffer_lock, flags); return; } urb_index = ep->next_urb; for (;;) { if (!(ep->active_urbs & (1 << urb_index))) { urb = ep->urbs[urb_index].urb; urb->transfer_buffer_length = 0; ep->umidi->usb_protocol_ops->output(ep, urb); if (urb->transfer_buffer_length == 0) break; dump_urb("sending", urb->transfer_buffer, urb->transfer_buffer_length); urb->dev = ep->umidi->dev; if (snd_usbmidi_submit_urb(urb, GFP_ATOMIC) < 0) break; ep->active_urbs |= 1 << urb_index; } if (++urb_index >= OUTPUT_URBS) urb_index = 0; if (urb_index == ep->next_urb) break; } ep->next_urb = urb_index; spin_unlock_irqrestore(&ep->buffer_lock, flags); } static void snd_usbmidi_out_work(struct work_struct *work) { struct snd_usb_midi_out_endpoint *ep = container_of(work, struct snd_usb_midi_out_endpoint, work); snd_usbmidi_do_output(ep); } /* called after transfers had been interrupted due to some USB error */ static void snd_usbmidi_error_timer(struct timer_list *t) { struct snd_usb_midi *umidi = from_timer(umidi, t, error_timer); unsigned int i, j; spin_lock(&umidi->disc_lock); if (umidi->disconnected) { spin_unlock(&umidi->disc_lock); return; } for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { struct snd_usb_midi_in_endpoint *in = umidi->endpoints[i].in; if (in && in->error_resubmit) { in->error_resubmit = 0; for (j = 0; j < INPUT_URBS; ++j) { if (atomic_read(&in->urbs[j]->use_count)) continue; in->urbs[j]->dev = umidi->dev; snd_usbmidi_submit_urb(in->urbs[j], GFP_ATOMIC); } } if (umidi->endpoints[i].out) snd_usbmidi_do_output(umidi->endpoints[i].out); } spin_unlock(&umidi->disc_lock); } /* helper function to send static data that may not DMA-able */ static int send_bulk_static_data(struct snd_usb_midi_out_endpoint *ep, const void *data, int len) { int err = 0; void *buf = kmemdup(data, len, GFP_KERNEL); if (!buf) return -ENOMEM; dump_urb("sending", buf, len); if (ep->urbs[0].urb) err = usb_bulk_msg(ep->umidi->dev, ep->urbs[0].urb->pipe, buf, len, NULL, 250); kfree(buf); return err; } /* * Standard USB MIDI protocol: see the spec. * Midiman protocol: like the standard protocol, but the control byte is the * fourth byte in each packet, and uses length instead of CIN. */ static void snd_usbmidi_standard_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { int i; for (i = 0; i + 3 < buffer_length; i += 4) if (buffer[i] != 0) { int cable = buffer[i] >> 4; int length = snd_usbmidi_cin_length[buffer[i] & 0x0f]; snd_usbmidi_input_data(ep, cable, &buffer[i + 1], length); } } static void snd_usbmidi_midiman_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { int i; for (i = 0; i + 3 < buffer_length; i += 4) if (buffer[i + 3] != 0) { int port = buffer[i + 3] >> 4; int length = buffer[i + 3] & 3; snd_usbmidi_input_data(ep, port, &buffer[i], length); } } /* * Buggy M-Audio device: running status on input results in a packet that has * the data bytes but not the status byte and that is marked with CIN 4. */ static void snd_usbmidi_maudio_broken_running_status_input( struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { int i; for (i = 0; i + 3 < buffer_length; i += 4) if (buffer[i] != 0) { int cable = buffer[i] >> 4; u8 cin = buffer[i] & 0x0f; struct usbmidi_in_port *port = &ep->ports[cable]; int length; length = snd_usbmidi_cin_length[cin]; if (cin == 0xf && buffer[i + 1] >= 0xf8) ; /* realtime msg: no running status change */ else if (cin >= 0x8 && cin <= 0xe) /* channel msg */ port->running_status_length = length - 1; else if (cin == 0x4 && port->running_status_length != 0 && buffer[i + 1] < 0x80) /* CIN 4 that is not a SysEx */ length = port->running_status_length; else /* * All other msgs cannot begin running status. * (A channel msg sent as two or three CIN 0xF * packets could in theory, but this device * doesn't use this format.) */ port->running_status_length = 0; snd_usbmidi_input_data(ep, cable, &buffer[i + 1], length); } } /* * QinHeng CH345 is buggy: every second packet inside a SysEx has not CIN 4 * but the previously seen CIN, but still with three data bytes. */ static void ch345_broken_sysex_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { unsigned int i, cin, length; for (i = 0; i + 3 < buffer_length; i += 4) { if (buffer[i] == 0 && i > 0) break; cin = buffer[i] & 0x0f; if (ep->in_sysex && cin == ep->last_cin && (buffer[i + 1 + (cin == 0x6)] & 0x80) == 0) cin = 0x4; #if 0 if (buffer[i + 1] == 0x90) { /* * Either a corrupted running status or a real note-on * message; impossible to detect reliably. */ } #endif length = snd_usbmidi_cin_length[cin]; snd_usbmidi_input_data(ep, 0, &buffer[i + 1], length); ep->in_sysex = cin == 0x4; if (!ep->in_sysex) ep->last_cin = cin; } } /* * CME protocol: like the standard protocol, but SysEx commands are sent as a * single USB packet preceded by a 0x0F byte. */ static void snd_usbmidi_cme_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { if (buffer_length < 2 || (buffer[0] & 0x0f) != 0x0f) snd_usbmidi_standard_input(ep, buffer, buffer_length); else snd_usbmidi_input_data(ep, buffer[0] >> 4, &buffer[1], buffer_length - 1); } /* * Adds one USB MIDI packet to the output buffer. */ static void snd_usbmidi_output_standard_packet(struct urb *urb, uint8_t p0, uint8_t p1, uint8_t p2, uint8_t p3) { uint8_t *buf = (uint8_t *)urb->transfer_buffer + urb->transfer_buffer_length; buf[0] = p0; buf[1] = p1; buf[2] = p2; buf[3] = p3; urb->transfer_buffer_length += 4; } /* * Adds one Midiman packet to the output buffer. */ static void snd_usbmidi_output_midiman_packet(struct urb *urb, uint8_t p0, uint8_t p1, uint8_t p2, uint8_t p3) { uint8_t *buf = (uint8_t *)urb->transfer_buffer + urb->transfer_buffer_length; buf[0] = p1; buf[1] = p2; buf[2] = p3; buf[3] = (p0 & 0xf0) | snd_usbmidi_cin_length[p0 & 0x0f]; urb->transfer_buffer_length += 4; } /* * Converts MIDI commands to USB MIDI packets. */ static void snd_usbmidi_transmit_byte(struct usbmidi_out_port *port, uint8_t b, struct urb *urb) { uint8_t p0 = port->cable; void (*output_packet)(struct urb*, uint8_t, uint8_t, uint8_t, uint8_t) = port->ep->umidi->usb_protocol_ops->output_packet; if (b >= 0xf8) { output_packet(urb, p0 | 0x0f, b, 0, 0); } else if (b >= 0xf0) { switch (b) { case 0xf0: port->data[0] = b; port->state = STATE_SYSEX_1; break; case 0xf1: case 0xf3: port->data[0] = b; port->state = STATE_1PARAM; break; case 0xf2: port->data[0] = b; port->state = STATE_2PARAM_1; break; case 0xf4: case 0xf5: port->state = STATE_UNKNOWN; break; case 0xf6: output_packet(urb, p0 | 0x05, 0xf6, 0, 0); port->state = STATE_UNKNOWN; break; case 0xf7: switch (port->state) { case STATE_SYSEX_0: output_packet(urb, p0 | 0x05, 0xf7, 0, 0); break; case STATE_SYSEX_1: output_packet(urb, p0 | 0x06, port->data[0], 0xf7, 0); break; case STATE_SYSEX_2: output_packet(urb, p0 | 0x07, port->data[0], port->data[1], 0xf7); break; } port->state = STATE_UNKNOWN; break; } } else if (b >= 0x80) { port->data[0] = b; if (b >= 0xc0 && b <= 0xdf) port->state = STATE_1PARAM; else port->state = STATE_2PARAM_1; } else { /* b < 0x80 */ switch (port->state) { case STATE_1PARAM: if (port->data[0] < 0xf0) { p0 |= port->data[0] >> 4; } else { p0 |= 0x02; port->state = STATE_UNKNOWN; } output_packet(urb, p0, port->data[0], b, 0); break; case STATE_2PARAM_1: port->data[1] = b; port->state = STATE_2PARAM_2; break; case STATE_2PARAM_2: if (port->data[0] < 0xf0) { p0 |= port->data[0] >> 4; port->state = STATE_2PARAM_1; } else { p0 |= 0x03; port->state = STATE_UNKNOWN; } output_packet(urb, p0, port->data[0], port->data[1], b); break; case STATE_SYSEX_0: port->data[0] = b; port->state = STATE_SYSEX_1; break; case STATE_SYSEX_1: port->data[1] = b; port->state = STATE_SYSEX_2; break; case STATE_SYSEX_2: output_packet(urb, p0 | 0x04, port->data[0], port->data[1], b); port->state = STATE_SYSEX_0; break; } } } static void snd_usbmidi_standard_output(struct snd_usb_midi_out_endpoint *ep, struct urb *urb) { int p; /* FIXME: lower-numbered ports can starve higher-numbered ports */ for (p = 0; p < 0x10; ++p) { struct usbmidi_out_port *port = &ep->ports[p]; if (!port->active) continue; while (urb->transfer_buffer_length + 3 < ep->max_transfer) { uint8_t b; if (snd_rawmidi_transmit(port->substream, &b, 1) != 1) { port->active = 0; break; } snd_usbmidi_transmit_byte(port, b, urb); } } } static const struct usb_protocol_ops snd_usbmidi_standard_ops = { .input = snd_usbmidi_standard_input, .output = snd_usbmidi_standard_output, .output_packet = snd_usbmidi_output_standard_packet, }; static const struct usb_protocol_ops snd_usbmidi_midiman_ops = { .input = snd_usbmidi_midiman_input, .output = snd_usbmidi_standard_output, .output_packet = snd_usbmidi_output_midiman_packet, }; static const struct usb_protocol_ops snd_usbmidi_maudio_broken_running_status_ops = { .input = snd_usbmidi_maudio_broken_running_status_input, .output = snd_usbmidi_standard_output, .output_packet = snd_usbmidi_output_standard_packet, }; static const struct usb_protocol_ops snd_usbmidi_cme_ops = { .input = snd_usbmidi_cme_input, .output = snd_usbmidi_standard_output, .output_packet = snd_usbmidi_output_standard_packet, }; static const struct usb_protocol_ops snd_usbmidi_ch345_broken_sysex_ops = { .input = ch345_broken_sysex_input, .output = snd_usbmidi_standard_output, .output_packet = snd_usbmidi_output_standard_packet, }; /* * AKAI MPD16 protocol: * * For control port (endpoint 1): * ============================== * One or more chunks consisting of first byte of (0x10 | msg_len) and then a * SysEx message (msg_len=9 bytes long). * * For data port (endpoint 2): * =========================== * One or more chunks consisting of first byte of (0x20 | msg_len) and then a * MIDI message (msg_len bytes long) * * Messages sent: Active Sense, Note On, Poly Pressure, Control Change. */ static void snd_usbmidi_akai_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { unsigned int pos = 0; unsigned int len = (unsigned int)buffer_length; while (pos < len) { unsigned int port = (buffer[pos] >> 4) - 1; unsigned int msg_len = buffer[pos] & 0x0f; pos++; if (pos + msg_len <= len && port < 2) snd_usbmidi_input_data(ep, 0, &buffer[pos], msg_len); pos += msg_len; } } #define MAX_AKAI_SYSEX_LEN 9 static void snd_usbmidi_akai_output(struct snd_usb_midi_out_endpoint *ep, struct urb *urb) { uint8_t *msg; int pos, end, count, buf_end; uint8_t tmp[MAX_AKAI_SYSEX_LEN]; struct snd_rawmidi_substream *substream = ep->ports[0].substream; if (!ep->ports[0].active) return; msg = urb->transfer_buffer + urb->transfer_buffer_length; buf_end = ep->max_transfer - MAX_AKAI_SYSEX_LEN - 1; /* only try adding more data when there's space for at least 1 SysEx */ while (urb->transfer_buffer_length < buf_end) { count = snd_rawmidi_transmit_peek(substream, tmp, MAX_AKAI_SYSEX_LEN); if (!count) { ep->ports[0].active = 0; return; } /* try to skip non-SysEx data */ for (pos = 0; pos < count && tmp[pos] != 0xF0; pos++) ; if (pos > 0) { snd_rawmidi_transmit_ack(substream, pos); continue; } /* look for the start or end marker */ for (end = 1; end < count && tmp[end] < 0xF0; end++) ; /* next SysEx started before the end of current one */ if (end < count && tmp[end] == 0xF0) { /* it's incomplete - drop it */ snd_rawmidi_transmit_ack(substream, end); continue; } /* SysEx complete */ if (end < count && tmp[end] == 0xF7) { /* queue it, ack it, and get the next one */ count = end + 1; msg[0] = 0x10 | count; memcpy(&msg[1], tmp, count); snd_rawmidi_transmit_ack(substream, count); urb->transfer_buffer_length += count + 1; msg += count + 1; continue; } /* less than 9 bytes and no end byte - wait for more */ if (count < MAX_AKAI_SYSEX_LEN) { ep->ports[0].active = 0; return; } /* 9 bytes and no end marker in sight - malformed, skip it */ snd_rawmidi_transmit_ack(substream, count); } } static const struct usb_protocol_ops snd_usbmidi_akai_ops = { .input = snd_usbmidi_akai_input, .output = snd_usbmidi_akai_output, }; /* * Novation USB MIDI protocol: number of data bytes is in the first byte * (when receiving) (+1!) or in the second byte (when sending); data begins * at the third byte. */ static void snd_usbmidi_novation_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { if (buffer_length < 2 || !buffer[0] || buffer_length < buffer[0] + 1) return; snd_usbmidi_input_data(ep, 0, &buffer[2], buffer[0] - 1); } static void snd_usbmidi_novation_output(struct snd_usb_midi_out_endpoint *ep, struct urb *urb) { uint8_t *transfer_buffer; int count; if (!ep->ports[0].active) return; transfer_buffer = urb->transfer_buffer; count = snd_rawmidi_transmit(ep->ports[0].substream, &transfer_buffer[2], ep->max_transfer - 2); if (count < 1) { ep->ports[0].active = 0; return; } transfer_buffer[0] = 0; transfer_buffer[1] = count; urb->transfer_buffer_length = 2 + count; } static const struct usb_protocol_ops snd_usbmidi_novation_ops = { .input = snd_usbmidi_novation_input, .output = snd_usbmidi_novation_output, }; /* * "raw" protocol: just move raw MIDI bytes from/to the endpoint */ static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { snd_usbmidi_input_data(ep, 0, buffer, buffer_length); } static void snd_usbmidi_raw_output(struct snd_usb_midi_out_endpoint *ep, struct urb *urb) { int count; if (!ep->ports[0].active) return; count = snd_rawmidi_transmit(ep->ports[0].substream, urb->transfer_buffer, ep->max_transfer); if (count < 1) { ep->ports[0].active = 0; return; } urb->transfer_buffer_length = count; } static const struct usb_protocol_ops snd_usbmidi_raw_ops = { .input = snd_usbmidi_raw_input, .output = snd_usbmidi_raw_output, }; /* * FTDI protocol: raw MIDI bytes, but input packets have two modem status bytes. */ static void snd_usbmidi_ftdi_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { if (buffer_length > 2) snd_usbmidi_input_data(ep, 0, buffer + 2, buffer_length - 2); } static const struct usb_protocol_ops snd_usbmidi_ftdi_ops = { .input = snd_usbmidi_ftdi_input, .output = snd_usbmidi_raw_output, }; static void snd_usbmidi_us122l_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { if (buffer_length != 9) return; buffer_length = 8; while (buffer_length && buffer[buffer_length - 1] == 0xFD) buffer_length--; if (buffer_length) snd_usbmidi_input_data(ep, 0, buffer, buffer_length); } static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint *ep, struct urb *urb) { int count; if (!ep->ports[0].active) return; switch (snd_usb_get_speed(ep->umidi->dev)) { case USB_SPEED_HIGH: case USB_SPEED_SUPER: case USB_SPEED_SUPER_PLUS: count = 1; break; default: count = 2; } count = snd_rawmidi_transmit(ep->ports[0].substream, urb->transfer_buffer, count); if (count < 1) { ep->ports[0].active = 0; return; } memset(urb->transfer_buffer + count, 0xFD, ep->max_transfer - count); urb->transfer_buffer_length = ep->max_transfer; } static const struct usb_protocol_ops snd_usbmidi_122l_ops = { .input = snd_usbmidi_us122l_input, .output = snd_usbmidi_us122l_output, }; /* * Emagic USB MIDI protocol: raw MIDI with "F5 xx" port switching. */ static void snd_usbmidi_emagic_init_out(struct snd_usb_midi_out_endpoint *ep) { static const u8 init_data[] = { /* initialization magic: "get version" */ 0xf0, 0x00, 0x20, 0x31, /* Emagic */ 0x64, /* Unitor8 */ 0x0b, /* version number request */ 0x00, /* command version */ 0x00, /* EEPROM, box 0 */ 0xf7 }; send_bulk_static_data(ep, init_data, sizeof(init_data)); /* while we're at it, pour on more magic */ send_bulk_static_data(ep, init_data, sizeof(init_data)); } static void snd_usbmidi_emagic_finish_out(struct snd_usb_midi_out_endpoint *ep) { static const u8 finish_data[] = { /* switch to patch mode with last preset */ 0xf0, 0x00, 0x20, 0x31, /* Emagic */ 0x64, /* Unitor8 */ 0x10, /* patch switch command */ 0x00, /* command version */ 0x7f, /* to all boxes */ 0x40, /* last preset in EEPROM */ 0xf7 }; send_bulk_static_data(ep, finish_data, sizeof(finish_data)); } static void snd_usbmidi_emagic_input(struct snd_usb_midi_in_endpoint *ep, uint8_t *buffer, int buffer_length) { int i; /* FF indicates end of valid data */ for (i = 0; i < buffer_length; ++i) if (buffer[i] == 0xff) { buffer_length = i; break; } /* handle F5 at end of last buffer */ if (ep->seen_f5) goto switch_port; while (buffer_length > 0) { /* determine size of data until next F5 */ for (i = 0; i < buffer_length; ++i) if (buffer[i] == 0xf5) break; snd_usbmidi_input_data(ep, ep->current_port, buffer, i); buffer += i; buffer_length -= i; if (buffer_length <= 0) break; /* assert(buffer[0] == 0xf5); */ ep->seen_f5 = 1; ++buffer; --buffer_length; switch_port: if (buffer_length <= 0) break; if (buffer[0] < 0x80) { ep->current_port = (buffer[0] - 1) & 15; ++buffer; --buffer_length; } ep->seen_f5 = 0; } } static void snd_usbmidi_emagic_output(struct snd_usb_midi_out_endpoint *ep, struct urb *urb) { int port0 = ep->current_port; uint8_t *buf = urb->transfer_buffer; int buf_free = ep->max_transfer; int length, i; for (i = 0; i < 0x10; ++i) { /* round-robin, starting at the last current port */ int portnum = (port0 + i) & 15; struct usbmidi_out_port *port = &ep->ports[portnum]; if (!port->active) continue; if (snd_rawmidi_transmit_peek(port->substream, buf, 1) != 1) { port->active = 0; continue; } if (portnum != ep->current_port) { if (buf_free < 2) break; ep->current_port = portnum; buf[0] = 0xf5; buf[1] = (portnum + 1) & 15; buf += 2; buf_free -= 2; } if (buf_free < 1) break; length = snd_rawmidi_transmit(port->substream, buf, buf_free); if (length > 0) { buf += length; buf_free -= length; if (buf_free < 1) break; } } if (buf_free < ep->max_transfer && buf_free > 0) { *buf = 0xff; --buf_free; } urb->transfer_buffer_length = ep->max_transfer - buf_free; } static const struct usb_protocol_ops snd_usbmidi_emagic_ops = { .input = snd_usbmidi_emagic_input, .output = snd_usbmidi_emagic_output, .init_out_endpoint = snd_usbmidi_emagic_init_out, .finish_out_endpoint = snd_usbmidi_emagic_finish_out, }; static void update_roland_altsetting(struct snd_usb_midi *umidi) { struct usb_interface *intf; struct usb_host_interface *hostif; struct usb_interface_descriptor *intfd; int is_light_load; intf = umidi->iface; is_light_load = intf->cur_altsetting != intf->altsetting; if (umidi->roland_load_ctl->private_value == is_light_load) return; hostif = &intf->altsetting[umidi->roland_load_ctl->private_value]; intfd = get_iface_desc(hostif); snd_usbmidi_input_stop(&umidi->list); usb_set_interface(umidi->dev, intfd->bInterfaceNumber, intfd->bAlternateSetting); snd_usbmidi_input_start(&umidi->list); } static int substream_open(struct snd_rawmidi_substream *substream, int dir, int open) { struct snd_usb_midi *umidi = substream->rmidi->private_data; struct snd_kcontrol *ctl; down_read(&umidi->disc_rwsem); if (umidi->disconnected) { up_read(&umidi->disc_rwsem); return open ? -ENODEV : 0; } mutex_lock(&umidi->mutex); if (open) { if (!umidi->opened[0] && !umidi->opened[1]) { if (umidi->roland_load_ctl) { ctl = umidi->roland_load_ctl; ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE; snd_ctl_notify(umidi->card, SNDRV_CTL_EVENT_MASK_INFO, &ctl->id); update_roland_altsetting(umidi); } } umidi->opened[dir]++; if (umidi->opened[1]) snd_usbmidi_input_start(&umidi->list); } else { umidi->opened[dir]--; if (!umidi->opened[1]) snd_usbmidi_input_stop(&umidi->list); if (!umidi->opened[0] && !umidi->opened[1]) { if (umidi->roland_load_ctl) { ctl = umidi->roland_load_ctl; ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; snd_ctl_notify(umidi->card, SNDRV_CTL_EVENT_MASK_INFO, &ctl->id); } } } mutex_unlock(&umidi->mutex); up_read(&umidi->disc_rwsem); return 0; } static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream) { struct snd_usb_midi *umidi = substream->rmidi->private_data; struct usbmidi_out_port *port = NULL; int i, j; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) if (umidi->endpoints[i].out) for (j = 0; j < 0x10; ++j) if (umidi->endpoints[i].out->ports[j].substream == substream) { port = &umidi->endpoints[i].out->ports[j]; break; } if (!port) return -ENXIO; substream->runtime->private_data = port; port->state = STATE_UNKNOWN; return substream_open(substream, 0, 1); } static int snd_usbmidi_output_close(struct snd_rawmidi_substream *substream) { struct usbmidi_out_port *port = substream->runtime->private_data; cancel_work_sync(&port->ep->work); return substream_open(substream, 0, 0); } static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream, int up) { struct usbmidi_out_port *port = (struct usbmidi_out_port *)substream->runtime->private_data; port->active = up; if (up) { if (port->ep->umidi->disconnected) { /* gobble up remaining bytes to prevent wait in * snd_rawmidi_drain_output */ snd_rawmidi_proceed(substream); return; } queue_work(system_highpri_wq, &port->ep->work); } } static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream) { struct usbmidi_out_port *port = substream->runtime->private_data; struct snd_usb_midi_out_endpoint *ep = port->ep; unsigned int drain_urbs; DEFINE_WAIT(wait); long timeout = msecs_to_jiffies(50); if (ep->umidi->disconnected) return; /* * The substream buffer is empty, but some data might still be in the * currently active URBs, so we have to wait for those to complete. */ spin_lock_irq(&ep->buffer_lock); drain_urbs = ep->active_urbs; if (drain_urbs) { ep->drain_urbs |= drain_urbs; do { prepare_to_wait(&ep->drain_wait, &wait, TASK_UNINTERRUPTIBLE); spin_unlock_irq(&ep->buffer_lock); timeout = schedule_timeout(timeout); spin_lock_irq(&ep->buffer_lock); drain_urbs &= ep->drain_urbs; } while (drain_urbs && timeout); finish_wait(&ep->drain_wait, &wait); } port->active = 0; spin_unlock_irq(&ep->buffer_lock); } static int snd_usbmidi_input_open(struct snd_rawmidi_substream *substream) { return substream_open(substream, 1, 1); } static int snd_usbmidi_input_close(struct snd_rawmidi_substream *substream) { return substream_open(substream, 1, 0); } static void snd_usbmidi_input_trigger(struct snd_rawmidi_substream *substream, int up) { struct snd_usb_midi *umidi = substream->rmidi->private_data; if (up) set_bit(substream->number, &umidi->input_triggered); else clear_bit(substream->number, &umidi->input_triggered); } static const struct snd_rawmidi_ops snd_usbmidi_output_ops = { .open = snd_usbmidi_output_open, .close = snd_usbmidi_output_close, .trigger = snd_usbmidi_output_trigger, .drain = snd_usbmidi_output_drain, }; static const struct snd_rawmidi_ops snd_usbmidi_input_ops = { .open = snd_usbmidi_input_open, .close = snd_usbmidi_input_close, .trigger = snd_usbmidi_input_trigger }; static void free_urb_and_buffer(struct snd_usb_midi *umidi, struct urb *urb, unsigned int buffer_length) { usb_free_coherent(umidi->dev, buffer_length, urb->transfer_buffer, urb->transfer_dma); usb_free_urb(urb); } /* * Frees an input endpoint. * May be called when ep hasn't been initialized completely. */ static void snd_usbmidi_in_endpoint_delete(struct snd_usb_midi_in_endpoint *ep) { unsigned int i; for (i = 0; i < INPUT_URBS; ++i) if (ep->urbs[i]) free_urb_and_buffer(ep->umidi, ep->urbs[i], ep->urbs[i]->transfer_buffer_length); kfree(ep); } /* * Creates an input endpoint. */ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *ep_info, struct snd_usb_midi_endpoint *rep) { struct snd_usb_midi_in_endpoint *ep; void *buffer; unsigned int pipe; int length; unsigned int i; int err; rep->in = NULL; ep = kzalloc(sizeof(*ep), GFP_KERNEL); if (!ep) return -ENOMEM; ep->umidi = umidi; for (i = 0; i < INPUT_URBS; ++i) { ep->urbs[i] = usb_alloc_urb(0, GFP_KERNEL); if (!ep->urbs[i]) { err = -ENOMEM; goto error; } } if (ep_info->in_interval) pipe = usb_rcvintpipe(umidi->dev, ep_info->in_ep); else pipe = usb_rcvbulkpipe(umidi->dev, ep_info->in_ep); length = usb_maxpacket(umidi->dev, pipe); for (i = 0; i < INPUT_URBS; ++i) { buffer = usb_alloc_coherent(umidi->dev, length, GFP_KERNEL, &ep->urbs[i]->transfer_dma); if (!buffer) { err = -ENOMEM; goto error; } if (ep_info->in_interval) usb_fill_int_urb(ep->urbs[i], umidi->dev, pipe, buffer, length, snd_usbmidi_in_urb_complete, ep, ep_info->in_interval); else usb_fill_bulk_urb(ep->urbs[i], umidi->dev, pipe, buffer, length, snd_usbmidi_in_urb_complete, ep); ep->urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP; err = usb_urb_ep_type_check(ep->urbs[i]); if (err < 0) { dev_err(&umidi->dev->dev, "invalid MIDI in EP %x\n", ep_info->in_ep); goto error; } } rep->in = ep; return 0; error: snd_usbmidi_in_endpoint_delete(ep); return err; } /* * Frees an output endpoint. * May be called when ep hasn't been initialized completely. */ static void snd_usbmidi_out_endpoint_clear(struct snd_usb_midi_out_endpoint *ep) { unsigned int i; for (i = 0; i < OUTPUT_URBS; ++i) if (ep->urbs[i].urb) { free_urb_and_buffer(ep->umidi, ep->urbs[i].urb, ep->max_transfer); ep->urbs[i].urb = NULL; } } static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint *ep) { snd_usbmidi_out_endpoint_clear(ep); kfree(ep); } /* * Creates an output endpoint, and initializes output ports. */ static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *ep_info, struct snd_usb_midi_endpoint *rep) { struct snd_usb_midi_out_endpoint *ep; unsigned int i; unsigned int pipe; void *buffer; int err; rep->out = NULL; ep = kzalloc(sizeof(*ep), GFP_KERNEL); if (!ep) return -ENOMEM; ep->umidi = umidi; for (i = 0; i < OUTPUT_URBS; ++i) { ep->urbs[i].urb = usb_alloc_urb(0, GFP_KERNEL); if (!ep->urbs[i].urb) { err = -ENOMEM; goto error; } ep->urbs[i].ep = ep; } if (ep_info->out_interval) pipe = usb_sndintpipe(umidi->dev, ep_info->out_ep); else pipe = usb_sndbulkpipe(umidi->dev, ep_info->out_ep); switch (umidi->usb_id) { default: ep->max_transfer = usb_maxpacket(umidi->dev, pipe); break; /* * Various chips declare a packet size larger than 4 bytes, but * do not actually work with larger packets: */ case USB_ID(0x0a67, 0x5011): /* Medeli DD305 */ case USB_ID(0x0a92, 0x1020): /* ESI M4U */ case USB_ID(0x1430, 0x474b): /* RedOctane GH MIDI INTERFACE */ case USB_ID(0x15ca, 0x0101): /* Textech USB Midi Cable */ case USB_ID(0x15ca, 0x1806): /* Textech USB Midi Cable */ case USB_ID(0x1a86, 0x752d): /* QinHeng CH345 "USB2.0-MIDI" */ case USB_ID(0xfc08, 0x0101): /* Unknown vendor Cable */ ep->max_transfer = 4; break; /* * Some devices only work with 9 bytes packet size: */ case USB_ID(0x0644, 0x800e): /* Tascam US-122L */ case USB_ID(0x0644, 0x800f): /* Tascam US-144 */ ep->max_transfer = 9; break; } for (i = 0; i < OUTPUT_URBS; ++i) { buffer = usb_alloc_coherent(umidi->dev, ep->max_transfer, GFP_KERNEL, &ep->urbs[i].urb->transfer_dma); if (!buffer) { err = -ENOMEM; goto error; } if (ep_info->out_interval) usb_fill_int_urb(ep->urbs[i].urb, umidi->dev, pipe, buffer, ep->max_transfer, snd_usbmidi_out_urb_complete, &ep->urbs[i], ep_info->out_interval); else usb_fill_bulk_urb(ep->urbs[i].urb, umidi->dev, pipe, buffer, ep->max_transfer, snd_usbmidi_out_urb_complete, &ep->urbs[i]); err = usb_urb_ep_type_check(ep->urbs[i].urb); if (err < 0) { dev_err(&umidi->dev->dev, "invalid MIDI out EP %x\n", ep_info->out_ep); goto error; } ep->urbs[i].urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; } spin_lock_init(&ep->buffer_lock); INIT_WORK(&ep->work, snd_usbmidi_out_work); init_waitqueue_head(&ep->drain_wait); for (i = 0; i < 0x10; ++i) if (ep_info->out_cables & (1 << i)) { ep->ports[i].ep = ep; ep->ports[i].cable = i << 4; } if (umidi->usb_protocol_ops->init_out_endpoint) umidi->usb_protocol_ops->init_out_endpoint(ep); rep->out = ep; return 0; error: snd_usbmidi_out_endpoint_delete(ep); return err; } /* * Frees everything. */ static void snd_usbmidi_free(struct snd_usb_midi *umidi) { int i; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i]; if (ep->out) snd_usbmidi_out_endpoint_delete(ep->out); if (ep->in) snd_usbmidi_in_endpoint_delete(ep->in); } mutex_destroy(&umidi->mutex); kfree(umidi); } /* * Unlinks all URBs (must be done before the usb_device is deleted). */ void snd_usbmidi_disconnect(struct list_head *p) { struct snd_usb_midi *umidi; unsigned int i, j; umidi = list_entry(p, struct snd_usb_midi, list); /* * an URB's completion handler may start the timer and * a timer may submit an URB. To reliably break the cycle * a flag under lock must be used */ down_write(&umidi->disc_rwsem); spin_lock_irq(&umidi->disc_lock); umidi->disconnected = 1; spin_unlock_irq(&umidi->disc_lock); up_write(&umidi->disc_rwsem); del_timer_sync(&umidi->error_timer); for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i]; if (ep->out) cancel_work_sync(&ep->out->work); if (ep->out) { for (j = 0; j < OUTPUT_URBS; ++j) usb_kill_urb(ep->out->urbs[j].urb); if (umidi->usb_protocol_ops->finish_out_endpoint) umidi->usb_protocol_ops->finish_out_endpoint(ep->out); ep->out->active_urbs = 0; if (ep->out->drain_urbs) { ep->out->drain_urbs = 0; wake_up(&ep->out->drain_wait); } } if (ep->in) for (j = 0; j < INPUT_URBS; ++j) usb_kill_urb(ep->in->urbs[j]); /* free endpoints here; later call can result in Oops */ if (ep->out) snd_usbmidi_out_endpoint_clear(ep->out); if (ep->in) { snd_usbmidi_in_endpoint_delete(ep->in); ep->in = NULL; } } } EXPORT_SYMBOL(snd_usbmidi_disconnect); static void snd_usbmidi_rawmidi_free(struct snd_rawmidi *rmidi) { struct snd_usb_midi *umidi = rmidi->private_data; snd_usbmidi_free(umidi); } static struct snd_rawmidi_substream *snd_usbmidi_find_substream(struct snd_usb_midi *umidi, int stream, int number) { struct snd_rawmidi_substream *substream; list_for_each_entry(substream, &umidi->rmidi->streams[stream].substreams, list) { if (substream->number == number) return substream; } return NULL; } /* * This list specifies names for ports that do not fit into the standard * "(product) MIDI (n)" schema because they aren't external MIDI ports, * such as internal control or synthesizer ports. */ static struct port_info { u32 id; short int port; short int voices; const char *name; unsigned int seq_flags; } snd_usbmidi_port_info[] = { #define PORT_INFO(vendor, product, num, name_, voices_, flags) \ { .id = USB_ID(vendor, product), \ .port = num, .voices = voices_, \ .name = name_, .seq_flags = flags } #define EXTERNAL_PORT(vendor, product, num, name) \ PORT_INFO(vendor, product, num, name, 0, \ SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \ SNDRV_SEQ_PORT_TYPE_HARDWARE | \ SNDRV_SEQ_PORT_TYPE_PORT) #define CONTROL_PORT(vendor, product, num, name) \ PORT_INFO(vendor, product, num, name, 0, \ SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \ SNDRV_SEQ_PORT_TYPE_HARDWARE) #define GM_SYNTH_PORT(vendor, product, num, name, voices) \ PORT_INFO(vendor, product, num, name, voices, \ SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \ SNDRV_SEQ_PORT_TYPE_MIDI_GM | \ SNDRV_SEQ_PORT_TYPE_HARDWARE | \ SNDRV_SEQ_PORT_TYPE_SYNTHESIZER) #define ROLAND_SYNTH_PORT(vendor, product, num, name, voices) \ PORT_INFO(vendor, product, num, name, voices, \ SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \ SNDRV_SEQ_PORT_TYPE_MIDI_GM | \ SNDRV_SEQ_PORT_TYPE_MIDI_GM2 | \ SNDRV_SEQ_PORT_TYPE_MIDI_GS | \ SNDRV_SEQ_PORT_TYPE_MIDI_XG | \ SNDRV_SEQ_PORT_TYPE_HARDWARE | \ SNDRV_SEQ_PORT_TYPE_SYNTHESIZER) #define SOUNDCANVAS_PORT(vendor, product, num, name, voices) \ PORT_INFO(vendor, product, num, name, voices, \ SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | \ SNDRV_SEQ_PORT_TYPE_MIDI_GM | \ SNDRV_SEQ_PORT_TYPE_MIDI_GM2 | \ SNDRV_SEQ_PORT_TYPE_MIDI_GS | \ SNDRV_SEQ_PORT_TYPE_MIDI_XG | \ SNDRV_SEQ_PORT_TYPE_MIDI_MT32 | \ SNDRV_SEQ_PORT_TYPE_HARDWARE | \ SNDRV_SEQ_PORT_TYPE_SYNTHESIZER) /* Yamaha MOTIF XF */ GM_SYNTH_PORT(0x0499, 0x105c, 0, "%s Tone Generator", 128), CONTROL_PORT(0x0499, 0x105c, 1, "%s Remote Control"), EXTERNAL_PORT(0x0499, 0x105c, 2, "%s Thru"), CONTROL_PORT(0x0499, 0x105c, 3, "%s Editor"), /* Roland UA-100 */ CONTROL_PORT(0x0582, 0x0000, 2, "%s Control"), /* Roland SC-8850 */ SOUNDCANVAS_PORT(0x0582, 0x0003, 0, "%s Part A", 128), SOUNDCANVAS_PORT(0x0582, 0x0003, 1, "%s Part B", 128), SOUNDCANVAS_PORT(0x0582, 0x0003, 2, "%s Part C", 128), SOUNDCANVAS_PORT(0x0582, 0x0003, 3, "%s Part D", 128), EXTERNAL_PORT(0x0582, 0x0003, 4, "%s MIDI 1"), EXTERNAL_PORT(0x0582, 0x0003, 5, "%s MIDI 2"), /* Roland U-8 */ EXTERNAL_PORT(0x0582, 0x0004, 0, "%s MIDI"), CONTROL_PORT(0x0582, 0x0004, 1, "%s Control"), /* Roland SC-8820 */ SOUNDCANVAS_PORT(0x0582, 0x0007, 0, "%s Part A", 64), SOUNDCANVAS_PORT(0x0582, 0x0007, 1, "%s Part B", 64), EXTERNAL_PORT(0x0582, 0x0007, 2, "%s MIDI"), /* Roland SK-500 */ SOUNDCANVAS_PORT(0x0582, 0x000b, 0, "%s Part A", 64), SOUNDCANVAS_PORT(0x0582, 0x000b, 1, "%s Part B", 64), EXTERNAL_PORT(0x0582, 0x000b, 2, "%s MIDI"), /* Roland SC-D70 */ SOUNDCANVAS_PORT(0x0582, 0x000c, 0, "%s Part A", 64), SOUNDCANVAS_PORT(0x0582, 0x000c, 1, "%s Part B", 64), EXTERNAL_PORT(0x0582, 0x000c, 2, "%s MIDI"), /* Edirol UM-880 */ CONTROL_PORT(0x0582, 0x0014, 8, "%s Control"), /* Edirol SD-90 */ ROLAND_SYNTH_PORT(0x0582, 0x0016, 0, "%s Part A", 128), ROLAND_SYNTH_PORT(0x0582, 0x0016, 1, "%s Part B", 128), EXTERNAL_PORT(0x0582, 0x0016, 2, "%s MIDI 1"), EXTERNAL_PORT(0x0582, 0x0016, 3, "%s MIDI 2"), /* Edirol UM-550 */ CONTROL_PORT(0x0582, 0x0023, 5, "%s Control"), /* Edirol SD-20 */ ROLAND_SYNTH_PORT(0x0582, 0x0027, 0, "%s Part A", 64), ROLAND_SYNTH_PORT(0x0582, 0x0027, 1, "%s Part B", 64), EXTERNAL_PORT(0x0582, 0x0027, 2, "%s MIDI"), /* Edirol SD-80 */ ROLAND_SYNTH_PORT(0x0582, 0x0029, 0, "%s Part A", 128), ROLAND_SYNTH_PORT(0x0582, 0x0029, 1, "%s Part B", 128), EXTERNAL_PORT(0x0582, 0x0029, 2, "%s MIDI 1"), EXTERNAL_PORT(0x0582, 0x0029, 3, "%s MIDI 2"), /* Edirol UA-700 */ EXTERNAL_PORT(0x0582, 0x002b, 0, "%s MIDI"), CONTROL_PORT(0x0582, 0x002b, 1, "%s Control"), /* Roland VariOS */ EXTERNAL_PORT(0x0582, 0x002f, 0, "%s MIDI"), EXTERNAL_PORT(0x0582, 0x002f, 1, "%s External MIDI"), EXTERNAL_PORT(0x0582, 0x002f, 2, "%s Sync"), /* Edirol PCR */ EXTERNAL_PORT(0x0582, 0x0033, 0, "%s MIDI"), EXTERNAL_PORT(0x0582, 0x0033, 1, "%s 1"), EXTERNAL_PORT(0x0582, 0x0033, 2, "%s 2"), /* BOSS GS-10 */ EXTERNAL_PORT(0x0582, 0x003b, 0, "%s MIDI"), CONTROL_PORT(0x0582, 0x003b, 1, "%s Control"), /* Edirol UA-1000 */ EXTERNAL_PORT(0x0582, 0x0044, 0, "%s MIDI"), CONTROL_PORT(0x0582, 0x0044, 1, "%s Control"), /* Edirol UR-80 */ EXTERNAL_PORT(0x0582, 0x0048, 0, "%s MIDI"), EXTERNAL_PORT(0x0582, 0x0048, 1, "%s 1"), EXTERNAL_PORT(0x0582, 0x0048, 2, "%s 2"), /* Edirol PCR-A */ EXTERNAL_PORT(0x0582, 0x004d, 0, "%s MIDI"), EXTERNAL_PORT(0x0582, 0x004d, 1, "%s 1"), EXTERNAL_PORT(0x0582, 0x004d, 2, "%s 2"), /* BOSS GT-PRO */ CONTROL_PORT(0x0582, 0x0089, 0, "%s Control"), /* Edirol UM-3EX */ CONTROL_PORT(0x0582, 0x009a, 3, "%s Control"), /* Roland VG-99 */ CONTROL_PORT(0x0582, 0x00b2, 0, "%s Control"), EXTERNAL_PORT(0x0582, 0x00b2, 1, "%s MIDI"), /* Cakewalk Sonar V-Studio 100 */ EXTERNAL_PORT(0x0582, 0x00eb, 0, "%s MIDI"), CONTROL_PORT(0x0582, 0x00eb, 1, "%s Control"), /* Roland VB-99 */ CONTROL_PORT(0x0582, 0x0102, 0, "%s Control"), EXTERNAL_PORT(0x0582, 0x0102, 1, "%s MIDI"), /* Roland A-PRO */ EXTERNAL_PORT(0x0582, 0x010f, 0, "%s MIDI"), CONTROL_PORT(0x0582, 0x010f, 1, "%s 1"), CONTROL_PORT(0x0582, 0x010f, 2, "%s 2"), /* Roland SD-50 */ ROLAND_SYNTH_PORT(0x0582, 0x0114, 0, "%s Synth", 128), EXTERNAL_PORT(0x0582, 0x0114, 1, "%s MIDI"), CONTROL_PORT(0x0582, 0x0114, 2, "%s Control"), /* Roland OCTA-CAPTURE */ EXTERNAL_PORT(0x0582, 0x0120, 0, "%s MIDI"), CONTROL_PORT(0x0582, 0x0120, 1, "%s Control"), EXTERNAL_PORT(0x0582, 0x0121, 0, "%s MIDI"), CONTROL_PORT(0x0582, 0x0121, 1, "%s Control"), /* Roland SPD-SX */ CONTROL_PORT(0x0582, 0x0145, 0, "%s Control"), EXTERNAL_PORT(0x0582, 0x0145, 1, "%s MIDI"), /* Roland A-Series */ CONTROL_PORT(0x0582, 0x0156, 0, "%s Keyboard"), EXTERNAL_PORT(0x0582, 0x0156, 1, "%s MIDI"), /* Roland INTEGRA-7 */ ROLAND_SYNTH_PORT(0x0582, 0x015b, 0, "%s Synth", 128), CONTROL_PORT(0x0582, 0x015b, 1, "%s Control"), /* M-Audio MidiSport 8x8 */ CONTROL_PORT(0x0763, 0x1031, 8, "%s Control"), CONTROL_PORT(0x0763, 0x1033, 8, "%s Control"), /* MOTU Fastlane */ EXTERNAL_PORT(0x07fd, 0x0001, 0, "%s MIDI A"), EXTERNAL_PORT(0x07fd, 0x0001, 1, "%s MIDI B"), /* Emagic Unitor8/AMT8/MT4 */ EXTERNAL_PORT(0x086a, 0x0001, 8, "%s Broadcast"), EXTERNAL_PORT(0x086a, 0x0002, 8, "%s Broadcast"), EXTERNAL_PORT(0x086a, 0x0003, 4, "%s Broadcast"), /* Akai MPD16 */ CONTROL_PORT(0x09e8, 0x0062, 0, "%s Control"), PORT_INFO(0x09e8, 0x0062, 1, "%s MIDI", 0, SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | SNDRV_SEQ_PORT_TYPE_HARDWARE), /* Access Music Virus TI */ EXTERNAL_PORT(0x133e, 0x0815, 0, "%s MIDI"), PORT_INFO(0x133e, 0x0815, 1, "%s Synth", 0, SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC | SNDRV_SEQ_PORT_TYPE_HARDWARE | SNDRV_SEQ_PORT_TYPE_SYNTHESIZER), }; static struct port_info *find_port_info(struct snd_usb_midi *umidi, int number) { int i; for (i = 0; i < ARRAY_SIZE(snd_usbmidi_port_info); ++i) { if (snd_usbmidi_port_info[i].id == umidi->usb_id && snd_usbmidi_port_info[i].port == number) return &snd_usbmidi_port_info[i]; } return NULL; } static void snd_usbmidi_get_port_info(struct snd_rawmidi *rmidi, int number, struct snd_seq_port_info *seq_port_info) { struct snd_usb_midi *umidi = rmidi->private_data; struct port_info *port_info; /* TODO: read port flags from descriptors */ port_info = find_port_info(umidi, number); if (port_info) { seq_port_info->type = port_info->seq_flags; seq_port_info->midi_voices = port_info->voices; } } static struct usb_midi_in_jack_descriptor *find_usb_in_jack_descriptor( struct usb_host_interface *hostif, uint8_t jack_id) { unsigned char *extra = hostif->extra; int extralen = hostif->extralen; while (extralen > 4) { struct usb_midi_in_jack_descriptor *injd = (struct usb_midi_in_jack_descriptor *)extra; if (injd->bLength >= sizeof(*injd) && injd->bDescriptorType == USB_DT_CS_INTERFACE && injd->bDescriptorSubtype == UAC_MIDI_IN_JACK && injd->bJackID == jack_id) return injd; if (!extra[0]) break; extralen -= extra[0]; extra += extra[0]; } return NULL; } static struct usb_midi_out_jack_descriptor *find_usb_out_jack_descriptor( struct usb_host_interface *hostif, uint8_t jack_id) { unsigned char *extra = hostif->extra; int extralen = hostif->extralen; while (extralen > 4) { struct usb_midi_out_jack_descriptor *outjd = (struct usb_midi_out_jack_descriptor *)extra; if (outjd->bLength >= sizeof(*outjd) && outjd->bDescriptorType == USB_DT_CS_INTERFACE && outjd->bDescriptorSubtype == UAC_MIDI_OUT_JACK && outjd->bJackID == jack_id) return outjd; if (!extra[0]) break; extralen -= extra[0]; extra += extra[0]; } return NULL; } static void snd_usbmidi_init_substream(struct snd_usb_midi *umidi, int stream, int number, int jack_id, struct snd_rawmidi_substream **rsubstream) { struct port_info *port_info; const char *name_format; struct usb_interface *intf; struct usb_host_interface *hostif; struct usb_midi_in_jack_descriptor *injd; struct usb_midi_out_jack_descriptor *outjd; uint8_t jack_name_buf[32]; uint8_t *default_jack_name = "MIDI"; uint8_t *jack_name = default_jack_name; uint8_t iJack; size_t sz; int res; struct snd_rawmidi_substream *substream = snd_usbmidi_find_substream(umidi, stream, number); if (!substream) { dev_err(&umidi->dev->dev, "substream %d:%d not found\n", stream, number); return; } intf = umidi->iface; if (intf && jack_id >= 0) { hostif = intf->cur_altsetting; iJack = 0; if (stream != SNDRV_RAWMIDI_STREAM_OUTPUT) { /* in jacks connect to outs */ outjd = find_usb_out_jack_descriptor(hostif, jack_id); if (outjd) { sz = USB_DT_MIDI_OUT_SIZE(outjd->bNrInputPins); if (outjd->bLength >= sz) iJack = *(((uint8_t *) outjd) + sz - sizeof(uint8_t)); } } else { /* and out jacks connect to ins */ injd = find_usb_in_jack_descriptor(hostif, jack_id); if (injd) iJack = injd->iJack; } if (iJack != 0) { res = usb_string(umidi->dev, iJack, jack_name_buf, ARRAY_SIZE(jack_name_buf)); if (res) jack_name = jack_name_buf; } } port_info = find_port_info(umidi, number); name_format = port_info ? port_info->name : (jack_name != default_jack_name ? "%s %s" : "%s %s %d"); snprintf(substream->name, sizeof(substream->name), name_format, umidi->card->shortname, jack_name, number + 1); *rsubstream = substream; } /* * Creates the endpoints and their ports. */ static int snd_usbmidi_create_endpoints(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *endpoints) { int i, j, err; int out_ports = 0, in_ports = 0; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { if (endpoints[i].out_cables) { err = snd_usbmidi_out_endpoint_create(umidi, &endpoints[i], &umidi->endpoints[i]); if (err < 0) return err; } if (endpoints[i].in_cables) { err = snd_usbmidi_in_endpoint_create(umidi, &endpoints[i], &umidi->endpoints[i]); if (err < 0) return err; } for (j = 0; j < 0x10; ++j) { if (endpoints[i].out_cables & (1 << j)) { snd_usbmidi_init_substream(umidi, SNDRV_RAWMIDI_STREAM_OUTPUT, out_ports, endpoints[i].assoc_out_jacks[j], &umidi->endpoints[i].out->ports[j].substream); ++out_ports; } if (endpoints[i].in_cables & (1 << j)) { snd_usbmidi_init_substream(umidi, SNDRV_RAWMIDI_STREAM_INPUT, in_ports, endpoints[i].assoc_in_jacks[j], &umidi->endpoints[i].in->ports[j].substream); ++in_ports; } } } dev_dbg(&umidi->dev->dev, "created %d output and %d input ports\n", out_ports, in_ports); return 0; } static struct usb_ms_endpoint_descriptor *find_usb_ms_endpoint_descriptor( struct usb_host_endpoint *hostep) { unsigned char *extra = hostep->extra; int extralen = hostep->extralen; while (extralen > 3) { struct usb_ms_endpoint_descriptor *ms_ep = (struct usb_ms_endpoint_descriptor *)extra; if (ms_ep->bLength > 3 && ms_ep->bDescriptorType == USB_DT_CS_ENDPOINT && ms_ep->bDescriptorSubtype == UAC_MS_GENERAL) return ms_ep; if (!extra[0]) break; extralen -= extra[0]; extra += extra[0]; } return NULL; } /* * Returns MIDIStreaming device capabilities. */ static int snd_usbmidi_get_ms_info(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *endpoints) { struct usb_interface *intf; struct usb_host_interface *hostif; struct usb_interface_descriptor *intfd; struct usb_ms_header_descriptor *ms_header; struct usb_host_endpoint *hostep; struct usb_endpoint_descriptor *ep; struct usb_ms_endpoint_descriptor *ms_ep; int i, j, epidx; intf = umidi->iface; if (!intf) return -ENXIO; hostif = &intf->altsetting[0]; intfd = get_iface_desc(hostif); ms_header = (struct usb_ms_header_descriptor *)hostif->extra; if (hostif->extralen >= 7 && ms_header->bLength >= 7 && ms_header->bDescriptorType == USB_DT_CS_INTERFACE && ms_header->bDescriptorSubtype == UAC_HEADER) dev_dbg(&umidi->dev->dev, "MIDIStreaming version %02x.%02x\n", ((uint8_t *)&ms_header->bcdMSC)[1], ((uint8_t *)&ms_header->bcdMSC)[0]); else dev_warn(&umidi->dev->dev, "MIDIStreaming interface descriptor not found\n"); epidx = 0; for (i = 0; i < intfd->bNumEndpoints; ++i) { hostep = &hostif->endpoint[i]; ep = get_ep_desc(hostep); if (!usb_endpoint_xfer_bulk(ep) && !usb_endpoint_xfer_int(ep)) continue; ms_ep = find_usb_ms_endpoint_descriptor(hostep); if (!ms_ep) continue; if (ms_ep->bLength <= sizeof(*ms_ep)) continue; if (ms_ep->bNumEmbMIDIJack > 0x10) continue; if (ms_ep->bLength < sizeof(*ms_ep) + ms_ep->bNumEmbMIDIJack) continue; if (usb_endpoint_dir_out(ep)) { if (endpoints[epidx].out_ep) { if (++epidx >= MIDI_MAX_ENDPOINTS) { dev_warn(&umidi->dev->dev, "too many endpoints\n"); break; } } endpoints[epidx].out_ep = usb_endpoint_num(ep); if (usb_endpoint_xfer_int(ep)) endpoints[epidx].out_interval = ep->bInterval; else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW) /* * Low speed bulk transfers don't exist, so * force interrupt transfers for devices like * ESI MIDI Mate that try to use them anyway. */ endpoints[epidx].out_interval = 1; endpoints[epidx].out_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1; for (j = 0; j < ms_ep->bNumEmbMIDIJack; ++j) endpoints[epidx].assoc_out_jacks[j] = ms_ep->baAssocJackID[j]; for (; j < ARRAY_SIZE(endpoints[epidx].assoc_out_jacks); ++j) endpoints[epidx].assoc_out_jacks[j] = -1; dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n", ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack); } else { if (endpoints[epidx].in_ep) { if (++epidx >= MIDI_MAX_ENDPOINTS) { dev_warn(&umidi->dev->dev, "too many endpoints\n"); break; } } endpoints[epidx].in_ep = usb_endpoint_num(ep); if (usb_endpoint_xfer_int(ep)) endpoints[epidx].in_interval = ep->bInterval; else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW) endpoints[epidx].in_interval = 1; endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1; for (j = 0; j < ms_ep->bNumEmbMIDIJack; ++j) endpoints[epidx].assoc_in_jacks[j] = ms_ep->baAssocJackID[j]; for (; j < ARRAY_SIZE(endpoints[epidx].assoc_in_jacks); ++j) endpoints[epidx].assoc_in_jacks[j] = -1; dev_dbg(&umidi->dev->dev, "EP %02X: %d jack(s)\n", ep->bEndpointAddress, ms_ep->bNumEmbMIDIJack); } } return 0; } static int roland_load_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *info) { static const char *const names[] = { "High Load", "Light Load" }; return snd_ctl_enum_info(info, 1, 2, names); } static int roland_load_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *value) { value->value.enumerated.item[0] = kcontrol->private_value; return 0; } static int roland_load_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *value) { struct snd_usb_midi *umidi = kcontrol->private_data; int changed; if (value->value.enumerated.item[0] > 1) return -EINVAL; mutex_lock(&umidi->mutex); changed = value->value.enumerated.item[0] != kcontrol->private_value; if (changed) kcontrol->private_value = value->value.enumerated.item[0]; mutex_unlock(&umidi->mutex); return changed; } static const struct snd_kcontrol_new roland_load_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "MIDI Input Mode", .info = roland_load_info, .get = roland_load_get, .put = roland_load_put, .private_value = 1, }; /* * On Roland devices, use the second alternate setting to be able to use * the interrupt input endpoint. */ static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi *umidi) { struct usb_interface *intf; struct usb_host_interface *hostif; struct usb_interface_descriptor *intfd; intf = umidi->iface; if (!intf || intf->num_altsetting != 2) return; hostif = &intf->altsetting[1]; intfd = get_iface_desc(hostif); /* If either or both of the endpoints support interrupt transfer, * then use the alternate setting */ if (intfd->bNumEndpoints != 2 || !((get_endpoint(hostif, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT || (get_endpoint(hostif, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) return; dev_dbg(&umidi->dev->dev, "switching to altsetting %d with int ep\n", intfd->bAlternateSetting); usb_set_interface(umidi->dev, intfd->bInterfaceNumber, intfd->bAlternateSetting); umidi->roland_load_ctl = snd_ctl_new1(&roland_load_ctl, umidi); if (snd_ctl_add(umidi->card, umidi->roland_load_ctl) < 0) umidi->roland_load_ctl = NULL; } /* * Try to find any usable endpoints in the interface. */ static int snd_usbmidi_detect_endpoints(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *endpoint, int max_endpoints) { struct usb_interface *intf; struct usb_host_interface *hostif; struct usb_interface_descriptor *intfd; struct usb_endpoint_descriptor *epd; int i, out_eps = 0, in_eps = 0; if (USB_ID_VENDOR(umidi->usb_id) == 0x0582) snd_usbmidi_switch_roland_altsetting(umidi); if (endpoint[0].out_ep || endpoint[0].in_ep) return 0; intf = umidi->iface; if (!intf || intf->num_altsetting < 1) return -ENOENT; hostif = intf->cur_altsetting; intfd = get_iface_desc(hostif); for (i = 0; i < intfd->bNumEndpoints; ++i) { epd = get_endpoint(hostif, i); if (!usb_endpoint_xfer_bulk(epd) && !usb_endpoint_xfer_int(epd)) continue; if (out_eps < max_endpoints && usb_endpoint_dir_out(epd)) { endpoint[out_eps].out_ep = usb_endpoint_num(epd); if (usb_endpoint_xfer_int(epd)) endpoint[out_eps].out_interval = epd->bInterval; ++out_eps; } if (in_eps < max_endpoints && usb_endpoint_dir_in(epd)) { endpoint[in_eps].in_ep = usb_endpoint_num(epd); if (usb_endpoint_xfer_int(epd)) endpoint[in_eps].in_interval = epd->bInterval; ++in_eps; } } return (out_eps || in_eps) ? 0 : -ENOENT; } /* * Detects the endpoints for one-port-per-endpoint protocols. */ static int snd_usbmidi_detect_per_port_endpoints(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *endpoints) { int err, i; err = snd_usbmidi_detect_endpoints(umidi, endpoints, MIDI_MAX_ENDPOINTS); for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { if (endpoints[i].out_ep) endpoints[i].out_cables = 0x0001; if (endpoints[i].in_ep) endpoints[i].in_cables = 0x0001; } return err; } /* * Detects the endpoints and ports of Yamaha devices. */ static int snd_usbmidi_detect_yamaha(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *endpoint) { struct usb_interface *intf; struct usb_host_interface *hostif; struct usb_interface_descriptor *intfd; uint8_t *cs_desc; intf = umidi->iface; if (!intf) return -ENOENT; hostif = intf->altsetting; intfd = get_iface_desc(hostif); if (intfd->bNumEndpoints < 1) return -ENOENT; /* * For each port there is one MIDI_IN/OUT_JACK descriptor, not * necessarily with any useful contents. So simply count 'em. */ for (cs_desc = hostif->extra; cs_desc < hostif->extra + hostif->extralen && cs_desc[0] >= 2; cs_desc += cs_desc[0]) { if (cs_desc[1] == USB_DT_CS_INTERFACE) { if (cs_desc[2] == UAC_MIDI_IN_JACK) endpoint->in_cables = (endpoint->in_cables << 1) | 1; else if (cs_desc[2] == UAC_MIDI_OUT_JACK) endpoint->out_cables = (endpoint->out_cables << 1) | 1; } } if (!endpoint->in_cables && !endpoint->out_cables) return -ENOENT; return snd_usbmidi_detect_endpoints(umidi, endpoint, 1); } /* * Detects the endpoints and ports of Roland devices. */ static int snd_usbmidi_detect_roland(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *endpoint) { struct usb_interface *intf; struct usb_host_interface *hostif; u8 *cs_desc; intf = umidi->iface; if (!intf) return -ENOENT; hostif = intf->altsetting; /* * Some devices have a descriptor <06 24 F1 02 <inputs> <outputs>>, * some have standard class descriptors, or both kinds, or neither. */ for (cs_desc = hostif->extra; cs_desc < hostif->extra + hostif->extralen && cs_desc[0] >= 2; cs_desc += cs_desc[0]) { if (cs_desc[0] >= 6 && cs_desc[1] == USB_DT_CS_INTERFACE && cs_desc[2] == 0xf1 && cs_desc[3] == 0x02) { if (cs_desc[4] > 0x10 || cs_desc[5] > 0x10) continue; endpoint->in_cables = (1 << cs_desc[4]) - 1; endpoint->out_cables = (1 << cs_desc[5]) - 1; return snd_usbmidi_detect_endpoints(umidi, endpoint, 1); } else if (cs_desc[0] >= 7 && cs_desc[1] == USB_DT_CS_INTERFACE && cs_desc[2] == UAC_HEADER) { return snd_usbmidi_get_ms_info(umidi, endpoint); } } return -ENODEV; } /* * Creates the endpoints and their ports for Midiman devices. */ static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi *umidi, struct snd_usb_midi_endpoint_info *endpoint) { struct snd_usb_midi_endpoint_info ep_info; struct usb_interface *intf; struct usb_host_interface *hostif; struct usb_interface_descriptor *intfd; struct usb_endpoint_descriptor *epd; int cable, err; intf = umidi->iface; if (!intf) return -ENOENT; hostif = intf->altsetting; intfd = get_iface_desc(hostif); /* * The various MidiSport devices have more or less random endpoint * numbers, so we have to identify the endpoints by their index in * the descriptor array, like the driver for that other OS does. * * There is one interrupt input endpoint for all input ports, one * bulk output endpoint for even-numbered ports, and one for odd- * numbered ports. Both bulk output endpoints have corresponding * input bulk endpoints (at indices 1 and 3) which aren't used. */ if (intfd->bNumEndpoints < (endpoint->out_cables > 0x0001 ? 5 : 3)) { dev_dbg(&umidi->dev->dev, "not enough endpoints\n"); return -ENOENT; } epd = get_endpoint(hostif, 0); if (!usb_endpoint_dir_in(epd) || !usb_endpoint_xfer_int(epd)) { dev_dbg(&umidi->dev->dev, "endpoint[0] isn't interrupt\n"); return -ENXIO; } epd = get_endpoint(hostif, 2); if (!usb_endpoint_dir_out(epd) || !usb_endpoint_xfer_bulk(epd)) { dev_dbg(&umidi->dev->dev, "endpoint[2] isn't bulk output\n"); return -ENXIO; } if (endpoint->out_cables > 0x0001) { epd = get_endpoint(hostif, 4); if (!usb_endpoint_dir_out(epd) || !usb_endpoint_xfer_bulk(epd)) { dev_dbg(&umidi->dev->dev, "endpoint[4] isn't bulk output\n"); return -ENXIO; } } ep_info.out_ep = get_endpoint(hostif, 2)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; ep_info.out_interval = 0; ep_info.out_cables = endpoint->out_cables & 0x5555; err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]); if (err < 0) return err; ep_info.in_ep = get_endpoint(hostif, 0)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; ep_info.in_interval = get_endpoint(hostif, 0)->bInterval; ep_info.in_cables = endpoint->in_cables; err = snd_usbmidi_in_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]); if (err < 0) return err; if (endpoint->out_cables > 0x0001) { ep_info.out_ep = get_endpoint(hostif, 4)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; ep_info.out_cables = endpoint->out_cables & 0xaaaa; err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[1]); if (err < 0) return err; } for (cable = 0; cable < 0x10; ++cable) { if (endpoint->out_cables & (1 << cable)) snd_usbmidi_init_substream(umidi, SNDRV_RAWMIDI_STREAM_OUTPUT, cable, -1 /* prevent trying to find jack */, &umidi->endpoints[cable & 1].out->ports[cable].substream); if (endpoint->in_cables & (1 << cable)) snd_usbmidi_init_substream(umidi, SNDRV_RAWMIDI_STREAM_INPUT, cable, -1 /* prevent trying to find jack */, &umidi->endpoints[0].in->ports[cable].substream); } return 0; } static const struct snd_rawmidi_global_ops snd_usbmidi_ops = { .get_port_info = snd_usbmidi_get_port_info, }; static int snd_usbmidi_create_rawmidi(struct snd_usb_midi *umidi, int out_ports, int in_ports) { struct snd_rawmidi *rmidi; int err; err = snd_rawmidi_new(umidi->card, "USB MIDI", umidi->next_midi_device++, out_ports, in_ports, &rmidi); if (err < 0) return err; strcpy(rmidi->name, umidi->card->shortname); rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; rmidi->ops = &snd_usbmidi_ops; rmidi->private_data = umidi; rmidi->private_free = snd_usbmidi_rawmidi_free; snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_usbmidi_output_ops); snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_usbmidi_input_ops); umidi->rmidi = rmidi; return 0; } /* * Temporarily stop input. */ void snd_usbmidi_input_stop(struct list_head *p) { struct snd_usb_midi *umidi; unsigned int i, j; umidi = list_entry(p, struct snd_usb_midi, list); if (!umidi->input_running) return; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { struct snd_usb_midi_endpoint *ep = &umidi->endpoints[i]; if (ep->in) for (j = 0; j < INPUT_URBS; ++j) usb_kill_urb(ep->in->urbs[j]); } umidi->input_running = 0; } EXPORT_SYMBOL(snd_usbmidi_input_stop); static void snd_usbmidi_input_start_ep(struct snd_usb_midi *umidi, struct snd_usb_midi_in_endpoint *ep) { unsigned int i; unsigned long flags; if (!ep) return; for (i = 0; i < INPUT_URBS; ++i) { struct urb *urb = ep->urbs[i]; spin_lock_irqsave(&umidi->disc_lock, flags); if (!atomic_read(&urb->use_count)) { urb->dev = ep->umidi->dev; snd_usbmidi_submit_urb(urb, GFP_ATOMIC); } spin_unlock_irqrestore(&umidi->disc_lock, flags); } } /* * Resume input after a call to snd_usbmidi_input_stop(). */ void snd_usbmidi_input_start(struct list_head *p) { struct snd_usb_midi *umidi; int i; umidi = list_entry(p, struct snd_usb_midi, list); if (umidi->input_running || !umidi->opened[1]) return; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) snd_usbmidi_input_start_ep(umidi, umidi->endpoints[i].in); umidi->input_running = 1; } EXPORT_SYMBOL(snd_usbmidi_input_start); /* * Prepare for suspend. Typically called from the USB suspend callback. */ void snd_usbmidi_suspend(struct list_head *p) { struct snd_usb_midi *umidi; umidi = list_entry(p, struct snd_usb_midi, list); mutex_lock(&umidi->mutex); snd_usbmidi_input_stop(p); mutex_unlock(&umidi->mutex); } EXPORT_SYMBOL(snd_usbmidi_suspend); /* * Resume. Typically called from the USB resume callback. */ void snd_usbmidi_resume(struct list_head *p) { struct snd_usb_midi *umidi; umidi = list_entry(p, struct snd_usb_midi, list); mutex_lock(&umidi->mutex); snd_usbmidi_input_start(p); mutex_unlock(&umidi->mutex); } EXPORT_SYMBOL(snd_usbmidi_resume); /* * Creates and registers everything needed for a MIDI streaming interface. */ int __snd_usbmidi_create(struct snd_card *card, struct usb_interface *iface, struct list_head *midi_list, const struct snd_usb_audio_quirk *quirk, unsigned int usb_id, unsigned int *num_rawmidis) { struct snd_usb_midi *umidi; struct snd_usb_midi_endpoint_info endpoints[MIDI_MAX_ENDPOINTS]; int out_ports, in_ports; int i, err; umidi = kzalloc(sizeof(*umidi), GFP_KERNEL); if (!umidi) return -ENOMEM; umidi->dev = interface_to_usbdev(iface); umidi->card = card; umidi->iface = iface; umidi->quirk = quirk; umidi->usb_protocol_ops = &snd_usbmidi_standard_ops; if (num_rawmidis) umidi->next_midi_device = *num_rawmidis; spin_lock_init(&umidi->disc_lock); init_rwsem(&umidi->disc_rwsem); mutex_init(&umidi->mutex); if (!usb_id) usb_id = USB_ID(le16_to_cpu(umidi->dev->descriptor.idVendor), le16_to_cpu(umidi->dev->descriptor.idProduct)); umidi->usb_id = usb_id; timer_setup(&umidi->error_timer, snd_usbmidi_error_timer, 0); /* detect the endpoint(s) to use */ memset(endpoints, 0, sizeof(endpoints)); switch (quirk ? quirk->type : QUIRK_MIDI_STANDARD_INTERFACE) { case QUIRK_MIDI_STANDARD_INTERFACE: err = snd_usbmidi_get_ms_info(umidi, endpoints); if (umidi->usb_id == USB_ID(0x0763, 0x0150)) /* M-Audio Uno */ umidi->usb_protocol_ops = &snd_usbmidi_maudio_broken_running_status_ops; break; case QUIRK_MIDI_US122L: umidi->usb_protocol_ops = &snd_usbmidi_122l_ops; fallthrough; case QUIRK_MIDI_FIXED_ENDPOINT: memcpy(&endpoints[0], quirk->data, sizeof(struct snd_usb_midi_endpoint_info)); err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1); break; case QUIRK_MIDI_YAMAHA: err = snd_usbmidi_detect_yamaha(umidi, &endpoints[0]); break; case QUIRK_MIDI_ROLAND: err = snd_usbmidi_detect_roland(umidi, &endpoints[0]); break; case QUIRK_MIDI_MIDIMAN: umidi->usb_protocol_ops = &snd_usbmidi_midiman_ops; memcpy(&endpoints[0], quirk->data, sizeof(struct snd_usb_midi_endpoint_info)); err = 0; break; case QUIRK_MIDI_NOVATION: umidi->usb_protocol_ops = &snd_usbmidi_novation_ops; err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); break; case QUIRK_MIDI_RAW_BYTES: umidi->usb_protocol_ops = &snd_usbmidi_raw_ops; /* * Interface 1 contains isochronous endpoints, but with the same * numbers as in interface 0. Since it is interface 1 that the * USB core has most recently seen, these descriptors are now * associated with the endpoint numbers. This will foul up our * attempts to submit bulk/interrupt URBs to the endpoints in * interface 0, so we have to make sure that the USB core looks * again at interface 0 by calling usb_set_interface() on it. */ if (umidi->usb_id == USB_ID(0x07fd, 0x0001)) /* MOTU Fastlane */ usb_set_interface(umidi->dev, 0, 0); err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); break; case QUIRK_MIDI_EMAGIC: umidi->usb_protocol_ops = &snd_usbmidi_emagic_ops; memcpy(&endpoints[0], quirk->data, sizeof(struct snd_usb_midi_endpoint_info)); err = snd_usbmidi_detect_endpoints(umidi, &endpoints[0], 1); break; case QUIRK_MIDI_CME: umidi->usb_protocol_ops = &snd_usbmidi_cme_ops; err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); break; case QUIRK_MIDI_AKAI: umidi->usb_protocol_ops = &snd_usbmidi_akai_ops; err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); /* endpoint 1 is input-only */ endpoints[1].out_cables = 0; break; case QUIRK_MIDI_FTDI: umidi->usb_protocol_ops = &snd_usbmidi_ftdi_ops; /* set baud rate to 31250 (48 MHz / 16 / 96) */ err = usb_control_msg(umidi->dev, usb_sndctrlpipe(umidi->dev, 0), 3, 0x40, 0x60, 0, NULL, 0, 1000); if (err < 0) break; err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); break; case QUIRK_MIDI_CH345: umidi->usb_protocol_ops = &snd_usbmidi_ch345_broken_sysex_ops; err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); break; default: dev_err(&umidi->dev->dev, "invalid quirk type %d\n", quirk->type); err = -ENXIO; break; } if (err < 0) goto free_midi; /* create rawmidi device */ out_ports = 0; in_ports = 0; for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) { out_ports += hweight16(endpoints[i].out_cables); in_ports += hweight16(endpoints[i].in_cables); } err = snd_usbmidi_create_rawmidi(umidi, out_ports, in_ports); if (err < 0) goto free_midi; /* create endpoint/port structures */ if (quirk && quirk->type == QUIRK_MIDI_MIDIMAN) err = snd_usbmidi_create_endpoints_midiman(umidi, &endpoints[0]); else err = snd_usbmidi_create_endpoints(umidi, endpoints); if (err < 0) goto exit; usb_autopm_get_interface_no_resume(umidi->iface); list_add_tail(&umidi->list, midi_list); if (num_rawmidis) *num_rawmidis = umidi->next_midi_device; return 0; free_midi: kfree(umidi); exit: return err; } EXPORT_SYMBOL(__snd_usbmidi_create);
linux-master
sound/usb/midi.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Tascam US-16x08 ALSA driver * * Copyright (c) 2016 by Detlef Urban ([email protected]) */ #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio-v2.h> #include <sound/core.h> #include <sound/control.h> #include "usbaudio.h" #include "mixer.h" #include "helper.h" #include "mixer_us16x08.h" /* USB control message templates */ static const char route_msg[] = { 0x61, 0x02, 0x03, /* input from master (0x02) or input from computer bus (0x03) */ 0x62, 0x02, 0x01, /* input index (0x01/0x02 eq. left/right) or bus (0x01-0x08) */ 0x41, 0x01, 0x61, 0x02, 0x01, 0x62, 0x02, 0x01, /* output index (0x01-0x08) */ 0x42, 0x01, 0x43, 0x01, 0x00, 0x00 }; static const char mix_init_msg1[] = { 0x71, 0x01, 0x00, 0x00 }; static const char mix_init_msg2[] = { 0x62, 0x02, 0x00, 0x61, 0x02, 0x04, 0xb1, 0x01, 0x00, 0x00 }; static const char mix_msg_in[] = { /* default message head, equal to all mixers */ 0x61, 0x02, 0x04, 0x62, 0x02, 0x01, 0x81, /* 0x06: Controller ID */ 0x02, /* 0x07: */ 0x00, /* 0x08: Value of common mixer */ 0x00, 0x00 }; static const char mix_msg_out[] = { /* default message head, equal to all mixers */ 0x61, 0x02, 0x02, 0x62, 0x02, 0x01, 0x81, /* 0x06: Controller ID */ 0x02, /* 0x07: */ 0x00, /* 0x08: Value of common mixer */ 0x00, 0x00 }; static const char bypass_msg_out[] = { 0x45, 0x02, 0x01, /* on/off flag */ 0x00, 0x00 }; static const char bus_msg_out[] = { 0x44, 0x02, 0x01, /* on/off flag */ 0x00, 0x00 }; static const char comp_msg[] = { /* default message head, equal to all mixers */ 0x61, 0x02, 0x04, 0x62, 0x02, 0x01, 0x91, 0x02, 0xf0, /* 0x08: Threshold db (8) (e0 ... 00) (+-0dB -- -32dB) x-32 */ 0x92, 0x02, 0x0a, /* 0x0b: Ratio (0a,0b,0d,0f,11,14,19,1e,23,28,32,3c,50,a0,ff) */ 0x93, 0x02, 0x02, /* 0x0e: Attack (0x02 ... 0xc0) (2ms ... 200ms) */ 0x94, 0x02, 0x01, /* 0x11: Release (0x01 ... 0x64) (10ms ... 1000ms) x*10 */ 0x95, 0x02, 0x03, /* 0x14: gain (0 ... 20) (0dB .. 20dB) */ 0x96, 0x02, 0x01, 0x97, 0x02, 0x01, /* 0x1a: main Comp switch (0 ... 1) (off ... on)) */ 0x00, 0x00 }; static const char eqs_msq[] = { /* default message head, equal to all mixers */ 0x61, 0x02, 0x04, 0x62, 0x02, 0x01, 0x51, /* 0x06: Controller ID */ 0x02, 0x04, /* 0x08: EQ set num (0x01..0x04) (LOW, LOWMID, HIGHMID, HIGH)) */ 0x52, 0x02, 0x0c, /* 0x0b: value dB (0 ... 12) (-12db .. +12db) x-6 */ 0x53, 0x02, 0x0f, /* 0x0e: value freq (32-47) (1.7kHz..18kHz) */ 0x54, 0x02, 0x02, /* 0x11: band width (0-6) (Q16-Q0.25) 2^x/4 (EQ xxMID only) */ 0x55, 0x02, 0x01, /* 0x14: main EQ switch (0 ... 1) (off ... on)) */ 0x00, 0x00 }; /* compressor ratio map */ static const char ratio_map[] = { 0x0a, 0x0b, 0x0d, 0x0f, 0x11, 0x14, 0x19, 0x1e, 0x23, 0x28, 0x32, 0x3c, 0x50, 0xa0, 0xff }; /* route enumeration names */ static const char *const route_names[] = { "Master Left", "Master Right", "Output 1", "Output 2", "Output 3", "Output 4", "Output 5", "Output 6", "Output 7", "Output 8", }; static int snd_us16x08_recv_urb(struct snd_usb_audio *chip, unsigned char *buf, int size) { mutex_lock(&chip->mutex); snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), SND_US16X08_URB_METER_REQUEST, SND_US16X08_URB_METER_REQUESTTYPE, 0, 0, buf, size); mutex_unlock(&chip->mutex); return 0; } /* wrapper function to send prepared URB buffer to usb device. Return an error * code if something went wrong */ static int snd_us16x08_send_urb(struct snd_usb_audio *chip, char *buf, int size) { return snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), SND_US16X08_URB_REQUEST, SND_US16X08_URB_REQUESTTYPE, 0, 0, buf, size); } static int snd_us16x08_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { return snd_ctl_enum_info(uinfo, 1, 10, route_names); } static int snd_us16x08_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; int index = ucontrol->id.index; /* route has no bias */ ucontrol->value.enumerated.item[0] = elem->cache_val[index]; return 0; } static int snd_us16x08_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; int index = ucontrol->id.index; char buf[sizeof(route_msg)]; int val, val_org, err; /* get the new value (no bias for routes) */ val = ucontrol->value.enumerated.item[0]; /* sanity check */ if (val < 0 || val > 9) return -EINVAL; /* prepare the message buffer from template */ memcpy(buf, route_msg, sizeof(route_msg)); if (val < 2) { /* input comes from a master channel */ val_org = val; buf[2] = 0x02; } else { /* input comes from a computer channel */ buf[2] = 0x03; val_org = val - 2; } /* place new route selection in URB message */ buf[5] = (unsigned char) (val_org & 0x0f) + 1; /* place route selector in URB message */ buf[13] = index + 1; err = snd_us16x08_send_urb(chip, buf, sizeof(route_msg)); if (err > 0) { elem->cached |= 1 << index; elem->cache_val[index] = val; } else { usb_audio_dbg(chip, "Failed to set routing, err:%d\n", err); } return err > 0 ? 1 : 0; } static int snd_us16x08_master_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->count = 1; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->value.integer.max = SND_US16X08_KCMAX(kcontrol); uinfo->value.integer.min = SND_US16X08_KCMIN(kcontrol); uinfo->value.integer.step = SND_US16X08_KCSTEP(kcontrol); return 0; } static int snd_us16x08_master_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; int index = ucontrol->id.index; ucontrol->value.integer.value[0] = elem->cache_val[index]; return 0; } static int snd_us16x08_master_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; char buf[sizeof(mix_msg_out)]; int val, err; int index = ucontrol->id.index; /* new control value incl. bias*/ val = ucontrol->value.integer.value[0]; /* sanity check */ if (val < SND_US16X08_KCMIN(kcontrol) || val > SND_US16X08_KCMAX(kcontrol)) return -EINVAL; /* prepare the message buffer from template */ memcpy(buf, mix_msg_out, sizeof(mix_msg_out)); buf[8] = val - SND_US16X08_KCBIAS(kcontrol); buf[6] = elem->head.id; /* place channel selector in URB message */ buf[5] = index + 1; err = snd_us16x08_send_urb(chip, buf, sizeof(mix_msg_out)); if (err > 0) { elem->cached |= 1 << index; elem->cache_val[index] = val; } else { usb_audio_dbg(chip, "Failed to set master, err:%d\n", err); } return err > 0 ? 1 : 0; } static int snd_us16x08_bus_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; char buf[sizeof(mix_msg_out)]; int val, err = 0; val = ucontrol->value.integer.value[0]; /* prepare the message buffer from template */ switch (elem->head.id) { case SND_US16X08_ID_BYPASS: memcpy(buf, bypass_msg_out, sizeof(bypass_msg_out)); buf[2] = val; err = snd_us16x08_send_urb(chip, buf, sizeof(bypass_msg_out)); break; case SND_US16X08_ID_BUSS_OUT: memcpy(buf, bus_msg_out, sizeof(bus_msg_out)); buf[2] = val; err = snd_us16x08_send_urb(chip, buf, sizeof(bus_msg_out)); break; case SND_US16X08_ID_MUTE: memcpy(buf, mix_msg_out, sizeof(mix_msg_out)); buf[8] = val; buf[6] = elem->head.id; buf[5] = 1; err = snd_us16x08_send_urb(chip, buf, sizeof(mix_msg_out)); break; } if (err > 0) { elem->cached |= 1; elem->cache_val[0] = val; } else { usb_audio_dbg(chip, "Failed to set bus parameter, err:%d\n", err); } return err > 0 ? 1 : 0; } static int snd_us16x08_bus_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; switch (elem->head.id) { case SND_US16X08_ID_BUSS_OUT: ucontrol->value.integer.value[0] = elem->cache_val[0]; break; case SND_US16X08_ID_BYPASS: ucontrol->value.integer.value[0] = elem->cache_val[0]; break; case SND_US16X08_ID_MUTE: ucontrol->value.integer.value[0] = elem->cache_val[0]; break; } return 0; } /* gets a current mixer value from common store */ static int snd_us16x08_channel_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; int index = ucontrol->id.index; ucontrol->value.integer.value[0] = elem->cache_val[index]; return 0; } static int snd_us16x08_channel_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; char buf[sizeof(mix_msg_in)]; int val, err; int index = ucontrol->id.index; val = ucontrol->value.integer.value[0]; /* sanity check */ if (val < SND_US16X08_KCMIN(kcontrol) || val > SND_US16X08_KCMAX(kcontrol)) return -EINVAL; /* prepare URB message from template */ memcpy(buf, mix_msg_in, sizeof(mix_msg_in)); /* add the bias to the new value */ buf[8] = val - SND_US16X08_KCBIAS(kcontrol); buf[6] = elem->head.id; buf[5] = index + 1; err = snd_us16x08_send_urb(chip, buf, sizeof(mix_msg_in)); if (err > 0) { elem->cached |= 1 << index; elem->cache_val[index] = val; } else { usb_audio_dbg(chip, "Failed to set channel, err:%d\n", err); } return err > 0 ? 1 : 0; } static int snd_us16x08_mix_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->count = 1; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->value.integer.max = SND_US16X08_KCMAX(kcontrol); uinfo->value.integer.min = SND_US16X08_KCMIN(kcontrol); uinfo->value.integer.step = SND_US16X08_KCSTEP(kcontrol); return 0; } static int snd_us16x08_comp_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_us16x08_comp_store *store = elem->private_data; int index = ucontrol->id.index; int val_idx = COMP_STORE_IDX(elem->head.id); ucontrol->value.integer.value[0] = store->val[val_idx][index]; return 0; } static int snd_us16x08_comp_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; struct snd_us16x08_comp_store *store = elem->private_data; int index = ucontrol->id.index; char buf[sizeof(comp_msg)]; int val_idx, val; int err; val = ucontrol->value.integer.value[0]; /* sanity check */ if (val < SND_US16X08_KCMIN(kcontrol) || val > SND_US16X08_KCMAX(kcontrol)) return -EINVAL; /* new control value incl. bias*/ val_idx = elem->head.id - SND_US16X08_ID_COMP_BASE; store->val[val_idx][index] = ucontrol->value.integer.value[0]; /* prepare compressor URB message from template */ memcpy(buf, comp_msg, sizeof(comp_msg)); /* place comp values in message buffer watch bias! */ buf[8] = store->val[ COMP_STORE_IDX(SND_US16X08_ID_COMP_THRESHOLD)][index] - SND_US16X08_COMP_THRESHOLD_BIAS; buf[11] = ratio_map[store->val[ COMP_STORE_IDX(SND_US16X08_ID_COMP_RATIO)][index]]; buf[14] = store->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_ATTACK)][index] + SND_US16X08_COMP_ATTACK_BIAS; buf[17] = store->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_RELEASE)][index] + SND_US16X08_COMP_RELEASE_BIAS; buf[20] = store->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_GAIN)][index]; buf[26] = store->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_SWITCH)][index]; /* place channel selector in message buffer */ buf[5] = index + 1; err = snd_us16x08_send_urb(chip, buf, sizeof(comp_msg)); if (err > 0) { elem->cached |= 1 << index; elem->cache_val[index] = val; } else { usb_audio_dbg(chip, "Failed to set compressor, err:%d\n", err); } return 1; } static int snd_us16x08_eqswitch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int val; struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_us16x08_eq_store *store = elem->private_data; int index = ucontrol->id.index; /* get low switch from cache is enough, cause all bands are together */ val = store->val[EQ_STORE_BAND_IDX(elem->head.id)] [EQ_STORE_PARAM_IDX(elem->head.id)][index]; ucontrol->value.integer.value[0] = val; return 0; } static int snd_us16x08_eqswitch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; struct snd_us16x08_eq_store *store = elem->private_data; int index = ucontrol->id.index; char buf[sizeof(eqs_msq)]; int val, err = 0; int b_idx; /* new control value incl. bias*/ val = ucontrol->value.integer.value[0] + SND_US16X08_KCBIAS(kcontrol); /* prepare URB message from EQ template */ memcpy(buf, eqs_msq, sizeof(eqs_msq)); /* place channel index in URB message */ buf[5] = index + 1; for (b_idx = 0; b_idx < SND_US16X08_ID_EQ_BAND_COUNT; b_idx++) { /* all four EQ bands have to be enabled/disabled in once */ buf[20] = val; buf[17] = store->val[b_idx][2][index]; buf[14] = store->val[b_idx][1][index]; buf[11] = store->val[b_idx][0][index]; buf[8] = b_idx + 1; err = snd_us16x08_send_urb(chip, buf, sizeof(eqs_msq)); if (err < 0) break; store->val[b_idx][3][index] = val; msleep(15); } if (err > 0) { elem->cached |= 1 << index; elem->cache_val[index] = val; } else { usb_audio_dbg(chip, "Failed to set eq switch, err:%d\n", err); } return 1; } static int snd_us16x08_eq_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int val; struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_us16x08_eq_store *store = elem->private_data; int index = ucontrol->id.index; int b_idx = EQ_STORE_BAND_IDX(elem->head.id) - 1; int p_idx = EQ_STORE_PARAM_IDX(elem->head.id); val = store->val[b_idx][p_idx][index]; ucontrol->value.integer.value[0] = val; return 0; } static int snd_us16x08_eq_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; struct snd_us16x08_eq_store *store = elem->private_data; int index = ucontrol->id.index; char buf[sizeof(eqs_msq)]; int val, err; int b_idx = EQ_STORE_BAND_IDX(elem->head.id) - 1; int p_idx = EQ_STORE_PARAM_IDX(elem->head.id); val = ucontrol->value.integer.value[0]; /* sanity check */ if (val < SND_US16X08_KCMIN(kcontrol) || val > SND_US16X08_KCMAX(kcontrol)) return -EINVAL; /* copy URB buffer from EQ template */ memcpy(buf, eqs_msq, sizeof(eqs_msq)); store->val[b_idx][p_idx][index] = val; buf[20] = store->val[b_idx][3][index]; buf[17] = store->val[b_idx][2][index]; buf[14] = store->val[b_idx][1][index]; buf[11] = store->val[b_idx][0][index]; /* place channel index in URB buffer */ buf[5] = index + 1; /* place EQ band in URB buffer */ buf[8] = b_idx + 1; err = snd_us16x08_send_urb(chip, buf, sizeof(eqs_msq)); if (err > 0) { /* store new value in EQ band cache */ elem->cached |= 1 << index; elem->cache_val[index] = val; } else { usb_audio_dbg(chip, "Failed to set eq param, err:%d\n", err); } return 1; } static int snd_us16x08_meter_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->count = 34; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->value.integer.max = 0x7FFF; uinfo->value.integer.min = 0; return 0; } /* calculate compressor index for reduction level request */ static int snd_get_meter_comp_index(struct snd_us16x08_meter_store *store) { int ret; /* any channel active */ if (store->comp_active_index) { /* check for stereo link */ if (store->comp_active_index & 0x20) { /* reset comp_index to left channel*/ if (store->comp_index - store->comp_active_index > 1) store->comp_index = store->comp_active_index; ret = store->comp_index++ & 0x1F; } else { /* no stereo link */ ret = store->comp_active_index; } } else { /* skip channels with no compressor active */ while (store->comp_index <= SND_US16X08_MAX_CHANNELS && !store->comp_store->val[ COMP_STORE_IDX(SND_US16X08_ID_COMP_SWITCH)] [store->comp_index - 1]) { store->comp_index++; } ret = store->comp_index++; if (store->comp_index > SND_US16X08_MAX_CHANNELS) store->comp_index = 1; } return ret; } /* retrieve the meter level values from URB message */ static void get_meter_levels_from_urb(int s, struct snd_us16x08_meter_store *store, u8 *meter_urb) { int val = MUC2(meter_urb, s) + (MUC3(meter_urb, s) << 8); if (MUA0(meter_urb, s) == 0x61 && MUA1(meter_urb, s) == 0x02 && MUA2(meter_urb, s) == 0x04 && MUB0(meter_urb, s) == 0x62) { if (MUC0(meter_urb, s) == 0x72) store->meter_level[MUB2(meter_urb, s) - 1] = val; if (MUC0(meter_urb, s) == 0xb2) store->comp_level[MUB2(meter_urb, s) - 1] = val; } if (MUA0(meter_urb, s) == 0x61 && MUA1(meter_urb, s) == 0x02 && MUA2(meter_urb, s) == 0x02 && MUB0(meter_urb, s) == 0x62) store->master_level[MUB2(meter_urb, s) - 1] = val; } /* Function to retrieve current meter values from the device. * * The device needs to be polled for meter values with an initial * requests. It will return with a sequence of different meter value * packages. The first request (case 0:) initiate this meter response sequence. * After the third response, an additional request can be placed, * to retrieve compressor reduction level value for given channel. This round * trip channel selector will skip all inactive compressors. * A mixer can interrupt this round-trip by selecting one ore two (stereo-link) * specific channels. */ static int snd_us16x08_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int i, set; struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_usb_audio *chip = elem->head.mixer->chip; struct snd_us16x08_meter_store *store = elem->private_data; u8 meter_urb[64]; switch (kcontrol->private_value) { case 0: { char tmp[sizeof(mix_init_msg1)]; memcpy(tmp, mix_init_msg1, sizeof(mix_init_msg1)); snd_us16x08_send_urb(chip, tmp, 4); snd_us16x08_recv_urb(chip, meter_urb, sizeof(meter_urb)); kcontrol->private_value++; break; } case 1: snd_us16x08_recv_urb(chip, meter_urb, sizeof(meter_urb)); kcontrol->private_value++; break; case 2: snd_us16x08_recv_urb(chip, meter_urb, sizeof(meter_urb)); kcontrol->private_value++; break; case 3: { char tmp[sizeof(mix_init_msg2)]; memcpy(tmp, mix_init_msg2, sizeof(mix_init_msg2)); tmp[2] = snd_get_meter_comp_index(store); snd_us16x08_send_urb(chip, tmp, 10); snd_us16x08_recv_urb(chip, meter_urb, sizeof(meter_urb)); kcontrol->private_value = 0; break; } } for (set = 0; set < 6; set++) get_meter_levels_from_urb(set, store, meter_urb); for (i = 0; i < SND_US16X08_MAX_CHANNELS; i++) { ucontrol->value.integer.value[i] = store ? store->meter_level[i] : 0; } ucontrol->value.integer.value[i++] = store ? store->master_level[0] : 0; ucontrol->value.integer.value[i++] = store ? store->master_level[1] : 0; for (i = 2; i < SND_US16X08_MAX_CHANNELS + 2; i++) ucontrol->value.integer.value[i + SND_US16X08_MAX_CHANNELS] = store ? store->comp_level[i - 2] : 0; return 1; } static int snd_us16x08_meter_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct usb_mixer_elem_info *elem = kcontrol->private_data; struct snd_us16x08_meter_store *store = elem->private_data; int val; val = ucontrol->value.integer.value[0]; /* sanity check */ if (val < 0 || val >= SND_US16X08_MAX_CHANNELS) return -EINVAL; store->comp_active_index = val; store->comp_index = val; return 1; } static const struct snd_kcontrol_new snd_us16x08_ch_boolean_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_switch_info, .get = snd_us16x08_channel_get, .put = snd_us16x08_channel_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 1) }; static const struct snd_kcontrol_new snd_us16x08_ch_int_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_channel_get, .put = snd_us16x08_channel_put, .private_value = SND_US16X08_KCSET(SND_US16X08_FADER_BIAS, 1, 0, 133) }; static const struct snd_kcontrol_new snd_us16x08_pan_int_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_channel_get, .put = snd_us16x08_channel_put, .private_value = SND_US16X08_KCSET(SND_US16X08_FADER_BIAS, 1, 0, 255) }; static const struct snd_kcontrol_new snd_us16x08_master_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 1, .info = snd_us16x08_master_info, .get = snd_us16x08_master_get, .put = snd_us16x08_master_put, .private_value = SND_US16X08_KCSET(SND_US16X08_FADER_BIAS, 1, 0, 133) }; static const struct snd_kcontrol_new snd_us16x08_route_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 8, .info = snd_us16x08_route_info, .get = snd_us16x08_route_get, .put = snd_us16x08_route_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 9) }; static const struct snd_kcontrol_new snd_us16x08_bus_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 1, .info = snd_us16x08_switch_info, .get = snd_us16x08_bus_get, .put = snd_us16x08_bus_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 1) }; static const struct snd_kcontrol_new snd_us16x08_compswitch_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_switch_info, .get = snd_us16x08_comp_get, .put = snd_us16x08_comp_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 1) }; static const struct snd_kcontrol_new snd_us16x08_comp_threshold_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_comp_get, .put = snd_us16x08_comp_put, .private_value = SND_US16X08_KCSET(SND_US16X08_COMP_THRESHOLD_BIAS, 1, 0, 0x20) }; static const struct snd_kcontrol_new snd_us16x08_comp_ratio_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_comp_get, .put = snd_us16x08_comp_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, sizeof(ratio_map) - 1), /*max*/ }; static const struct snd_kcontrol_new snd_us16x08_comp_gain_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_comp_get, .put = snd_us16x08_comp_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 0x14) }; static const struct snd_kcontrol_new snd_us16x08_comp_attack_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_comp_get, .put = snd_us16x08_comp_put, .private_value = SND_US16X08_KCSET(SND_US16X08_COMP_ATTACK_BIAS, 1, 0, 0xc6), }; static const struct snd_kcontrol_new snd_us16x08_comp_release_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_comp_get, .put = snd_us16x08_comp_put, .private_value = SND_US16X08_KCSET(SND_US16X08_COMP_RELEASE_BIAS, 1, 0, 0x63), }; static const struct snd_kcontrol_new snd_us16x08_eq_gain_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_eq_get, .put = snd_us16x08_eq_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 24), }; static const struct snd_kcontrol_new snd_us16x08_eq_low_freq_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_eq_get, .put = snd_us16x08_eq_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 0x1F), }; static const struct snd_kcontrol_new snd_us16x08_eq_mid_freq_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_eq_get, .put = snd_us16x08_eq_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 0x3F) }; static const struct snd_kcontrol_new snd_us16x08_eq_mid_width_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_eq_get, .put = snd_us16x08_eq_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 0x06) }; static const struct snd_kcontrol_new snd_us16x08_eq_high_freq_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_mix_info, .get = snd_us16x08_eq_get, .put = snd_us16x08_eq_put, .private_value = SND_US16X08_KCSET(SND_US16X08_EQ_HIGHFREQ_BIAS, 1, 0, 0x1F) }; static const struct snd_kcontrol_new snd_us16x08_eq_switch_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 16, .info = snd_us16x08_switch_info, .get = snd_us16x08_eqswitch_get, .put = snd_us16x08_eqswitch_put, .private_value = SND_US16X08_KCSET(SND_US16X08_NO_BIAS, 1, 0, 1) }; static const struct snd_kcontrol_new snd_us16x08_meter_ctl = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .count = 1, .info = snd_us16x08_meter_info, .get = snd_us16x08_meter_get, .put = snd_us16x08_meter_put }; /* control store preparation */ /* setup compressor store and assign default value */ static struct snd_us16x08_comp_store *snd_us16x08_create_comp_store(void) { int i; struct snd_us16x08_comp_store *tmp; tmp = kmalloc(sizeof(*tmp), GFP_KERNEL); if (!tmp) return NULL; for (i = 0; i < SND_US16X08_MAX_CHANNELS; i++) { tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_THRESHOLD)][i] = 0x20; tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_RATIO)][i] = 0x00; tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_GAIN)][i] = 0x00; tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_SWITCH)][i] = 0x00; tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_ATTACK)][i] = 0x00; tmp->val[COMP_STORE_IDX(SND_US16X08_ID_COMP_RELEASE)][i] = 0x00; } return tmp; } /* setup EQ store and assign default values */ static struct snd_us16x08_eq_store *snd_us16x08_create_eq_store(void) { int i, b_idx; struct snd_us16x08_eq_store *tmp; tmp = kmalloc(sizeof(*tmp), GFP_KERNEL); if (!tmp) return NULL; for (i = 0; i < SND_US16X08_MAX_CHANNELS; i++) { for (b_idx = 0; b_idx < SND_US16X08_ID_EQ_BAND_COUNT; b_idx++) { tmp->val[b_idx][0][i] = 0x0c; tmp->val[b_idx][3][i] = 0x00; switch (b_idx) { case 0: /* EQ Low */ tmp->val[b_idx][1][i] = 0x05; tmp->val[b_idx][2][i] = 0xff; break; case 1: /* EQ Mid low */ tmp->val[b_idx][1][i] = 0x0e; tmp->val[b_idx][2][i] = 0x02; break; case 2: /* EQ Mid High */ tmp->val[b_idx][1][i] = 0x1b; tmp->val[b_idx][2][i] = 0x02; break; case 3: /* EQ High */ tmp->val[b_idx][1][i] = 0x2f - SND_US16X08_EQ_HIGHFREQ_BIAS; tmp->val[b_idx][2][i] = 0xff; break; } } } return tmp; } static struct snd_us16x08_meter_store *snd_us16x08_create_meter_store(void) { struct snd_us16x08_meter_store *tmp; tmp = kzalloc(sizeof(*tmp), GFP_KERNEL); if (!tmp) return NULL; tmp->comp_index = 1; tmp->comp_active_index = 0; return tmp; } /* release elem->private_free as well; called only once for each *_store */ static void elem_private_free(struct snd_kcontrol *kctl) { struct usb_mixer_elem_info *elem = kctl->private_data; if (elem) kfree(elem->private_data); kfree(elem); kctl->private_data = NULL; } static int add_new_ctl(struct usb_mixer_interface *mixer, const struct snd_kcontrol_new *ncontrol, int index, int val_type, int channels, const char *name, void *opt, bool do_private_free, struct usb_mixer_elem_info **elem_ret) { struct snd_kcontrol *kctl; struct usb_mixer_elem_info *elem; int err; usb_audio_dbg(mixer->chip, "us16x08 add mixer %s\n", name); elem = kzalloc(sizeof(*elem), GFP_KERNEL); if (!elem) return -ENOMEM; elem->head.mixer = mixer; elem->head.resume = NULL; elem->control = 0; elem->idx_off = 0; elem->head.id = index; elem->val_type = val_type; elem->channels = channels; elem->private_data = opt; kctl = snd_ctl_new1(ncontrol, elem); if (!kctl) { kfree(elem); return -ENOMEM; } if (do_private_free) kctl->private_free = elem_private_free; else kctl->private_free = snd_usb_mixer_elem_free; strscpy(kctl->id.name, name, sizeof(kctl->id.name)); err = snd_usb_mixer_add_control(&elem->head, kctl); if (err < 0) return err; if (elem_ret) *elem_ret = elem; return 0; } /* table of EQ controls */ static const struct snd_us16x08_control_params eq_controls[] = { { /* EQ switch */ .kcontrol_new = &snd_us16x08_eq_switch_ctl, .control_id = SND_US16X08_ID_EQENABLE, .type = USB_MIXER_BOOLEAN, .num_channels = 16, .name = "EQ Switch", }, { /* EQ low gain */ .kcontrol_new = &snd_us16x08_eq_gain_ctl, .control_id = SND_US16X08_ID_EQLOWLEVEL, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ Low Volume", }, { /* EQ low freq */ .kcontrol_new = &snd_us16x08_eq_low_freq_ctl, .control_id = SND_US16X08_ID_EQLOWFREQ, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ Low Frequency", }, { /* EQ mid low gain */ .kcontrol_new = &snd_us16x08_eq_gain_ctl, .control_id = SND_US16X08_ID_EQLOWMIDLEVEL, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ MidLow Volume", }, { /* EQ mid low freq */ .kcontrol_new = &snd_us16x08_eq_mid_freq_ctl, .control_id = SND_US16X08_ID_EQLOWMIDFREQ, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ MidLow Frequency", }, { /* EQ mid low Q */ .kcontrol_new = &snd_us16x08_eq_mid_width_ctl, .control_id = SND_US16X08_ID_EQLOWMIDWIDTH, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ MidLow Q", }, { /* EQ mid high gain */ .kcontrol_new = &snd_us16x08_eq_gain_ctl, .control_id = SND_US16X08_ID_EQHIGHMIDLEVEL, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ MidHigh Volume", }, { /* EQ mid high freq */ .kcontrol_new = &snd_us16x08_eq_mid_freq_ctl, .control_id = SND_US16X08_ID_EQHIGHMIDFREQ, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ MidHigh Frequency", }, { /* EQ mid high Q */ .kcontrol_new = &snd_us16x08_eq_mid_width_ctl, .control_id = SND_US16X08_ID_EQHIGHMIDWIDTH, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ MidHigh Q", }, { /* EQ high gain */ .kcontrol_new = &snd_us16x08_eq_gain_ctl, .control_id = SND_US16X08_ID_EQHIGHLEVEL, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ High Volume", }, { /* EQ low freq */ .kcontrol_new = &snd_us16x08_eq_high_freq_ctl, .control_id = SND_US16X08_ID_EQHIGHFREQ, .type = USB_MIXER_U8, .num_channels = 16, .name = "EQ High Frequency", }, }; /* table of compressor controls */ static const struct snd_us16x08_control_params comp_controls[] = { { /* Comp enable */ .kcontrol_new = &snd_us16x08_compswitch_ctl, .control_id = SND_US16X08_ID_COMP_SWITCH, .type = USB_MIXER_BOOLEAN, .num_channels = 16, .name = "Compressor Switch", }, { /* Comp threshold */ .kcontrol_new = &snd_us16x08_comp_threshold_ctl, .control_id = SND_US16X08_ID_COMP_THRESHOLD, .type = USB_MIXER_U8, .num_channels = 16, .name = "Compressor Threshold Volume", }, { /* Comp ratio */ .kcontrol_new = &snd_us16x08_comp_ratio_ctl, .control_id = SND_US16X08_ID_COMP_RATIO, .type = USB_MIXER_U8, .num_channels = 16, .name = "Compressor Ratio", }, { /* Comp attack */ .kcontrol_new = &snd_us16x08_comp_attack_ctl, .control_id = SND_US16X08_ID_COMP_ATTACK, .type = USB_MIXER_U8, .num_channels = 16, .name = "Compressor Attack", }, { /* Comp release */ .kcontrol_new = &snd_us16x08_comp_release_ctl, .control_id = SND_US16X08_ID_COMP_RELEASE, .type = USB_MIXER_U8, .num_channels = 16, .name = "Compressor Release", }, { /* Comp gain */ .kcontrol_new = &snd_us16x08_comp_gain_ctl, .control_id = SND_US16X08_ID_COMP_GAIN, .type = USB_MIXER_U8, .num_channels = 16, .name = "Compressor Volume", }, }; /* table of channel controls */ static const struct snd_us16x08_control_params channel_controls[] = { { /* Phase */ .kcontrol_new = &snd_us16x08_ch_boolean_ctl, .control_id = SND_US16X08_ID_PHASE, .type = USB_MIXER_BOOLEAN, .num_channels = 16, .name = "Phase Switch", .default_val = 0 }, { /* Fader */ .kcontrol_new = &snd_us16x08_ch_int_ctl, .control_id = SND_US16X08_ID_FADER, .type = USB_MIXER_U8, .num_channels = 16, .name = "Line Volume", .default_val = 127 }, { /* Mute */ .kcontrol_new = &snd_us16x08_ch_boolean_ctl, .control_id = SND_US16X08_ID_MUTE, .type = USB_MIXER_BOOLEAN, .num_channels = 16, .name = "Mute Switch", .default_val = 0 }, { /* Pan */ .kcontrol_new = &snd_us16x08_pan_int_ctl, .control_id = SND_US16X08_ID_PAN, .type = USB_MIXER_U16, .num_channels = 16, .name = "Pan Left-Right Volume", .default_val = 127 }, }; /* table of master controls */ static const struct snd_us16x08_control_params master_controls[] = { { /* Master */ .kcontrol_new = &snd_us16x08_master_ctl, .control_id = SND_US16X08_ID_FADER, .type = USB_MIXER_U8, .num_channels = 16, .name = "Master Volume", .default_val = 127 }, { /* Bypass */ .kcontrol_new = &snd_us16x08_bus_ctl, .control_id = SND_US16X08_ID_BYPASS, .type = USB_MIXER_BOOLEAN, .num_channels = 16, .name = "DSP Bypass Switch", .default_val = 0 }, { /* Buss out */ .kcontrol_new = &snd_us16x08_bus_ctl, .control_id = SND_US16X08_ID_BUSS_OUT, .type = USB_MIXER_BOOLEAN, .num_channels = 16, .name = "Buss Out Switch", .default_val = 0 }, { /* Master mute */ .kcontrol_new = &snd_us16x08_bus_ctl, .control_id = SND_US16X08_ID_MUTE, .type = USB_MIXER_BOOLEAN, .num_channels = 16, .name = "Master Mute Switch", .default_val = 0 }, }; int snd_us16x08_controls_create(struct usb_mixer_interface *mixer) { int i, j; int err; struct usb_mixer_elem_info *elem; struct snd_us16x08_comp_store *comp_store; struct snd_us16x08_meter_store *meter_store; struct snd_us16x08_eq_store *eq_store; /* just check for non-MIDI interface */ if (mixer->hostif->desc.bInterfaceNumber == 3) { /* add routing control */ err = add_new_ctl(mixer, &snd_us16x08_route_ctl, SND_US16X08_ID_ROUTE, USB_MIXER_U8, 8, "Line Out Route", NULL, false, &elem); if (err < 0) { usb_audio_dbg(mixer->chip, "Failed to create route control, err:%d\n", err); return err; } for (i = 0; i < 8; i++) elem->cache_val[i] = i < 2 ? i : i + 2; elem->cached = 0xff; /* create compressor mixer elements */ comp_store = snd_us16x08_create_comp_store(); if (!comp_store) return -ENOMEM; /* add master controls */ for (i = 0; i < ARRAY_SIZE(master_controls); i++) { err = add_new_ctl(mixer, master_controls[i].kcontrol_new, master_controls[i].control_id, master_controls[i].type, master_controls[i].num_channels, master_controls[i].name, comp_store, i == 0, /* release comp_store only once */ &elem); if (err < 0) return err; elem->cache_val[0] = master_controls[i].default_val; elem->cached = 1; } /* add channel controls */ for (i = 0; i < ARRAY_SIZE(channel_controls); i++) { err = add_new_ctl(mixer, channel_controls[i].kcontrol_new, channel_controls[i].control_id, channel_controls[i].type, channel_controls[i].num_channels, channel_controls[i].name, comp_store, false, &elem); if (err < 0) return err; for (j = 0; j < SND_US16X08_MAX_CHANNELS; j++) { elem->cache_val[j] = channel_controls[i].default_val; } elem->cached = 0xffff; } /* create eq store */ eq_store = snd_us16x08_create_eq_store(); if (!eq_store) return -ENOMEM; /* add EQ controls */ for (i = 0; i < ARRAY_SIZE(eq_controls); i++) { err = add_new_ctl(mixer, eq_controls[i].kcontrol_new, eq_controls[i].control_id, eq_controls[i].type, eq_controls[i].num_channels, eq_controls[i].name, eq_store, i == 0, /* release eq_store only once */ NULL); if (err < 0) return err; } /* add compressor controls */ for (i = 0; i < ARRAY_SIZE(comp_controls); i++) { err = add_new_ctl(mixer, comp_controls[i].kcontrol_new, comp_controls[i].control_id, comp_controls[i].type, comp_controls[i].num_channels, comp_controls[i].name, comp_store, false, NULL); if (err < 0) return err; } /* create meters store */ meter_store = snd_us16x08_create_meter_store(); if (!meter_store) return -ENOMEM; /* meter function 'get' must access to compressor store * so place a reference here */ meter_store->comp_store = comp_store; err = add_new_ctl(mixer, &snd_us16x08_meter_ctl, SND_US16X08_ID_METER, USB_MIXER_U16, 0, "Level Meter", meter_store, true, NULL); if (err < 0) return err; } return 0; }
linux-master
sound/usb/mixer_us16x08.c
// SPDX-License-Identifier: GPL-2.0-or-later /* */ #include <linux/init.h> #include <linux/usb.h> #include <sound/core.h> #include <sound/info.h> #include <sound/pcm.h> #include "usbaudio.h" #include "helper.h" #include "card.h" #include "endpoint.h" #include "proc.h" /* convert our full speed USB rate into sampling rate in Hz */ static inline unsigned get_full_speed_hz(unsigned int usb_rate) { return (usb_rate * 125 + (1 << 12)) >> 13; } /* convert our high speed USB rate into sampling rate in Hz */ static inline unsigned get_high_speed_hz(unsigned int usb_rate) { return (usb_rate * 125 + (1 << 9)) >> 10; } /* * common proc files to show the usb device info */ static void proc_audio_usbbus_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_usb_audio *chip = entry->private_data; if (!atomic_read(&chip->shutdown)) snd_iprintf(buffer, "%03d/%03d\n", chip->dev->bus->busnum, chip->dev->devnum); } static void proc_audio_usbid_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_usb_audio *chip = entry->private_data; if (!atomic_read(&chip->shutdown)) snd_iprintf(buffer, "%04x:%04x\n", USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id)); } void snd_usb_audio_create_proc(struct snd_usb_audio *chip) { snd_card_ro_proc_new(chip->card, "usbbus", chip, proc_audio_usbbus_read); snd_card_ro_proc_new(chip->card, "usbid", chip, proc_audio_usbid_read); } static const char * const channel_labels[] = { [SNDRV_CHMAP_NA] = "N/A", [SNDRV_CHMAP_MONO] = "MONO", [SNDRV_CHMAP_FL] = "FL", [SNDRV_CHMAP_FR] = "FR", [SNDRV_CHMAP_FC] = "FC", [SNDRV_CHMAP_LFE] = "LFE", [SNDRV_CHMAP_RL] = "RL", [SNDRV_CHMAP_RR] = "RR", [SNDRV_CHMAP_FLC] = "FLC", [SNDRV_CHMAP_FRC] = "FRC", [SNDRV_CHMAP_RC] = "RC", [SNDRV_CHMAP_SL] = "SL", [SNDRV_CHMAP_SR] = "SR", [SNDRV_CHMAP_TC] = "TC", [SNDRV_CHMAP_TFL] = "TFL", [SNDRV_CHMAP_TFC] = "TFC", [SNDRV_CHMAP_TFR] = "TFR", [SNDRV_CHMAP_TRL] = "TRL", [SNDRV_CHMAP_TRC] = "TRC", [SNDRV_CHMAP_TRR] = "TRR", [SNDRV_CHMAP_TFLC] = "TFLC", [SNDRV_CHMAP_TFRC] = "TFRC", [SNDRV_CHMAP_LLFE] = "LLFE", [SNDRV_CHMAP_RLFE] = "RLFE", [SNDRV_CHMAP_TSL] = "TSL", [SNDRV_CHMAP_TSR] = "TSR", [SNDRV_CHMAP_BC] = "BC", [SNDRV_CHMAP_RLC] = "RLC", [SNDRV_CHMAP_RRC] = "RRC", }; /* * proc interface for list the supported pcm formats */ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct snd_info_buffer *buffer) { struct audioformat *fp; static const char * const sync_types[4] = { "NONE", "ASYNC", "ADAPTIVE", "SYNC" }; list_for_each_entry(fp, &subs->fmt_list, list) { snd_pcm_format_t fmt; snd_iprintf(buffer, " Interface %d\n", fp->iface); snd_iprintf(buffer, " Altset %d\n", fp->altsetting); snd_iprintf(buffer, " Format:"); pcm_for_each_format(fmt) if (fp->formats & pcm_format_to_bits(fmt)) snd_iprintf(buffer, " %s", snd_pcm_format_name(fmt)); snd_iprintf(buffer, "\n"); snd_iprintf(buffer, " Channels: %d\n", fp->channels); snd_iprintf(buffer, " Endpoint: 0x%02x (%d %s) (%s)\n", fp->endpoint, fp->endpoint & USB_ENDPOINT_NUMBER_MASK, fp->endpoint & USB_DIR_IN ? "IN" : "OUT", sync_types[(fp->ep_attr & USB_ENDPOINT_SYNCTYPE) >> 2]); if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) { snd_iprintf(buffer, " Rates: %d - %d (continuous)\n", fp->rate_min, fp->rate_max); } else { unsigned int i; snd_iprintf(buffer, " Rates: "); for (i = 0; i < fp->nr_rates; i++) { if (i > 0) snd_iprintf(buffer, ", "); snd_iprintf(buffer, "%d", fp->rate_table[i]); } snd_iprintf(buffer, "\n"); } if (subs->speed != USB_SPEED_FULL) snd_iprintf(buffer, " Data packet interval: %d us\n", 125 * (1 << fp->datainterval)); snd_iprintf(buffer, " Bits: %d\n", fp->fmt_bits); if (fp->dsd_raw) snd_iprintf(buffer, " DSD raw: DOP=%d, bitrev=%d\n", fp->dsd_dop, fp->dsd_bitrev); if (fp->chmap) { const struct snd_pcm_chmap_elem *map = fp->chmap; int c; snd_iprintf(buffer, " Channel map:"); for (c = 0; c < map->channels; c++) { if (map->map[c] >= ARRAY_SIZE(channel_labels) || !channel_labels[map->map[c]]) snd_iprintf(buffer, " --"); else snd_iprintf(buffer, " %s", channel_labels[map->map[c]]); } snd_iprintf(buffer, "\n"); } if (fp->sync_ep) { snd_iprintf(buffer, " Sync Endpoint: 0x%02x (%d %s)\n", fp->sync_ep, fp->sync_ep & USB_ENDPOINT_NUMBER_MASK, fp->sync_ep & USB_DIR_IN ? "IN" : "OUT"); snd_iprintf(buffer, " Sync EP Interface: %d\n", fp->sync_iface); snd_iprintf(buffer, " Sync EP Altset: %d\n", fp->sync_altsetting); snd_iprintf(buffer, " Implicit Feedback Mode: %s\n", fp->implicit_fb ? "Yes" : "No"); } // snd_iprintf(buffer, " Max Packet Size = %d\n", fp->maxpacksize); // snd_iprintf(buffer, " EP Attribute = %#x\n", fp->attributes); } } static void proc_dump_ep_status(struct snd_usb_substream *subs, struct snd_usb_endpoint *data_ep, struct snd_usb_endpoint *sync_ep, struct snd_info_buffer *buffer) { if (!data_ep) return; snd_iprintf(buffer, " Packet Size = %d\n", data_ep->curpacksize); snd_iprintf(buffer, " Momentary freq = %u Hz (%#x.%04x)\n", subs->speed == USB_SPEED_FULL ? get_full_speed_hz(data_ep->freqm) : get_high_speed_hz(data_ep->freqm), data_ep->freqm >> 16, data_ep->freqm & 0xffff); if (sync_ep && data_ep->freqshift != INT_MIN) { int res = 16 - data_ep->freqshift; snd_iprintf(buffer, " Feedback Format = %d.%d\n", (sync_ep->syncmaxsize > 3 ? 32 : 24) - res, res); } } static void proc_dump_substream_status(struct snd_usb_audio *chip, struct snd_usb_substream *subs, struct snd_info_buffer *buffer) { mutex_lock(&chip->mutex); if (subs->running) { snd_iprintf(buffer, " Status: Running\n"); if (subs->cur_audiofmt) { snd_iprintf(buffer, " Interface = %d\n", subs->cur_audiofmt->iface); snd_iprintf(buffer, " Altset = %d\n", subs->cur_audiofmt->altsetting); } proc_dump_ep_status(subs, subs->data_endpoint, subs->sync_endpoint, buffer); } else { snd_iprintf(buffer, " Status: Stop\n"); } mutex_unlock(&chip->mutex); } static void proc_pcm_format_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_usb_stream *stream = entry->private_data; struct snd_usb_audio *chip = stream->chip; snd_iprintf(buffer, "%s : %s\n", chip->card->longname, stream->pcm->name); if (stream->substream[SNDRV_PCM_STREAM_PLAYBACK].num_formats) { snd_iprintf(buffer, "\nPlayback:\n"); proc_dump_substream_status(chip, &stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer); proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_PLAYBACK], buffer); } if (stream->substream[SNDRV_PCM_STREAM_CAPTURE].num_formats) { snd_iprintf(buffer, "\nCapture:\n"); proc_dump_substream_status(chip, &stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer); proc_dump_substream_formats(&stream->substream[SNDRV_PCM_STREAM_CAPTURE], buffer); } } void snd_usb_proc_pcm_format_add(struct snd_usb_stream *stream) { char name[32]; struct snd_card *card = stream->chip->card; sprintf(name, "stream%d", stream->pcm_index); snd_card_ro_proc_new(card, name, stream, proc_pcm_format_read); }
linux-master
sound/usb/proc.c
// SPDX-License-Identifier: GPL-2.0-or-later // // Special handling for implicit feedback mode // #include <linux/init.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "usbaudio.h" #include "card.h" #include "helper.h" #include "pcm.h" #include "implicit.h" enum { IMPLICIT_FB_NONE, IMPLICIT_FB_GENERIC, IMPLICIT_FB_FIXED, IMPLICIT_FB_BOTH, /* generic playback + capture (for BOSS) */ }; struct snd_usb_implicit_fb_match { unsigned int id; unsigned int iface_class; unsigned int ep_num; unsigned int iface; int type; }; #define IMPLICIT_FB_GENERIC_DEV(vend, prod) \ { .id = USB_ID(vend, prod), .type = IMPLICIT_FB_GENERIC } #define IMPLICIT_FB_FIXED_DEV(vend, prod, ep, ifnum) \ { .id = USB_ID(vend, prod), .type = IMPLICIT_FB_FIXED, .ep_num = (ep),\ .iface = (ifnum) } #define IMPLICIT_FB_BOTH_DEV(vend, prod, ep, ifnum) \ { .id = USB_ID(vend, prod), .type = IMPLICIT_FB_BOTH, .ep_num = (ep),\ .iface = (ifnum) } #define IMPLICIT_FB_SKIP_DEV(vend, prod) \ { .id = USB_ID(vend, prod), .type = IMPLICIT_FB_NONE } /* Implicit feedback quirk table for playback */ static const struct snd_usb_implicit_fb_match playback_implicit_fb_quirks[] = { /* Fixed EP */ /* FIXME: check the availability of generic matching */ IMPLICIT_FB_FIXED_DEV(0x0763, 0x2030, 0x81, 3), /* M-Audio Fast Track C400 */ IMPLICIT_FB_FIXED_DEV(0x0763, 0x2031, 0x81, 3), /* M-Audio Fast Track C600 */ IMPLICIT_FB_FIXED_DEV(0x0763, 0x2080, 0x81, 2), /* M-Audio FastTrack Ultra */ IMPLICIT_FB_FIXED_DEV(0x0763, 0x2081, 0x81, 2), /* M-Audio FastTrack Ultra */ IMPLICIT_FB_FIXED_DEV(0x2466, 0x8010, 0x81, 2), /* Fractal Audio Axe-Fx III */ IMPLICIT_FB_FIXED_DEV(0x31e9, 0x0001, 0x81, 2), /* Solid State Logic SSL2 */ IMPLICIT_FB_FIXED_DEV(0x31e9, 0x0002, 0x81, 2), /* Solid State Logic SSL2+ */ IMPLICIT_FB_FIXED_DEV(0x0499, 0x172f, 0x81, 2), /* Steinberg UR22C */ IMPLICIT_FB_FIXED_DEV(0x0d9a, 0x00df, 0x81, 2), /* RTX6001 */ IMPLICIT_FB_FIXED_DEV(0x22f0, 0x0006, 0x81, 3), /* Allen&Heath Qu-16 */ IMPLICIT_FB_FIXED_DEV(0x1686, 0xf029, 0x82, 2), /* Zoom UAC-2 */ IMPLICIT_FB_FIXED_DEV(0x2466, 0x8003, 0x86, 2), /* Fractal Audio Axe-Fx II */ IMPLICIT_FB_FIXED_DEV(0x0499, 0x172a, 0x86, 2), /* Yamaha MODX */ /* Special matching */ { .id = USB_ID(0x07fd, 0x0004), .iface_class = USB_CLASS_AUDIO, .type = IMPLICIT_FB_NONE }, /* MicroBook IIc */ /* ep = 0x84, ifnum = 0 */ { .id = USB_ID(0x07fd, 0x0004), .iface_class = USB_CLASS_VENDOR_SPEC, .type = IMPLICIT_FB_FIXED, .ep_num = 0x84, .iface = 0 }, /* MOTU MicroBook II */ {} /* terminator */ }; /* Implicit feedback quirk table for capture: only FIXED type */ static const struct snd_usb_implicit_fb_match capture_implicit_fb_quirks[] = { {} /* terminator */ }; /* set up sync EP information on the audioformat */ static int add_implicit_fb_sync_ep(struct snd_usb_audio *chip, struct audioformat *fmt, int ep, int ep_idx, int ifnum, const struct usb_host_interface *alts) { struct usb_interface *iface; if (!alts) { iface = usb_ifnum_to_if(chip->dev, ifnum); if (!iface || iface->num_altsetting < 2) return 0; alts = &iface->altsetting[1]; } fmt->sync_ep = ep; fmt->sync_iface = ifnum; fmt->sync_altsetting = alts->desc.bAlternateSetting; fmt->sync_ep_idx = ep_idx; fmt->implicit_fb = 1; usb_audio_dbg(chip, "%d:%d: added %s implicit_fb sync_ep %x, iface %d:%d\n", fmt->iface, fmt->altsetting, (ep & USB_DIR_IN) ? "playback" : "capture", fmt->sync_ep, fmt->sync_iface, fmt->sync_altsetting); return 1; } /* Check whether the given UAC2 iface:altset points to an implicit fb source */ static int add_generic_uac2_implicit_fb(struct snd_usb_audio *chip, struct audioformat *fmt, unsigned int ifnum, unsigned int altsetting) { struct usb_host_interface *alts; struct usb_endpoint_descriptor *epd; alts = snd_usb_get_host_interface(chip, ifnum, altsetting); if (!alts) return 0; if (alts->desc.bInterfaceClass != USB_CLASS_AUDIO || alts->desc.bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING || alts->desc.bInterfaceProtocol != UAC_VERSION_2 || alts->desc.bNumEndpoints < 1) return 0; epd = get_endpoint(alts, 0); if (!usb_endpoint_is_isoc_in(epd) || (epd->bmAttributes & USB_ENDPOINT_USAGE_MASK) != USB_ENDPOINT_USAGE_IMPLICIT_FB) return 0; return add_implicit_fb_sync_ep(chip, fmt, epd->bEndpointAddress, 0, ifnum, alts); } static bool roland_sanity_check_iface(struct usb_host_interface *alts) { if (alts->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC || (alts->desc.bInterfaceSubClass != 2 && alts->desc.bInterfaceProtocol != 2) || alts->desc.bNumEndpoints < 1) return false; return true; } /* Like the UAC2 case above, but specific to Roland with vendor class and hack */ static int add_roland_implicit_fb(struct snd_usb_audio *chip, struct audioformat *fmt, struct usb_host_interface *alts) { struct usb_endpoint_descriptor *epd; if (!roland_sanity_check_iface(alts)) return 0; /* only when both streams are with ASYNC type */ epd = get_endpoint(alts, 0); if (!usb_endpoint_is_isoc_out(epd) || (epd->bmAttributes & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) return 0; /* check capture EP */ alts = snd_usb_get_host_interface(chip, alts->desc.bInterfaceNumber + 1, alts->desc.bAlternateSetting); if (!alts || !roland_sanity_check_iface(alts)) return 0; epd = get_endpoint(alts, 0); if (!usb_endpoint_is_isoc_in(epd) || (epd->bmAttributes & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) return 0; chip->quirk_flags |= QUIRK_FLAG_PLAYBACK_FIRST; return add_implicit_fb_sync_ep(chip, fmt, epd->bEndpointAddress, 0, alts->desc.bInterfaceNumber, alts); } /* capture quirk for Roland device; always full-duplex */ static int add_roland_capture_quirk(struct snd_usb_audio *chip, struct audioformat *fmt, struct usb_host_interface *alts) { struct usb_endpoint_descriptor *epd; if (!roland_sanity_check_iface(alts)) return 0; epd = get_endpoint(alts, 0); if (!usb_endpoint_is_isoc_in(epd) || (epd->bmAttributes & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) return 0; alts = snd_usb_get_host_interface(chip, alts->desc.bInterfaceNumber - 1, alts->desc.bAlternateSetting); if (!alts || !roland_sanity_check_iface(alts)) return 0; epd = get_endpoint(alts, 0); if (!usb_endpoint_is_isoc_out(epd)) return 0; return add_implicit_fb_sync_ep(chip, fmt, epd->bEndpointAddress, 0, alts->desc.bInterfaceNumber, alts); } /* Playback and capture EPs on Pioneer devices share the same iface/altset * for the implicit feedback operation */ static bool is_pioneer_implicit_fb(struct snd_usb_audio *chip, struct usb_host_interface *alts) { struct usb_endpoint_descriptor *epd; if (USB_ID_VENDOR(chip->usb_id) != 0x2b73 && USB_ID_VENDOR(chip->usb_id) != 0x08e4) return false; if (alts->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC) return false; if (alts->desc.bNumEndpoints != 2) return false; epd = get_endpoint(alts, 0); if (!usb_endpoint_is_isoc_out(epd) || (epd->bmAttributes & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) return false; epd = get_endpoint(alts, 1); if (!usb_endpoint_is_isoc_in(epd) || (epd->bmAttributes & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC || ((epd->bmAttributes & USB_ENDPOINT_USAGE_MASK) != USB_ENDPOINT_USAGE_DATA && (epd->bmAttributes & USB_ENDPOINT_USAGE_MASK) != USB_ENDPOINT_USAGE_IMPLICIT_FB)) return false; return true; } static int __add_generic_implicit_fb(struct snd_usb_audio *chip, struct audioformat *fmt, int iface, int altset) { struct usb_host_interface *alts; struct usb_endpoint_descriptor *epd; alts = snd_usb_get_host_interface(chip, iface, altset); if (!alts) return 0; if ((alts->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC && alts->desc.bInterfaceClass != USB_CLASS_AUDIO) || alts->desc.bNumEndpoints < 1) return 0; epd = get_endpoint(alts, 0); if (!usb_endpoint_is_isoc_in(epd) || (epd->bmAttributes & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) return 0; return add_implicit_fb_sync_ep(chip, fmt, epd->bEndpointAddress, 0, iface, alts); } /* More generic quirk: look for the sync EP next to the data EP */ static int add_generic_implicit_fb(struct snd_usb_audio *chip, struct audioformat *fmt, struct usb_host_interface *alts) { if ((fmt->ep_attr & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) return 0; if (__add_generic_implicit_fb(chip, fmt, alts->desc.bInterfaceNumber + 1, alts->desc.bAlternateSetting)) return 1; return __add_generic_implicit_fb(chip, fmt, alts->desc.bInterfaceNumber - 1, alts->desc.bAlternateSetting); } static const struct snd_usb_implicit_fb_match * find_implicit_fb_entry(struct snd_usb_audio *chip, const struct snd_usb_implicit_fb_match *match, const struct usb_host_interface *alts) { for (; match->id; match++) if (match->id == chip->usb_id && (!match->iface_class || (alts->desc.bInterfaceClass == match->iface_class))) return match; return NULL; } /* Setup an implicit feedback endpoint from a quirk. Returns 0 if no quirk * applies. Returns 1 if a quirk was found. */ static int audioformat_implicit_fb_quirk(struct snd_usb_audio *chip, struct audioformat *fmt, struct usb_host_interface *alts) { const struct snd_usb_implicit_fb_match *p; unsigned int attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE; p = find_implicit_fb_entry(chip, playback_implicit_fb_quirks, alts); if (p) { switch (p->type) { case IMPLICIT_FB_GENERIC: return add_generic_implicit_fb(chip, fmt, alts); case IMPLICIT_FB_NONE: return 0; /* No quirk */ case IMPLICIT_FB_FIXED: return add_implicit_fb_sync_ep(chip, fmt, p->ep_num, 0, p->iface, NULL); } } /* Special handling for devices with capture quirks */ p = find_implicit_fb_entry(chip, capture_implicit_fb_quirks, alts); if (p) { switch (p->type) { case IMPLICIT_FB_FIXED: return 0; /* no quirk */ case IMPLICIT_FB_BOTH: chip->quirk_flags |= QUIRK_FLAG_PLAYBACK_FIRST; return add_generic_implicit_fb(chip, fmt, alts); } } /* Generic UAC2 implicit feedback */ if (attr == USB_ENDPOINT_SYNC_ASYNC && alts->desc.bInterfaceClass == USB_CLASS_AUDIO && alts->desc.bInterfaceProtocol == UAC_VERSION_2 && alts->desc.bNumEndpoints == 1) { if (add_generic_uac2_implicit_fb(chip, fmt, alts->desc.bInterfaceNumber + 1, alts->desc.bAlternateSetting)) return 1; } /* Roland/BOSS implicit feedback with vendor spec class */ if (USB_ID_VENDOR(chip->usb_id) == 0x0582) { if (add_roland_implicit_fb(chip, fmt, alts) > 0) return 1; } /* Pioneer devices with vendor spec class */ if (is_pioneer_implicit_fb(chip, alts)) { chip->quirk_flags |= QUIRK_FLAG_PLAYBACK_FIRST; return add_implicit_fb_sync_ep(chip, fmt, get_endpoint(alts, 1)->bEndpointAddress, 1, alts->desc.bInterfaceNumber, alts); } /* Try the generic implicit fb if available */ if (chip->generic_implicit_fb || (chip->quirk_flags & QUIRK_FLAG_GENERIC_IMPLICIT_FB)) return add_generic_implicit_fb(chip, fmt, alts); /* No quirk */ return 0; } /* same for capture, but only handling FIXED entry */ static int audioformat_capture_quirk(struct snd_usb_audio *chip, struct audioformat *fmt, struct usb_host_interface *alts) { const struct snd_usb_implicit_fb_match *p; p = find_implicit_fb_entry(chip, capture_implicit_fb_quirks, alts); if (p && (p->type == IMPLICIT_FB_FIXED || p->type == IMPLICIT_FB_BOTH)) return add_implicit_fb_sync_ep(chip, fmt, p->ep_num, 0, p->iface, NULL); /* Roland/BOSS need full-duplex streams */ if (USB_ID_VENDOR(chip->usb_id) == 0x0582) { if (add_roland_capture_quirk(chip, fmt, alts) > 0) return 1; } if (is_pioneer_implicit_fb(chip, alts)) return 1; /* skip the quirk, also don't handle generic sync EP */ return 0; } /* * Parse altset and set up implicit feedback endpoint on the audioformat */ int snd_usb_parse_implicit_fb_quirk(struct snd_usb_audio *chip, struct audioformat *fmt, struct usb_host_interface *alts) { if (chip->quirk_flags & QUIRK_FLAG_SKIP_IMPLICIT_FB) return 0; if (fmt->endpoint & USB_DIR_IN) return audioformat_capture_quirk(chip, fmt, alts); else return audioformat_implicit_fb_quirk(chip, fmt, alts); } /* * Return the score of matching two audioformats. * Veto the audioformat if: * - It has no channels for some reason. * - Requested PCM format is not supported. * - Requested sample rate is not supported. */ static int match_endpoint_audioformats(struct snd_usb_substream *subs, const struct audioformat *fp, int rate, int channels, snd_pcm_format_t pcm_format) { int i, score; if (fp->channels < 1) return 0; if (!(fp->formats & pcm_format_to_bits(pcm_format))) return 0; if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) { if (rate < fp->rate_min || rate > fp->rate_max) return 0; } else { for (i = 0; i < fp->nr_rates; i++) { if (fp->rate_table[i] == rate) break; } if (i >= fp->nr_rates) return 0; } score = 1; if (fp->channels == channels) score++; return score; } static struct snd_usb_substream * find_matching_substream(struct snd_usb_audio *chip, int stream, int ep_num, int fmt_type) { struct snd_usb_stream *as; struct snd_usb_substream *subs; list_for_each_entry(as, &chip->pcm_list, list) { subs = &as->substream[stream]; if (as->fmt_type == fmt_type && subs->ep_num == ep_num) return subs; } return NULL; } /* * Return the audioformat that is suitable for the implicit fb */ const struct audioformat * snd_usb_find_implicit_fb_sync_format(struct snd_usb_audio *chip, const struct audioformat *target, const struct snd_pcm_hw_params *params, int stream, bool *fixed_rate) { struct snd_usb_substream *subs; const struct audioformat *fp, *sync_fmt = NULL; int score, high_score; /* Use the original audioformat as fallback for the shared altset */ if (target->iface == target->sync_iface && target->altsetting == target->sync_altsetting) sync_fmt = target; subs = find_matching_substream(chip, stream, target->sync_ep, target->fmt_type); if (!subs) goto end; high_score = 0; list_for_each_entry(fp, &subs->fmt_list, list) { score = match_endpoint_audioformats(subs, fp, params_rate(params), params_channels(params), params_format(params)); if (score > high_score) { sync_fmt = fp; high_score = score; } } end: if (fixed_rate) *fixed_rate = snd_usb_pcm_has_fixed_rate(subs); return sync_fmt; }
linux-master
sound/usb/implicit.c
// SPDX-License-Identifier: GPL-2.0 /* * media.c - Media Controller specific ALSA driver code * * Copyright (c) 2019 Shuah Khan <[email protected]> * */ /* * This file adds Media Controller support to the ALSA driver * to use the Media Controller API to share the tuner with DVB * and V4L2 drivers that control the media device. * * The media device is created based on the existing quirks framework. * Using this approach, the media controller API usage can be added for * a specific device. */ #include <linux/init.h> #include <linux/list.h> #include <linux/mutex.h> #include <linux/slab.h> #include <linux/usb.h> #include <sound/pcm.h> #include <sound/core.h> #include "usbaudio.h" #include "card.h" #include "mixer.h" #include "media.h" int snd_media_stream_init(struct snd_usb_substream *subs, struct snd_pcm *pcm, int stream) { struct media_device *mdev; struct media_ctl *mctl; struct device *pcm_dev = pcm->streams[stream].dev; u32 intf_type; int ret = 0; u16 mixer_pad; struct media_entity *entity; mdev = subs->stream->chip->media_dev; if (!mdev) return 0; if (subs->media_ctl) return 0; /* allocate media_ctl */ mctl = kzalloc(sizeof(*mctl), GFP_KERNEL); if (!mctl) return -ENOMEM; mctl->media_dev = mdev; if (stream == SNDRV_PCM_STREAM_PLAYBACK) { intf_type = MEDIA_INTF_T_ALSA_PCM_PLAYBACK; mctl->media_entity.function = MEDIA_ENT_F_AUDIO_PLAYBACK; mctl->media_pad.flags = MEDIA_PAD_FL_SOURCE; mixer_pad = 1; } else { intf_type = MEDIA_INTF_T_ALSA_PCM_CAPTURE; mctl->media_entity.function = MEDIA_ENT_F_AUDIO_CAPTURE; mctl->media_pad.flags = MEDIA_PAD_FL_SINK; mixer_pad = 2; } mctl->media_entity.name = pcm->name; media_entity_pads_init(&mctl->media_entity, 1, &mctl->media_pad); ret = media_device_register_entity(mctl->media_dev, &mctl->media_entity); if (ret) goto free_mctl; mctl->intf_devnode = media_devnode_create(mdev, intf_type, 0, MAJOR(pcm_dev->devt), MINOR(pcm_dev->devt)); if (!mctl->intf_devnode) { ret = -ENOMEM; goto unregister_entity; } mctl->intf_link = media_create_intf_link(&mctl->media_entity, &mctl->intf_devnode->intf, MEDIA_LNK_FL_ENABLED); if (!mctl->intf_link) { ret = -ENOMEM; goto devnode_remove; } /* create link between mixer and audio */ media_device_for_each_entity(entity, mdev) { switch (entity->function) { case MEDIA_ENT_F_AUDIO_MIXER: ret = media_create_pad_link(entity, mixer_pad, &mctl->media_entity, 0, MEDIA_LNK_FL_ENABLED); if (ret) goto remove_intf_link; break; } } subs->media_ctl = mctl; return 0; remove_intf_link: media_remove_intf_link(mctl->intf_link); devnode_remove: media_devnode_remove(mctl->intf_devnode); unregister_entity: media_device_unregister_entity(&mctl->media_entity); free_mctl: kfree(mctl); return ret; } void snd_media_stream_delete(struct snd_usb_substream *subs) { struct media_ctl *mctl = subs->media_ctl; if (mctl) { struct media_device *mdev; mdev = mctl->media_dev; if (mdev && media_devnode_is_registered(mdev->devnode)) { media_devnode_remove(mctl->intf_devnode); media_device_unregister_entity(&mctl->media_entity); media_entity_cleanup(&mctl->media_entity); } kfree(mctl); subs->media_ctl = NULL; } } int snd_media_start_pipeline(struct snd_usb_substream *subs) { struct media_ctl *mctl = subs->media_ctl; int ret = 0; if (!mctl) return 0; mutex_lock(&mctl->media_dev->graph_mutex); if (mctl->media_dev->enable_source) ret = mctl->media_dev->enable_source(&mctl->media_entity, &mctl->media_pipe); mutex_unlock(&mctl->media_dev->graph_mutex); return ret; } void snd_media_stop_pipeline(struct snd_usb_substream *subs) { struct media_ctl *mctl = subs->media_ctl; if (!mctl) return; mutex_lock(&mctl->media_dev->graph_mutex); if (mctl->media_dev->disable_source) mctl->media_dev->disable_source(&mctl->media_entity); mutex_unlock(&mctl->media_dev->graph_mutex); } static int snd_media_mixer_init(struct snd_usb_audio *chip) { struct device *ctl_dev = chip->card->ctl_dev; struct media_intf_devnode *ctl_intf; struct usb_mixer_interface *mixer; struct media_device *mdev = chip->media_dev; struct media_mixer_ctl *mctl; u32 intf_type = MEDIA_INTF_T_ALSA_CONTROL; int ret; if (!mdev) return -ENODEV; ctl_intf = chip->ctl_intf_media_devnode; if (!ctl_intf) { ctl_intf = media_devnode_create(mdev, intf_type, 0, MAJOR(ctl_dev->devt), MINOR(ctl_dev->devt)); if (!ctl_intf) return -ENOMEM; chip->ctl_intf_media_devnode = ctl_intf; } list_for_each_entry(mixer, &chip->mixer_list, list) { if (mixer->media_mixer_ctl) continue; /* allocate media_mixer_ctl */ mctl = kzalloc(sizeof(*mctl), GFP_KERNEL); if (!mctl) return -ENOMEM; mctl->media_dev = mdev; mctl->media_entity.function = MEDIA_ENT_F_AUDIO_MIXER; mctl->media_entity.name = chip->card->mixername; mctl->media_pad[0].flags = MEDIA_PAD_FL_SINK; mctl->media_pad[1].flags = MEDIA_PAD_FL_SOURCE; mctl->media_pad[2].flags = MEDIA_PAD_FL_SOURCE; media_entity_pads_init(&mctl->media_entity, MEDIA_MIXER_PAD_MAX, mctl->media_pad); ret = media_device_register_entity(mctl->media_dev, &mctl->media_entity); if (ret) { kfree(mctl); return ret; } mctl->intf_link = media_create_intf_link(&mctl->media_entity, &ctl_intf->intf, MEDIA_LNK_FL_ENABLED); if (!mctl->intf_link) { media_device_unregister_entity(&mctl->media_entity); media_entity_cleanup(&mctl->media_entity); kfree(mctl); return -ENOMEM; } mctl->intf_devnode = ctl_intf; mixer->media_mixer_ctl = mctl; } return 0; } static void snd_media_mixer_delete(struct snd_usb_audio *chip) { struct usb_mixer_interface *mixer; struct media_device *mdev = chip->media_dev; if (!mdev) return; list_for_each_entry(mixer, &chip->mixer_list, list) { struct media_mixer_ctl *mctl; mctl = mixer->media_mixer_ctl; if (!mixer->media_mixer_ctl) continue; if (media_devnode_is_registered(mdev->devnode)) { media_device_unregister_entity(&mctl->media_entity); media_entity_cleanup(&mctl->media_entity); } kfree(mctl); mixer->media_mixer_ctl = NULL; } if (media_devnode_is_registered(mdev->devnode)) media_devnode_remove(chip->ctl_intf_media_devnode); chip->ctl_intf_media_devnode = NULL; } int snd_media_device_create(struct snd_usb_audio *chip, struct usb_interface *iface) { struct media_device *mdev; struct usb_device *usbdev = interface_to_usbdev(iface); int ret = 0; /* usb-audio driver is probed for each usb interface, and * there are multiple interfaces per device. Avoid calling * media_device_usb_allocate() each time usb_audio_probe() * is called. Do it only once. */ if (chip->media_dev) { mdev = chip->media_dev; goto snd_mixer_init; } mdev = media_device_usb_allocate(usbdev, KBUILD_MODNAME, THIS_MODULE); if (IS_ERR(mdev)) return -ENOMEM; /* save media device - avoid lookups */ chip->media_dev = mdev; snd_mixer_init: /* Create media entities for mixer and control dev */ ret = snd_media_mixer_init(chip); /* media_device might be registered, print error and continue */ if (ret) dev_err(&usbdev->dev, "Couldn't create media mixer entities. Error: %d\n", ret); if (!media_devnode_is_registered(mdev->devnode)) { /* don't register if snd_media_mixer_init() failed */ if (ret) goto create_fail; /* register media_device */ ret = media_device_register(mdev); create_fail: if (ret) { snd_media_mixer_delete(chip); media_device_delete(mdev, KBUILD_MODNAME, THIS_MODULE); /* clear saved media_dev */ chip->media_dev = NULL; dev_err(&usbdev->dev, "Couldn't register media device. Error: %d\n", ret); return ret; } } return ret; } void snd_media_device_delete(struct snd_usb_audio *chip) { struct media_device *mdev = chip->media_dev; struct snd_usb_stream *stream; /* release resources */ list_for_each_entry(stream, &chip->pcm_list, list) { snd_media_stream_delete(&stream->substream[0]); snd_media_stream_delete(&stream->substream[1]); } snd_media_mixer_delete(chip); if (mdev) { media_device_delete(mdev, KBUILD_MODNAME, THIS_MODULE); chip->media_dev = NULL; } }
linux-master
sound/usb/media.c
// SPDX-License-Identifier: GPL-2.0-or-later /* */ #include <linux/init.h> #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/midi.h> #include <linux/bits.h> #include <sound/control.h> #include <sound/core.h> #include <sound/info.h> #include <sound/pcm.h> #include "usbaudio.h" #include "card.h" #include "mixer.h" #include "mixer_quirks.h" #include "midi.h" #include "midi2.h" #include "quirks.h" #include "helper.h" #include "endpoint.h" #include "pcm.h" #include "clock.h" #include "stream.h" /* * handle the quirks for the contained interfaces */ static int create_composite_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk_comp) { int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber; const struct snd_usb_audio_quirk *quirk; int err; for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) { iface = usb_ifnum_to_if(chip->dev, quirk->ifnum); if (!iface) continue; if (quirk->ifnum != probed_ifnum && usb_interface_claimed(iface)) continue; err = snd_usb_create_quirk(chip, iface, driver, quirk); if (err < 0) return err; } for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) { iface = usb_ifnum_to_if(chip->dev, quirk->ifnum); if (!iface) continue; if (quirk->ifnum != probed_ifnum && !usb_interface_claimed(iface)) { err = usb_driver_claim_interface(driver, iface, USB_AUDIO_IFACE_UNUSED); if (err < 0) return err; } } return 0; } static int ignore_interface_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk) { return 0; } static int create_any_midi_quirk(struct snd_usb_audio *chip, struct usb_interface *intf, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk) { return snd_usb_midi_v2_create(chip, intf, quirk, 0); } /* * create a stream for an interface with proper descriptors */ static int create_standard_audio_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk) { struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; int err; alts = &iface->altsetting[0]; altsd = get_iface_desc(alts); err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber); if (err < 0) { usb_audio_err(chip, "cannot setup if %d: error %d\n", altsd->bInterfaceNumber, err); return err; } /* reset the current interface */ usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0); return 0; } /* create the audio stream and the corresponding endpoints from the fixed * audioformat object; this is used for quirks with the fixed EPs */ static int add_audio_stream_from_fixed_fmt(struct snd_usb_audio *chip, struct audioformat *fp) { int stream, err; stream = (fp->endpoint & USB_DIR_IN) ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; snd_usb_audioformat_set_sync_ep(chip, fp); err = snd_usb_add_audio_stream(chip, stream, fp); if (err < 0) return err; err = snd_usb_add_endpoint(chip, fp->endpoint, SND_USB_ENDPOINT_TYPE_DATA); if (err < 0) return err; if (fp->sync_ep) { err = snd_usb_add_endpoint(chip, fp->sync_ep, fp->implicit_fb ? SND_USB_ENDPOINT_TYPE_DATA : SND_USB_ENDPOINT_TYPE_SYNC); if (err < 0) return err; } return 0; } /* * create a stream for an endpoint/altsetting without proper descriptors */ static int create_fixed_stream_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk) { struct audioformat *fp; struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; unsigned *rate_table = NULL; int err; fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL); if (!fp) return -ENOMEM; INIT_LIST_HEAD(&fp->list); if (fp->nr_rates > MAX_NR_RATES) { kfree(fp); return -EINVAL; } if (fp->nr_rates > 0) { rate_table = kmemdup(fp->rate_table, sizeof(int) * fp->nr_rates, GFP_KERNEL); if (!rate_table) { kfree(fp); return -ENOMEM; } fp->rate_table = rate_table; } if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber || fp->altset_idx >= iface->num_altsetting) { err = -EINVAL; goto error; } alts = &iface->altsetting[fp->altset_idx]; altsd = get_iface_desc(alts); if (altsd->bNumEndpoints <= fp->ep_idx) { err = -EINVAL; goto error; } fp->protocol = altsd->bInterfaceProtocol; if (fp->datainterval == 0) fp->datainterval = snd_usb_parse_datainterval(chip, alts); if (fp->maxpacksize == 0) fp->maxpacksize = le16_to_cpu(get_endpoint(alts, fp->ep_idx)->wMaxPacketSize); if (!fp->fmt_type) fp->fmt_type = UAC_FORMAT_TYPE_I; err = add_audio_stream_from_fixed_fmt(chip, fp); if (err < 0) goto error; usb_set_interface(chip->dev, fp->iface, 0); snd_usb_init_pitch(chip, fp); snd_usb_init_sample_rate(chip, fp, fp->rate_max); return 0; error: list_del(&fp->list); /* unlink for avoiding double-free */ kfree(fp); kfree(rate_table); return err; } static int create_auto_pcm_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver) { struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; struct usb_endpoint_descriptor *epd; struct uac1_as_header_descriptor *ashd; struct uac_format_type_i_discrete_descriptor *fmtd; /* * Most Roland/Yamaha audio streaming interfaces have more or less * standard descriptors, but older devices might lack descriptors, and * future ones might change, so ensure that we fail silently if the * interface doesn't look exactly right. */ /* must have a non-zero altsetting for streaming */ if (iface->num_altsetting < 2) return -ENODEV; alts = &iface->altsetting[1]; altsd = get_iface_desc(alts); /* must have an isochronous endpoint for streaming */ if (altsd->bNumEndpoints < 1) return -ENODEV; epd = get_endpoint(alts, 0); if (!usb_endpoint_xfer_isoc(epd)) return -ENODEV; /* must have format descriptors */ ashd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); fmtd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE); if (!ashd || ashd->bLength < 7 || !fmtd || fmtd->bLength < 8) return -ENODEV; return create_standard_audio_quirk(chip, iface, driver, NULL); } static int create_yamaha_midi_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, struct usb_host_interface *alts) { static const struct snd_usb_audio_quirk yamaha_midi_quirk = { .type = QUIRK_MIDI_YAMAHA }; struct usb_midi_in_jack_descriptor *injd; struct usb_midi_out_jack_descriptor *outjd; /* must have some valid jack descriptors */ injd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, USB_MS_MIDI_IN_JACK); outjd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, USB_MS_MIDI_OUT_JACK); if (!injd && !outjd) return -ENODEV; if ((injd && !snd_usb_validate_midi_desc(injd)) || (outjd && !snd_usb_validate_midi_desc(outjd))) return -ENODEV; if (injd && (injd->bLength < 5 || (injd->bJackType != USB_MS_EMBEDDED && injd->bJackType != USB_MS_EXTERNAL))) return -ENODEV; if (outjd && (outjd->bLength < 6 || (outjd->bJackType != USB_MS_EMBEDDED && outjd->bJackType != USB_MS_EXTERNAL))) return -ENODEV; return create_any_midi_quirk(chip, iface, driver, &yamaha_midi_quirk); } static int create_roland_midi_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, struct usb_host_interface *alts) { static const struct snd_usb_audio_quirk roland_midi_quirk = { .type = QUIRK_MIDI_ROLAND }; u8 *roland_desc = NULL; /* might have a vendor-specific descriptor <06 24 F1 02 ...> */ for (;;) { roland_desc = snd_usb_find_csint_desc(alts->extra, alts->extralen, roland_desc, 0xf1); if (!roland_desc) return -ENODEV; if (roland_desc[0] < 6 || roland_desc[3] != 2) continue; return create_any_midi_quirk(chip, iface, driver, &roland_midi_quirk); } } static int create_std_midi_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, struct usb_host_interface *alts) { struct usb_ms_header_descriptor *mshd; struct usb_ms_endpoint_descriptor *msepd; /* must have the MIDIStreaming interface header descriptor*/ mshd = (struct usb_ms_header_descriptor *)alts->extra; if (alts->extralen < 7 || mshd->bLength < 7 || mshd->bDescriptorType != USB_DT_CS_INTERFACE || mshd->bDescriptorSubtype != USB_MS_HEADER) return -ENODEV; /* must have the MIDIStreaming endpoint descriptor*/ msepd = (struct usb_ms_endpoint_descriptor *)alts->endpoint[0].extra; if (alts->endpoint[0].extralen < 4 || msepd->bLength < 4 || msepd->bDescriptorType != USB_DT_CS_ENDPOINT || msepd->bDescriptorSubtype != UAC_MS_GENERAL || msepd->bNumEmbMIDIJack < 1 || msepd->bNumEmbMIDIJack > 16) return -ENODEV; return create_any_midi_quirk(chip, iface, driver, NULL); } static int create_auto_midi_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver) { struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; struct usb_endpoint_descriptor *epd; int err; alts = &iface->altsetting[0]; altsd = get_iface_desc(alts); /* must have at least one bulk/interrupt endpoint for streaming */ if (altsd->bNumEndpoints < 1) return -ENODEV; epd = get_endpoint(alts, 0); if (!usb_endpoint_xfer_bulk(epd) && !usb_endpoint_xfer_int(epd)) return -ENODEV; switch (USB_ID_VENDOR(chip->usb_id)) { case 0x0499: /* Yamaha */ err = create_yamaha_midi_quirk(chip, iface, driver, alts); if (err != -ENODEV) return err; break; case 0x0582: /* Roland */ err = create_roland_midi_quirk(chip, iface, driver, alts); if (err != -ENODEV) return err; break; } return create_std_midi_quirk(chip, iface, driver, alts); } static int create_autodetect_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk) { int err; err = create_auto_pcm_quirk(chip, iface, driver); if (err == -ENODEV) err = create_auto_midi_quirk(chip, iface, driver); return err; } /* * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface. * The only way to detect the sample rate is by looking at wMaxPacketSize. */ static int create_uaxx_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk) { static const struct audioformat ua_format = { .formats = SNDRV_PCM_FMTBIT_S24_3LE, .channels = 2, .fmt_type = UAC_FORMAT_TYPE_I, .altsetting = 1, .altset_idx = 1, .rates = SNDRV_PCM_RATE_CONTINUOUS, }; struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; struct audioformat *fp; int err; /* both PCM and MIDI interfaces have 2 or more altsettings */ if (iface->num_altsetting < 2) return -ENXIO; alts = &iface->altsetting[1]; altsd = get_iface_desc(alts); if (altsd->bNumEndpoints == 2) { static const struct snd_usb_midi_endpoint_info ua700_ep = { .out_cables = 0x0003, .in_cables = 0x0003 }; static const struct snd_usb_audio_quirk ua700_quirk = { .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = &ua700_ep }; static const struct snd_usb_midi_endpoint_info uaxx_ep = { .out_cables = 0x0001, .in_cables = 0x0001 }; static const struct snd_usb_audio_quirk uaxx_quirk = { .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = &uaxx_ep }; const struct snd_usb_audio_quirk *quirk = chip->usb_id == USB_ID(0x0582, 0x002b) ? &ua700_quirk : &uaxx_quirk; return __snd_usbmidi_create(chip->card, iface, &chip->midi_list, quirk, chip->usb_id, &chip->num_rawmidis); } if (altsd->bNumEndpoints != 1) return -ENXIO; fp = kmemdup(&ua_format, sizeof(*fp), GFP_KERNEL); if (!fp) return -ENOMEM; fp->iface = altsd->bInterfaceNumber; fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; fp->datainterval = 0; fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); INIT_LIST_HEAD(&fp->list); switch (fp->maxpacksize) { case 0x120: fp->rate_max = fp->rate_min = 44100; break; case 0x138: case 0x140: fp->rate_max = fp->rate_min = 48000; break; case 0x258: case 0x260: fp->rate_max = fp->rate_min = 96000; break; default: usb_audio_err(chip, "unknown sample rate\n"); kfree(fp); return -ENXIO; } err = add_audio_stream_from_fixed_fmt(chip, fp); if (err < 0) { list_del(&fp->list); /* unlink for avoiding double-free */ kfree(fp); return err; } usb_set_interface(chip->dev, fp->iface, 0); return 0; } /* * Create a standard mixer for the specified interface. */ static int create_standard_mixer_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk) { if (quirk->ifnum < 0) return 0; return snd_usb_create_mixer(chip, quirk->ifnum); } /* * audio-interface quirks * * returns zero if no standard audio/MIDI parsing is needed. * returns a positive value if standard audio/midi interfaces are parsed * after this. * returns a negative value at error. */ int snd_usb_create_quirk(struct snd_usb_audio *chip, struct usb_interface *iface, struct usb_driver *driver, const struct snd_usb_audio_quirk *quirk) { typedef int (*quirk_func_t)(struct snd_usb_audio *, struct usb_interface *, struct usb_driver *, const struct snd_usb_audio_quirk *); static const quirk_func_t quirk_funcs[] = { [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk, [QUIRK_COMPOSITE] = create_composite_quirk, [QUIRK_AUTODETECT] = create_autodetect_quirk, [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk, [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk, [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk, [QUIRK_MIDI_ROLAND] = create_any_midi_quirk, [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk, [QUIRK_MIDI_NOVATION] = create_any_midi_quirk, [QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk, [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk, [QUIRK_MIDI_CME] = create_any_midi_quirk, [QUIRK_MIDI_AKAI] = create_any_midi_quirk, [QUIRK_MIDI_FTDI] = create_any_midi_quirk, [QUIRK_MIDI_CH345] = create_any_midi_quirk, [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk, [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk, [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk, [QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk, }; if (quirk->type < QUIRK_TYPE_COUNT) { return quirk_funcs[quirk->type](chip, iface, driver, quirk); } else { usb_audio_err(chip, "invalid quirk type %d\n", quirk->type); return -ENXIO; } } /* * boot quirks */ #define EXTIGY_FIRMWARE_SIZE_OLD 794 #define EXTIGY_FIRMWARE_SIZE_NEW 483 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf) { struct usb_host_config *config = dev->actconfig; int err; if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD || le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) { dev_dbg(&dev->dev, "sending Extigy boot sequence...\n"); /* Send message to force it to reconnect with full interface. */ err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0), 0x10, 0x43, 0x0001, 0x000a, NULL, 0); if (err < 0) dev_dbg(&dev->dev, "error sending boot message: %d\n", err); err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, sizeof(dev->descriptor)); config = dev->actconfig; if (err < 0) dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err); err = usb_reset_configuration(dev); if (err < 0) dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err); dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n", le16_to_cpu(get_cfg_desc(config)->wTotalLength)); return -ENODEV; /* quit this anyway */ } return 0; } static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev) { u8 buf = 1; snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER, 0, 0, &buf, 1); if (buf == 0) { snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, 1, 2000, NULL, 0); return -ENODEV; } return 0; } static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev) { int err; if (dev->actconfig->desc.bConfigurationValue == 1) { dev_info(&dev->dev, "Fast Track Pro switching to config #2\n"); /* This function has to be available by the usb core module. * if it is not avialable the boot quirk has to be left out * and the configuration has to be set by udev or hotplug * rules */ err = usb_driver_set_configuration(dev, 2); if (err < 0) dev_dbg(&dev->dev, "error usb_driver_set_configuration: %d\n", err); /* Always return an error, so that we stop creating a device that will just be destroyed and recreated with a new configuration */ return -ENODEV; } else dev_info(&dev->dev, "Fast Track Pro config OK\n"); return 0; } /* * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely * documented in the device's data sheet. */ static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value) { u8 buf[4]; buf[0] = 0x20; buf[1] = value & 0xff; buf[2] = (value >> 8) & 0xff; buf[3] = reg; return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION, USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 0, 0, &buf, 4); } static int snd_usb_cm106_boot_quirk(struct usb_device *dev) { /* * Enable line-out driver mode, set headphone source to front * channels, enable stereo mic. */ return snd_usb_cm106_write_int_reg(dev, 2, 0x8004); } /* * CM6206 registers from the CM6206 datasheet rev 2.1 */ #define CM6206_REG0_DMA_MASTER BIT(15) #define CM6206_REG0_SPDIFO_RATE_48K (2 << 12) #define CM6206_REG0_SPDIFO_RATE_96K (7 << 12) /* Bit 4 thru 11 is the S/PDIF category code */ #define CM6206_REG0_SPDIFO_CAT_CODE_GENERAL (0 << 4) #define CM6206_REG0_SPDIFO_EMPHASIS_CD BIT(3) #define CM6206_REG0_SPDIFO_COPYRIGHT_NA BIT(2) #define CM6206_REG0_SPDIFO_NON_AUDIO BIT(1) #define CM6206_REG0_SPDIFO_PRO_FORMAT BIT(0) #define CM6206_REG1_TEST_SEL_CLK BIT(14) #define CM6206_REG1_PLLBIN_EN BIT(13) #define CM6206_REG1_SOFT_MUTE_EN BIT(12) #define CM6206_REG1_GPIO4_OUT BIT(11) #define CM6206_REG1_GPIO4_OE BIT(10) #define CM6206_REG1_GPIO3_OUT BIT(9) #define CM6206_REG1_GPIO3_OE BIT(8) #define CM6206_REG1_GPIO2_OUT BIT(7) #define CM6206_REG1_GPIO2_OE BIT(6) #define CM6206_REG1_GPIO1_OUT BIT(5) #define CM6206_REG1_GPIO1_OE BIT(4) #define CM6206_REG1_SPDIFO_INVALID BIT(3) #define CM6206_REG1_SPDIF_LOOP_EN BIT(2) #define CM6206_REG1_SPDIFO_DIS BIT(1) #define CM6206_REG1_SPDIFI_MIX BIT(0) #define CM6206_REG2_DRIVER_ON BIT(15) #define CM6206_REG2_HEADP_SEL_SIDE_CHANNELS (0 << 13) #define CM6206_REG2_HEADP_SEL_SURROUND_CHANNELS (1 << 13) #define CM6206_REG2_HEADP_SEL_CENTER_SUBW (2 << 13) #define CM6206_REG2_HEADP_SEL_FRONT_CHANNELS (3 << 13) #define CM6206_REG2_MUTE_HEADPHONE_RIGHT BIT(12) #define CM6206_REG2_MUTE_HEADPHONE_LEFT BIT(11) #define CM6206_REG2_MUTE_REAR_SURROUND_RIGHT BIT(10) #define CM6206_REG2_MUTE_REAR_SURROUND_LEFT BIT(9) #define CM6206_REG2_MUTE_SIDE_SURROUND_RIGHT BIT(8) #define CM6206_REG2_MUTE_SIDE_SURROUND_LEFT BIT(7) #define CM6206_REG2_MUTE_SUBWOOFER BIT(6) #define CM6206_REG2_MUTE_CENTER BIT(5) #define CM6206_REG2_MUTE_RIGHT_FRONT BIT(3) #define CM6206_REG2_MUTE_LEFT_FRONT BIT(3) #define CM6206_REG2_EN_BTL BIT(2) #define CM6206_REG2_MCUCLKSEL_1_5_MHZ (0) #define CM6206_REG2_MCUCLKSEL_3_MHZ (1) #define CM6206_REG2_MCUCLKSEL_6_MHZ (2) #define CM6206_REG2_MCUCLKSEL_12_MHZ (3) /* Bit 11..13 sets the sensitivity to FLY tuner volume control VP/VD signal */ #define CM6206_REG3_FLYSPEED_DEFAULT (2 << 11) #define CM6206_REG3_VRAP25EN BIT(10) #define CM6206_REG3_MSEL1 BIT(9) #define CM6206_REG3_SPDIFI_RATE_44_1K BIT(0 << 7) #define CM6206_REG3_SPDIFI_RATE_48K BIT(2 << 7) #define CM6206_REG3_SPDIFI_RATE_32K BIT(3 << 7) #define CM6206_REG3_PINSEL BIT(6) #define CM6206_REG3_FOE BIT(5) #define CM6206_REG3_ROE BIT(4) #define CM6206_REG3_CBOE BIT(3) #define CM6206_REG3_LOSE BIT(2) #define CM6206_REG3_HPOE BIT(1) #define CM6206_REG3_SPDIFI_CANREC BIT(0) #define CM6206_REG5_DA_RSTN BIT(13) #define CM6206_REG5_AD_RSTN BIT(12) #define CM6206_REG5_SPDIFO_AD2SPDO BIT(12) #define CM6206_REG5_SPDIFO_SEL_FRONT (0 << 9) #define CM6206_REG5_SPDIFO_SEL_SIDE_SUR (1 << 9) #define CM6206_REG5_SPDIFO_SEL_CEN_LFE (2 << 9) #define CM6206_REG5_SPDIFO_SEL_REAR_SUR (3 << 9) #define CM6206_REG5_CODECM BIT(8) #define CM6206_REG5_EN_HPF BIT(7) #define CM6206_REG5_T_SEL_DSDA4 BIT(6) #define CM6206_REG5_T_SEL_DSDA3 BIT(5) #define CM6206_REG5_T_SEL_DSDA2 BIT(4) #define CM6206_REG5_T_SEL_DSDA1 BIT(3) #define CM6206_REG5_T_SEL_DSDAD_NORMAL 0 #define CM6206_REG5_T_SEL_DSDAD_FRONT 4 #define CM6206_REG5_T_SEL_DSDAD_S_SURROUND 5 #define CM6206_REG5_T_SEL_DSDAD_CEN_LFE 6 #define CM6206_REG5_T_SEL_DSDAD_R_SURROUND 7 static int snd_usb_cm6206_boot_quirk(struct usb_device *dev) { int err = 0, reg; int val[] = { /* * Values here are chosen based on sniffing USB traffic * under Windows. * * REG0: DAC is master, sample rate 48kHz, no copyright */ CM6206_REG0_SPDIFO_RATE_48K | CM6206_REG0_SPDIFO_COPYRIGHT_NA, /* * REG1: PLL binary search enable, soft mute enable. */ CM6206_REG1_PLLBIN_EN | CM6206_REG1_SOFT_MUTE_EN, /* * REG2: enable output drivers, * select front channels to the headphone output, * then mute the headphone channels, run the MCU * at 1.5 MHz. */ CM6206_REG2_DRIVER_ON | CM6206_REG2_HEADP_SEL_FRONT_CHANNELS | CM6206_REG2_MUTE_HEADPHONE_RIGHT | CM6206_REG2_MUTE_HEADPHONE_LEFT, /* * REG3: default flyspeed, set 2.5V mic bias * enable all line out ports and enable SPDIF */ CM6206_REG3_FLYSPEED_DEFAULT | CM6206_REG3_VRAP25EN | CM6206_REG3_FOE | CM6206_REG3_ROE | CM6206_REG3_CBOE | CM6206_REG3_LOSE | CM6206_REG3_HPOE | CM6206_REG3_SPDIFI_CANREC, /* REG4 is just a bunch of GPIO lines */ 0x0000, /* REG5: de-assert AD/DA reset signals */ CM6206_REG5_DA_RSTN | CM6206_REG5_AD_RSTN }; for (reg = 0; reg < ARRAY_SIZE(val); reg++) { err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]); if (err < 0) return err; } return err; } /* quirk for Plantronics GameCom 780 with CM6302 chip */ static int snd_usb_gamecon780_boot_quirk(struct usb_device *dev) { /* set the initial volume and don't change; other values are either * too loud or silent due to firmware bug (bko#65251) */ u8 buf[2] = { 0x74, 0xe3 }; return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, UAC_FU_VOLUME << 8, 9 << 8, buf, 2); } /* * Novation Twitch DJ controller * Focusrite Novation Saffire 6 USB audio card */ static int snd_usb_novation_boot_quirk(struct usb_device *dev) { /* preemptively set up the device because otherwise the * raw MIDI endpoints are not active */ usb_set_interface(dev, 0, 1); return 0; } /* * This call will put the synth in "USB send" mode, i.e it will send MIDI * messages through USB (this is disabled at startup). The synth will * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB * sign on its LCD. Values here are chosen based on sniffing USB traffic * under Windows. */ static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev) { int err, actual_length; /* "midi send" enable */ static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 }; void *buf; if (usb_pipe_type_check(dev, usb_sndintpipe(dev, 0x05))) return -EINVAL; buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL); if (!buf) return -ENOMEM; err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf, ARRAY_SIZE(seq), &actual_length, 1000); kfree(buf); if (err < 0) return err; return 0; } /* * Some sound cards from Native Instruments are in fact compliant to the USB * audio standard of version 2 and other approved USB standards, even though * they come up as vendor-specific device when first connected. * * However, they can be told to come up with a new set of descriptors * upon their next enumeration, and the interfaces announced by the new * descriptors will then be handled by the kernel's class drivers. As the * product ID will also change, no further checks are required. */ static int snd_usb_nativeinstruments_boot_quirk(struct usb_device *dev) { int ret; ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0xaf, USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1, 0, NULL, 0, 1000); if (ret < 0) return ret; usb_reset_device(dev); /* return -EAGAIN, so the creation of an audio interface for this * temporary device is aborted. The device will reconnect with a * new product ID */ return -EAGAIN; } static void mbox2_setup_48_24_magic(struct usb_device *dev) { u8 srate[3]; u8 temp[12]; /* Choose 48000Hz permanently */ srate[0] = 0x80; srate[1] = 0xbb; srate[2] = 0x00; /* Send the magic! */ snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x01, 0x22, 0x0100, 0x0085, &temp, 0x0003); snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x81, 0xa2, 0x0100, 0x0085, &srate, 0x0003); snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x81, 0xa2, 0x0100, 0x0086, &srate, 0x0003); snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x81, 0xa2, 0x0100, 0x0003, &srate, 0x0003); return; } /* Digidesign Mbox 2 needs to load firmware onboard * and driver must wait a few seconds for initialisation. */ #define MBOX2_FIRMWARE_SIZE 646 #define MBOX2_BOOT_LOADING 0x01 /* Hard coded into the device */ #define MBOX2_BOOT_READY 0x02 /* Hard coded into the device */ static int snd_usb_mbox2_boot_quirk(struct usb_device *dev) { struct usb_host_config *config = dev->actconfig; int err; u8 bootresponse[0x12]; int fwsize; int count; fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength); if (fwsize != MBOX2_FIRMWARE_SIZE) { dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize); return -ENODEV; } dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n"); count = 0; bootresponse[0] = MBOX2_BOOT_LOADING; while ((bootresponse[0] == MBOX2_BOOT_LOADING) && (count < 10)) { msleep(500); /* 0.5 second delay */ snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), /* Control magic - load onboard firmware */ 0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012); if (bootresponse[0] == MBOX2_BOOT_READY) break; dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n"); count++; } if (bootresponse[0] != MBOX2_BOOT_READY) { dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]); return -ENODEV; } dev_dbg(&dev->dev, "device initialised!\n"); err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, sizeof(dev->descriptor)); config = dev->actconfig; if (err < 0) dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err); err = usb_reset_configuration(dev); if (err < 0) dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err); dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n", le16_to_cpu(get_cfg_desc(config)->wTotalLength)); mbox2_setup_48_24_magic(dev); dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz"); return 0; /* Successful boot */ } static int snd_usb_axefx3_boot_quirk(struct usb_device *dev) { int err; dev_dbg(&dev->dev, "Waiting for Axe-Fx III to boot up...\n"); /* If the Axe-Fx III has not fully booted, it will timeout when trying * to enable the audio streaming interface. A more generous timeout is * used here to detect when the Axe-Fx III has finished booting as the * set interface message will be acked once it has */ err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, 1, 1, NULL, 0, 120000); if (err < 0) { dev_err(&dev->dev, "failed waiting for Axe-Fx III to boot: %d\n", err); return err; } dev_dbg(&dev->dev, "Axe-Fx III is now ready\n"); err = usb_set_interface(dev, 1, 0); if (err < 0) dev_dbg(&dev->dev, "error stopping Axe-Fx III interface: %d\n", err); return 0; } static void mbox3_setup_48_24_magic(struct usb_device *dev) { /* The Mbox 3 is "little endian" */ /* max volume is: 0x0000. */ /* min volume is: 0x0080 (shown in little endian form) */ /* Load 48000Hz rate into buffer */ u8 com_buff[4] = {0x80, 0xbb, 0x00, 0x00}; /* Set 48000Hz sample rate */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x01, 0x21, 0x0100, 0x0001, &com_buff, 4); //Is this really needed? snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x01, 0x21, 0x0100, 0x8101, &com_buff, 4); /* Deactivate Tuner */ /* on = 0x01*/ /* off = 0x00*/ com_buff[0] = 0x00; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x01, 0x21, 0x0003, 0x2001, &com_buff, 1); /* Set clock source to Internal (as opposed to S/PDIF) */ com_buff[0] = 0x01; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0100, 0x8001, &com_buff, 1); /* Mute the hardware loopbacks to start the device in a known state. */ com_buff[0] = 0x00; com_buff[1] = 0x80; /* Analogue input 1 left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0110, 0x4001, &com_buff, 2); /* Analogue input 1 right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0111, 0x4001, &com_buff, 2); /* Analogue input 2 left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0114, 0x4001, &com_buff, 2); /* Analogue input 2 right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0115, 0x4001, &com_buff, 2); /* Analogue input 3 left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0118, 0x4001, &com_buff, 2); /* Analogue input 3 right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0119, 0x4001, &com_buff, 2); /* Analogue input 4 left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x011c, 0x4001, &com_buff, 2); /* Analogue input 4 right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x011d, 0x4001, &com_buff, 2); /* Set software sends to output */ com_buff[0] = 0x00; com_buff[1] = 0x00; /* Analogue software return 1 left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0100, 0x4001, &com_buff, 2); com_buff[0] = 0x00; com_buff[1] = 0x80; /* Analogue software return 1 right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0101, 0x4001, &com_buff, 2); com_buff[0] = 0x00; com_buff[1] = 0x80; /* Analogue software return 2 left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0104, 0x4001, &com_buff, 2); com_buff[0] = 0x00; com_buff[1] = 0x00; /* Analogue software return 2 right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0105, 0x4001, &com_buff, 2); com_buff[0] = 0x00; com_buff[1] = 0x80; /* Analogue software return 3 left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0108, 0x4001, &com_buff, 2); /* Analogue software return 3 right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0109, 0x4001, &com_buff, 2); /* Analogue software return 4 left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x010c, 0x4001, &com_buff, 2); /* Analogue software return 4 right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x010d, 0x4001, &com_buff, 2); /* Return to muting sends */ com_buff[0] = 0x00; com_buff[1] = 0x80; /* Analogue fx return left channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0120, 0x4001, &com_buff, 2); /* Analogue fx return right channel: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0121, 0x4001, &com_buff, 2); /* Analogue software input 1 fx send: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0100, 0x4201, &com_buff, 2); /* Analogue software input 2 fx send: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0101, 0x4201, &com_buff, 2); /* Analogue software input 3 fx send: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0102, 0x4201, &com_buff, 2); /* Analogue software input 4 fx send: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0103, 0x4201, &com_buff, 2); /* Analogue input 1 fx send: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0104, 0x4201, &com_buff, 2); /* Analogue input 2 fx send: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0105, 0x4201, &com_buff, 2); /* Analogue input 3 fx send: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0106, 0x4201, &com_buff, 2); /* Analogue input 4 fx send: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0107, 0x4201, &com_buff, 2); /* Toggle allowing host control */ com_buff[0] = 0x02; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 3, 0x21, 0x0000, 0x2001, &com_buff, 1); /* Do not dim fx returns */ com_buff[0] = 0x00; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 3, 0x21, 0x0002, 0x2001, &com_buff, 1); /* Do not set fx returns to mono */ com_buff[0] = 0x00; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 3, 0x21, 0x0001, 0x2001, &com_buff, 1); /* Mute the S/PDIF hardware loopback * same odd volume logic here as above */ com_buff[0] = 0x00; com_buff[1] = 0x80; /* S/PDIF hardware input 1 left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0112, 0x4001, &com_buff, 2); /* S/PDIF hardware input 1 right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0113, 0x4001, &com_buff, 2); /* S/PDIF hardware input 2 left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0116, 0x4001, &com_buff, 2); /* S/PDIF hardware input 2 right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0117, 0x4001, &com_buff, 2); /* S/PDIF hardware input 3 left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x011a, 0x4001, &com_buff, 2); /* S/PDIF hardware input 3 right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x011b, 0x4001, &com_buff, 2); /* S/PDIF hardware input 4 left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x011e, 0x4001, &com_buff, 2); /* S/PDIF hardware input 4 right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x011f, 0x4001, &com_buff, 2); /* S/PDIF software return 1 left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0102, 0x4001, &com_buff, 2); /* S/PDIF software return 1 right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0103, 0x4001, &com_buff, 2); /* S/PDIF software return 2 left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0106, 0x4001, &com_buff, 2); /* S/PDIF software return 2 right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0107, 0x4001, &com_buff, 2); com_buff[0] = 0x00; com_buff[1] = 0x00; /* S/PDIF software return 3 left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x010a, 0x4001, &com_buff, 2); com_buff[0] = 0x00; com_buff[1] = 0x80; /* S/PDIF software return 3 right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x010b, 0x4001, &com_buff, 2); /* S/PDIF software return 4 left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x010e, 0x4001, &com_buff, 2); com_buff[0] = 0x00; com_buff[1] = 0x00; /* S/PDIF software return 4 right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x010f, 0x4001, &com_buff, 2); com_buff[0] = 0x00; com_buff[1] = 0x80; /* S/PDIF fx returns left channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0122, 0x4001, &com_buff, 2); /* S/PDIF fx returns right channel */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0123, 0x4001, &com_buff, 2); /* Set the dropdown "Effect" to the first option */ /* Room1 = 0x00 */ /* Room2 = 0x01 */ /* Room3 = 0x02 */ /* Hall 1 = 0x03 */ /* Hall 2 = 0x04 */ /* Plate = 0x05 */ /* Delay = 0x06 */ /* Echo = 0x07 */ com_buff[0] = 0x00; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0200, 0x4301, &com_buff, 1); /* max is 0xff */ /* min is 0x00 */ /* Set the effect duration to 0 */ /* max is 0xffff */ /* min is 0x0000 */ com_buff[0] = 0x00; com_buff[1] = 0x00; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0400, 0x4301, &com_buff, 2); /* Set the effect volume and feedback to 0 */ /* max is 0xff */ /* min is 0x00 */ com_buff[0] = 0x00; /* feedback: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0500, 0x4301, &com_buff, 1); /* volume: */ snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1, 0x21, 0x0300, 0x4301, &com_buff, 1); /* Set soft button hold duration */ /* 0x03 = 250ms */ /* 0x05 = 500ms DEFAULT */ /* 0x08 = 750ms */ /* 0x0a = 1sec */ com_buff[0] = 0x05; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 3, 0x21, 0x0005, 0x2001, &com_buff, 1); /* Use dim LEDs for button of state */ com_buff[0] = 0x00; snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 3, 0x21, 0x0004, 0x2001, &com_buff, 1); } #define MBOX3_DESCRIPTOR_SIZE 464 static int snd_usb_mbox3_boot_quirk(struct usb_device *dev) { struct usb_host_config *config = dev->actconfig; int err; int descriptor_size; descriptor_size = le16_to_cpu(get_cfg_desc(config)->wTotalLength); if (descriptor_size != MBOX3_DESCRIPTOR_SIZE) { dev_err(&dev->dev, "Invalid descriptor size=%d.\n", descriptor_size); return -ENODEV; } dev_dbg(&dev->dev, "device initialised!\n"); err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, sizeof(dev->descriptor)); config = dev->actconfig; if (err < 0) dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err); err = usb_reset_configuration(dev); if (err < 0) dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err); dev_dbg(&dev->dev, "mbox3_boot: new boot length = %d\n", le16_to_cpu(get_cfg_desc(config)->wTotalLength)); mbox3_setup_48_24_magic(dev); dev_info(&dev->dev, "Digidesign Mbox 3: 24bit 48kHz"); return 0; /* Successful boot */ } #define MICROBOOK_BUF_SIZE 128 static int snd_usb_motu_microbookii_communicate(struct usb_device *dev, u8 *buf, int buf_size, int *length) { int err, actual_length; if (usb_pipe_type_check(dev, usb_sndintpipe(dev, 0x01))) return -EINVAL; err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x01), buf, *length, &actual_length, 1000); if (err < 0) return err; print_hex_dump(KERN_DEBUG, "MicroBookII snd: ", DUMP_PREFIX_NONE, 16, 1, buf, actual_length, false); memset(buf, 0, buf_size); if (usb_pipe_type_check(dev, usb_rcvintpipe(dev, 0x82))) return -EINVAL; err = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x82), buf, buf_size, &actual_length, 1000); if (err < 0) return err; print_hex_dump(KERN_DEBUG, "MicroBookII rcv: ", DUMP_PREFIX_NONE, 16, 1, buf, actual_length, false); *length = actual_length; return 0; } static int snd_usb_motu_microbookii_boot_quirk(struct usb_device *dev) { int err, actual_length, poll_attempts = 0; static const u8 set_samplerate_seq[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x14, 0x00, 0x00, 0x00, 0x01 }; static const u8 poll_ready_seq[] = { 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x18 }; u8 *buf = kzalloc(MICROBOOK_BUF_SIZE, GFP_KERNEL); if (!buf) return -ENOMEM; dev_info(&dev->dev, "Waiting for MOTU Microbook II to boot up...\n"); /* First we tell the device which sample rate to use. */ memcpy(buf, set_samplerate_seq, sizeof(set_samplerate_seq)); actual_length = sizeof(set_samplerate_seq); err = snd_usb_motu_microbookii_communicate(dev, buf, MICROBOOK_BUF_SIZE, &actual_length); if (err < 0) { dev_err(&dev->dev, "failed setting the sample rate for Motu MicroBook II: %d\n", err); goto free_buf; } /* Then we poll every 100 ms until the device informs of its readiness. */ while (true) { if (++poll_attempts > 100) { dev_err(&dev->dev, "failed booting Motu MicroBook II: timeout\n"); err = -ENODEV; goto free_buf; } memset(buf, 0, MICROBOOK_BUF_SIZE); memcpy(buf, poll_ready_seq, sizeof(poll_ready_seq)); actual_length = sizeof(poll_ready_seq); err = snd_usb_motu_microbookii_communicate( dev, buf, MICROBOOK_BUF_SIZE, &actual_length); if (err < 0) { dev_err(&dev->dev, "failed booting Motu MicroBook II: communication error %d\n", err); goto free_buf; } /* the device signals its readiness through a message of the * form * XX 06 00 00 00 00 0b 18 00 00 00 01 * If the device is not yet ready to accept audio data, the * last byte of that sequence is 00. */ if (actual_length == 12 && buf[actual_length - 1] == 1) break; msleep(100); } dev_info(&dev->dev, "MOTU MicroBook II ready\n"); free_buf: kfree(buf); return err; } static int snd_usb_motu_m_series_boot_quirk(struct usb_device *dev) { msleep(2000); return 0; } /* * Setup quirks */ #define MAUDIO_SET 0x01 /* parse device_setup */ #define MAUDIO_SET_COMPATIBLE 0x80 /* use only "win-compatible" interfaces */ #define MAUDIO_SET_DTS 0x02 /* enable DTS Digital Output */ #define MAUDIO_SET_96K 0x04 /* 48-96kHz rate if set, 8-48kHz otherwise */ #define MAUDIO_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */ #define MAUDIO_SET_DI 0x10 /* enable Digital Input */ #define MAUDIO_SET_MASK 0x1f /* bit mask for setup value */ #define MAUDIO_SET_24B_48K_DI 0x19 /* 24bits+48kHz+Digital Input */ #define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48kHz+No Digital Input */ #define MAUDIO_SET_16B_48K_DI 0x11 /* 16bits+48kHz+Digital Input */ #define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48kHz+No Digital Input */ static int quattro_skip_setting_quirk(struct snd_usb_audio *chip, int iface, int altno) { /* Reset ALL ifaces to 0 altsetting. * Call it for every possible altsetting of every interface. */ usb_set_interface(chip->dev, iface, 0); if (chip->setup & MAUDIO_SET) { if (chip->setup & MAUDIO_SET_COMPATIBLE) { if (iface != 1 && iface != 2) return 1; /* skip all interfaces but 1 and 2 */ } else { unsigned int mask; if (iface == 1 || iface == 2) return 1; /* skip interfaces 1 and 2 */ if ((chip->setup & MAUDIO_SET_96K) && altno != 1) return 1; /* skip this altsetting */ mask = chip->setup & MAUDIO_SET_MASK; if (mask == MAUDIO_SET_24B_48K_DI && altno != 2) return 1; /* skip this altsetting */ if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3) return 1; /* skip this altsetting */ if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 4) return 1; /* skip this altsetting */ } } usb_audio_dbg(chip, "using altsetting %d for interface %d config %d\n", altno, iface, chip->setup); return 0; /* keep this altsetting */ } static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip, int iface, int altno) { /* Reset ALL ifaces to 0 altsetting. * Call it for every possible altsetting of every interface. */ usb_set_interface(chip->dev, iface, 0); if (chip->setup & MAUDIO_SET) { unsigned int mask; if ((chip->setup & MAUDIO_SET_DTS) && altno != 6) return 1; /* skip this altsetting */ if ((chip->setup & MAUDIO_SET_96K) && altno != 1) return 1; /* skip this altsetting */ mask = chip->setup & MAUDIO_SET_MASK; if (mask == MAUDIO_SET_24B_48K_DI && altno != 2) return 1; /* skip this altsetting */ if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3) return 1; /* skip this altsetting */ if (mask == MAUDIO_SET_16B_48K_DI && altno != 4) return 1; /* skip this altsetting */ if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 5) return 1; /* skip this altsetting */ } return 0; /* keep this altsetting */ } static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip, int iface, int altno) { /* Reset ALL ifaces to 0 altsetting. * Call it for every possible altsetting of every interface. */ usb_set_interface(chip->dev, iface, 0); /* possible configuration where both inputs and only one output is *used is not supported by the current setup */ if (chip->setup & (MAUDIO_SET | MAUDIO_SET_24B)) { if (chip->setup & MAUDIO_SET_96K) { if (altno != 3 && altno != 6) return 1; } else if (chip->setup & MAUDIO_SET_DI) { if (iface == 4) return 1; /* no analog input */ if (altno != 2 && altno != 5) return 1; /* enable only altsets 2 and 5 */ } else { if (iface == 5) return 1; /* disable digialt input */ if (altno != 2 && altno != 5) return 1; /* enalbe only altsets 2 and 5 */ } } else { /* keep only 16-Bit mode */ if (altno != 1) return 1; } usb_audio_dbg(chip, "using altsetting %d for interface %d config %d\n", altno, iface, chip->setup); return 0; /* keep this altsetting */ } static int s1810c_skip_setting_quirk(struct snd_usb_audio *chip, int iface, int altno) { /* * Altno settings: * * Playback (Interface 1): * 1: 6 Analog + 2 S/PDIF * 2: 6 Analog + 2 S/PDIF * 3: 6 Analog * * Capture (Interface 2): * 1: 8 Analog + 2 S/PDIF + 8 ADAT * 2: 8 Analog + 2 S/PDIF + 4 ADAT * 3: 8 Analog */ /* * I'll leave 2 as the default one and * use device_setup to switch to the * other two. */ if ((chip->setup == 0 || chip->setup > 2) && altno != 2) return 1; else if (chip->setup == 1 && altno != 1) return 1; else if (chip->setup == 2 && altno != 3) return 1; return 0; } int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip, int iface, int altno) { /* audiophile usb: skip altsets incompatible with device_setup */ if (chip->usb_id == USB_ID(0x0763, 0x2003)) return audiophile_skip_setting_quirk(chip, iface, altno); /* quattro usb: skip altsets incompatible with device_setup */ if (chip->usb_id == USB_ID(0x0763, 0x2001)) return quattro_skip_setting_quirk(chip, iface, altno); /* fasttrackpro usb: skip altsets incompatible with device_setup */ if (chip->usb_id == USB_ID(0x0763, 0x2012)) return fasttrackpro_skip_setting_quirk(chip, iface, altno); /* presonus studio 1810c: skip altsets incompatible with device_setup */ if (chip->usb_id == USB_ID(0x194f, 0x010c)) return s1810c_skip_setting_quirk(chip, iface, altno); return 0; } int snd_usb_apply_boot_quirk(struct usb_device *dev, struct usb_interface *intf, const struct snd_usb_audio_quirk *quirk, unsigned int id) { switch (id) { case USB_ID(0x041e, 0x3000): /* SB Extigy needs special boot-up sequence */ /* if more models come, this will go to the quirk list. */ return snd_usb_extigy_boot_quirk(dev, intf); case USB_ID(0x041e, 0x3020): /* SB Audigy 2 NX needs its own boot-up magic, too */ return snd_usb_audigy2nx_boot_quirk(dev); case USB_ID(0x10f5, 0x0200): /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */ return snd_usb_cm106_boot_quirk(dev); case USB_ID(0x0d8c, 0x0102): /* C-Media CM6206 / CM106-Like Sound Device */ case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */ return snd_usb_cm6206_boot_quirk(dev); case USB_ID(0x0dba, 0x3000): /* Digidesign Mbox 2 */ return snd_usb_mbox2_boot_quirk(dev); case USB_ID(0x0dba, 0x5000): /* Digidesign Mbox 3 */ return snd_usb_mbox3_boot_quirk(dev); case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */ case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */ return snd_usb_novation_boot_quirk(dev); case USB_ID(0x133e, 0x0815): /* Access Music VirusTI Desktop */ return snd_usb_accessmusic_boot_quirk(dev); case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */ case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */ case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */ return snd_usb_nativeinstruments_boot_quirk(dev); case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */ return snd_usb_fasttrackpro_boot_quirk(dev); case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */ return snd_usb_gamecon780_boot_quirk(dev); case USB_ID(0x2466, 0x8010): /* Fractal Audio Axe-Fx 3 */ return snd_usb_axefx3_boot_quirk(dev); case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook II */ /* * For some reason interface 3 with vendor-spec class is * detected on MicroBook IIc. */ if (get_iface_desc(intf->altsetting)->bInterfaceClass == USB_CLASS_VENDOR_SPEC && get_iface_desc(intf->altsetting)->bInterfaceNumber < 3) return snd_usb_motu_microbookii_boot_quirk(dev); break; } return 0; } int snd_usb_apply_boot_quirk_once(struct usb_device *dev, struct usb_interface *intf, const struct snd_usb_audio_quirk *quirk, unsigned int id) { switch (id) { case USB_ID(0x07fd, 0x0008): /* MOTU M Series */ return snd_usb_motu_m_series_boot_quirk(dev); } return 0; } /* * check if the device uses big-endian samples */ int snd_usb_is_big_endian_format(struct snd_usb_audio *chip, const struct audioformat *fp) { /* it depends on altsetting whether the device is big-endian or not */ switch (chip->usb_id) { case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */ if (fp->altsetting == 2 || fp->altsetting == 3 || fp->altsetting == 5 || fp->altsetting == 6) return 1; break; case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ if (chip->setup == 0x00 || fp->altsetting == 1 || fp->altsetting == 2 || fp->altsetting == 3) return 1; break; case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */ if (fp->altsetting == 2 || fp->altsetting == 3 || fp->altsetting == 5 || fp->altsetting == 6) return 1; break; } return 0; } /* * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device, * not for interface. */ enum { EMU_QUIRK_SR_44100HZ = 0, EMU_QUIRK_SR_48000HZ, EMU_QUIRK_SR_88200HZ, EMU_QUIRK_SR_96000HZ, EMU_QUIRK_SR_176400HZ, EMU_QUIRK_SR_192000HZ }; static void set_format_emu_quirk(struct snd_usb_substream *subs, const struct audioformat *fmt) { unsigned char emu_samplerate_id = 0; /* When capture is active * sample rate shouldn't be changed * by playback substream */ if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) { if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].cur_audiofmt) return; } switch (fmt->rate_min) { case 48000: emu_samplerate_id = EMU_QUIRK_SR_48000HZ; break; case 88200: emu_samplerate_id = EMU_QUIRK_SR_88200HZ; break; case 96000: emu_samplerate_id = EMU_QUIRK_SR_96000HZ; break; case 176400: emu_samplerate_id = EMU_QUIRK_SR_176400HZ; break; case 192000: emu_samplerate_id = EMU_QUIRK_SR_192000HZ; break; default: emu_samplerate_id = EMU_QUIRK_SR_44100HZ; break; } snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id); subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0; } static int pioneer_djm_set_format_quirk(struct snd_usb_substream *subs, u16 windex) { unsigned int cur_rate = subs->data_endpoint->cur_rate; u8 sr[3]; // Convert to little endian sr[0] = cur_rate & 0xff; sr[1] = (cur_rate >> 8) & 0xff; sr[2] = (cur_rate >> 16) & 0xff; usb_set_interface(subs->dev, 0, 1); // we should derive windex from fmt-sync_ep but it's not set snd_usb_ctl_msg(subs->stream->chip->dev, usb_sndctrlpipe(subs->stream->chip->dev, 0), 0x01, 0x22, 0x0100, windex, &sr, 0x0003); return 0; } void snd_usb_set_format_quirk(struct snd_usb_substream *subs, const struct audioformat *fmt) { switch (subs->stream->chip->usb_id) { case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */ case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */ case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */ case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */ set_format_emu_quirk(subs, fmt); break; case USB_ID(0x534d, 0x0021): /* MacroSilicon MS2100/MS2106 */ case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */ subs->stream_offset_adj = 2; break; case USB_ID(0x2b73, 0x0013): /* Pioneer DJM-450 */ pioneer_djm_set_format_quirk(subs, 0x0082); break; case USB_ID(0x08e4, 0x017f): /* Pioneer DJM-750 */ case USB_ID(0x08e4, 0x0163): /* Pioneer DJM-850 */ pioneer_djm_set_format_quirk(subs, 0x0086); break; } } int snd_usb_select_mode_quirk(struct snd_usb_audio *chip, const struct audioformat *fmt) { struct usb_device *dev = chip->dev; int err; if (chip->quirk_flags & QUIRK_FLAG_ITF_USB_DSD_DAC) { /* First switch to alt set 0, otherwise the mode switch cmd * will not be accepted by the DAC */ err = usb_set_interface(dev, fmt->iface, 0); if (err < 0) return err; msleep(20); /* Delay needed after setting the interface */ /* Vendor mode switch cmd is required. */ if (fmt->formats & SNDRV_PCM_FMTBIT_DSD_U32_BE) { /* DSD mode (DSD_U32) requested */ err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0, USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE, 1, 1, NULL, 0); if (err < 0) return err; } else { /* PCM or DOP mode (S32) requested */ /* PCM mode (S16) requested */ err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0, USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE, 0, 1, NULL, 0); if (err < 0) return err; } msleep(20); } return 0; } void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint *ep) { /* * "Playback Design" products send bogus feedback data at the start * of the stream. Ignore them. */ if (USB_ID_VENDOR(ep->chip->usb_id) == 0x23ba && ep->type == SND_USB_ENDPOINT_TYPE_SYNC) ep->skip_packets = 4; /* * M-Audio Fast Track C400/C600 - when packets are not skipped, real * world latency varies by approx. +/- 50 frames (at 96kHz) each time * the stream is (re)started. When skipping packets 16 at endpoint * start up, the real world latency is stable within +/- 1 frame (also * across power cycles). */ if ((ep->chip->usb_id == USB_ID(0x0763, 0x2030) || ep->chip->usb_id == USB_ID(0x0763, 0x2031)) && ep->type == SND_USB_ENDPOINT_TYPE_DATA) ep->skip_packets = 16; /* Work around devices that report unreasonable feedback data */ if ((ep->chip->usb_id == USB_ID(0x0644, 0x8038) || /* TEAC UD-H01 */ ep->chip->usb_id == USB_ID(0x1852, 0x5034)) && /* T+A Dac8 */ ep->syncmaxsize == 4) ep->tenor_fb_quirk = 1; } /* quirk applied after snd_usb_ctl_msg(); not applied during boot quirks */ void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype, __u16 value, __u16 index, void *data, __u16 size) { struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev); if (!chip || (requesttype & USB_TYPE_MASK) != USB_TYPE_CLASS) return; if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY) msleep(20); else if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY_1M) usleep_range(1000, 2000); else if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY_5M) usleep_range(5000, 6000); } /* * snd_usb_interface_dsd_format_quirks() is called from format.c to * augment the PCM format bit-field for DSD types. The UAC standards * don't have a designated bit field to denote DSD-capable interfaces, * hence all hardware that is known to support this format has to be * listed here. */ u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip, struct audioformat *fp, unsigned int sample_bytes) { struct usb_interface *iface; /* Playback Designs */ if (USB_ID_VENDOR(chip->usb_id) == 0x23ba && USB_ID_PRODUCT(chip->usb_id) < 0x0110) { switch (fp->altsetting) { case 1: fp->dsd_dop = true; return SNDRV_PCM_FMTBIT_DSD_U16_LE; case 2: fp->dsd_bitrev = true; return SNDRV_PCM_FMTBIT_DSD_U8; case 3: fp->dsd_bitrev = true; return SNDRV_PCM_FMTBIT_DSD_U16_LE; } } /* XMOS based USB DACs */ switch (chip->usb_id) { case USB_ID(0x139f, 0x5504): /* Nagra DAC */ case USB_ID(0x20b1, 0x3089): /* Mola-Mola DAC */ case USB_ID(0x2522, 0x0007): /* LH Labs Geek Out 1V5 */ case USB_ID(0x2522, 0x0009): /* LH Labs Geek Pulse X Inifinity 2V0 */ case USB_ID(0x2522, 0x0012): /* LH Labs VI DAC Infinity */ case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */ if (fp->altsetting == 2) return SNDRV_PCM_FMTBIT_DSD_U32_BE; break; case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */ case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */ case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */ case USB_ID(0x16d0, 0x06b4): /* NuPrime Audio HD-AVP/AVA */ case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */ case USB_ID(0x16d0, 0x09d8): /* NuPrime IDA-8 */ case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */ case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */ case USB_ID(0x1db5, 0x0003): /* Bryston BDA3 */ case USB_ID(0x20a0, 0x4143): /* WaveIO USB Audio 2.0 */ case USB_ID(0x22e1, 0xca01): /* HDTA Serenade DSD */ case USB_ID(0x249c, 0x9326): /* M2Tech Young MkIII */ case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */ case USB_ID(0x2622, 0x0041): /* Audiolab M-DAC+ */ case USB_ID(0x278b, 0x5100): /* Rotel RC-1590 */ case USB_ID(0x27f7, 0x3002): /* W4S DAC-2v2SE */ case USB_ID(0x29a2, 0x0086): /* Mutec MC3+ USB */ case USB_ID(0x6b42, 0x0042): /* MSB Technology */ if (fp->altsetting == 3) return SNDRV_PCM_FMTBIT_DSD_U32_BE; break; /* Amanero Combo384 USB based DACs with native DSD support */ case USB_ID(0x16d0, 0x071a): /* Amanero - Combo384 */ if (fp->altsetting == 2) { switch (le16_to_cpu(chip->dev->descriptor.bcdDevice)) { case 0x199: return SNDRV_PCM_FMTBIT_DSD_U32_LE; case 0x19b: case 0x203: return SNDRV_PCM_FMTBIT_DSD_U32_BE; default: break; } } break; case USB_ID(0x16d0, 0x0a23): if (fp->altsetting == 2) return SNDRV_PCM_FMTBIT_DSD_U32_BE; break; default: break; } /* ITF-USB DSD based DACs */ if (chip->quirk_flags & QUIRK_FLAG_ITF_USB_DSD_DAC) { iface = usb_ifnum_to_if(chip->dev, fp->iface); /* Altsetting 2 support native DSD if the num of altsets is * three (0-2), * Altsetting 3 support native DSD if the num of altsets is * four (0-3). */ if (fp->altsetting == iface->num_altsetting - 1) return SNDRV_PCM_FMTBIT_DSD_U32_BE; } /* Mostly generic method to detect many DSD-capable implementations */ if ((chip->quirk_flags & QUIRK_FLAG_DSD_RAW) && fp->dsd_raw) return SNDRV_PCM_FMTBIT_DSD_U32_BE; return 0; } void snd_usb_audioformat_attributes_quirk(struct snd_usb_audio *chip, struct audioformat *fp, int stream) { switch (chip->usb_id) { case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */ /* Optoplay sets the sample rate attribute although * it seems not supporting it in fact. */ fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE; break; case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */ case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ /* doesn't set the sample rate attribute, but supports it */ fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE; break; case USB_ID(0x0763, 0x2001): /* M-Audio Quattro USB */ case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */ case USB_ID(0x047f, 0x0ca1): /* plantronics headset */ case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is an older model 77d:223) */ /* * plantronics headset and Griffin iMic have set adaptive-in * although it's really not... */ fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE; if (stream == SNDRV_PCM_STREAM_PLAYBACK) fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE; else fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC; break; case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook IIc */ /* * MaxPacketsOnly attribute is erroneously set in endpoint * descriptors. As a result this card produces noise with * all sample rates other than 96 kHz. */ fp->attributes &= ~UAC_EP_CS_ATTR_FILL_MAX; break; case USB_ID(0x1224, 0x2a25): /* Jieli Technology USB PHY 2.0 */ /* mic works only when ep packet size is set to wMaxPacketSize */ fp->attributes |= UAC_EP_CS_ATTR_FILL_MAX; break; } } /* * driver behavior quirk flags */ struct usb_audio_quirk_flags_table { u32 id; u32 flags; }; #define DEVICE_FLG(vid, pid, _flags) \ { .id = USB_ID(vid, pid), .flags = (_flags) } #define VENDOR_FLG(vid, _flags) DEVICE_FLG(vid, 0, _flags) static const struct usb_audio_quirk_flags_table quirk_flags_table[] = { /* Device matches */ DEVICE_FLG(0x041e, 0x3000, /* Creative SB Extigy */ QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x041e, 0x4080, /* Creative Live Cam VF0610 */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x045e, 0x083c, /* MS USB Link headset */ QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_DISABLE_AUTOSUSPEND), DEVICE_FLG(0x046d, 0x084c, /* Logitech ConferenceCam Connect */ QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY_1M), DEVICE_FLG(0x046d, 0x0991, /* Logitech QuickCam Pro */ QUIRK_FLAG_CTL_MSG_DELAY_1M | QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x046d, 0x09a4, /* Logitech QuickCam E 3500 */ QUIRK_FLAG_CTL_MSG_DELAY_1M | QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x0499, 0x1509, /* Steinberg UR22 */ QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x04d8, 0xfeea, /* Benchmark DAC1 Pre */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x04e8, 0xa051, /* Samsung USBC Headset (AKG) */ QUIRK_FLAG_SKIP_CLOCK_SELECTOR | QUIRK_FLAG_CTL_MSG_DELAY_5M), DEVICE_FLG(0x054c, 0x0b8c, /* Sony WALKMAN NW-A45 DAC */ QUIRK_FLAG_SET_IFACE_FIRST), DEVICE_FLG(0x0556, 0x0014, /* Phoenix Audio TMX320VC */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x05a3, 0x9420, /* ELP HD USB Camera */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x05a7, 0x1020, /* Bose Companion 5 */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x05e1, 0x0408, /* Syntek STK1160 */ QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x05e1, 0x0480, /* Hauppauge Woodbury */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x0644, 0x8043, /* TEAC UD-501/UD-501V2/UD-503/NT-503 */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY), DEVICE_FLG(0x0644, 0x8044, /* Esoteric D-05X */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY), DEVICE_FLG(0x0644, 0x804a, /* TEAC UD-301 */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY), DEVICE_FLG(0x0644, 0x805f, /* TEAC Model 12 */ QUIRK_FLAG_FORCE_IFACE_RESET), DEVICE_FLG(0x0644, 0x806b, /* TEAC UD-701 */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY), DEVICE_FLG(0x06f8, 0xb000, /* Hercules DJ Console (Windows Edition) */ QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x06f8, 0xd002, /* Hercules DJ Console (Macintosh Edition) */ QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x0711, 0x5800, /* MCT Trigger 5 USB-to-HDMI */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x074d, 0x3553, /* Outlaw RR2150 (Micronas UAC3553B) */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x0763, 0x2030, /* M-Audio Fast Track C400 */ QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x0763, 0x2031, /* M-Audio Fast Track C600 */ QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x08bb, 0x2702, /* LineX FM Transmitter */ QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x0951, 0x16ad, /* Kingston HyperX */ QUIRK_FLAG_CTL_MSG_DELAY_1M), DEVICE_FLG(0x0b0e, 0x0349, /* Jabra 550a */ QUIRK_FLAG_CTL_MSG_DELAY_1M), DEVICE_FLG(0x0fd9, 0x0008, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x1395, 0x740a, /* Sennheiser DECT */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x1397, 0x0507, /* Behringer UMC202HD */ QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x1397, 0x0508, /* Behringer UMC204HD */ QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x1397, 0x0509, /* Behringer UMC404HD */ QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x13e5, 0x0001, /* Serato Phono */ QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x154e, 0x1002, /* Denon DCD-1500RE */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY), DEVICE_FLG(0x154e, 0x1003, /* Denon DA-300USB */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY), DEVICE_FLG(0x154e, 0x3005, /* Marantz HD-DAC1 */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY), DEVICE_FLG(0x154e, 0x3006, /* Marantz SA-14S1 */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY), DEVICE_FLG(0x154e, 0x300b, /* Marantz SA-KI RUBY / SA-12 */ QUIRK_FLAG_DSD_RAW), DEVICE_FLG(0x154e, 0x500e, /* Denon DN-X1600 */ QUIRK_FLAG_IGNORE_CLOCK_SOURCE), DEVICE_FLG(0x1686, 0x00dd, /* Zoom R16/24 */ QUIRK_FLAG_TX_LENGTH | QUIRK_FLAG_CTL_MSG_DELAY_1M), DEVICE_FLG(0x17aa, 0x1046, /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */ QUIRK_FLAG_DISABLE_AUTOSUSPEND), DEVICE_FLG(0x17aa, 0x104d, /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */ QUIRK_FLAG_DISABLE_AUTOSUSPEND), DEVICE_FLG(0x1852, 0x5065, /* Luxman DA-06 */ QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY), DEVICE_FLG(0x1901, 0x0191, /* GE B850V3 CP2114 audio interface */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x2040, 0x7200, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7201, /* Hauppauge HVR-950Q-MXL */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7210, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7211, /* Hauppauge HVR-950Q-MXL */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7213, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7217, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x721b, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x721e, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x721f, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7240, /* Hauppauge HVR-850 */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7260, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7270, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7280, /* Hauppauge HVR-950Q */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x7281, /* Hauppauge HVR-950Q-MXL */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x2040, 0x8200, /* Hauppauge Woodbury */ QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x21b4, 0x0081, /* AudioQuest DragonFly */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x21b4, 0x0230, /* Ayre QB-9 Twenty */ QUIRK_FLAG_DSD_RAW), DEVICE_FLG(0x21b4, 0x0232, /* Ayre QX-5 Twenty */ QUIRK_FLAG_DSD_RAW), DEVICE_FLG(0x2522, 0x0007, /* LH Labs Geek Out HD Audio 1V5 */ QUIRK_FLAG_SET_IFACE_FIRST), DEVICE_FLG(0x2708, 0x0002, /* Audient iD14 */ QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x2912, 0x30c8, /* Audioengine D1 */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x30be, 0x0101, /* Schiit Hel */ QUIRK_FLAG_IGNORE_CTL_ERROR), DEVICE_FLG(0x413c, 0xa506, /* Dell AE515 sound bar */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x534d, 0x0021, /* MacroSilicon MS2100/MS2106 */ QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x534d, 0x2109, /* MacroSilicon MS2109 */ QUIRK_FLAG_ALIGN_TRANSFER), DEVICE_FLG(0x1224, 0x2a25, /* Jieli Technology USB PHY 2.0 */ QUIRK_FLAG_GET_SAMPLE_RATE), DEVICE_FLG(0x2b53, 0x0023, /* Fiero SC-01 (firmware v1.0.0 @ 48 kHz) */ QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x2b53, 0x0024, /* Fiero SC-01 (firmware v1.0.0 @ 96 kHz) */ QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x2b53, 0x0031, /* Fiero SC-01 (firmware v1.1.0) */ QUIRK_FLAG_GENERIC_IMPLICIT_FB), DEVICE_FLG(0x0525, 0xa4ad, /* Hamedal C20 usb camero */ QUIRK_FLAG_IFACE_SKIP_CLOSE), DEVICE_FLG(0x0ecb, 0x205c, /* JBL Quantum610 Wireless */ QUIRK_FLAG_FIXED_RATE), DEVICE_FLG(0x0ecb, 0x2069, /* JBL Quantum810 Wireless */ QUIRK_FLAG_FIXED_RATE), /* Vendor matches */ VENDOR_FLG(0x045e, /* MS Lifecam */ QUIRK_FLAG_GET_SAMPLE_RATE), VENDOR_FLG(0x046d, /* Logitech */ QUIRK_FLAG_CTL_MSG_DELAY_1M), VENDOR_FLG(0x047f, /* Plantronics */ QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY), VENDOR_FLG(0x0644, /* TEAC Corp. */ QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY), VENDOR_FLG(0x07fd, /* MOTU */ QUIRK_FLAG_VALIDATE_RATES), VENDOR_FLG(0x1235, /* Focusrite Novation */ QUIRK_FLAG_VALIDATE_RATES), VENDOR_FLG(0x1511, /* AURALiC */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x152a, /* Thesycon devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x18d1, /* iBasso devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x1de7, /* Phoenix Audio */ QUIRK_FLAG_GET_SAMPLE_RATE), VENDOR_FLG(0x20b1, /* XMOS based devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x21ed, /* Accuphase Laboratory */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x22d9, /* Oppo */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x23ba, /* Playback Design */ QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY | QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x25ce, /* Mytek devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x278b, /* Rotel? */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x292b, /* Gustard/Ess based devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x2972, /* FiiO devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x2ab6, /* T+A devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x2d87, /* Cayin device */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x3336, /* HEM devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x3353, /* Khadas devices */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x35f4, /* MSB Technology */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0x3842, /* EVGA */ QUIRK_FLAG_DSD_RAW), VENDOR_FLG(0xc502, /* HiBy devices */ QUIRK_FLAG_DSD_RAW), {} /* terminator */ }; void snd_usb_init_quirk_flags(struct snd_usb_audio *chip) { const struct usb_audio_quirk_flags_table *p; for (p = quirk_flags_table; p->id; p++) { if (chip->usb_id == p->id || (!USB_ID_PRODUCT(p->id) && USB_ID_VENDOR(chip->usb_id) == USB_ID_VENDOR(p->id))) { usb_audio_dbg(chip, "Set quirk_flags 0x%x for device %04x:%04x\n", p->flags, USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id)); chip->quirk_flags |= p->flags; return; } } }
linux-master
sound/usb/quirks.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * MIDI 2.0 support */ #include <linux/bitops.h> #include <linux/string.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/usb.h> #include <linux/wait.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/usb/audio.h> #include <linux/usb/midi.h> #include <linux/usb/midi-v2.h> #include <sound/core.h> #include <sound/control.h> #include <sound/ump.h> #include "usbaudio.h" #include "midi.h" #include "midi2.h" #include "helper.h" static bool midi2_enable = true; module_param(midi2_enable, bool, 0444); MODULE_PARM_DESC(midi2_enable, "Enable MIDI 2.0 support."); static bool midi2_ump_probe = true; module_param(midi2_ump_probe, bool, 0444); MODULE_PARM_DESC(midi2_ump_probe, "Probe UMP v1.1 support at first."); /* stream direction; just shorter names */ enum { STR_OUT = SNDRV_RAWMIDI_STREAM_OUTPUT, STR_IN = SNDRV_RAWMIDI_STREAM_INPUT }; #define NUM_URBS 8 struct snd_usb_midi2_urb; struct snd_usb_midi2_endpoint; struct snd_usb_midi2_ump; struct snd_usb_midi2_interface; /* URB context */ struct snd_usb_midi2_urb { struct urb *urb; struct snd_usb_midi2_endpoint *ep; unsigned int index; /* array index */ }; /* A USB MIDI input/output endpoint */ struct snd_usb_midi2_endpoint { struct usb_device *dev; const struct usb_ms20_endpoint_descriptor *ms_ep; /* reference to EP descriptor */ struct snd_usb_midi2_endpoint *pair; /* bidirectional pair EP */ struct snd_usb_midi2_ump *rmidi; /* assigned UMP EP pair */ struct snd_ump_endpoint *ump; /* assigned UMP EP */ int direction; /* direction (STR_IN/OUT) */ unsigned int endpoint; /* EP number */ unsigned int pipe; /* URB pipe */ unsigned int packets; /* packet buffer size in bytes */ unsigned int interval; /* interval for INT EP */ wait_queue_head_t wait; /* URB waiter */ spinlock_t lock; /* URB locking */ struct snd_rawmidi_substream *substream; /* NULL when closed */ unsigned int num_urbs; /* number of allocated URBs */ unsigned long urb_free; /* bitmap for free URBs */ unsigned long urb_free_mask; /* bitmask for free URBs */ atomic_t running; /* running status */ atomic_t suspended; /* saved running status for suspend */ bool disconnected; /* shadow of umidi->disconnected */ struct list_head list; /* list to umidi->ep_list */ struct snd_usb_midi2_urb urbs[NUM_URBS]; }; /* A UMP endpoint - one or two USB MIDI endpoints are assigned */ struct snd_usb_midi2_ump { struct usb_device *dev; struct snd_usb_midi2_interface *umidi; /* reference to MIDI iface */ struct snd_ump_endpoint *ump; /* assigned UMP EP object */ struct snd_usb_midi2_endpoint *eps[2]; /* USB MIDI endpoints */ int index; /* rawmidi device index */ unsigned char usb_block_id; /* USB GTB id used for finding a pair */ bool ump_parsed; /* Parsed UMP 1.1 EP/FB info*/ struct list_head list; /* list to umidi->rawmidi_list */ }; /* top-level instance per USB MIDI interface */ struct snd_usb_midi2_interface { struct snd_usb_audio *chip; /* assigned USB-audio card */ struct usb_interface *iface; /* assigned USB interface */ struct usb_host_interface *hostif; const char *blk_descs; /* group terminal block descriptors */ unsigned int blk_desc_size; /* size of GTB descriptors */ bool disconnected; struct list_head ep_list; /* list of endpoints */ struct list_head rawmidi_list; /* list of UMP rawmidis */ struct list_head list; /* list to chip->midi_v2_list */ }; /* submit URBs as much as possible; used for both input and output */ static void do_submit_urbs_locked(struct snd_usb_midi2_endpoint *ep, int (*prepare)(struct snd_usb_midi2_endpoint *, struct urb *)) { struct snd_usb_midi2_urb *ctx; int index, err = 0; if (ep->disconnected) return; while (ep->urb_free) { index = find_first_bit(&ep->urb_free, ep->num_urbs); if (index >= ep->num_urbs) return; ctx = &ep->urbs[index]; err = prepare(ep, ctx->urb); if (err < 0) return; if (!ctx->urb->transfer_buffer_length) return; ctx->urb->dev = ep->dev; err = usb_submit_urb(ctx->urb, GFP_ATOMIC); if (err < 0) { dev_dbg(&ep->dev->dev, "usb_submit_urb error %d\n", err); return; } clear_bit(index, &ep->urb_free); } } /* prepare for output submission: copy from rawmidi buffer to urb packet */ static int prepare_output_urb(struct snd_usb_midi2_endpoint *ep, struct urb *urb) { int count; count = snd_ump_transmit(ep->ump, urb->transfer_buffer, ep->packets); if (count < 0) { dev_dbg(&ep->dev->dev, "rawmidi transmit error %d\n", count); return count; } cpu_to_le32_array((u32 *)urb->transfer_buffer, count >> 2); urb->transfer_buffer_length = count; return 0; } static void submit_output_urbs_locked(struct snd_usb_midi2_endpoint *ep) { do_submit_urbs_locked(ep, prepare_output_urb); } /* URB completion for output; re-filling and re-submit */ static void output_urb_complete(struct urb *urb) { struct snd_usb_midi2_urb *ctx = urb->context; struct snd_usb_midi2_endpoint *ep = ctx->ep; unsigned long flags; spin_lock_irqsave(&ep->lock, flags); set_bit(ctx->index, &ep->urb_free); if (urb->status >= 0 && atomic_read(&ep->running)) submit_output_urbs_locked(ep); if (ep->urb_free == ep->urb_free_mask) wake_up(&ep->wait); spin_unlock_irqrestore(&ep->lock, flags); } /* prepare for input submission: just set the buffer length */ static int prepare_input_urb(struct snd_usb_midi2_endpoint *ep, struct urb *urb) { urb->transfer_buffer_length = ep->packets; return 0; } static void submit_input_urbs_locked(struct snd_usb_midi2_endpoint *ep) { do_submit_urbs_locked(ep, prepare_input_urb); } /* URB completion for input; copy into rawmidi buffer and resubmit */ static void input_urb_complete(struct urb *urb) { struct snd_usb_midi2_urb *ctx = urb->context; struct snd_usb_midi2_endpoint *ep = ctx->ep; unsigned long flags; int len; spin_lock_irqsave(&ep->lock, flags); if (ep->disconnected || urb->status < 0) goto dequeue; len = urb->actual_length; len &= ~3; /* align UMP */ if (len > ep->packets) len = ep->packets; if (len > 0) { le32_to_cpu_array((u32 *)urb->transfer_buffer, len >> 2); snd_ump_receive(ep->ump, (u32 *)urb->transfer_buffer, len); } dequeue: set_bit(ctx->index, &ep->urb_free); submit_input_urbs_locked(ep); if (ep->urb_free == ep->urb_free_mask) wake_up(&ep->wait); spin_unlock_irqrestore(&ep->lock, flags); } /* URB submission helper; for both direction */ static void submit_io_urbs(struct snd_usb_midi2_endpoint *ep) { unsigned long flags; if (!ep) return; spin_lock_irqsave(&ep->lock, flags); if (ep->direction == STR_IN) submit_input_urbs_locked(ep); else submit_output_urbs_locked(ep); spin_unlock_irqrestore(&ep->lock, flags); } /* kill URBs for close, suspend and disconnect */ static void kill_midi_urbs(struct snd_usb_midi2_endpoint *ep, bool suspending) { int i; if (!ep) return; if (suspending) ep->suspended = ep->running; atomic_set(&ep->running, 0); for (i = 0; i < ep->num_urbs; i++) { if (!ep->urbs[i].urb) break; usb_kill_urb(ep->urbs[i].urb); } } /* wait until all URBs get freed */ static void drain_urb_queue(struct snd_usb_midi2_endpoint *ep) { if (!ep) return; spin_lock_irq(&ep->lock); atomic_set(&ep->running, 0); wait_event_lock_irq_timeout(ep->wait, ep->disconnected || ep->urb_free == ep->urb_free_mask, ep->lock, msecs_to_jiffies(500)); spin_unlock_irq(&ep->lock); } /* release URBs for an EP */ static void free_midi_urbs(struct snd_usb_midi2_endpoint *ep) { struct snd_usb_midi2_urb *ctx; int i; if (!ep) return; for (i = 0; i < NUM_URBS; ++i) { ctx = &ep->urbs[i]; if (!ctx->urb) break; usb_free_coherent(ep->dev, ep->packets, ctx->urb->transfer_buffer, ctx->urb->transfer_dma); usb_free_urb(ctx->urb); ctx->urb = NULL; } ep->num_urbs = 0; } /* allocate URBs for an EP */ /* the callers should handle allocation errors via free_midi_urbs() */ static int alloc_midi_urbs(struct snd_usb_midi2_endpoint *ep) { struct snd_usb_midi2_urb *ctx; void (*comp)(struct urb *urb); void *buffer; int i, err; int endpoint, len; endpoint = ep->endpoint; len = ep->packets; if (ep->direction == STR_IN) comp = input_urb_complete; else comp = output_urb_complete; ep->num_urbs = 0; ep->urb_free = ep->urb_free_mask = 0; for (i = 0; i < NUM_URBS; i++) { ctx = &ep->urbs[i]; ctx->index = i; ctx->urb = usb_alloc_urb(0, GFP_KERNEL); if (!ctx->urb) { dev_err(&ep->dev->dev, "URB alloc failed\n"); return -ENOMEM; } ctx->ep = ep; buffer = usb_alloc_coherent(ep->dev, len, GFP_KERNEL, &ctx->urb->transfer_dma); if (!buffer) { dev_err(&ep->dev->dev, "URB buffer alloc failed (size %d)\n", len); return -ENOMEM; } if (ep->interval) usb_fill_int_urb(ctx->urb, ep->dev, ep->pipe, buffer, len, comp, ctx, ep->interval); else usb_fill_bulk_urb(ctx->urb, ep->dev, ep->pipe, buffer, len, comp, ctx); err = usb_urb_ep_type_check(ctx->urb); if (err < 0) { dev_err(&ep->dev->dev, "invalid MIDI EP %x\n", endpoint); return err; } ctx->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; ep->num_urbs++; } ep->urb_free = ep->urb_free_mask = GENMASK(ep->num_urbs - 1, 0); return 0; } static struct snd_usb_midi2_endpoint * ump_to_endpoint(struct snd_ump_endpoint *ump, int dir) { struct snd_usb_midi2_ump *rmidi = ump->private_data; return rmidi->eps[dir]; } /* ump open callback */ static int snd_usb_midi_v2_open(struct snd_ump_endpoint *ump, int dir) { struct snd_usb_midi2_endpoint *ep = ump_to_endpoint(ump, dir); int err = 0; if (!ep || !ep->endpoint) return -ENODEV; if (ep->disconnected) return -EIO; if (ep->direction == STR_OUT) { err = alloc_midi_urbs(ep); if (err) { free_midi_urbs(ep); return err; } } return 0; } /* ump close callback */ static void snd_usb_midi_v2_close(struct snd_ump_endpoint *ump, int dir) { struct snd_usb_midi2_endpoint *ep = ump_to_endpoint(ump, dir); if (ep->direction == STR_OUT) { kill_midi_urbs(ep, false); drain_urb_queue(ep); free_midi_urbs(ep); } } /* ump trigger callback */ static void snd_usb_midi_v2_trigger(struct snd_ump_endpoint *ump, int dir, int up) { struct snd_usb_midi2_endpoint *ep = ump_to_endpoint(ump, dir); atomic_set(&ep->running, up); if (up && ep->direction == STR_OUT && !ep->disconnected) submit_io_urbs(ep); } /* ump drain callback */ static void snd_usb_midi_v2_drain(struct snd_ump_endpoint *ump, int dir) { struct snd_usb_midi2_endpoint *ep = ump_to_endpoint(ump, dir); drain_urb_queue(ep); } /* allocate and start all input streams */ static int start_input_streams(struct snd_usb_midi2_interface *umidi) { struct snd_usb_midi2_endpoint *ep; int err; list_for_each_entry(ep, &umidi->ep_list, list) { if (ep->direction == STR_IN) { err = alloc_midi_urbs(ep); if (err < 0) goto error; } } list_for_each_entry(ep, &umidi->ep_list, list) { if (ep->direction == STR_IN) submit_io_urbs(ep); } return 0; error: list_for_each_entry(ep, &umidi->ep_list, list) { if (ep->direction == STR_IN) free_midi_urbs(ep); } return err; } static const struct snd_ump_ops snd_usb_midi_v2_ump_ops = { .open = snd_usb_midi_v2_open, .close = snd_usb_midi_v2_close, .trigger = snd_usb_midi_v2_trigger, .drain = snd_usb_midi_v2_drain, }; /* create a USB MIDI 2.0 endpoint object */ static int create_midi2_endpoint(struct snd_usb_midi2_interface *umidi, struct usb_host_endpoint *hostep, const struct usb_ms20_endpoint_descriptor *ms_ep) { struct snd_usb_midi2_endpoint *ep; int endpoint, dir; usb_audio_dbg(umidi->chip, "Creating an EP 0x%02x, #GTB=%d\n", hostep->desc.bEndpointAddress, ms_ep->bNumGrpTrmBlock); ep = kzalloc(sizeof(*ep), GFP_KERNEL); if (!ep) return -ENOMEM; spin_lock_init(&ep->lock); init_waitqueue_head(&ep->wait); ep->dev = umidi->chip->dev; endpoint = hostep->desc.bEndpointAddress; dir = (endpoint & USB_DIR_IN) ? STR_IN : STR_OUT; ep->endpoint = endpoint; ep->direction = dir; ep->ms_ep = ms_ep; if (usb_endpoint_xfer_int(&hostep->desc)) ep->interval = hostep->desc.bInterval; else ep->interval = 0; if (dir == STR_IN) { if (ep->interval) ep->pipe = usb_rcvintpipe(ep->dev, endpoint); else ep->pipe = usb_rcvbulkpipe(ep->dev, endpoint); } else { if (ep->interval) ep->pipe = usb_sndintpipe(ep->dev, endpoint); else ep->pipe = usb_sndbulkpipe(ep->dev, endpoint); } ep->packets = usb_maxpacket(ep->dev, ep->pipe); list_add_tail(&ep->list, &umidi->ep_list); return 0; } /* destructor for endpoint; from snd_usb_midi_v2_free() */ static void free_midi2_endpoint(struct snd_usb_midi2_endpoint *ep) { list_del(&ep->list); free_midi_urbs(ep); kfree(ep); } /* call all endpoint destructors */ static void free_all_midi2_endpoints(struct snd_usb_midi2_interface *umidi) { struct snd_usb_midi2_endpoint *ep; while (!list_empty(&umidi->ep_list)) { ep = list_first_entry(&umidi->ep_list, struct snd_usb_midi2_endpoint, list); free_midi2_endpoint(ep); } } /* find a MIDI STREAMING descriptor with a given subtype */ static void *find_usb_ms_endpoint_descriptor(struct usb_host_endpoint *hostep, unsigned char subtype) { unsigned char *extra = hostep->extra; int extralen = hostep->extralen; while (extralen > 3) { struct usb_ms_endpoint_descriptor *ms_ep = (struct usb_ms_endpoint_descriptor *)extra; if (ms_ep->bLength > 3 && ms_ep->bDescriptorType == USB_DT_CS_ENDPOINT && ms_ep->bDescriptorSubtype == subtype) return ms_ep; if (!extra[0]) break; extralen -= extra[0]; extra += extra[0]; } return NULL; } /* get the full group terminal block descriptors and return the size */ static int get_group_terminal_block_descs(struct snd_usb_midi2_interface *umidi) { struct usb_host_interface *hostif = umidi->hostif; struct usb_device *dev = umidi->chip->dev; struct usb_ms20_gr_trm_block_header_descriptor header = { 0 }; unsigned char *data; int err, size; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_TYPE_STANDARD | USB_DIR_IN, USB_DT_CS_GR_TRM_BLOCK << 8 | hostif->desc.bAlternateSetting, hostif->desc.bInterfaceNumber, &header, sizeof(header)); if (err < 0) return err; size = __le16_to_cpu(header.wTotalLength); if (!size) { dev_err(&dev->dev, "Failed to get GTB descriptors for %d:%d\n", hostif->desc.bInterfaceNumber, hostif->desc.bAlternateSetting); return -EINVAL; } data = kzalloc(size, GFP_KERNEL); if (!data) return -ENOMEM; err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_TYPE_STANDARD | USB_DIR_IN, USB_DT_CS_GR_TRM_BLOCK << 8 | hostif->desc.bAlternateSetting, hostif->desc.bInterfaceNumber, data, size); if (err < 0) { kfree(data); return err; } umidi->blk_descs = data; umidi->blk_desc_size = size; return 0; } /* find the corresponding group terminal block descriptor */ static const struct usb_ms20_gr_trm_block_descriptor * find_group_terminal_block(struct snd_usb_midi2_interface *umidi, int id) { const unsigned char *data = umidi->blk_descs; int size = umidi->blk_desc_size; const struct usb_ms20_gr_trm_block_descriptor *desc; size -= sizeof(struct usb_ms20_gr_trm_block_header_descriptor); data += sizeof(struct usb_ms20_gr_trm_block_header_descriptor); while (size > 0 && *data && *data <= size) { desc = (const struct usb_ms20_gr_trm_block_descriptor *)data; if (desc->bLength >= sizeof(*desc) && desc->bDescriptorType == USB_DT_CS_GR_TRM_BLOCK && desc->bDescriptorSubtype == USB_MS_GR_TRM_BLOCK && desc->bGrpTrmBlkID == id) return desc; size -= *data; data += *data; } return NULL; } /* fill up the information from GTB */ static int parse_group_terminal_block(struct snd_usb_midi2_ump *rmidi, const struct usb_ms20_gr_trm_block_descriptor *desc) { struct snd_ump_endpoint *ump = rmidi->ump; unsigned int protocol, protocol_caps; /* set default protocol */ switch (desc->bMIDIProtocol) { case USB_MS_MIDI_PROTO_1_0_64: case USB_MS_MIDI_PROTO_1_0_64_JRTS: case USB_MS_MIDI_PROTO_1_0_128: case USB_MS_MIDI_PROTO_1_0_128_JRTS: protocol = SNDRV_UMP_EP_INFO_PROTO_MIDI1; break; case USB_MS_MIDI_PROTO_2_0: case USB_MS_MIDI_PROTO_2_0_JRTS: protocol = SNDRV_UMP_EP_INFO_PROTO_MIDI2; break; default: return 0; } if (ump->info.protocol && ump->info.protocol != protocol) usb_audio_info(rmidi->umidi->chip, "Overriding preferred MIDI protocol in GTB %d: %x -> %x\n", rmidi->usb_block_id, ump->info.protocol, protocol); ump->info.protocol = protocol; protocol_caps = protocol; switch (desc->bMIDIProtocol) { case USB_MS_MIDI_PROTO_1_0_64_JRTS: case USB_MS_MIDI_PROTO_1_0_128_JRTS: case USB_MS_MIDI_PROTO_2_0_JRTS: protocol_caps |= SNDRV_UMP_EP_INFO_PROTO_JRTS_TX | SNDRV_UMP_EP_INFO_PROTO_JRTS_RX; break; } if (ump->info.protocol_caps && ump->info.protocol_caps != protocol_caps) usb_audio_info(rmidi->umidi->chip, "Overriding MIDI protocol caps in GTB %d: %x -> %x\n", rmidi->usb_block_id, ump->info.protocol_caps, protocol_caps); ump->info.protocol_caps = protocol_caps; return 0; } /* allocate and parse for each assigned group terminal block */ static int parse_group_terminal_blocks(struct snd_usb_midi2_interface *umidi) { struct snd_usb_midi2_ump *rmidi; const struct usb_ms20_gr_trm_block_descriptor *desc; int err; err = get_group_terminal_block_descs(umidi); if (err < 0) return err; if (!umidi->blk_descs) return 0; list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { desc = find_group_terminal_block(umidi, rmidi->usb_block_id); if (!desc) continue; err = parse_group_terminal_block(rmidi, desc); if (err < 0) return err; } return 0; } /* parse endpoints included in the given interface and create objects */ static int parse_midi_2_0_endpoints(struct snd_usb_midi2_interface *umidi) { struct usb_host_interface *hostif = umidi->hostif; struct usb_host_endpoint *hostep; struct usb_ms20_endpoint_descriptor *ms_ep; int i, err; for (i = 0; i < hostif->desc.bNumEndpoints; i++) { hostep = &hostif->endpoint[i]; if (!usb_endpoint_xfer_bulk(&hostep->desc) && !usb_endpoint_xfer_int(&hostep->desc)) continue; ms_ep = find_usb_ms_endpoint_descriptor(hostep, USB_MS_GENERAL_2_0); if (!ms_ep) continue; if (ms_ep->bLength <= sizeof(*ms_ep)) continue; if (!ms_ep->bNumGrpTrmBlock) continue; if (ms_ep->bLength < sizeof(*ms_ep) + ms_ep->bNumGrpTrmBlock) continue; err = create_midi2_endpoint(umidi, hostep, ms_ep); if (err < 0) return err; } return 0; } static void free_all_midi2_umps(struct snd_usb_midi2_interface *umidi) { struct snd_usb_midi2_ump *rmidi; while (!list_empty(&umidi->rawmidi_list)) { rmidi = list_first_entry(&umidi->rawmidi_list, struct snd_usb_midi2_ump, list); list_del(&rmidi->list); kfree(rmidi); } } static int create_midi2_ump(struct snd_usb_midi2_interface *umidi, struct snd_usb_midi2_endpoint *ep_in, struct snd_usb_midi2_endpoint *ep_out, int blk_id) { struct snd_usb_midi2_ump *rmidi; struct snd_ump_endpoint *ump; int input, output; char idstr[16]; int err; rmidi = kzalloc(sizeof(*rmidi), GFP_KERNEL); if (!rmidi) return -ENOMEM; INIT_LIST_HEAD(&rmidi->list); rmidi->dev = umidi->chip->dev; rmidi->umidi = umidi; rmidi->usb_block_id = blk_id; rmidi->index = umidi->chip->num_rawmidis; snprintf(idstr, sizeof(idstr), "UMP %d", rmidi->index); input = ep_in ? 1 : 0; output = ep_out ? 1 : 0; err = snd_ump_endpoint_new(umidi->chip->card, idstr, rmidi->index, output, input, &ump); if (err < 0) { usb_audio_dbg(umidi->chip, "Failed to create a UMP object\n"); kfree(rmidi); return err; } rmidi->ump = ump; umidi->chip->num_rawmidis++; ump->private_data = rmidi; ump->ops = &snd_usb_midi_v2_ump_ops; rmidi->eps[STR_IN] = ep_in; rmidi->eps[STR_OUT] = ep_out; if (ep_in) { ep_in->pair = ep_out; ep_in->rmidi = rmidi; ep_in->ump = ump; } if (ep_out) { ep_out->pair = ep_in; ep_out->rmidi = rmidi; ep_out->ump = ump; } list_add_tail(&rmidi->list, &umidi->rawmidi_list); return 0; } /* find the UMP EP with the given USB block id */ static struct snd_usb_midi2_ump * find_midi2_ump(struct snd_usb_midi2_interface *umidi, int blk_id) { struct snd_usb_midi2_ump *rmidi; list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { if (rmidi->usb_block_id == blk_id) return rmidi; } return NULL; } /* look for the matching output endpoint and create UMP object if found */ static int find_matching_ep_partner(struct snd_usb_midi2_interface *umidi, struct snd_usb_midi2_endpoint *ep, int blk_id) { struct snd_usb_midi2_endpoint *pair_ep; int blk; usb_audio_dbg(umidi->chip, "Looking for a pair for EP-in 0x%02x\n", ep->endpoint); list_for_each_entry(pair_ep, &umidi->ep_list, list) { if (pair_ep->direction != STR_OUT) continue; if (pair_ep->pair) continue; /* already paired */ for (blk = 0; blk < pair_ep->ms_ep->bNumGrpTrmBlock; blk++) { if (pair_ep->ms_ep->baAssoGrpTrmBlkID[blk] == blk_id) { usb_audio_dbg(umidi->chip, "Found a match with EP-out 0x%02x blk %d\n", pair_ep->endpoint, blk); return create_midi2_ump(umidi, ep, pair_ep, blk_id); } } } return 0; } /* Call UMP helper to parse UMP endpoints; * this needs to be called after starting the input streams for bi-directional * communications */ static int parse_ump_endpoints(struct snd_usb_midi2_interface *umidi) { struct snd_usb_midi2_ump *rmidi; int err; list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { if (!rmidi->ump || !(rmidi->ump->core.info_flags & SNDRV_RAWMIDI_INFO_DUPLEX)) continue; err = snd_ump_parse_endpoint(rmidi->ump); if (!err) { rmidi->ump_parsed = true; } else { if (err == -ENOMEM) return err; /* fall back to GTB later */ } } return 0; } /* create a UMP block from a GTB entry */ static int create_gtb_block(struct snd_usb_midi2_ump *rmidi, int dir, int blk) { struct snd_usb_midi2_interface *umidi = rmidi->umidi; const struct usb_ms20_gr_trm_block_descriptor *desc; struct snd_ump_block *fb; int type, err; desc = find_group_terminal_block(umidi, blk); if (!desc) return 0; usb_audio_dbg(umidi->chip, "GTB %d: type=%d, group=%d/%d, protocol=%d, in bw=%d, out bw=%d\n", blk, desc->bGrpTrmBlkType, desc->nGroupTrm, desc->nNumGroupTrm, desc->bMIDIProtocol, __le16_to_cpu(desc->wMaxInputBandwidth), __le16_to_cpu(desc->wMaxOutputBandwidth)); /* assign the direction */ switch (desc->bGrpTrmBlkType) { case USB_MS_GR_TRM_BLOCK_TYPE_BIDIRECTIONAL: type = SNDRV_UMP_DIR_BIDIRECTION; break; case USB_MS_GR_TRM_BLOCK_TYPE_INPUT_ONLY: type = SNDRV_UMP_DIR_INPUT; break; case USB_MS_GR_TRM_BLOCK_TYPE_OUTPUT_ONLY: type = SNDRV_UMP_DIR_OUTPUT; break; default: usb_audio_dbg(umidi->chip, "Unsupported GTB type %d\n", desc->bGrpTrmBlkType); return 0; /* unsupported */ } /* guess work: set blk-1 as the (0-based) block ID */ err = snd_ump_block_new(rmidi->ump, blk - 1, type, desc->nGroupTrm, desc->nNumGroupTrm, &fb); if (err == -EBUSY) return 0; /* already present */ else if (err) return err; if (desc->iBlockItem) usb_string(rmidi->dev, desc->iBlockItem, fb->info.name, sizeof(fb->info.name)); if (__le16_to_cpu(desc->wMaxInputBandwidth) == 1 || __le16_to_cpu(desc->wMaxOutputBandwidth) == 1) fb->info.flags |= SNDRV_UMP_BLOCK_IS_MIDI1 | SNDRV_UMP_BLOCK_IS_LOWSPEED; usb_audio_dbg(umidi->chip, "Created a UMP block %d from GTB, name=%s\n", blk, fb->info.name); return 0; } /* Create UMP blocks for each UMP EP */ static int create_blocks_from_gtb(struct snd_usb_midi2_interface *umidi) { struct snd_usb_midi2_ump *rmidi; int i, blk, err, dir; list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { if (!rmidi->ump) continue; /* Blocks have been already created? */ if (rmidi->ump_parsed || rmidi->ump->info.num_blocks) continue; /* GTB is static-only */ rmidi->ump->info.flags |= SNDRV_UMP_EP_INFO_STATIC_BLOCKS; /* loop over GTBs */ for (dir = 0; dir < 2; dir++) { if (!rmidi->eps[dir]) continue; for (i = 0; i < rmidi->eps[dir]->ms_ep->bNumGrpTrmBlock; i++) { blk = rmidi->eps[dir]->ms_ep->baAssoGrpTrmBlkID[i]; err = create_gtb_block(rmidi, dir, blk); if (err < 0) return err; } } } return 0; } /* attach legacy rawmidis */ static int attach_legacy_rawmidi(struct snd_usb_midi2_interface *umidi) { #if IS_ENABLED(CONFIG_SND_UMP_LEGACY_RAWMIDI) struct snd_usb_midi2_ump *rmidi; int err; list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { err = snd_ump_attach_legacy_rawmidi(rmidi->ump, "Legacy MIDI", umidi->chip->num_rawmidis); if (err < 0) return err; umidi->chip->num_rawmidis++; } #endif return 0; } static void snd_usb_midi_v2_free(struct snd_usb_midi2_interface *umidi) { free_all_midi2_endpoints(umidi); free_all_midi2_umps(umidi); list_del(&umidi->list); kfree(umidi->blk_descs); kfree(umidi); } /* parse the interface for MIDI 2.0 */ static int parse_midi_2_0(struct snd_usb_midi2_interface *umidi) { struct snd_usb_midi2_endpoint *ep; int blk, id, err; /* First, create an object for each USB MIDI Endpoint */ err = parse_midi_2_0_endpoints(umidi); if (err < 0) return err; if (list_empty(&umidi->ep_list)) { usb_audio_warn(umidi->chip, "No MIDI endpoints found\n"); return -ENODEV; } /* * Next, look for EP I/O pairs that are found in group terminal blocks * A UMP object is created for each EP I/O pair as bidirecitonal * UMP EP */ list_for_each_entry(ep, &umidi->ep_list, list) { /* only input in this loop; output is matched in find_midi_ump() */ if (ep->direction != STR_IN) continue; for (blk = 0; blk < ep->ms_ep->bNumGrpTrmBlock; blk++) { id = ep->ms_ep->baAssoGrpTrmBlkID[blk]; err = find_matching_ep_partner(umidi, ep, id); if (err < 0) return err; } } /* * For the remaining EPs, treat as singles, create a UMP object with * unidirectional EP */ list_for_each_entry(ep, &umidi->ep_list, list) { if (ep->rmidi) continue; /* already paired */ for (blk = 0; blk < ep->ms_ep->bNumGrpTrmBlock; blk++) { id = ep->ms_ep->baAssoGrpTrmBlkID[blk]; if (find_midi2_ump(umidi, id)) continue; usb_audio_dbg(umidi->chip, "Creating a unidirection UMP for EP=0x%02x, blk=%d\n", ep->endpoint, id); if (ep->direction == STR_IN) err = create_midi2_ump(umidi, ep, NULL, id); else err = create_midi2_ump(umidi, NULL, ep, id); if (err < 0) return err; break; } } return 0; } /* is the given interface for MIDI 2.0? */ static bool is_midi2_altset(struct usb_host_interface *hostif) { struct usb_ms_header_descriptor *ms_header = (struct usb_ms_header_descriptor *)hostif->extra; if (hostif->extralen < 7 || ms_header->bLength < 7 || ms_header->bDescriptorType != USB_DT_CS_INTERFACE || ms_header->bDescriptorSubtype != UAC_HEADER) return false; return le16_to_cpu(ms_header->bcdMSC) == USB_MS_REV_MIDI_2_0; } /* change the altsetting */ static int set_altset(struct snd_usb_midi2_interface *umidi) { usb_audio_dbg(umidi->chip, "Setting host iface %d:%d\n", umidi->hostif->desc.bInterfaceNumber, umidi->hostif->desc.bAlternateSetting); return usb_set_interface(umidi->chip->dev, umidi->hostif->desc.bInterfaceNumber, umidi->hostif->desc.bAlternateSetting); } /* fill UMP Endpoint name string from USB descriptor */ static void fill_ump_ep_name(struct snd_ump_endpoint *ump, struct usb_device *dev, int id) { int len; usb_string(dev, id, ump->info.name, sizeof(ump->info.name)); /* trim superfluous "MIDI" suffix */ len = strlen(ump->info.name); if (len > 5 && !strcmp(ump->info.name + len - 5, " MIDI")) ump->info.name[len - 5] = 0; } /* fill the fallback name string for each rawmidi instance */ static void set_fallback_rawmidi_names(struct snd_usb_midi2_interface *umidi) { struct usb_device *dev = umidi->chip->dev; struct snd_usb_midi2_ump *rmidi; struct snd_ump_endpoint *ump; list_for_each_entry(rmidi, &umidi->rawmidi_list, list) { ump = rmidi->ump; /* fill UMP EP name from USB descriptors */ if (!*ump->info.name && umidi->hostif->desc.iInterface) fill_ump_ep_name(ump, dev, umidi->hostif->desc.iInterface); else if (!*ump->info.name && dev->descriptor.iProduct) fill_ump_ep_name(ump, dev, dev->descriptor.iProduct); /* fill fallback name */ if (!*ump->info.name) sprintf(ump->info.name, "USB MIDI %d", rmidi->index); /* copy as rawmidi name if not set */ if (!*ump->core.name) strscpy(ump->core.name, ump->info.name, sizeof(ump->core.name)); /* use serial number string as unique UMP product id */ if (!*ump->info.product_id && dev->descriptor.iSerialNumber) usb_string(dev, dev->descriptor.iSerialNumber, ump->info.product_id, sizeof(ump->info.product_id)); } } /* create MIDI interface; fallback to MIDI 1.0 if needed */ int snd_usb_midi_v2_create(struct snd_usb_audio *chip, struct usb_interface *iface, const struct snd_usb_audio_quirk *quirk, unsigned int usb_id) { struct snd_usb_midi2_interface *umidi; struct usb_host_interface *hostif; int err; usb_audio_dbg(chip, "Parsing interface %d...\n", iface->altsetting[0].desc.bInterfaceNumber); /* fallback to MIDI 1.0? */ if (!midi2_enable) { usb_audio_info(chip, "Falling back to MIDI 1.0 by module option\n"); goto fallback_to_midi1; } if ((quirk && quirk->type != QUIRK_MIDI_STANDARD_INTERFACE) || iface->num_altsetting < 2) { usb_audio_info(chip, "Quirk or no altest; falling back to MIDI 1.0\n"); goto fallback_to_midi1; } hostif = &iface->altsetting[1]; if (!is_midi2_altset(hostif)) { usb_audio_info(chip, "No MIDI 2.0 at altset 1, falling back to MIDI 1.0\n"); goto fallback_to_midi1; } if (!hostif->desc.bNumEndpoints) { usb_audio_info(chip, "No endpoint at altset 1, falling back to MIDI 1.0\n"); goto fallback_to_midi1; } usb_audio_dbg(chip, "Creating a MIDI 2.0 instance for %d:%d\n", hostif->desc.bInterfaceNumber, hostif->desc.bAlternateSetting); umidi = kzalloc(sizeof(*umidi), GFP_KERNEL); if (!umidi) return -ENOMEM; umidi->chip = chip; umidi->iface = iface; umidi->hostif = hostif; INIT_LIST_HEAD(&umidi->rawmidi_list); INIT_LIST_HEAD(&umidi->ep_list); list_add_tail(&umidi->list, &chip->midi_v2_list); err = set_altset(umidi); if (err < 0) { usb_audio_err(chip, "Failed to set altset\n"); goto error; } /* assume only altset 1 corresponding to MIDI 2.0 interface */ err = parse_midi_2_0(umidi); if (err < 0) { usb_audio_err(chip, "Failed to parse MIDI 2.0 interface\n"); goto error; } /* parse USB group terminal blocks */ err = parse_group_terminal_blocks(umidi); if (err < 0) { usb_audio_err(chip, "Failed to parse GTB\n"); goto error; } err = start_input_streams(umidi); if (err < 0) { usb_audio_err(chip, "Failed to start input streams\n"); goto error; } if (midi2_ump_probe) { err = parse_ump_endpoints(umidi); if (err < 0) { usb_audio_err(chip, "Failed to parse UMP endpoint\n"); goto error; } } err = create_blocks_from_gtb(umidi); if (err < 0) { usb_audio_err(chip, "Failed to create GTB blocks\n"); goto error; } set_fallback_rawmidi_names(umidi); err = attach_legacy_rawmidi(umidi); if (err < 0) { usb_audio_err(chip, "Failed to create legacy rawmidi\n"); goto error; } return 0; error: snd_usb_midi_v2_free(umidi); return err; fallback_to_midi1: return __snd_usbmidi_create(chip->card, iface, &chip->midi_list, quirk, usb_id, &chip->num_rawmidis); } static void suspend_midi2_endpoint(struct snd_usb_midi2_endpoint *ep) { kill_midi_urbs(ep, true); drain_urb_queue(ep); } void snd_usb_midi_v2_suspend_all(struct snd_usb_audio *chip) { struct snd_usb_midi2_interface *umidi; struct snd_usb_midi2_endpoint *ep; list_for_each_entry(umidi, &chip->midi_v2_list, list) { list_for_each_entry(ep, &umidi->ep_list, list) suspend_midi2_endpoint(ep); } } static void resume_midi2_endpoint(struct snd_usb_midi2_endpoint *ep) { ep->running = ep->suspended; if (ep->direction == STR_IN) submit_io_urbs(ep); /* FIXME: does it all? */ } void snd_usb_midi_v2_resume_all(struct snd_usb_audio *chip) { struct snd_usb_midi2_interface *umidi; struct snd_usb_midi2_endpoint *ep; list_for_each_entry(umidi, &chip->midi_v2_list, list) { set_altset(umidi); list_for_each_entry(ep, &umidi->ep_list, list) resume_midi2_endpoint(ep); } } void snd_usb_midi_v2_disconnect_all(struct snd_usb_audio *chip) { struct snd_usb_midi2_interface *umidi; struct snd_usb_midi2_endpoint *ep; list_for_each_entry(umidi, &chip->midi_v2_list, list) { umidi->disconnected = 1; list_for_each_entry(ep, &umidi->ep_list, list) { ep->disconnected = 1; kill_midi_urbs(ep, false); drain_urb_queue(ep); } } } /* release the MIDI instance */ void snd_usb_midi_v2_free_all(struct snd_usb_audio *chip) { struct snd_usb_midi2_interface *umidi, *next; list_for_each_entry_safe(umidi, next, &chip->midi_v2_list, list) snd_usb_midi_v2_free(umidi); }
linux-master
sound/usb/midi2.c
// SPDX-License-Identifier: GPL-2.0-or-later /* */ #include <linux/init.h> #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/usb/audio-v2.h> #include <linux/usb/audio-v3.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/control.h> #include <sound/tlv.h> #include "usbaudio.h" #include "card.h" #include "proc.h" #include "quirks.h" #include "endpoint.h" #include "pcm.h" #include "helper.h" #include "format.h" #include "clock.h" #include "stream.h" #include "power.h" #include "media.h" static void audioformat_free(struct audioformat *fp) { list_del(&fp->list); /* unlink for avoiding double-free */ kfree(fp->rate_table); kfree(fp->chmap); kfree(fp); } /* * free a substream */ static void free_substream(struct snd_usb_substream *subs) { struct audioformat *fp, *n; if (!subs->num_formats) return; /* not initialized */ list_for_each_entry_safe(fp, n, &subs->fmt_list, list) audioformat_free(fp); kfree(subs->str_pd); snd_media_stream_delete(subs); } /* * free a usb stream instance */ static void snd_usb_audio_stream_free(struct snd_usb_stream *stream) { free_substream(&stream->substream[0]); free_substream(&stream->substream[1]); list_del(&stream->list); kfree(stream); } static void snd_usb_audio_pcm_free(struct snd_pcm *pcm) { struct snd_usb_stream *stream = pcm->private_data; if (stream) { stream->pcm = NULL; snd_usb_audio_stream_free(stream); } } /* * initialize the substream instance. */ static void snd_usb_init_substream(struct snd_usb_stream *as, int stream, struct audioformat *fp, struct snd_usb_power_domain *pd) { struct snd_usb_substream *subs = &as->substream[stream]; INIT_LIST_HEAD(&subs->fmt_list); spin_lock_init(&subs->lock); subs->stream = as; subs->direction = stream; subs->dev = as->chip->dev; subs->txfr_quirk = !!(as->chip->quirk_flags & QUIRK_FLAG_ALIGN_TRANSFER); subs->tx_length_quirk = !!(as->chip->quirk_flags & QUIRK_FLAG_TX_LENGTH); subs->speed = snd_usb_get_speed(subs->dev); subs->pkt_offset_adj = 0; subs->stream_offset_adj = 0; snd_usb_set_pcm_ops(as->pcm, stream); list_add_tail(&fp->list, &subs->fmt_list); subs->formats |= fp->formats; subs->num_formats++; subs->fmt_type = fp->fmt_type; subs->ep_num = fp->endpoint; if (fp->channels > subs->channels_max) subs->channels_max = fp->channels; if (pd) { subs->str_pd = pd; /* Initialize Power Domain to idle status D1 */ snd_usb_power_domain_set(subs->stream->chip, pd, UAC3_PD_STATE_D1); } snd_usb_preallocate_buffer(subs); } /* kctl callbacks for usb-audio channel maps */ static int usb_chmap_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); struct snd_usb_substream *subs = info->private_data; uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = subs->channels_max; uinfo->value.integer.min = 0; uinfo->value.integer.max = SNDRV_CHMAP_LAST; return 0; } /* check whether a duplicated entry exists in the audiofmt list */ static bool have_dup_chmap(struct snd_usb_substream *subs, struct audioformat *fp) { struct audioformat *prev = fp; list_for_each_entry_continue_reverse(prev, &subs->fmt_list, list) { if (prev->chmap && !memcmp(prev->chmap, fp->chmap, sizeof(*fp->chmap))) return true; } return false; } static int usb_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag, unsigned int size, unsigned int __user *tlv) { struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); struct snd_usb_substream *subs = info->private_data; struct audioformat *fp; unsigned int __user *dst; int count = 0; if (size < 8) return -ENOMEM; if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv)) return -EFAULT; size -= 8; dst = tlv + 2; list_for_each_entry(fp, &subs->fmt_list, list) { int i, ch_bytes; if (!fp->chmap) continue; if (have_dup_chmap(subs, fp)) continue; /* copy the entry */ ch_bytes = fp->chmap->channels * 4; if (size < 8 + ch_bytes) return -ENOMEM; if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) || put_user(ch_bytes, dst + 1)) return -EFAULT; dst += 2; for (i = 0; i < fp->chmap->channels; i++, dst++) { if (put_user(fp->chmap->map[i], dst)) return -EFAULT; } count += 8 + ch_bytes; size -= 8 + ch_bytes; } if (put_user(count, tlv + 1)) return -EFAULT; return 0; } static int usb_chmap_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); struct snd_usb_substream *subs = info->private_data; struct snd_pcm_chmap_elem *chmap = NULL; int i = 0; if (subs->cur_audiofmt) chmap = subs->cur_audiofmt->chmap; if (chmap) { for (i = 0; i < chmap->channels; i++) ucontrol->value.integer.value[i] = chmap->map[i]; } for (; i < subs->channels_max; i++) ucontrol->value.integer.value[i] = 0; return 0; } /* create a chmap kctl assigned to the given USB substream */ static int add_chmap(struct snd_pcm *pcm, int stream, struct snd_usb_substream *subs) { struct audioformat *fp; struct snd_pcm_chmap *chmap; struct snd_kcontrol *kctl; int err; list_for_each_entry(fp, &subs->fmt_list, list) if (fp->chmap) goto ok; /* no chmap is found */ return 0; ok: err = snd_pcm_add_chmap_ctls(pcm, stream, NULL, 0, 0, &chmap); if (err < 0) return err; /* override handlers */ chmap->private_data = subs; kctl = chmap->kctl; kctl->info = usb_chmap_ctl_info; kctl->get = usb_chmap_ctl_get; kctl->tlv.c = usb_chmap_ctl_tlv; return 0; } /* convert from USB ChannelConfig bits to ALSA chmap element */ static struct snd_pcm_chmap_elem *convert_chmap(int channels, unsigned int bits, int protocol) { static const unsigned int uac1_maps[] = { SNDRV_CHMAP_FL, /* left front */ SNDRV_CHMAP_FR, /* right front */ SNDRV_CHMAP_FC, /* center front */ SNDRV_CHMAP_LFE, /* LFE */ SNDRV_CHMAP_SL, /* left surround */ SNDRV_CHMAP_SR, /* right surround */ SNDRV_CHMAP_FLC, /* left of center */ SNDRV_CHMAP_FRC, /* right of center */ SNDRV_CHMAP_RC, /* surround */ SNDRV_CHMAP_SL, /* side left */ SNDRV_CHMAP_SR, /* side right */ SNDRV_CHMAP_TC, /* top */ 0 /* terminator */ }; static const unsigned int uac2_maps[] = { SNDRV_CHMAP_FL, /* front left */ SNDRV_CHMAP_FR, /* front right */ SNDRV_CHMAP_FC, /* front center */ SNDRV_CHMAP_LFE, /* LFE */ SNDRV_CHMAP_RL, /* back left */ SNDRV_CHMAP_RR, /* back right */ SNDRV_CHMAP_FLC, /* front left of center */ SNDRV_CHMAP_FRC, /* front right of center */ SNDRV_CHMAP_RC, /* back center */ SNDRV_CHMAP_SL, /* side left */ SNDRV_CHMAP_SR, /* side right */ SNDRV_CHMAP_TC, /* top center */ SNDRV_CHMAP_TFL, /* top front left */ SNDRV_CHMAP_TFC, /* top front center */ SNDRV_CHMAP_TFR, /* top front right */ SNDRV_CHMAP_TRL, /* top back left */ SNDRV_CHMAP_TRC, /* top back center */ SNDRV_CHMAP_TRR, /* top back right */ SNDRV_CHMAP_TFLC, /* top front left of center */ SNDRV_CHMAP_TFRC, /* top front right of center */ SNDRV_CHMAP_LLFE, /* left LFE */ SNDRV_CHMAP_RLFE, /* right LFE */ SNDRV_CHMAP_TSL, /* top side left */ SNDRV_CHMAP_TSR, /* top side right */ SNDRV_CHMAP_BC, /* bottom center */ SNDRV_CHMAP_RLC, /* back left of center */ SNDRV_CHMAP_RRC, /* back right of center */ 0 /* terminator */ }; struct snd_pcm_chmap_elem *chmap; const unsigned int *maps; int c; if (channels > ARRAY_SIZE(chmap->map)) return NULL; chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); if (!chmap) return NULL; maps = protocol == UAC_VERSION_2 ? uac2_maps : uac1_maps; chmap->channels = channels; c = 0; if (bits) { for (; bits && *maps; maps++, bits >>= 1) if (bits & 1) chmap->map[c++] = *maps; } else { /* If we're missing wChannelConfig, then guess something to make sure the channel map is not skipped entirely */ if (channels == 1) chmap->map[c++] = SNDRV_CHMAP_MONO; else for (; c < channels && *maps; maps++) chmap->map[c++] = *maps; } for (; c < channels; c++) chmap->map[c] = SNDRV_CHMAP_UNKNOWN; return chmap; } /* UAC3 device stores channels information in Cluster Descriptors */ static struct snd_pcm_chmap_elem *convert_chmap_v3(struct uac3_cluster_header_descriptor *cluster) { unsigned int channels = cluster->bNrChannels; struct snd_pcm_chmap_elem *chmap; void *p = cluster; int len, c; if (channels > ARRAY_SIZE(chmap->map)) return NULL; chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); if (!chmap) return NULL; len = le16_to_cpu(cluster->wLength); c = 0; p += sizeof(struct uac3_cluster_header_descriptor); while (((p - (void *)cluster) < len) && (c < channels)) { struct uac3_cluster_segment_descriptor *cs_desc = p; u16 cs_len; u8 cs_type; cs_len = le16_to_cpu(cs_desc->wLength); cs_type = cs_desc->bSegmentType; if (cs_type == UAC3_CHANNEL_INFORMATION) { struct uac3_cluster_information_segment_descriptor *is = p; unsigned char map; /* * TODO: this conversion is not complete, update it * after adding UAC3 values to asound.h */ switch (is->bChRelationship) { case UAC3_CH_MONO: map = SNDRV_CHMAP_MONO; break; case UAC3_CH_LEFT: case UAC3_CH_FRONT_LEFT: case UAC3_CH_HEADPHONE_LEFT: map = SNDRV_CHMAP_FL; break; case UAC3_CH_RIGHT: case UAC3_CH_FRONT_RIGHT: case UAC3_CH_HEADPHONE_RIGHT: map = SNDRV_CHMAP_FR; break; case UAC3_CH_FRONT_CENTER: map = SNDRV_CHMAP_FC; break; case UAC3_CH_FRONT_LEFT_OF_CENTER: map = SNDRV_CHMAP_FLC; break; case UAC3_CH_FRONT_RIGHT_OF_CENTER: map = SNDRV_CHMAP_FRC; break; case UAC3_CH_SIDE_LEFT: map = SNDRV_CHMAP_SL; break; case UAC3_CH_SIDE_RIGHT: map = SNDRV_CHMAP_SR; break; case UAC3_CH_BACK_LEFT: map = SNDRV_CHMAP_RL; break; case UAC3_CH_BACK_RIGHT: map = SNDRV_CHMAP_RR; break; case UAC3_CH_BACK_CENTER: map = SNDRV_CHMAP_RC; break; case UAC3_CH_BACK_LEFT_OF_CENTER: map = SNDRV_CHMAP_RLC; break; case UAC3_CH_BACK_RIGHT_OF_CENTER: map = SNDRV_CHMAP_RRC; break; case UAC3_CH_TOP_CENTER: map = SNDRV_CHMAP_TC; break; case UAC3_CH_TOP_FRONT_LEFT: map = SNDRV_CHMAP_TFL; break; case UAC3_CH_TOP_FRONT_RIGHT: map = SNDRV_CHMAP_TFR; break; case UAC3_CH_TOP_FRONT_CENTER: map = SNDRV_CHMAP_TFC; break; case UAC3_CH_TOP_FRONT_LOC: map = SNDRV_CHMAP_TFLC; break; case UAC3_CH_TOP_FRONT_ROC: map = SNDRV_CHMAP_TFRC; break; case UAC3_CH_TOP_SIDE_LEFT: map = SNDRV_CHMAP_TSL; break; case UAC3_CH_TOP_SIDE_RIGHT: map = SNDRV_CHMAP_TSR; break; case UAC3_CH_TOP_BACK_LEFT: map = SNDRV_CHMAP_TRL; break; case UAC3_CH_TOP_BACK_RIGHT: map = SNDRV_CHMAP_TRR; break; case UAC3_CH_TOP_BACK_CENTER: map = SNDRV_CHMAP_TRC; break; case UAC3_CH_BOTTOM_CENTER: map = SNDRV_CHMAP_BC; break; case UAC3_CH_LOW_FREQUENCY_EFFECTS: map = SNDRV_CHMAP_LFE; break; case UAC3_CH_LFE_LEFT: map = SNDRV_CHMAP_LLFE; break; case UAC3_CH_LFE_RIGHT: map = SNDRV_CHMAP_RLFE; break; case UAC3_CH_RELATIONSHIP_UNDEFINED: default: map = SNDRV_CHMAP_UNKNOWN; break; } chmap->map[c++] = map; } p += cs_len; } if (channels < c) pr_err("%s: channel number mismatch\n", __func__); chmap->channels = channels; for (; c < channels; c++) chmap->map[c] = SNDRV_CHMAP_UNKNOWN; return chmap; } /* * add this endpoint to the chip instance. * if a stream with the same endpoint already exists, append to it. * if not, create a new pcm stream. note, fp is added to the substream * fmt_list and will be freed on the chip instance release. do not free * fp or do remove it from the substream fmt_list to avoid double-free. */ static int __snd_usb_add_audio_stream(struct snd_usb_audio *chip, int stream, struct audioformat *fp, struct snd_usb_power_domain *pd) { struct snd_usb_stream *as; struct snd_usb_substream *subs; struct snd_pcm *pcm; int err; list_for_each_entry(as, &chip->pcm_list, list) { if (as->fmt_type != fp->fmt_type) continue; subs = &as->substream[stream]; if (subs->ep_num == fp->endpoint) { list_add_tail(&fp->list, &subs->fmt_list); subs->num_formats++; subs->formats |= fp->formats; return 0; } } if (chip->card->registered) chip->need_delayed_register = true; /* look for an empty stream */ list_for_each_entry(as, &chip->pcm_list, list) { if (as->fmt_type != fp->fmt_type) continue; subs = &as->substream[stream]; if (subs->ep_num) continue; err = snd_pcm_new_stream(as->pcm, stream, 1); if (err < 0) return err; snd_usb_init_substream(as, stream, fp, pd); return add_chmap(as->pcm, stream, subs); } /* create a new pcm */ as = kzalloc(sizeof(*as), GFP_KERNEL); if (!as) return -ENOMEM; as->pcm_index = chip->pcm_devs; as->chip = chip; as->fmt_type = fp->fmt_type; err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs, stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0, stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1, &pcm); if (err < 0) { kfree(as); return err; } as->pcm = pcm; pcm->private_data = as; pcm->private_free = snd_usb_audio_pcm_free; pcm->info_flags = 0; if (chip->pcm_devs > 0) sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs); else strcpy(pcm->name, "USB Audio"); snd_usb_init_substream(as, stream, fp, pd); /* * Keep using head insertion for M-Audio Audiophile USB (tm) which has a * fix to swap capture stream order in conf/cards/USB-audio.conf */ if (chip->usb_id == USB_ID(0x0763, 0x2003)) list_add(&as->list, &chip->pcm_list); else list_add_tail(&as->list, &chip->pcm_list); chip->pcm_devs++; snd_usb_proc_pcm_format_add(as); return add_chmap(pcm, stream, &as->substream[stream]); } int snd_usb_add_audio_stream(struct snd_usb_audio *chip, int stream, struct audioformat *fp) { return __snd_usb_add_audio_stream(chip, stream, fp, NULL); } static int snd_usb_add_audio_stream_v3(struct snd_usb_audio *chip, int stream, struct audioformat *fp, struct snd_usb_power_domain *pd) { return __snd_usb_add_audio_stream(chip, stream, fp, pd); } static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip, struct usb_host_interface *alts, int protocol, int iface_no) { /* parsed with a v1 header here. that's ok as we only look at the * header first which is the same for both versions */ struct uac_iso_endpoint_descriptor *csep; struct usb_interface_descriptor *altsd = get_iface_desc(alts); int attributes = 0; csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT); /* Creamware Noah has this descriptor after the 2nd endpoint */ if (!csep && altsd->bNumEndpoints >= 2) csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT); /* * If we can't locate the USB_DT_CS_ENDPOINT descriptor in the extra * bytes after the first endpoint, go search the entire interface. * Some devices have it directly *before* the standard endpoint. */ if (!csep) csep = snd_usb_find_desc(alts->extra, alts->extralen, NULL, USB_DT_CS_ENDPOINT); if (!csep || csep->bLength < 7 || csep->bDescriptorSubtype != UAC_EP_GENERAL) goto error; if (protocol == UAC_VERSION_1) { attributes = csep->bmAttributes; } else if (protocol == UAC_VERSION_2) { struct uac2_iso_endpoint_descriptor *csep2 = (struct uac2_iso_endpoint_descriptor *) csep; if (csep2->bLength < sizeof(*csep2)) goto error; attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX; /* emulate the endpoint attributes of a v1 device */ if (csep2->bmControls & UAC2_CONTROL_PITCH) attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL; } else { /* UAC_VERSION_3 */ struct uac3_iso_endpoint_descriptor *csep3 = (struct uac3_iso_endpoint_descriptor *) csep; if (csep3->bLength < sizeof(*csep3)) goto error; /* emulate the endpoint attributes of a v1 device */ if (le32_to_cpu(csep3->bmControls) & UAC2_CONTROL_PITCH) attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL; } return attributes; error: usb_audio_warn(chip, "%u:%d : no or invalid class specific endpoint descriptor\n", iface_no, altsd->bAlternateSetting); return 0; } /* find an input terminal descriptor (either UAC1 or UAC2) with the given * terminal id */ static void * snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface, int terminal_id, int protocol) { struct uac2_input_terminal_descriptor *term = NULL; while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, ctrl_iface->extralen, term, UAC_INPUT_TERMINAL))) { if (!snd_usb_validate_audio_desc(term, protocol)) continue; if (term->bTerminalID == terminal_id) return term; } return NULL; } static void * snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface, int terminal_id, int protocol) { /* OK to use with both UAC2 and UAC3 */ struct uac2_output_terminal_descriptor *term = NULL; while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, ctrl_iface->extralen, term, UAC_OUTPUT_TERMINAL))) { if (!snd_usb_validate_audio_desc(term, protocol)) continue; if (term->bTerminalID == terminal_id) return term; } return NULL; } static struct audioformat * audio_format_alloc_init(struct snd_usb_audio *chip, struct usb_host_interface *alts, int protocol, int iface_no, int altset_idx, int altno, int num_channels, int clock) { struct audioformat *fp; fp = kzalloc(sizeof(*fp), GFP_KERNEL); if (!fp) return NULL; fp->iface = iface_no; fp->altsetting = altno; fp->altset_idx = altset_idx; fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; fp->datainterval = snd_usb_parse_datainterval(chip, alts); fp->protocol = protocol; fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); fp->channels = num_channels; if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH) fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1) * (fp->maxpacksize & 0x7ff); fp->clock = clock; INIT_LIST_HEAD(&fp->list); return fp; } static struct audioformat * snd_usb_get_audioformat_uac12(struct snd_usb_audio *chip, struct usb_host_interface *alts, int protocol, int iface_no, int altset_idx, int altno, int stream, int bm_quirk) { struct usb_device *dev = chip->dev; struct uac_format_type_i_continuous_descriptor *fmt; unsigned int num_channels = 0, chconfig = 0; struct audioformat *fp; int clock = 0; u64 format; /* get audio formats */ if (protocol == UAC_VERSION_1) { struct uac1_as_header_descriptor *as = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); struct uac_input_terminal_descriptor *iterm; if (!as) { dev_err(&dev->dev, "%u:%d : UAC_AS_GENERAL descriptor not found\n", iface_no, altno); return NULL; } if (as->bLength < sizeof(*as)) { dev_err(&dev->dev, "%u:%d : invalid UAC_AS_GENERAL desc\n", iface_no, altno); return NULL; } format = le16_to_cpu(as->wFormatTag); /* remember the format value */ iterm = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, as->bTerminalLink, protocol); if (iterm) { num_channels = iterm->bNrChannels; chconfig = le16_to_cpu(iterm->wChannelConfig); } } else { /* UAC_VERSION_2 */ struct uac2_input_terminal_descriptor *input_term; struct uac2_output_terminal_descriptor *output_term; struct uac2_as_header_descriptor *as = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); if (!as) { dev_err(&dev->dev, "%u:%d : UAC_AS_GENERAL descriptor not found\n", iface_no, altno); return NULL; } if (as->bLength < sizeof(*as)) { dev_err(&dev->dev, "%u:%d : invalid UAC_AS_GENERAL desc\n", iface_no, altno); return NULL; } num_channels = as->bNrChannels; format = le32_to_cpu(as->bmFormats); chconfig = le32_to_cpu(as->bmChannelConfig); /* * lookup the terminal associated to this interface * to extract the clock */ input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, as->bTerminalLink, protocol); if (input_term) { clock = input_term->bCSourceID; if (!chconfig && (num_channels == input_term->bNrChannels)) chconfig = le32_to_cpu(input_term->bmChannelConfig); goto found_clock; } output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf, as->bTerminalLink, protocol); if (output_term) { clock = output_term->bCSourceID; goto found_clock; } dev_err(&dev->dev, "%u:%d : bogus bTerminalLink %d\n", iface_no, altno, as->bTerminalLink); return NULL; } found_clock: /* get format type */ fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE); if (!fmt) { dev_err(&dev->dev, "%u:%d : no UAC_FORMAT_TYPE desc\n", iface_no, altno); return NULL; } if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) || ((protocol == UAC_VERSION_2) && (fmt->bLength < 6))) { dev_err(&dev->dev, "%u:%d : invalid UAC_FORMAT_TYPE desc\n", iface_no, altno); return NULL; } /* * Blue Microphones workaround: The last altsetting is * identical with the previous one, except for a larger * packet size, but is actually a mislabeled two-channel * setting; ignore it. * * Part 2: analyze quirk flag and format */ if (bm_quirk && fmt->bNrChannels == 1 && fmt->bSubframeSize == 2) return NULL; fp = audio_format_alloc_init(chip, alts, protocol, iface_no, altset_idx, altno, num_channels, clock); if (!fp) return ERR_PTR(-ENOMEM); fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, iface_no); /* some quirks for attributes here */ snd_usb_audioformat_attributes_quirk(chip, fp, stream); /* ok, let's parse further... */ if (snd_usb_parse_audio_format(chip, fp, format, fmt, stream) < 0) { audioformat_free(fp); return NULL; } /* Create chmap */ if (fp->channels != num_channels) chconfig = 0; fp->chmap = convert_chmap(fp->channels, chconfig, protocol); return fp; } static struct audioformat * snd_usb_get_audioformat_uac3(struct snd_usb_audio *chip, struct usb_host_interface *alts, struct snd_usb_power_domain **pd_out, int iface_no, int altset_idx, int altno, int stream) { struct usb_device *dev = chip->dev; struct uac3_input_terminal_descriptor *input_term; struct uac3_output_terminal_descriptor *output_term; struct uac3_cluster_header_descriptor *cluster; struct uac3_as_header_descriptor *as = NULL; struct uac3_hc_descriptor_header hc_header; struct snd_pcm_chmap_elem *chmap; struct snd_usb_power_domain *pd; unsigned char badd_profile; u64 badd_formats = 0; unsigned int num_channels; struct audioformat *fp; u16 cluster_id, wLength; int clock = 0; int err; badd_profile = chip->badd_profile; if (badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { unsigned int maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); switch (maxpacksize) { default: dev_err(&dev->dev, "%u:%d : incorrect wMaxPacketSize for BADD profile\n", iface_no, altno); return NULL; case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16: case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16: badd_formats = SNDRV_PCM_FMTBIT_S16_LE; num_channels = 1; break; case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24: case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24: badd_formats = SNDRV_PCM_FMTBIT_S24_3LE; num_channels = 1; break; case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16: case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16: badd_formats = SNDRV_PCM_FMTBIT_S16_LE; num_channels = 2; break; case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24: case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24: badd_formats = SNDRV_PCM_FMTBIT_S24_3LE; num_channels = 2; break; } chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); if (!chmap) return ERR_PTR(-ENOMEM); if (num_channels == 1) { chmap->map[0] = SNDRV_CHMAP_MONO; } else { chmap->map[0] = SNDRV_CHMAP_FL; chmap->map[1] = SNDRV_CHMAP_FR; } chmap->channels = num_channels; clock = UAC3_BADD_CS_ID9; goto found_clock; } as = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); if (!as) { dev_err(&dev->dev, "%u:%d : UAC_AS_GENERAL descriptor not found\n", iface_no, altno); return NULL; } if (as->bLength < sizeof(*as)) { dev_err(&dev->dev, "%u:%d : invalid UAC_AS_GENERAL desc\n", iface_no, altno); return NULL; } cluster_id = le16_to_cpu(as->wClusterDescrID); if (!cluster_id) { dev_err(&dev->dev, "%u:%d : no cluster descriptor\n", iface_no, altno); return NULL; } /* * Get number of channels and channel map through * High Capability Cluster Descriptor * * First step: get High Capability header and * read size of Cluster Descriptor */ err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, cluster_id, snd_usb_ctrl_intf(chip), &hc_header, sizeof(hc_header)); if (err < 0) return ERR_PTR(err); else if (err != sizeof(hc_header)) { dev_err(&dev->dev, "%u:%d : can't get High Capability descriptor\n", iface_no, altno); return ERR_PTR(-EIO); } /* * Second step: allocate needed amount of memory * and request Cluster Descriptor */ wLength = le16_to_cpu(hc_header.wLength); cluster = kzalloc(wLength, GFP_KERNEL); if (!cluster) return ERR_PTR(-ENOMEM); err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR, USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, cluster_id, snd_usb_ctrl_intf(chip), cluster, wLength); if (err < 0) { kfree(cluster); return ERR_PTR(err); } else if (err != wLength) { dev_err(&dev->dev, "%u:%d : can't get Cluster Descriptor\n", iface_no, altno); kfree(cluster); return ERR_PTR(-EIO); } num_channels = cluster->bNrChannels; chmap = convert_chmap_v3(cluster); kfree(cluster); /* * lookup the terminal associated to this interface * to extract the clock */ input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, as->bTerminalLink, UAC_VERSION_3); if (input_term) { clock = input_term->bCSourceID; goto found_clock; } output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf, as->bTerminalLink, UAC_VERSION_3); if (output_term) { clock = output_term->bCSourceID; goto found_clock; } dev_err(&dev->dev, "%u:%d : bogus bTerminalLink %d\n", iface_no, altno, as->bTerminalLink); kfree(chmap); return NULL; found_clock: fp = audio_format_alloc_init(chip, alts, UAC_VERSION_3, iface_no, altset_idx, altno, num_channels, clock); if (!fp) { kfree(chmap); return ERR_PTR(-ENOMEM); } fp->chmap = chmap; if (badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { fp->attributes = 0; /* No attributes */ fp->fmt_type = UAC_FORMAT_TYPE_I; fp->formats = badd_formats; fp->nr_rates = 0; /* SNDRV_PCM_RATE_CONTINUOUS */ fp->rate_min = UAC3_BADD_SAMPLING_RATE; fp->rate_max = UAC3_BADD_SAMPLING_RATE; fp->rates = SNDRV_PCM_RATE_CONTINUOUS; pd = kzalloc(sizeof(*pd), GFP_KERNEL); if (!pd) { audioformat_free(fp); return NULL; } pd->pd_id = (stream == SNDRV_PCM_STREAM_PLAYBACK) ? UAC3_BADD_PD_ID10 : UAC3_BADD_PD_ID11; pd->pd_d1d0_rec = UAC3_BADD_PD_RECOVER_D1D0; pd->pd_d2d0_rec = UAC3_BADD_PD_RECOVER_D2D0; } else { fp->attributes = parse_uac_endpoint_attributes(chip, alts, UAC_VERSION_3, iface_no); pd = snd_usb_find_power_domain(chip->ctrl_intf, as->bTerminalLink); /* ok, let's parse further... */ if (snd_usb_parse_audio_format_v3(chip, fp, as, stream) < 0) { kfree(pd); audioformat_free(fp); return NULL; } } if (pd) *pd_out = pd; return fp; } static int __snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no, bool *has_non_pcm, bool non_pcm) { struct usb_device *dev; struct usb_interface *iface; struct usb_host_interface *alts; struct usb_interface_descriptor *altsd; int i, altno, err, stream; struct audioformat *fp = NULL; struct snd_usb_power_domain *pd = NULL; bool set_iface_first; int num, protocol; dev = chip->dev; /* parse the interface's altsettings */ iface = usb_ifnum_to_if(dev, iface_no); num = iface->num_altsetting; /* * Dallas DS4201 workaround: It presents 5 altsettings, but the last * one misses syncpipe, and does not produce any sound. */ if (chip->usb_id == USB_ID(0x04fa, 0x4201) && num >= 4) num = 4; for (i = 0; i < num; i++) { alts = &iface->altsetting[i]; altsd = get_iface_desc(alts); protocol = altsd->bInterfaceProtocol; /* skip invalid one */ if (((altsd->bInterfaceClass != USB_CLASS_AUDIO || (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING && altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC)) && altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || altsd->bNumEndpoints < 1 || le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0) continue; /* must be isochronous */ if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_ISOC) continue; /* check direction */ stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; altno = altsd->bAlternateSetting; if (snd_usb_apply_interface_quirk(chip, iface_no, altno)) continue; /* * Roland audio streaming interfaces are marked with protocols * 0/1/2, but are UAC 1 compatible. */ if (USB_ID_VENDOR(chip->usb_id) == 0x0582 && altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC && protocol <= 2) protocol = UAC_VERSION_1; switch (protocol) { default: dev_dbg(&dev->dev, "%u:%d: unknown interface protocol %#02x, assuming v1\n", iface_no, altno, protocol); protocol = UAC_VERSION_1; fallthrough; case UAC_VERSION_1: case UAC_VERSION_2: { int bm_quirk = 0; /* * Blue Microphones workaround: The last altsetting is * identical with the previous one, except for a larger * packet size, but is actually a mislabeled two-channel * setting; ignore it. * * Part 1: prepare quirk flag */ if (altno == 2 && num == 3 && fp && fp->altsetting == 1 && fp->channels == 1 && fp->formats == SNDRV_PCM_FMTBIT_S16_LE && protocol == UAC_VERSION_1 && le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == fp->maxpacksize * 2) bm_quirk = 1; fp = snd_usb_get_audioformat_uac12(chip, alts, protocol, iface_no, i, altno, stream, bm_quirk); break; } case UAC_VERSION_3: fp = snd_usb_get_audioformat_uac3(chip, alts, &pd, iface_no, i, altno, stream); break; } if (!fp) continue; else if (IS_ERR(fp)) return PTR_ERR(fp); if (fp->fmt_type != UAC_FORMAT_TYPE_I) *has_non_pcm = true; if ((fp->fmt_type == UAC_FORMAT_TYPE_I) == non_pcm) { audioformat_free(fp); kfree(pd); fp = NULL; pd = NULL; continue; } snd_usb_audioformat_set_sync_ep(chip, fp); dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint); if (protocol == UAC_VERSION_3) err = snd_usb_add_audio_stream_v3(chip, stream, fp, pd); else err = snd_usb_add_audio_stream(chip, stream, fp); if (err < 0) { audioformat_free(fp); kfree(pd); return err; } /* add endpoints */ err = snd_usb_add_endpoint(chip, fp->endpoint, SND_USB_ENDPOINT_TYPE_DATA); if (err < 0) return err; if (fp->sync_ep) { err = snd_usb_add_endpoint(chip, fp->sync_ep, fp->implicit_fb ? SND_USB_ENDPOINT_TYPE_DATA : SND_USB_ENDPOINT_TYPE_SYNC); if (err < 0) return err; } set_iface_first = false; if (protocol == UAC_VERSION_1 || (chip->quirk_flags & QUIRK_FLAG_SET_IFACE_FIRST)) set_iface_first = true; /* try to set the interface... */ usb_set_interface(chip->dev, iface_no, 0); if (set_iface_first) usb_set_interface(chip->dev, iface_no, altno); snd_usb_init_pitch(chip, fp); snd_usb_init_sample_rate(chip, fp, fp->rate_max); if (!set_iface_first) usb_set_interface(chip->dev, iface_no, altno); } return 0; } int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no) { int err; bool has_non_pcm = false; /* parse PCM formats */ err = __snd_usb_parse_audio_interface(chip, iface_no, &has_non_pcm, false); if (err < 0) return err; if (has_non_pcm) { /* parse non-PCM formats */ err = __snd_usb_parse_audio_interface(chip, iface_no, &has_non_pcm, true); if (err < 0) return err; } return 0; }
linux-master
sound/usb/stream.c
// SPDX-License-Identifier: GPL-2.0-only /* * Edirol UA-101/UA-1000 driver * Copyright (c) Clemens Ladisch <[email protected]> */ #include <linux/init.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <sound/core.h> #include <sound/initval.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "../usbaudio.h" #include "../midi.h" MODULE_DESCRIPTION("Edirol UA-101/1000 driver"); MODULE_AUTHOR("Clemens Ladisch <[email protected]>"); MODULE_LICENSE("GPL v2"); /* * Should not be lower than the minimum scheduling delay of the host * controller. Some Intel controllers need more than one frame; as long as * that driver doesn't tell us about this, use 1.5 frames just to be sure. */ #define MIN_QUEUE_LENGTH 12 /* Somewhat random. */ #define MAX_QUEUE_LENGTH 30 /* * This magic value optimizes memory usage efficiency for the UA-101's packet * sizes at all sample rates, taking into account the stupid cache pool sizes * that usb_alloc_coherent() uses. */ #define DEFAULT_QUEUE_LENGTH 21 #define MAX_PACKET_SIZE 672 /* hardware specific */ #define MAX_MEMORY_BUFFERS DIV_ROUND_UP(MAX_QUEUE_LENGTH, \ PAGE_SIZE / MAX_PACKET_SIZE) static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; static unsigned int queue_length = 21; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "card index"); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string"); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "enable card"); module_param(queue_length, uint, 0644); MODULE_PARM_DESC(queue_length, "USB queue length in microframes, " __stringify(MIN_QUEUE_LENGTH)"-"__stringify(MAX_QUEUE_LENGTH)); enum { INTF_PLAYBACK, INTF_CAPTURE, INTF_MIDI, INTF_COUNT }; /* bits in struct ua101::states */ enum { USB_CAPTURE_RUNNING, USB_PLAYBACK_RUNNING, ALSA_CAPTURE_OPEN, ALSA_PLAYBACK_OPEN, ALSA_CAPTURE_RUNNING, ALSA_PLAYBACK_RUNNING, CAPTURE_URB_COMPLETED, PLAYBACK_URB_COMPLETED, DISCONNECTED, }; struct ua101 { struct usb_device *dev; struct snd_card *card; struct usb_interface *intf[INTF_COUNT]; int card_index; struct snd_pcm *pcm; struct list_head midi_list; u64 format_bit; unsigned int rate; unsigned int packets_per_second; spinlock_t lock; struct mutex mutex; unsigned long states; /* FIFO to synchronize playback rate to capture rate */ unsigned int rate_feedback_start; unsigned int rate_feedback_count; u8 rate_feedback[MAX_QUEUE_LENGTH]; struct list_head ready_playback_urbs; struct work_struct playback_work; wait_queue_head_t alsa_capture_wait; wait_queue_head_t rate_feedback_wait; wait_queue_head_t alsa_playback_wait; struct ua101_stream { struct snd_pcm_substream *substream; unsigned int usb_pipe; unsigned int channels; unsigned int frame_bytes; unsigned int max_packet_bytes; unsigned int period_pos; unsigned int buffer_pos; unsigned int queue_length; struct ua101_urb { struct urb urb; struct usb_iso_packet_descriptor iso_frame_desc[1]; struct list_head ready_list; } *urbs[MAX_QUEUE_LENGTH]; struct { unsigned int size; void *addr; dma_addr_t dma; } buffers[MAX_MEMORY_BUFFERS]; } capture, playback; }; static DEFINE_MUTEX(devices_mutex); static unsigned int devices_used; static struct usb_driver ua101_driver; static void abort_alsa_playback(struct ua101 *ua); static void abort_alsa_capture(struct ua101 *ua); static const char *usb_error_string(int err) { switch (err) { case -ENODEV: return "no device"; case -ENOENT: return "endpoint not enabled"; case -EPIPE: return "endpoint stalled"; case -ENOSPC: return "not enough bandwidth"; case -ESHUTDOWN: return "device disabled"; case -EHOSTUNREACH: return "device suspended"; case -EINVAL: case -EAGAIN: case -EFBIG: case -EMSGSIZE: return "internal error"; default: return "unknown error"; } } static void abort_usb_capture(struct ua101 *ua) { if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) { wake_up(&ua->alsa_capture_wait); wake_up(&ua->rate_feedback_wait); } } static void abort_usb_playback(struct ua101 *ua) { if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states)) wake_up(&ua->alsa_playback_wait); } static void playback_urb_complete(struct urb *usb_urb) { struct ua101_urb *urb = (struct ua101_urb *)usb_urb; struct ua101 *ua = urb->urb.context; unsigned long flags; if (unlikely(urb->urb.status == -ENOENT || /* unlinked */ urb->urb.status == -ENODEV || /* device removed */ urb->urb.status == -ECONNRESET || /* unlinked */ urb->urb.status == -ESHUTDOWN)) { /* device disabled */ abort_usb_playback(ua); abort_alsa_playback(ua); return; } if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) { /* append URB to FIFO */ spin_lock_irqsave(&ua->lock, flags); list_add_tail(&urb->ready_list, &ua->ready_playback_urbs); if (ua->rate_feedback_count > 0) queue_work(system_highpri_wq, &ua->playback_work); ua->playback.substream->runtime->delay -= urb->urb.iso_frame_desc[0].length / ua->playback.frame_bytes; spin_unlock_irqrestore(&ua->lock, flags); } } static void first_playback_urb_complete(struct urb *urb) { struct ua101 *ua = urb->context; urb->complete = playback_urb_complete; playback_urb_complete(urb); set_bit(PLAYBACK_URB_COMPLETED, &ua->states); wake_up(&ua->alsa_playback_wait); } /* copy data from the ALSA ring buffer into the URB buffer */ static bool copy_playback_data(struct ua101_stream *stream, struct urb *urb, unsigned int frames) { struct snd_pcm_runtime *runtime; unsigned int frame_bytes, frames1; const u8 *source; runtime = stream->substream->runtime; frame_bytes = stream->frame_bytes; source = runtime->dma_area + stream->buffer_pos * frame_bytes; if (stream->buffer_pos + frames <= runtime->buffer_size) { memcpy(urb->transfer_buffer, source, frames * frame_bytes); } else { /* wrap around at end of ring buffer */ frames1 = runtime->buffer_size - stream->buffer_pos; memcpy(urb->transfer_buffer, source, frames1 * frame_bytes); memcpy(urb->transfer_buffer + frames1 * frame_bytes, runtime->dma_area, (frames - frames1) * frame_bytes); } stream->buffer_pos += frames; if (stream->buffer_pos >= runtime->buffer_size) stream->buffer_pos -= runtime->buffer_size; stream->period_pos += frames; if (stream->period_pos >= runtime->period_size) { stream->period_pos -= runtime->period_size; return true; } return false; } static inline void add_with_wraparound(struct ua101 *ua, unsigned int *value, unsigned int add) { *value += add; if (*value >= ua->playback.queue_length) *value -= ua->playback.queue_length; } static void playback_work(struct work_struct *work) { struct ua101 *ua = container_of(work, struct ua101, playback_work); unsigned long flags; unsigned int frames; struct ua101_urb *urb; bool do_period_elapsed = false; int err; if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states))) return; /* * Synchronizing the playback rate to the capture rate is done by using * the same sequence of packet sizes for both streams. * Submitting a playback URB therefore requires both a ready URB and * the size of the corresponding capture packet, i.e., both playback * and capture URBs must have been completed. Since the USB core does * not guarantee that playback and capture complete callbacks are * called alternately, we use two FIFOs for packet sizes and read URBs; * submitting playback URBs is possible as long as both FIFOs are * nonempty. */ spin_lock_irqsave(&ua->lock, flags); while (ua->rate_feedback_count > 0 && !list_empty(&ua->ready_playback_urbs)) { /* take packet size out of FIFO */ frames = ua->rate_feedback[ua->rate_feedback_start]; add_with_wraparound(ua, &ua->rate_feedback_start, 1); ua->rate_feedback_count--; /* take URB out of FIFO */ urb = list_first_entry(&ua->ready_playback_urbs, struct ua101_urb, ready_list); list_del(&urb->ready_list); /* fill packet with data or silence */ urb->urb.iso_frame_desc[0].length = frames * ua->playback.frame_bytes; if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states)) do_period_elapsed |= copy_playback_data(&ua->playback, &urb->urb, frames); else memset(urb->urb.transfer_buffer, 0, urb->urb.iso_frame_desc[0].length); /* and off you go ... */ err = usb_submit_urb(&urb->urb, GFP_ATOMIC); if (unlikely(err < 0)) { spin_unlock_irqrestore(&ua->lock, flags); abort_usb_playback(ua); abort_alsa_playback(ua); dev_err(&ua->dev->dev, "USB request error %d: %s\n", err, usb_error_string(err)); return; } ua->playback.substream->runtime->delay += frames; } spin_unlock_irqrestore(&ua->lock, flags); if (do_period_elapsed) snd_pcm_period_elapsed(ua->playback.substream); } /* copy data from the URB buffer into the ALSA ring buffer */ static bool copy_capture_data(struct ua101_stream *stream, struct urb *urb, unsigned int frames) { struct snd_pcm_runtime *runtime; unsigned int frame_bytes, frames1; u8 *dest; runtime = stream->substream->runtime; frame_bytes = stream->frame_bytes; dest = runtime->dma_area + stream->buffer_pos * frame_bytes; if (stream->buffer_pos + frames <= runtime->buffer_size) { memcpy(dest, urb->transfer_buffer, frames * frame_bytes); } else { /* wrap around at end of ring buffer */ frames1 = runtime->buffer_size - stream->buffer_pos; memcpy(dest, urb->transfer_buffer, frames1 * frame_bytes); memcpy(runtime->dma_area, urb->transfer_buffer + frames1 * frame_bytes, (frames - frames1) * frame_bytes); } stream->buffer_pos += frames; if (stream->buffer_pos >= runtime->buffer_size) stream->buffer_pos -= runtime->buffer_size; stream->period_pos += frames; if (stream->period_pos >= runtime->period_size) { stream->period_pos -= runtime->period_size; return true; } return false; } static void capture_urb_complete(struct urb *urb) { struct ua101 *ua = urb->context; struct ua101_stream *stream = &ua->capture; unsigned long flags; unsigned int frames, write_ptr; bool do_period_elapsed; int err; if (unlikely(urb->status == -ENOENT || /* unlinked */ urb->status == -ENODEV || /* device removed */ urb->status == -ECONNRESET || /* unlinked */ urb->status == -ESHUTDOWN)) /* device disabled */ goto stream_stopped; if (urb->status >= 0 && urb->iso_frame_desc[0].status >= 0) frames = urb->iso_frame_desc[0].actual_length / stream->frame_bytes; else frames = 0; spin_lock_irqsave(&ua->lock, flags); if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states)) do_period_elapsed = copy_capture_data(stream, urb, frames); else do_period_elapsed = false; if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) { err = usb_submit_urb(urb, GFP_ATOMIC); if (unlikely(err < 0)) { spin_unlock_irqrestore(&ua->lock, flags); dev_err(&ua->dev->dev, "USB request error %d: %s\n", err, usb_error_string(err)); goto stream_stopped; } /* append packet size to FIFO */ write_ptr = ua->rate_feedback_start; add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count); ua->rate_feedback[write_ptr] = frames; if (ua->rate_feedback_count < ua->playback.queue_length) { ua->rate_feedback_count++; if (ua->rate_feedback_count == ua->playback.queue_length) wake_up(&ua->rate_feedback_wait); } else { /* * Ring buffer overflow; this happens when the playback * stream is not running. Throw away the oldest entry, * so that the playback stream, when it starts, sees * the most recent packet sizes. */ add_with_wraparound(ua, &ua->rate_feedback_start, 1); } if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) && !list_empty(&ua->ready_playback_urbs)) queue_work(system_highpri_wq, &ua->playback_work); } spin_unlock_irqrestore(&ua->lock, flags); if (do_period_elapsed) snd_pcm_period_elapsed(stream->substream); return; stream_stopped: abort_usb_playback(ua); abort_usb_capture(ua); abort_alsa_playback(ua); abort_alsa_capture(ua); } static void first_capture_urb_complete(struct urb *urb) { struct ua101 *ua = urb->context; urb->complete = capture_urb_complete; capture_urb_complete(urb); set_bit(CAPTURE_URB_COMPLETED, &ua->states); wake_up(&ua->alsa_capture_wait); } static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream) { unsigned int i; for (i = 0; i < stream->queue_length; ++i) { int err = usb_submit_urb(&stream->urbs[i]->urb, GFP_KERNEL); if (err < 0) { dev_err(&ua->dev->dev, "USB request error %d: %s\n", err, usb_error_string(err)); return err; } } return 0; } static void kill_stream_urbs(struct ua101_stream *stream) { unsigned int i; for (i = 0; i < stream->queue_length; ++i) if (stream->urbs[i]) usb_kill_urb(&stream->urbs[i]->urb); } static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index) { struct usb_host_interface *alts; alts = ua->intf[intf_index]->cur_altsetting; if (alts->desc.bAlternateSetting != 1) { int err = usb_set_interface(ua->dev, alts->desc.bInterfaceNumber, 1); if (err < 0) { dev_err(&ua->dev->dev, "cannot initialize interface; error %d: %s\n", err, usb_error_string(err)); return err; } } return 0; } static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index) { struct usb_host_interface *alts; if (!ua->intf[intf_index]) return; alts = ua->intf[intf_index]->cur_altsetting; if (alts->desc.bAlternateSetting != 0) { int err = usb_set_interface(ua->dev, alts->desc.bInterfaceNumber, 0); if (err < 0 && !test_bit(DISCONNECTED, &ua->states)) dev_warn(&ua->dev->dev, "interface reset failed; error %d: %s\n", err, usb_error_string(err)); } } static void stop_usb_capture(struct ua101 *ua) { clear_bit(USB_CAPTURE_RUNNING, &ua->states); kill_stream_urbs(&ua->capture); disable_iso_interface(ua, INTF_CAPTURE); } static int start_usb_capture(struct ua101 *ua) { int err; if (test_bit(DISCONNECTED, &ua->states)) return -ENODEV; if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) return 0; kill_stream_urbs(&ua->capture); err = enable_iso_interface(ua, INTF_CAPTURE); if (err < 0) return err; clear_bit(CAPTURE_URB_COMPLETED, &ua->states); ua->capture.urbs[0]->urb.complete = first_capture_urb_complete; ua->rate_feedback_start = 0; ua->rate_feedback_count = 0; set_bit(USB_CAPTURE_RUNNING, &ua->states); err = submit_stream_urbs(ua, &ua->capture); if (err < 0) stop_usb_capture(ua); return err; } static void stop_usb_playback(struct ua101 *ua) { clear_bit(USB_PLAYBACK_RUNNING, &ua->states); kill_stream_urbs(&ua->playback); cancel_work_sync(&ua->playback_work); disable_iso_interface(ua, INTF_PLAYBACK); } static int start_usb_playback(struct ua101 *ua) { unsigned int i, frames; struct urb *urb; int err = 0; if (test_bit(DISCONNECTED, &ua->states)) return -ENODEV; if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) return 0; kill_stream_urbs(&ua->playback); cancel_work_sync(&ua->playback_work); err = enable_iso_interface(ua, INTF_PLAYBACK); if (err < 0) return err; clear_bit(PLAYBACK_URB_COMPLETED, &ua->states); ua->playback.urbs[0]->urb.complete = first_playback_urb_complete; spin_lock_irq(&ua->lock); INIT_LIST_HEAD(&ua->ready_playback_urbs); spin_unlock_irq(&ua->lock); /* * We submit the initial URBs all at once, so we have to wait for the * packet size FIFO to be full. */ wait_event(ua->rate_feedback_wait, ua->rate_feedback_count >= ua->playback.queue_length || !test_bit(USB_CAPTURE_RUNNING, &ua->states) || test_bit(DISCONNECTED, &ua->states)); if (test_bit(DISCONNECTED, &ua->states)) { stop_usb_playback(ua); return -ENODEV; } if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) { stop_usb_playback(ua); return -EIO; } for (i = 0; i < ua->playback.queue_length; ++i) { /* all initial URBs contain silence */ spin_lock_irq(&ua->lock); frames = ua->rate_feedback[ua->rate_feedback_start]; add_with_wraparound(ua, &ua->rate_feedback_start, 1); ua->rate_feedback_count--; spin_unlock_irq(&ua->lock); urb = &ua->playback.urbs[i]->urb; urb->iso_frame_desc[0].length = frames * ua->playback.frame_bytes; memset(urb->transfer_buffer, 0, urb->iso_frame_desc[0].length); } set_bit(USB_PLAYBACK_RUNNING, &ua->states); err = submit_stream_urbs(ua, &ua->playback); if (err < 0) stop_usb_playback(ua); return err; } static void abort_alsa_capture(struct ua101 *ua) { if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states)) snd_pcm_stop_xrun(ua->capture.substream); } static void abort_alsa_playback(struct ua101 *ua) { if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states)) snd_pcm_stop_xrun(ua->playback.substream); } static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream, unsigned int channels) { int err; substream->runtime->hw.info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BATCH | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_FIFO_IN_FRAMES; substream->runtime->hw.formats = ua->format_bit; substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate); substream->runtime->hw.rate_min = ua->rate; substream->runtime->hw.rate_max = ua->rate; substream->runtime->hw.channels_min = channels; substream->runtime->hw.channels_max = channels; substream->runtime->hw.buffer_bytes_max = 45000 * 1024; substream->runtime->hw.period_bytes_min = 1; substream->runtime->hw.period_bytes_max = UINT_MAX; substream->runtime->hw.periods_min = 2; substream->runtime->hw.periods_max = UINT_MAX; err = snd_pcm_hw_constraint_minmax(substream->runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1500000 / ua->packets_per_second, UINT_MAX); if (err < 0) return err; err = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24); return err; } static int capture_pcm_open(struct snd_pcm_substream *substream) { struct ua101 *ua = substream->private_data; int err; ua->capture.substream = substream; err = set_stream_hw(ua, substream, ua->capture.channels); if (err < 0) return err; substream->runtime->hw.fifo_size = DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second); substream->runtime->delay = substream->runtime->hw.fifo_size; mutex_lock(&ua->mutex); err = start_usb_capture(ua); if (err >= 0) set_bit(ALSA_CAPTURE_OPEN, &ua->states); mutex_unlock(&ua->mutex); return err; } static int playback_pcm_open(struct snd_pcm_substream *substream) { struct ua101 *ua = substream->private_data; int err; ua->playback.substream = substream; err = set_stream_hw(ua, substream, ua->playback.channels); if (err < 0) return err; substream->runtime->hw.fifo_size = DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length, ua->packets_per_second); mutex_lock(&ua->mutex); err = start_usb_capture(ua); if (err < 0) goto error; err = start_usb_playback(ua); if (err < 0) { if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states)) stop_usb_capture(ua); goto error; } set_bit(ALSA_PLAYBACK_OPEN, &ua->states); error: mutex_unlock(&ua->mutex); return err; } static int capture_pcm_close(struct snd_pcm_substream *substream) { struct ua101 *ua = substream->private_data; mutex_lock(&ua->mutex); clear_bit(ALSA_CAPTURE_OPEN, &ua->states); if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states)) stop_usb_capture(ua); mutex_unlock(&ua->mutex); return 0; } static int playback_pcm_close(struct snd_pcm_substream *substream) { struct ua101 *ua = substream->private_data; mutex_lock(&ua->mutex); stop_usb_playback(ua); clear_bit(ALSA_PLAYBACK_OPEN, &ua->states); if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states)) stop_usb_capture(ua); mutex_unlock(&ua->mutex); return 0; } static int capture_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { struct ua101 *ua = substream->private_data; int err; mutex_lock(&ua->mutex); err = start_usb_capture(ua); mutex_unlock(&ua->mutex); return err; } static int playback_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { struct ua101 *ua = substream->private_data; int err; mutex_lock(&ua->mutex); err = start_usb_capture(ua); if (err >= 0) err = start_usb_playback(ua); mutex_unlock(&ua->mutex); return err; } static int capture_pcm_prepare(struct snd_pcm_substream *substream) { struct ua101 *ua = substream->private_data; int err; mutex_lock(&ua->mutex); err = start_usb_capture(ua); mutex_unlock(&ua->mutex); if (err < 0) return err; /* * The EHCI driver schedules the first packet of an iso stream at 10 ms * in the future, i.e., no data is actually captured for that long. * Take the wait here so that the stream is known to be actually * running when the start trigger has been called. */ wait_event(ua->alsa_capture_wait, test_bit(CAPTURE_URB_COMPLETED, &ua->states) || !test_bit(USB_CAPTURE_RUNNING, &ua->states)); if (test_bit(DISCONNECTED, &ua->states)) return -ENODEV; if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) return -EIO; ua->capture.period_pos = 0; ua->capture.buffer_pos = 0; return 0; } static int playback_pcm_prepare(struct snd_pcm_substream *substream) { struct ua101 *ua = substream->private_data; int err; mutex_lock(&ua->mutex); err = start_usb_capture(ua); if (err >= 0) err = start_usb_playback(ua); mutex_unlock(&ua->mutex); if (err < 0) return err; /* see the comment in capture_pcm_prepare() */ wait_event(ua->alsa_playback_wait, test_bit(PLAYBACK_URB_COMPLETED, &ua->states) || !test_bit(USB_PLAYBACK_RUNNING, &ua->states)); if (test_bit(DISCONNECTED, &ua->states)) return -ENODEV; if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states)) return -EIO; substream->runtime->delay = 0; ua->playback.period_pos = 0; ua->playback.buffer_pos = 0; return 0; } static int capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { struct ua101 *ua = substream->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) return -EIO; set_bit(ALSA_CAPTURE_RUNNING, &ua->states); return 0; case SNDRV_PCM_TRIGGER_STOP: clear_bit(ALSA_CAPTURE_RUNNING, &ua->states); return 0; default: return -EINVAL; } } static int playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { struct ua101 *ua = substream->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states)) return -EIO; set_bit(ALSA_PLAYBACK_RUNNING, &ua->states); return 0; case SNDRV_PCM_TRIGGER_STOP: clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states); return 0; default: return -EINVAL; } } static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua, struct ua101_stream *stream) { unsigned long flags; unsigned int pos; spin_lock_irqsave(&ua->lock, flags); pos = stream->buffer_pos; spin_unlock_irqrestore(&ua->lock, flags); return pos; } static snd_pcm_uframes_t capture_pcm_pointer(struct snd_pcm_substream *subs) { struct ua101 *ua = subs->private_data; return ua101_pcm_pointer(ua, &ua->capture); } static snd_pcm_uframes_t playback_pcm_pointer(struct snd_pcm_substream *subs) { struct ua101 *ua = subs->private_data; return ua101_pcm_pointer(ua, &ua->playback); } static const struct snd_pcm_ops capture_pcm_ops = { .open = capture_pcm_open, .close = capture_pcm_close, .hw_params = capture_pcm_hw_params, .prepare = capture_pcm_prepare, .trigger = capture_pcm_trigger, .pointer = capture_pcm_pointer, }; static const struct snd_pcm_ops playback_pcm_ops = { .open = playback_pcm_open, .close = playback_pcm_close, .hw_params = playback_pcm_hw_params, .prepare = playback_pcm_prepare, .trigger = playback_pcm_trigger, .pointer = playback_pcm_pointer, }; static const struct uac_format_type_i_discrete_descriptor * find_format_descriptor(struct usb_interface *interface) { struct usb_host_interface *alt; u8 *extra; int extralen; if (interface->num_altsetting != 2) { dev_err(&interface->dev, "invalid num_altsetting\n"); return NULL; } alt = &interface->altsetting[0]; if (alt->desc.bNumEndpoints != 0) { dev_err(&interface->dev, "invalid bNumEndpoints\n"); return NULL; } alt = &interface->altsetting[1]; if (alt->desc.bNumEndpoints != 1) { dev_err(&interface->dev, "invalid bNumEndpoints\n"); return NULL; } extra = alt->extra; extralen = alt->extralen; while (extralen >= sizeof(struct usb_descriptor_header)) { struct uac_format_type_i_discrete_descriptor *desc; desc = (struct uac_format_type_i_discrete_descriptor *)extra; if (desc->bLength > extralen) { dev_err(&interface->dev, "descriptor overflow\n"); return NULL; } if (desc->bLength == UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1) && desc->bDescriptorType == USB_DT_CS_INTERFACE && desc->bDescriptorSubtype == UAC_FORMAT_TYPE) { if (desc->bFormatType != UAC_FORMAT_TYPE_I_PCM || desc->bSamFreqType != 1) { dev_err(&interface->dev, "invalid format type\n"); return NULL; } return desc; } extralen -= desc->bLength; extra += desc->bLength; } dev_err(&interface->dev, "sample format descriptor not found\n"); return NULL; } static int detect_usb_format(struct ua101 *ua) { const struct uac_format_type_i_discrete_descriptor *fmt_capture; const struct uac_format_type_i_discrete_descriptor *fmt_playback; const struct usb_endpoint_descriptor *epd; unsigned int rate2; fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]); fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]); if (!fmt_capture || !fmt_playback) return -ENXIO; switch (fmt_capture->bSubframeSize) { case 3: ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE; break; case 4: ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE; break; default: dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n"); return -ENXIO; } if (fmt_capture->bSubframeSize != fmt_playback->bSubframeSize) { dev_err(&ua->dev->dev, "playback/capture sample widths do not match\n"); return -ENXIO; } if (fmt_capture->bBitResolution != 24 || fmt_playback->bBitResolution != 24) { dev_err(&ua->dev->dev, "sample width is not 24 bits\n"); return -ENXIO; } ua->rate = combine_triple(fmt_capture->tSamFreq[0]); rate2 = combine_triple(fmt_playback->tSamFreq[0]); if (ua->rate != rate2) { dev_err(&ua->dev->dev, "playback/capture rates do not match: %u/%u\n", rate2, ua->rate); return -ENXIO; } switch (ua->dev->speed) { case USB_SPEED_FULL: ua->packets_per_second = 1000; break; case USB_SPEED_HIGH: ua->packets_per_second = 8000; break; default: dev_err(&ua->dev->dev, "unknown device speed\n"); return -ENXIO; } ua->capture.channels = fmt_capture->bNrChannels; ua->playback.channels = fmt_playback->bNrChannels; ua->capture.frame_bytes = fmt_capture->bSubframeSize * ua->capture.channels; ua->playback.frame_bytes = fmt_playback->bSubframeSize * ua->playback.channels; epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc; if (!usb_endpoint_is_isoc_in(epd) || usb_endpoint_maxp(epd) == 0) { dev_err(&ua->dev->dev, "invalid capture endpoint\n"); return -ENXIO; } ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd)); ua->capture.max_packet_bytes = usb_endpoint_maxp(epd); epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc; if (!usb_endpoint_is_isoc_out(epd) || usb_endpoint_maxp(epd) == 0) { dev_err(&ua->dev->dev, "invalid playback endpoint\n"); return -ENXIO; } ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd)); ua->playback.max_packet_bytes = usb_endpoint_maxp(epd); return 0; } static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) { unsigned int remaining_packets, packets, packets_per_page, i; size_t size; stream->queue_length = queue_length; stream->queue_length = max(stream->queue_length, (unsigned int)MIN_QUEUE_LENGTH); stream->queue_length = min(stream->queue_length, (unsigned int)MAX_QUEUE_LENGTH); /* * The cache pool sizes used by usb_alloc_coherent() (128, 512, 2048) are * quite bad when used with the packet sizes of this device (e.g. 280, * 520, 624). Therefore, we allocate and subdivide entire pages, using * a smaller buffer only for the last chunk. */ remaining_packets = stream->queue_length; packets_per_page = PAGE_SIZE / stream->max_packet_bytes; for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) { packets = min(remaining_packets, packets_per_page); size = packets * stream->max_packet_bytes; stream->buffers[i].addr = usb_alloc_coherent(ua->dev, size, GFP_KERNEL, &stream->buffers[i].dma); if (!stream->buffers[i].addr) return -ENOMEM; stream->buffers[i].size = size; remaining_packets -= packets; if (!remaining_packets) break; } if (remaining_packets) { dev_err(&ua->dev->dev, "too many packets\n"); return -ENXIO; } return 0; } static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) { unsigned int i; for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) usb_free_coherent(ua->dev, stream->buffers[i].size, stream->buffers[i].addr, stream->buffers[i].dma); } static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream, void (*urb_complete)(struct urb *)) { unsigned max_packet_size = stream->max_packet_bytes; struct ua101_urb *urb; unsigned int b, u = 0; for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) { unsigned int size = stream->buffers[b].size; u8 *addr = stream->buffers[b].addr; dma_addr_t dma = stream->buffers[b].dma; while (size >= max_packet_size) { if (u >= stream->queue_length) goto bufsize_error; urb = kmalloc(sizeof(*urb), GFP_KERNEL); if (!urb) return -ENOMEM; usb_init_urb(&urb->urb); urb->urb.dev = ua->dev; urb->urb.pipe = stream->usb_pipe; urb->urb.transfer_flags = URB_NO_TRANSFER_DMA_MAP; urb->urb.transfer_buffer = addr; urb->urb.transfer_dma = dma; urb->urb.transfer_buffer_length = max_packet_size; urb->urb.number_of_packets = 1; urb->urb.interval = 1; urb->urb.context = ua; urb->urb.complete = urb_complete; urb->urb.iso_frame_desc[0].offset = 0; urb->urb.iso_frame_desc[0].length = max_packet_size; stream->urbs[u++] = urb; size -= max_packet_size; addr += max_packet_size; dma += max_packet_size; } } if (u == stream->queue_length) return 0; bufsize_error: dev_err(&ua->dev->dev, "internal buffer size error\n"); return -ENXIO; } static void free_stream_urbs(struct ua101_stream *stream) { unsigned int i; for (i = 0; i < stream->queue_length; ++i) { kfree(stream->urbs[i]); stream->urbs[i] = NULL; } } static void free_usb_related_resources(struct ua101 *ua, struct usb_interface *interface) { unsigned int i; struct usb_interface *intf; mutex_lock(&ua->mutex); free_stream_urbs(&ua->capture); free_stream_urbs(&ua->playback); mutex_unlock(&ua->mutex); free_stream_buffers(ua, &ua->capture); free_stream_buffers(ua, &ua->playback); for (i = 0; i < ARRAY_SIZE(ua->intf); ++i) { mutex_lock(&ua->mutex); intf = ua->intf[i]; ua->intf[i] = NULL; mutex_unlock(&ua->mutex); if (intf) { usb_set_intfdata(intf, NULL); if (intf != interface) usb_driver_release_interface(&ua101_driver, intf); } } } static void ua101_card_free(struct snd_card *card) { struct ua101 *ua = card->private_data; mutex_destroy(&ua->mutex); } static int ua101_probe(struct usb_interface *interface, const struct usb_device_id *usb_id) { static const struct snd_usb_midi_endpoint_info midi_ep = { .out_cables = 0x0001, .in_cables = 0x0001 }; static const struct snd_usb_audio_quirk midi_quirk = { .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = &midi_ep }; static const int intf_numbers[2][3] = { { /* UA-101 */ [INTF_PLAYBACK] = 0, [INTF_CAPTURE] = 1, [INTF_MIDI] = 2, }, { /* UA-1000 */ [INTF_CAPTURE] = 1, [INTF_PLAYBACK] = 2, [INTF_MIDI] = 3, }, }; struct snd_card *card; struct ua101 *ua; unsigned int card_index, i; int is_ua1000; const char *name; char usb_path[32]; int err; is_ua1000 = usb_id->idProduct == 0x0044; if (interface->altsetting->desc.bInterfaceNumber != intf_numbers[is_ua1000][0]) return -ENODEV; mutex_lock(&devices_mutex); for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) if (enable[card_index] && !(devices_used & (1 << card_index))) break; if (card_index >= SNDRV_CARDS) { mutex_unlock(&devices_mutex); return -ENOENT; } err = snd_card_new(&interface->dev, index[card_index], id[card_index], THIS_MODULE, sizeof(*ua), &card); if (err < 0) { mutex_unlock(&devices_mutex); return err; } card->private_free = ua101_card_free; ua = card->private_data; ua->dev = interface_to_usbdev(interface); ua->card = card; ua->card_index = card_index; INIT_LIST_HEAD(&ua->midi_list); spin_lock_init(&ua->lock); mutex_init(&ua->mutex); INIT_LIST_HEAD(&ua->ready_playback_urbs); INIT_WORK(&ua->playback_work, playback_work); init_waitqueue_head(&ua->alsa_capture_wait); init_waitqueue_head(&ua->rate_feedback_wait); init_waitqueue_head(&ua->alsa_playback_wait); ua->intf[0] = interface; for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) { ua->intf[i] = usb_ifnum_to_if(ua->dev, intf_numbers[is_ua1000][i]); if (!ua->intf[i]) { dev_err(&ua->dev->dev, "interface %u not found\n", intf_numbers[is_ua1000][i]); err = -ENXIO; goto probe_error; } err = usb_driver_claim_interface(&ua101_driver, ua->intf[i], ua); if (err < 0) { ua->intf[i] = NULL; err = -EBUSY; goto probe_error; } } err = detect_usb_format(ua); if (err < 0) goto probe_error; name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101"; strcpy(card->driver, "UA-101"); strcpy(card->shortname, name); usb_make_path(ua->dev, usb_path, sizeof(usb_path)); snprintf(ua->card->longname, sizeof(ua->card->longname), "EDIROL %s (serial %s), %u Hz at %s, %s speed", name, ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path, ua->dev->speed == USB_SPEED_HIGH ? "high" : "full"); err = alloc_stream_buffers(ua, &ua->capture); if (err < 0) goto probe_error; err = alloc_stream_buffers(ua, &ua->playback); if (err < 0) goto probe_error; err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete); if (err < 0) goto probe_error; err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete); if (err < 0) goto probe_error; err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm); if (err < 0) goto probe_error; ua->pcm->private_data = ua; strcpy(ua->pcm->name, name); snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops); snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops); snd_pcm_set_managed_buffer_all(ua->pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0); err = snd_usbmidi_create(card, ua->intf[INTF_MIDI], &ua->midi_list, &midi_quirk); if (err < 0) goto probe_error; err = snd_card_register(card); if (err < 0) goto probe_error; usb_set_intfdata(interface, ua); devices_used |= 1 << card_index; mutex_unlock(&devices_mutex); return 0; probe_error: free_usb_related_resources(ua, interface); snd_card_free(card); mutex_unlock(&devices_mutex); return err; } static void ua101_disconnect(struct usb_interface *interface) { struct ua101 *ua = usb_get_intfdata(interface); struct list_head *midi; if (!ua) return; mutex_lock(&devices_mutex); set_bit(DISCONNECTED, &ua->states); wake_up(&ua->rate_feedback_wait); /* make sure that userspace cannot create new requests */ snd_card_disconnect(ua->card); /* make sure that there are no pending USB requests */ list_for_each(midi, &ua->midi_list) snd_usbmidi_disconnect(midi); abort_alsa_playback(ua); abort_alsa_capture(ua); mutex_lock(&ua->mutex); stop_usb_playback(ua); stop_usb_capture(ua); mutex_unlock(&ua->mutex); free_usb_related_resources(ua, interface); devices_used &= ~(1 << ua->card_index); snd_card_free_when_closed(ua->card); mutex_unlock(&devices_mutex); } static const struct usb_device_id ua101_ids[] = { { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */ { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */ { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */ { } }; MODULE_DEVICE_TABLE(usb, ua101_ids); static struct usb_driver ua101_driver = { .name = "snd-ua101", .id_table = ua101_ids, .probe = ua101_probe, .disconnect = ua101_disconnect, #if 0 .suspend = ua101_suspend, .resume = ua101_resume, #endif }; module_usb_driver(ua101_driver);
linux-master
sound/usb/misc/ua101.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Behringer BCD2000 driver * * Copyright (C) 2014 Mario Kicherer ([email protected]) */ #include <linux/kernel.h> #include <linux/errno.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/module.h> #include <linux/bitmap.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <sound/core.h> #include <sound/initval.h> #include <sound/rawmidi.h> #define PREFIX "snd-bcd2000: " #define BUFSIZE 64 static const struct usb_device_id id_table[] = { { USB_DEVICE(0x1397, 0x00bd) }, { }, }; static const unsigned char device_cmd_prefix[] = {0x03, 0x00}; static const unsigned char bcd2000_init_sequence[] = { 0x07, 0x00, 0x00, 0x00, 0x78, 0x48, 0x1c, 0x81, 0xc4, 0x00, 0x00, 0x00, 0x5e, 0x53, 0x4a, 0xf7, 0x18, 0xfa, 0x11, 0xff, 0x6c, 0xf3, 0x90, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0xfa, 0x11, 0xff, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf2, 0x34, 0x4a, 0xf7, 0x18, 0xfa, 0x11, 0xff }; struct bcd2000 { struct usb_device *dev; struct snd_card *card; struct usb_interface *intf; int card_index; int midi_out_active; struct snd_rawmidi *rmidi; struct snd_rawmidi_substream *midi_receive_substream; struct snd_rawmidi_substream *midi_out_substream; unsigned char midi_in_buf[BUFSIZE]; unsigned char midi_out_buf[BUFSIZE]; struct urb *midi_out_urb; struct urb *midi_in_urb; struct usb_anchor anchor; }; static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; static DEFINE_MUTEX(devices_mutex); static DECLARE_BITMAP(devices_used, SNDRV_CARDS); static struct usb_driver bcd2000_driver; #ifdef CONFIG_SND_DEBUG static void bcd2000_dump_buffer(const char *prefix, const char *buf, int len) { print_hex_dump(KERN_DEBUG, prefix, DUMP_PREFIX_NONE, 16, 1, buf, len, false); } #else static void bcd2000_dump_buffer(const char *prefix, const char *buf, int len) {} #endif static int bcd2000_midi_input_open(struct snd_rawmidi_substream *substream) { return 0; } static int bcd2000_midi_input_close(struct snd_rawmidi_substream *substream) { return 0; } /* (de)register midi substream from client */ static void bcd2000_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) { struct bcd2000 *bcd2k = substream->rmidi->private_data; bcd2k->midi_receive_substream = up ? substream : NULL; } static void bcd2000_midi_handle_input(struct bcd2000 *bcd2k, const unsigned char *buf, unsigned int buf_len) { unsigned int payload_length, tocopy; struct snd_rawmidi_substream *midi_receive_substream; midi_receive_substream = READ_ONCE(bcd2k->midi_receive_substream); if (!midi_receive_substream) return; bcd2000_dump_buffer(PREFIX "received from device: ", buf, buf_len); if (buf_len < 2) return; payload_length = buf[0]; /* ignore packets without payload */ if (payload_length == 0) return; tocopy = min(payload_length, buf_len-1); bcd2000_dump_buffer(PREFIX "sending to userspace: ", &buf[1], tocopy); snd_rawmidi_receive(midi_receive_substream, &buf[1], tocopy); } static void bcd2000_midi_send(struct bcd2000 *bcd2k) { int len, ret; struct snd_rawmidi_substream *midi_out_substream; BUILD_BUG_ON(sizeof(device_cmd_prefix) >= BUFSIZE); midi_out_substream = READ_ONCE(bcd2k->midi_out_substream); if (!midi_out_substream) return; /* copy command prefix bytes */ memcpy(bcd2k->midi_out_buf, device_cmd_prefix, sizeof(device_cmd_prefix)); /* * get MIDI packet and leave space for command prefix * and payload length */ len = snd_rawmidi_transmit(midi_out_substream, bcd2k->midi_out_buf + 3, BUFSIZE - 3); if (len < 0) dev_err(&bcd2k->dev->dev, "%s: snd_rawmidi_transmit error %d\n", __func__, len); if (len <= 0) return; /* set payload length */ bcd2k->midi_out_buf[2] = len; bcd2k->midi_out_urb->transfer_buffer_length = BUFSIZE; bcd2000_dump_buffer(PREFIX "sending to device: ", bcd2k->midi_out_buf, len+3); /* send packet to the BCD2000 */ ret = usb_submit_urb(bcd2k->midi_out_urb, GFP_ATOMIC); if (ret < 0) dev_err(&bcd2k->dev->dev, PREFIX "%s (%p): usb_submit_urb() failed, ret=%d, len=%d\n", __func__, midi_out_substream, ret, len); else bcd2k->midi_out_active = 1; } static int bcd2000_midi_output_open(struct snd_rawmidi_substream *substream) { return 0; } static int bcd2000_midi_output_close(struct snd_rawmidi_substream *substream) { struct bcd2000 *bcd2k = substream->rmidi->private_data; if (bcd2k->midi_out_active) { usb_kill_urb(bcd2k->midi_out_urb); bcd2k->midi_out_active = 0; } return 0; } /* (de)register midi substream from client */ static void bcd2000_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) { struct bcd2000 *bcd2k = substream->rmidi->private_data; if (up) { bcd2k->midi_out_substream = substream; /* check if there is data userspace wants to send */ if (!bcd2k->midi_out_active) bcd2000_midi_send(bcd2k); } else { bcd2k->midi_out_substream = NULL; } } static void bcd2000_output_complete(struct urb *urb) { struct bcd2000 *bcd2k = urb->context; bcd2k->midi_out_active = 0; if (urb->status) dev_warn(&urb->dev->dev, PREFIX "output urb->status: %d\n", urb->status); if (urb->status == -ESHUTDOWN) return; /* check if there is more data userspace wants to send */ bcd2000_midi_send(bcd2k); } static void bcd2000_input_complete(struct urb *urb) { int ret; struct bcd2000 *bcd2k = urb->context; if (urb->status) dev_warn(&urb->dev->dev, PREFIX "input urb->status: %i\n", urb->status); if (!bcd2k || urb->status == -ESHUTDOWN) return; if (urb->actual_length > 0) bcd2000_midi_handle_input(bcd2k, urb->transfer_buffer, urb->actual_length); /* return URB to device */ ret = usb_submit_urb(bcd2k->midi_in_urb, GFP_ATOMIC); if (ret < 0) dev_err(&bcd2k->dev->dev, PREFIX "%s: usb_submit_urb() failed, ret=%d\n", __func__, ret); } static const struct snd_rawmidi_ops bcd2000_midi_output = { .open = bcd2000_midi_output_open, .close = bcd2000_midi_output_close, .trigger = bcd2000_midi_output_trigger, }; static const struct snd_rawmidi_ops bcd2000_midi_input = { .open = bcd2000_midi_input_open, .close = bcd2000_midi_input_close, .trigger = bcd2000_midi_input_trigger, }; static void bcd2000_init_device(struct bcd2000 *bcd2k) { int ret; init_usb_anchor(&bcd2k->anchor); usb_anchor_urb(bcd2k->midi_out_urb, &bcd2k->anchor); usb_anchor_urb(bcd2k->midi_in_urb, &bcd2k->anchor); /* copy init sequence into buffer */ memcpy(bcd2k->midi_out_buf, bcd2000_init_sequence, 52); bcd2k->midi_out_urb->transfer_buffer_length = 52; /* submit sequence */ ret = usb_submit_urb(bcd2k->midi_out_urb, GFP_KERNEL); if (ret < 0) dev_err(&bcd2k->dev->dev, PREFIX "%s: usb_submit_urb() out failed, ret=%d: ", __func__, ret); else bcd2k->midi_out_active = 1; /* pass URB to device to enable button and controller events */ ret = usb_submit_urb(bcd2k->midi_in_urb, GFP_KERNEL); if (ret < 0) dev_err(&bcd2k->dev->dev, PREFIX "%s: usb_submit_urb() in failed, ret=%d: ", __func__, ret); /* ensure initialization is finished */ usb_wait_anchor_empty_timeout(&bcd2k->anchor, 1000); } static int bcd2000_init_midi(struct bcd2000 *bcd2k) { int ret; struct snd_rawmidi *rmidi; ret = snd_rawmidi_new(bcd2k->card, bcd2k->card->shortname, 0, 1, /* output */ 1, /* input */ &rmidi); if (ret < 0) return ret; strscpy(rmidi->name, bcd2k->card->shortname, sizeof(rmidi->name)); rmidi->info_flags = SNDRV_RAWMIDI_INFO_DUPLEX; rmidi->private_data = bcd2k; rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT; snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &bcd2000_midi_output); rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT; snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &bcd2000_midi_input); bcd2k->rmidi = rmidi; bcd2k->midi_in_urb = usb_alloc_urb(0, GFP_KERNEL); bcd2k->midi_out_urb = usb_alloc_urb(0, GFP_KERNEL); if (!bcd2k->midi_in_urb || !bcd2k->midi_out_urb) { dev_err(&bcd2k->dev->dev, PREFIX "usb_alloc_urb failed\n"); return -ENOMEM; } usb_fill_int_urb(bcd2k->midi_in_urb, bcd2k->dev, usb_rcvintpipe(bcd2k->dev, 0x81), bcd2k->midi_in_buf, BUFSIZE, bcd2000_input_complete, bcd2k, 1); usb_fill_int_urb(bcd2k->midi_out_urb, bcd2k->dev, usb_sndintpipe(bcd2k->dev, 0x1), bcd2k->midi_out_buf, BUFSIZE, bcd2000_output_complete, bcd2k, 1); /* sanity checks of EPs before actually submitting */ if (usb_urb_ep_type_check(bcd2k->midi_in_urb) || usb_urb_ep_type_check(bcd2k->midi_out_urb)) { dev_err(&bcd2k->dev->dev, "invalid MIDI EP\n"); return -EINVAL; } bcd2000_init_device(bcd2k); return 0; } static void bcd2000_free_usb_related_resources(struct bcd2000 *bcd2k, struct usb_interface *interface) { usb_kill_urb(bcd2k->midi_out_urb); usb_kill_urb(bcd2k->midi_in_urb); usb_free_urb(bcd2k->midi_out_urb); usb_free_urb(bcd2k->midi_in_urb); if (bcd2k->intf) { usb_set_intfdata(bcd2k->intf, NULL); bcd2k->intf = NULL; } } static int bcd2000_probe(struct usb_interface *interface, const struct usb_device_id *usb_id) { struct snd_card *card; struct bcd2000 *bcd2k; unsigned int card_index; char usb_path[32]; int err; mutex_lock(&devices_mutex); for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) if (!test_bit(card_index, devices_used)) break; if (card_index >= SNDRV_CARDS) { mutex_unlock(&devices_mutex); return -ENOENT; } err = snd_card_new(&interface->dev, index[card_index], id[card_index], THIS_MODULE, sizeof(*bcd2k), &card); if (err < 0) { mutex_unlock(&devices_mutex); return err; } bcd2k = card->private_data; bcd2k->dev = interface_to_usbdev(interface); bcd2k->card = card; bcd2k->card_index = card_index; bcd2k->intf = interface; snd_card_set_dev(card, &interface->dev); strscpy(card->driver, "snd-bcd2000", sizeof(card->driver)); strscpy(card->shortname, "BCD2000", sizeof(card->shortname)); usb_make_path(bcd2k->dev, usb_path, sizeof(usb_path)); snprintf(bcd2k->card->longname, sizeof(bcd2k->card->longname), "Behringer BCD2000 at %s", usb_path); err = bcd2000_init_midi(bcd2k); if (err < 0) goto probe_error; err = snd_card_register(card); if (err < 0) goto probe_error; usb_set_intfdata(interface, bcd2k); set_bit(card_index, devices_used); mutex_unlock(&devices_mutex); return 0; probe_error: dev_info(&bcd2k->dev->dev, PREFIX "error during probing"); bcd2000_free_usb_related_resources(bcd2k, interface); snd_card_free(card); mutex_unlock(&devices_mutex); return err; } static void bcd2000_disconnect(struct usb_interface *interface) { struct bcd2000 *bcd2k = usb_get_intfdata(interface); if (!bcd2k) return; mutex_lock(&devices_mutex); /* make sure that userspace cannot create new requests */ snd_card_disconnect(bcd2k->card); bcd2000_free_usb_related_resources(bcd2k, interface); clear_bit(bcd2k->card_index, devices_used); snd_card_free_when_closed(bcd2k->card); mutex_unlock(&devices_mutex); } static struct usb_driver bcd2000_driver = { .name = "snd-bcd2000", .probe = bcd2000_probe, .disconnect = bcd2000_disconnect, .id_table = id_table, }; module_usb_driver(bcd2000_driver); MODULE_DEVICE_TABLE(usb, id_table); MODULE_AUTHOR("Mario Kicherer, [email protected]"); MODULE_DESCRIPTION("Behringer BCD2000 driver"); MODULE_LICENSE("GPL");
linux-master
sound/usb/bcd2000/bcd2000.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux driver for TerraTec DMX 6Fire USB * * Firmware loader * * Author: Torsten Schenk <[email protected]> * Created: Jan 01, 2011 * Copyright: (C) Torsten Schenk */ #include <linux/firmware.h> #include <linux/module.h> #include <linux/bitrev.h> #include <linux/kernel.h> #include "firmware.h" #include "chip.h" MODULE_FIRMWARE("6fire/dmx6firel2.ihx"); MODULE_FIRMWARE("6fire/dmx6fireap.ihx"); MODULE_FIRMWARE("6fire/dmx6firecf.bin"); enum { FPGA_BUFSIZE = 512, FPGA_EP = 2 }; /* * wMaxPacketSize of pcm endpoints. * keep synced with rates_in_packet_size and rates_out_packet_size in pcm.c * fpp: frames per isopacket * * CAUTION: keep sizeof <= buffer[] in usb6fire_fw_init */ static const u8 ep_w_max_packet_size[] = { 0xe4, 0x00, 0xe4, 0x00, /* alt 1: 228 EP2 and EP6 (7 fpp) */ 0xa4, 0x01, 0xa4, 0x01, /* alt 2: 420 EP2 and EP6 (13 fpp)*/ 0x94, 0x01, 0x5c, 0x02 /* alt 3: 404 EP2 and 604 EP6 (25 fpp) */ }; static const u8 known_fw_versions[][2] = { { 0x03, 0x01 } }; struct ihex_record { u16 address; u8 len; u8 data[256]; char error; /* true if an error occurred parsing this record */ u8 max_len; /* maximum record length in whole ihex */ /* private */ const char *txt_data; unsigned int txt_length; unsigned int txt_offset; /* current position in txt_data */ }; static u8 usb6fire_fw_ihex_hex(const u8 *data, u8 *crc) { u8 val = 0; int hval; hval = hex_to_bin(data[0]); if (hval >= 0) val |= (hval << 4); hval = hex_to_bin(data[1]); if (hval >= 0) val |= hval; *crc += val; return val; } /* * returns true if record is available, false otherwise. * iff an error occurred, false will be returned and record->error will be true. */ static bool usb6fire_fw_ihex_next_record(struct ihex_record *record) { u8 crc = 0; u8 type; int i; record->error = false; /* find begin of record (marked by a colon) */ while (record->txt_offset < record->txt_length && record->txt_data[record->txt_offset] != ':') record->txt_offset++; if (record->txt_offset == record->txt_length) return false; /* number of characters needed for len, addr and type entries */ record->txt_offset++; if (record->txt_offset + 8 > record->txt_length) { record->error = true; return false; } record->len = usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc); record->txt_offset += 2; record->address = usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc) << 8; record->txt_offset += 2; record->address |= usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc); record->txt_offset += 2; type = usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc); record->txt_offset += 2; /* number of characters needed for data and crc entries */ if (record->txt_offset + 2 * (record->len + 1) > record->txt_length) { record->error = true; return false; } for (i = 0; i < record->len; i++) { record->data[i] = usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc); record->txt_offset += 2; } usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc); if (crc) { record->error = true; return false; } if (type == 1 || !record->len) /* eof */ return false; else if (type == 0) return true; else { record->error = true; return false; } } static int usb6fire_fw_ihex_init(const struct firmware *fw, struct ihex_record *record) { record->txt_data = fw->data; record->txt_length = fw->size; record->txt_offset = 0; record->max_len = 0; /* read all records, if loop ends, record->error indicates, * whether ihex is valid. */ while (usb6fire_fw_ihex_next_record(record)) record->max_len = max(record->len, record->max_len); if (record->error) return -EINVAL; record->txt_offset = 0; return 0; } static int usb6fire_fw_ezusb_write(struct usb_device *device, int type, int value, char *data, int len) { return usb_control_msg_send(device, 0, type, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, value, 0, data, len, 1000, GFP_KERNEL); } static int usb6fire_fw_ezusb_read(struct usb_device *device, int type, int value, char *data, int len) { return usb_control_msg_recv(device, 0, type, USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, value, 0, data, len, 1000, GFP_KERNEL); } static int usb6fire_fw_fpga_write(struct usb_device *device, char *data, int len) { int actual_len; int ret; ret = usb_bulk_msg(device, usb_sndbulkpipe(device, FPGA_EP), data, len, &actual_len, 1000); if (ret < 0) return ret; else if (actual_len != len) return -EIO; return 0; } static int usb6fire_fw_ezusb_upload( struct usb_interface *intf, const char *fwname, unsigned int postaddr, u8 *postdata, unsigned int postlen) { int ret; u8 data; struct usb_device *device = interface_to_usbdev(intf); const struct firmware *fw = NULL; struct ihex_record *rec = kmalloc(sizeof(struct ihex_record), GFP_KERNEL); if (!rec) return -ENOMEM; ret = request_firmware(&fw, fwname, &device->dev); if (ret < 0) { kfree(rec); dev_err(&intf->dev, "error requesting ezusb firmware %s.\n", fwname); return ret; } ret = usb6fire_fw_ihex_init(fw, rec); if (ret < 0) { kfree(rec); release_firmware(fw); dev_err(&intf->dev, "error validating ezusb firmware %s.\n", fwname); return ret; } /* upload firmware image */ data = 0x01; /* stop ezusb cpu */ ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1); if (ret) { kfree(rec); release_firmware(fw); dev_err(&intf->dev, "unable to upload ezusb firmware %s: begin message.\n", fwname); return ret; } while (usb6fire_fw_ihex_next_record(rec)) { /* write firmware */ ret = usb6fire_fw_ezusb_write(device, 0xa0, rec->address, rec->data, rec->len); if (ret) { kfree(rec); release_firmware(fw); dev_err(&intf->dev, "unable to upload ezusb firmware %s: data urb.\n", fwname); return ret; } } release_firmware(fw); kfree(rec); if (postdata) { /* write data after firmware has been uploaded */ ret = usb6fire_fw_ezusb_write(device, 0xa0, postaddr, postdata, postlen); if (ret) { dev_err(&intf->dev, "unable to upload ezusb firmware %s: post urb.\n", fwname); return ret; } } data = 0x00; /* resume ezusb cpu */ ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1); if (ret) { dev_err(&intf->dev, "unable to upload ezusb firmware %s: end message.\n", fwname); return ret; } return 0; } static int usb6fire_fw_fpga_upload( struct usb_interface *intf, const char *fwname) { int ret; int i; struct usb_device *device = interface_to_usbdev(intf); u8 *buffer = kmalloc(FPGA_BUFSIZE, GFP_KERNEL); const char *c; const char *end; const struct firmware *fw; if (!buffer) return -ENOMEM; ret = request_firmware(&fw, fwname, &device->dev); if (ret < 0) { dev_err(&intf->dev, "unable to get fpga firmware %s.\n", fwname); kfree(buffer); return -EIO; } c = fw->data; end = fw->data + fw->size; ret = usb6fire_fw_ezusb_write(device, 8, 0, NULL, 0); if (ret) { kfree(buffer); release_firmware(fw); dev_err(&intf->dev, "unable to upload fpga firmware: begin urb.\n"); return ret; } while (c != end) { for (i = 0; c != end && i < FPGA_BUFSIZE; i++, c++) buffer[i] = bitrev8((u8)*c); ret = usb6fire_fw_fpga_write(device, buffer, i); if (ret < 0) { release_firmware(fw); kfree(buffer); dev_err(&intf->dev, "unable to upload fpga firmware: fw urb.\n"); return ret; } } release_firmware(fw); kfree(buffer); ret = usb6fire_fw_ezusb_write(device, 9, 0, NULL, 0); if (ret) { dev_err(&intf->dev, "unable to upload fpga firmware: end urb.\n"); return ret; } return 0; } /* check, if the firmware version the devices has currently loaded * is known by this driver. 'version' needs to have 4 bytes version * info data. */ static int usb6fire_fw_check(struct usb_interface *intf, const u8 *version) { int i; for (i = 0; i < ARRAY_SIZE(known_fw_versions); i++) if (!memcmp(version, known_fw_versions + i, 2)) return 0; dev_err(&intf->dev, "invalid firmware version in device: %4ph. " "please reconnect to power. if this failure " "still happens, check your firmware installation.", version); return -EINVAL; } int usb6fire_fw_init(struct usb_interface *intf) { int i; int ret; struct usb_device *device = interface_to_usbdev(intf); /* buffer: 8 receiving bytes from device and * sizeof(EP_W_MAX_PACKET_SIZE) bytes for non-const copy */ u8 buffer[12]; ret = usb6fire_fw_ezusb_read(device, 1, 0, buffer, 8); if (ret) { dev_err(&intf->dev, "unable to receive device firmware state.\n"); return ret; } if (buffer[0] != 0xeb || buffer[1] != 0xaa || buffer[2] != 0x55) { dev_err(&intf->dev, "unknown device firmware state received from device:"); for (i = 0; i < 8; i++) printk(KERN_CONT "%02x ", buffer[i]); printk(KERN_CONT "\n"); return -EIO; } /* do we need fpga loader ezusb firmware? */ if (buffer[3] == 0x01) { ret = usb6fire_fw_ezusb_upload(intf, "6fire/dmx6firel2.ihx", 0, NULL, 0); if (ret < 0) return ret; return FW_NOT_READY; } /* do we need fpga firmware and application ezusb firmware? */ else if (buffer[3] == 0x02) { ret = usb6fire_fw_check(intf, buffer + 4); if (ret < 0) return ret; ret = usb6fire_fw_fpga_upload(intf, "6fire/dmx6firecf.bin"); if (ret < 0) return ret; memcpy(buffer, ep_w_max_packet_size, sizeof(ep_w_max_packet_size)); ret = usb6fire_fw_ezusb_upload(intf, "6fire/dmx6fireap.ihx", 0x0003, buffer, sizeof(ep_w_max_packet_size)); if (ret < 0) return ret; return FW_NOT_READY; } /* all fw loaded? */ else if (buffer[3] == 0x03) return usb6fire_fw_check(intf, buffer + 4); /* unknown data? */ else { dev_err(&intf->dev, "unknown device firmware state received from device: "); for (i = 0; i < 8; i++) printk(KERN_CONT "%02x ", buffer[i]); printk(KERN_CONT "\n"); return -EIO; } return 0; }
linux-master
sound/usb/6fire/firmware.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux driver for TerraTec DMX 6Fire USB * * Main routines and module definitions. * * Author: Torsten Schenk <[email protected]> * Created: Jan 01, 2011 * Copyright: (C) Torsten Schenk */ #include "chip.h" #include "firmware.h" #include "pcm.h" #include "control.h" #include "comm.h" #include "midi.h" #include <linux/moduleparam.h> #include <linux/interrupt.h> #include <linux/module.h> #include <linux/init.h> #include <linux/gfp.h> #include <sound/initval.h> MODULE_AUTHOR("Torsten Schenk <[email protected]>"); MODULE_DESCRIPTION("TerraTec DMX 6Fire USB audio driver"); MODULE_LICENSE("GPL v2"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable card */ static struct sfire_chip *chips[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; static struct usb_device *devices[SNDRV_CARDS] = SNDRV_DEFAULT_PTR; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for the 6fire sound device"); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for the 6fire sound device."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable the 6fire sound device."); static DEFINE_MUTEX(register_mutex); static void usb6fire_chip_abort(struct sfire_chip *chip) { if (chip) { if (chip->pcm) usb6fire_pcm_abort(chip); if (chip->midi) usb6fire_midi_abort(chip); if (chip->comm) usb6fire_comm_abort(chip); if (chip->control) usb6fire_control_abort(chip); if (chip->card) { snd_card_disconnect(chip->card); snd_card_free_when_closed(chip->card); chip->card = NULL; } } } static void usb6fire_chip_destroy(struct sfire_chip *chip) { if (chip) { if (chip->pcm) usb6fire_pcm_destroy(chip); if (chip->midi) usb6fire_midi_destroy(chip); if (chip->comm) usb6fire_comm_destroy(chip); if (chip->control) usb6fire_control_destroy(chip); if (chip->card) snd_card_free(chip->card); } } static int usb6fire_chip_probe(struct usb_interface *intf, const struct usb_device_id *usb_id) { int ret; int i; struct sfire_chip *chip = NULL; struct usb_device *device = interface_to_usbdev(intf); int regidx = -1; /* index in module parameter array */ struct snd_card *card = NULL; /* look if we already serve this card and return if so */ mutex_lock(&register_mutex); for (i = 0; i < SNDRV_CARDS; i++) { if (devices[i] == device) { if (chips[i]) chips[i]->intf_count++; usb_set_intfdata(intf, chips[i]); mutex_unlock(&register_mutex); return 0; } else if (!devices[i] && regidx < 0) regidx = i; } if (regidx < 0) { mutex_unlock(&register_mutex); dev_err(&intf->dev, "too many cards registered.\n"); return -ENODEV; } devices[regidx] = device; mutex_unlock(&register_mutex); /* check, if firmware is present on device, upload it if not */ ret = usb6fire_fw_init(intf); if (ret < 0) return ret; else if (ret == FW_NOT_READY) /* firmware update performed */ return 0; /* if we are here, card can be registered in alsa. */ if (usb_set_interface(device, 0, 0) != 0) { dev_err(&intf->dev, "can't set first interface.\n"); return -EIO; } ret = snd_card_new(&intf->dev, index[regidx], id[regidx], THIS_MODULE, sizeof(struct sfire_chip), &card); if (ret < 0) { dev_err(&intf->dev, "cannot create alsa card.\n"); return ret; } strcpy(card->driver, "6FireUSB"); strcpy(card->shortname, "TerraTec DMX6FireUSB"); sprintf(card->longname, "%s at %d:%d", card->shortname, device->bus->busnum, device->devnum); chip = card->private_data; chips[regidx] = chip; chip->dev = device; chip->regidx = regidx; chip->intf_count = 1; chip->card = card; ret = usb6fire_comm_init(chip); if (ret < 0) goto destroy_chip; ret = usb6fire_midi_init(chip); if (ret < 0) goto destroy_chip; ret = usb6fire_pcm_init(chip); if (ret < 0) goto destroy_chip; ret = usb6fire_control_init(chip); if (ret < 0) goto destroy_chip; ret = snd_card_register(card); if (ret < 0) { dev_err(&intf->dev, "cannot register card."); goto destroy_chip; } usb_set_intfdata(intf, chip); return 0; destroy_chip: usb6fire_chip_destroy(chip); return ret; } static void usb6fire_chip_disconnect(struct usb_interface *intf) { struct sfire_chip *chip; chip = usb_get_intfdata(intf); if (chip) { /* if !chip, fw upload has been performed */ chip->intf_count--; if (!chip->intf_count) { mutex_lock(&register_mutex); devices[chip->regidx] = NULL; chips[chip->regidx] = NULL; mutex_unlock(&register_mutex); chip->shutdown = true; usb6fire_chip_abort(chip); usb6fire_chip_destroy(chip); } } } static const struct usb_device_id device_table[] = { { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = 0x0ccd, .idProduct = 0x0080 }, {} }; MODULE_DEVICE_TABLE(usb, device_table); static struct usb_driver usb_driver = { .name = "snd-usb-6fire", .probe = usb6fire_chip_probe, .disconnect = usb6fire_chip_disconnect, .id_table = device_table, }; module_usb_driver(usb_driver);
linux-master
sound/usb/6fire/chip.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux driver for TerraTec DMX 6Fire USB * * PCM driver * * Author: Torsten Schenk <[email protected]> * 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 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; }
linux-master
sound/usb/6fire/pcm.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux driver for TerraTec DMX 6Fire USB * * Mixer control * * Author: Torsten Schenk <[email protected]> * Created: Jan 01, 2011 * Copyright: (C) Torsten Schenk * * Thanks to: * - Holger Ruckdeschel: he found out how to control individual channel * volumes and introduced mute switch */ #include <linux/interrupt.h> #include <sound/control.h> #include <sound/tlv.h> #include "control.h" #include "comm.h" #include "chip.h" static const char * const opt_coax_texts[2] = { "Optical", "Coax" }; static const char * const line_phono_texts[2] = { "Line", "Phono" }; /* * data that needs to be sent to device. sets up card internal stuff. * values dumped from windows driver and filtered by trial'n'error. */ static const struct { u8 type; u8 reg; u8 value; } init_data[] = { { 0x22, 0x00, 0x00 }, { 0x20, 0x00, 0x08 }, { 0x22, 0x01, 0x01 }, { 0x20, 0x01, 0x08 }, { 0x22, 0x02, 0x00 }, { 0x20, 0x02, 0x08 }, { 0x22, 0x03, 0x00 }, { 0x20, 0x03, 0x08 }, { 0x22, 0x04, 0x00 }, { 0x20, 0x04, 0x08 }, { 0x22, 0x05, 0x01 }, { 0x20, 0x05, 0x08 }, { 0x22, 0x04, 0x01 }, { 0x12, 0x04, 0x00 }, { 0x12, 0x05, 0x00 }, { 0x12, 0x0d, 0x38 }, { 0x12, 0x21, 0x82 }, { 0x12, 0x22, 0x80 }, { 0x12, 0x23, 0x00 }, { 0x12, 0x06, 0x02 }, { 0x12, 0x03, 0x00 }, { 0x12, 0x02, 0x00 }, { 0x22, 0x03, 0x01 }, { 0 } /* TERMINATING ENTRY */ }; static const int rates_altsetting[] = { 1, 1, 2, 2, 3, 3 }; /* values to write to soundcard register for all samplerates */ static const u16 rates_6fire_vl[] = {0x00, 0x01, 0x00, 0x01, 0x00, 0x01}; static const u16 rates_6fire_vh[] = {0x11, 0x11, 0x10, 0x10, 0x00, 0x00}; static DECLARE_TLV_DB_MINMAX(tlv_output, -9000, 0); static DECLARE_TLV_DB_MINMAX(tlv_input, -1500, 1500); enum { DIGITAL_THRU_ONLY_SAMPLERATE = 3 }; static void usb6fire_control_output_vol_update(struct control_runtime *rt) { struct comm_runtime *comm_rt = rt->chip->comm; int i; if (comm_rt) for (i = 0; i < 6; i++) if (!(rt->ovol_updated & (1 << i))) { comm_rt->write8(comm_rt, 0x12, 0x0f + i, 180 - rt->output_vol[i]); rt->ovol_updated |= 1 << i; } } static void usb6fire_control_output_mute_update(struct control_runtime *rt) { struct comm_runtime *comm_rt = rt->chip->comm; if (comm_rt) comm_rt->write8(comm_rt, 0x12, 0x0e, ~rt->output_mute); } static void usb6fire_control_input_vol_update(struct control_runtime *rt) { struct comm_runtime *comm_rt = rt->chip->comm; int i; if (comm_rt) for (i = 0; i < 2; i++) if (!(rt->ivol_updated & (1 << i))) { comm_rt->write8(comm_rt, 0x12, 0x1c + i, rt->input_vol[i] & 0x3f); rt->ivol_updated |= 1 << i; } } static void usb6fire_control_line_phono_update(struct control_runtime *rt) { struct comm_runtime *comm_rt = rt->chip->comm; if (comm_rt) { comm_rt->write8(comm_rt, 0x22, 0x02, rt->line_phono_switch); comm_rt->write8(comm_rt, 0x21, 0x02, rt->line_phono_switch); } } static void usb6fire_control_opt_coax_update(struct control_runtime *rt) { struct comm_runtime *comm_rt = rt->chip->comm; if (comm_rt) { comm_rt->write8(comm_rt, 0x22, 0x00, rt->opt_coax_switch); comm_rt->write8(comm_rt, 0x21, 0x00, rt->opt_coax_switch); } } static int usb6fire_control_set_rate(struct control_runtime *rt, int rate) { int ret; struct usb_device *device = rt->chip->dev; struct comm_runtime *comm_rt = rt->chip->comm; if (rate < 0 || rate >= CONTROL_N_RATES) return -EINVAL; ret = usb_set_interface(device, 1, rates_altsetting[rate]); if (ret < 0) return ret; /* set soundcard clock */ ret = comm_rt->write16(comm_rt, 0x02, 0x01, rates_6fire_vl[rate], rates_6fire_vh[rate]); if (ret < 0) return ret; return 0; } static int usb6fire_control_set_channels( struct control_runtime *rt, int n_analog_out, int n_analog_in, bool spdif_out, bool spdif_in) { int ret; struct comm_runtime *comm_rt = rt->chip->comm; /* enable analog inputs and outputs * (one bit per stereo-channel) */ ret = comm_rt->write16(comm_rt, 0x02, 0x02, (1 << (n_analog_out / 2)) - 1, (1 << (n_analog_in / 2)) - 1); if (ret < 0) return ret; /* disable digital inputs and outputs */ /* TODO: use spdif_x to enable/disable digital channels */ ret = comm_rt->write16(comm_rt, 0x02, 0x03, 0x00, 0x00); if (ret < 0) return ret; return 0; } static int usb6fire_control_streaming_update(struct control_runtime *rt) { struct comm_runtime *comm_rt = rt->chip->comm; if (comm_rt) { if (!rt->usb_streaming && rt->digital_thru_switch) usb6fire_control_set_rate(rt, DIGITAL_THRU_ONLY_SAMPLERATE); return comm_rt->write16(comm_rt, 0x02, 0x00, 0x00, (rt->usb_streaming ? 0x01 : 0x00) | (rt->digital_thru_switch ? 0x08 : 0x00)); } return -EINVAL; } static int usb6fire_control_output_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; uinfo->value.integer.max = 180; return 0; } static int usb6fire_control_output_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); unsigned int ch = kcontrol->private_value; int changed = 0; if (ch > 4) { dev_err(&rt->chip->dev->dev, "Invalid channel in volume control."); return -EINVAL; } if (rt->output_vol[ch] != ucontrol->value.integer.value[0]) { rt->output_vol[ch] = ucontrol->value.integer.value[0]; rt->ovol_updated &= ~(1 << ch); changed = 1; } if (rt->output_vol[ch + 1] != ucontrol->value.integer.value[1]) { rt->output_vol[ch + 1] = ucontrol->value.integer.value[1]; rt->ovol_updated &= ~(2 << ch); changed = 1; } if (changed) usb6fire_control_output_vol_update(rt); return changed; } static int usb6fire_control_output_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); unsigned int ch = kcontrol->private_value; if (ch > 4) { dev_err(&rt->chip->dev->dev, "Invalid channel in volume control."); return -EINVAL; } ucontrol->value.integer.value[0] = rt->output_vol[ch]; ucontrol->value.integer.value[1] = rt->output_vol[ch + 1]; return 0; } static int usb6fire_control_output_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); unsigned int ch = kcontrol->private_value; u8 old = rt->output_mute; u8 value = 0; if (ch > 4) { dev_err(&rt->chip->dev->dev, "Invalid channel in volume control."); return -EINVAL; } rt->output_mute &= ~(3 << ch); if (ucontrol->value.integer.value[0]) value |= 1; if (ucontrol->value.integer.value[1]) value |= 2; rt->output_mute |= value << ch; if (rt->output_mute != old) usb6fire_control_output_mute_update(rt); return rt->output_mute != old; } static int usb6fire_control_output_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); unsigned int ch = kcontrol->private_value; u8 value = rt->output_mute >> ch; if (ch > 4) { dev_err(&rt->chip->dev->dev, "Invalid channel in volume control."); return -EINVAL; } ucontrol->value.integer.value[0] = 1 & value; value >>= 1; ucontrol->value.integer.value[1] = 1 & value; return 0; } static int usb6fire_control_input_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; uinfo->value.integer.max = 30; return 0; } static int usb6fire_control_input_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); int changed = 0; if (rt->input_vol[0] != ucontrol->value.integer.value[0]) { rt->input_vol[0] = ucontrol->value.integer.value[0] - 15; rt->ivol_updated &= ~(1 << 0); changed = 1; } if (rt->input_vol[1] != ucontrol->value.integer.value[1]) { rt->input_vol[1] = ucontrol->value.integer.value[1] - 15; rt->ivol_updated &= ~(1 << 1); changed = 1; } if (changed) usb6fire_control_input_vol_update(rt); return changed; } static int usb6fire_control_input_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = rt->input_vol[0] + 15; ucontrol->value.integer.value[1] = rt->input_vol[1] + 15; return 0; } static int usb6fire_control_line_phono_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { return snd_ctl_enum_info(uinfo, 1, 2, line_phono_texts); } static int usb6fire_control_line_phono_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); int changed = 0; if (rt->line_phono_switch != ucontrol->value.integer.value[0]) { rt->line_phono_switch = ucontrol->value.integer.value[0]; usb6fire_control_line_phono_update(rt); changed = 1; } return changed; } static int usb6fire_control_line_phono_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = rt->line_phono_switch; return 0; } static int usb6fire_control_opt_coax_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { return snd_ctl_enum_info(uinfo, 1, 2, opt_coax_texts); } static int usb6fire_control_opt_coax_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); int changed = 0; if (rt->opt_coax_switch != ucontrol->value.enumerated.item[0]) { rt->opt_coax_switch = ucontrol->value.enumerated.item[0]; usb6fire_control_opt_coax_update(rt); changed = 1; } return changed; } static int usb6fire_control_opt_coax_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); ucontrol->value.enumerated.item[0] = rt->opt_coax_switch; return 0; } static int usb6fire_control_digital_thru_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); int changed = 0; if (rt->digital_thru_switch != ucontrol->value.integer.value[0]) { rt->digital_thru_switch = ucontrol->value.integer.value[0]; usb6fire_control_streaming_update(rt); changed = 1; } return changed; } static int usb6fire_control_digital_thru_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct control_runtime *rt = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = rt->digital_thru_switch; return 0; } static const struct snd_kcontrol_new vol_elements[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog Playback Volume", .index = 0, .private_value = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .info = usb6fire_control_output_vol_info, .get = usb6fire_control_output_vol_get, .put = usb6fire_control_output_vol_put, .tlv = { .p = tlv_output } }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog Playback Volume", .index = 1, .private_value = 2, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .info = usb6fire_control_output_vol_info, .get = usb6fire_control_output_vol_get, .put = usb6fire_control_output_vol_put, .tlv = { .p = tlv_output } }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog Playback Volume", .index = 2, .private_value = 4, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .info = usb6fire_control_output_vol_info, .get = usb6fire_control_output_vol_get, .put = usb6fire_control_output_vol_put, .tlv = { .p = tlv_output } }, {} }; static const struct snd_kcontrol_new mute_elements[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog Playback Switch", .index = 0, .private_value = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_ctl_boolean_stereo_info, .get = usb6fire_control_output_mute_get, .put = usb6fire_control_output_mute_put, }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog Playback Switch", .index = 1, .private_value = 2, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_ctl_boolean_stereo_info, .get = usb6fire_control_output_mute_get, .put = usb6fire_control_output_mute_put, }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog Playback Switch", .index = 2, .private_value = 4, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_ctl_boolean_stereo_info, .get = usb6fire_control_output_mute_get, .put = usb6fire_control_output_mute_put, }, {} }; static const struct snd_kcontrol_new elements[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line/Phono Capture Route", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = usb6fire_control_line_phono_info, .get = usb6fire_control_line_phono_get, .put = usb6fire_control_line_phono_put }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Opt/Coax Capture Route", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = usb6fire_control_opt_coax_info, .get = usb6fire_control_opt_coax_get, .put = usb6fire_control_opt_coax_put }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Digital Thru Playback Route", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_ctl_boolean_mono_info, .get = usb6fire_control_digital_thru_get, .put = usb6fire_control_digital_thru_put }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Analog Capture Volume", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, .info = usb6fire_control_input_vol_info, .get = usb6fire_control_input_vol_get, .put = usb6fire_control_input_vol_put, .tlv = { .p = tlv_input } }, {} }; static int usb6fire_control_add_virtual( struct control_runtime *rt, struct snd_card *card, char *name, const struct snd_kcontrol_new *elems) { int ret; int i; struct snd_kcontrol *vmaster = snd_ctl_make_virtual_master(name, tlv_output); struct snd_kcontrol *control; if (!vmaster) return -ENOMEM; ret = snd_ctl_add(card, vmaster); if (ret < 0) return ret; i = 0; while (elems[i].name) { control = snd_ctl_new1(&elems[i], rt); if (!control) return -ENOMEM; ret = snd_ctl_add(card, control); if (ret < 0) return ret; ret = snd_ctl_add_follower(vmaster, control); if (ret < 0) return ret; i++; } return 0; } int usb6fire_control_init(struct sfire_chip *chip) { int i; int ret; struct control_runtime *rt = kzalloc(sizeof(struct control_runtime), GFP_KERNEL); struct comm_runtime *comm_rt = chip->comm; if (!rt) return -ENOMEM; rt->chip = chip; rt->update_streaming = usb6fire_control_streaming_update; rt->set_rate = usb6fire_control_set_rate; rt->set_channels = usb6fire_control_set_channels; i = 0; while (init_data[i].type) { comm_rt->write8(comm_rt, init_data[i].type, init_data[i].reg, init_data[i].value); i++; } usb6fire_control_opt_coax_update(rt); usb6fire_control_line_phono_update(rt); usb6fire_control_output_vol_update(rt); usb6fire_control_output_mute_update(rt); usb6fire_control_input_vol_update(rt); usb6fire_control_streaming_update(rt); ret = usb6fire_control_add_virtual(rt, chip->card, "Master Playback Volume", vol_elements); if (ret) { dev_err(&chip->dev->dev, "cannot add control.\n"); kfree(rt); return ret; } ret = usb6fire_control_add_virtual(rt, chip->card, "Master Playback Switch", mute_elements); if (ret) { dev_err(&chip->dev->dev, "cannot add control.\n"); kfree(rt); return ret; } i = 0; while (elements[i].name) { ret = snd_ctl_add(chip->card, snd_ctl_new1(&elements[i], rt)); if (ret < 0) { kfree(rt); dev_err(&chip->dev->dev, "cannot add control.\n"); return ret; } i++; } chip->control = rt; return 0; } void usb6fire_control_abort(struct sfire_chip *chip) {} void usb6fire_control_destroy(struct sfire_chip *chip) { kfree(chip->control); chip->control = NULL; }
linux-master
sound/usb/6fire/control.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux driver for TerraTec DMX 6Fire USB * * Rawmidi driver * * Author: Torsten Schenk <[email protected]> * Created: Jan 01, 2011 * Copyright: (C) Torsten Schenk */ #include <sound/rawmidi.h> #include "midi.h" #include "chip.h" #include "comm.h" enum { MIDI_BUFSIZE = 64 }; static void usb6fire_midi_out_handler(struct urb *urb) { struct midi_runtime *rt = urb->context; int ret; unsigned long flags; spin_lock_irqsave(&rt->out_lock, flags); if (rt->out) { ret = snd_rawmidi_transmit(rt->out, rt->out_buffer + 4, MIDI_BUFSIZE - 4); if (ret > 0) { /* more data available, send next packet */ rt->out_buffer[1] = ret + 2; rt->out_buffer[3] = rt->out_serial++; urb->transfer_buffer_length = ret + 4; ret = usb_submit_urb(urb, GFP_ATOMIC); if (ret < 0) dev_err(&urb->dev->dev, "midi out urb submit failed: %d\n", ret); } else /* no more data to transmit */ rt->out = NULL; } spin_unlock_irqrestore(&rt->out_lock, flags); } static void usb6fire_midi_in_received( struct midi_runtime *rt, u8 *data, int length) { unsigned long flags; spin_lock_irqsave(&rt->in_lock, flags); if (rt->in) snd_rawmidi_receive(rt->in, data, length); spin_unlock_irqrestore(&rt->in_lock, flags); } static int usb6fire_midi_out_open(struct snd_rawmidi_substream *alsa_sub) { return 0; } static int usb6fire_midi_out_close(struct snd_rawmidi_substream *alsa_sub) { return 0; } static void usb6fire_midi_out_trigger( struct snd_rawmidi_substream *alsa_sub, int up) { struct midi_runtime *rt = alsa_sub->rmidi->private_data; struct urb *urb = &rt->out_urb; __s8 ret; unsigned long flags; spin_lock_irqsave(&rt->out_lock, flags); if (up) { /* start transfer */ if (rt->out) { /* we are already transmitting so just return */ spin_unlock_irqrestore(&rt->out_lock, flags); return; } ret = snd_rawmidi_transmit(alsa_sub, rt->out_buffer + 4, MIDI_BUFSIZE - 4); if (ret > 0) { rt->out_buffer[1] = ret + 2; rt->out_buffer[3] = rt->out_serial++; urb->transfer_buffer_length = ret + 4; ret = usb_submit_urb(urb, GFP_ATOMIC); if (ret < 0) dev_err(&urb->dev->dev, "midi out urb submit failed: %d\n", ret); else rt->out = alsa_sub; } } else if (rt->out == alsa_sub) rt->out = NULL; spin_unlock_irqrestore(&rt->out_lock, flags); } static void usb6fire_midi_out_drain(struct snd_rawmidi_substream *alsa_sub) { struct midi_runtime *rt = alsa_sub->rmidi->private_data; int retry = 0; while (rt->out && retry++ < 100) msleep(10); } static int usb6fire_midi_in_open(struct snd_rawmidi_substream *alsa_sub) { return 0; } static int usb6fire_midi_in_close(struct snd_rawmidi_substream *alsa_sub) { return 0; } static void usb6fire_midi_in_trigger( struct snd_rawmidi_substream *alsa_sub, int up) { struct midi_runtime *rt = alsa_sub->rmidi->private_data; unsigned long flags; spin_lock_irqsave(&rt->in_lock, flags); if (up) rt->in = alsa_sub; else rt->in = NULL; spin_unlock_irqrestore(&rt->in_lock, flags); } static const struct snd_rawmidi_ops out_ops = { .open = usb6fire_midi_out_open, .close = usb6fire_midi_out_close, .trigger = usb6fire_midi_out_trigger, .drain = usb6fire_midi_out_drain }; static const struct snd_rawmidi_ops in_ops = { .open = usb6fire_midi_in_open, .close = usb6fire_midi_in_close, .trigger = usb6fire_midi_in_trigger }; int usb6fire_midi_init(struct sfire_chip *chip) { int ret; struct midi_runtime *rt = kzalloc(sizeof(struct midi_runtime), GFP_KERNEL); struct comm_runtime *comm_rt = chip->comm; if (!rt) return -ENOMEM; rt->out_buffer = kzalloc(MIDI_BUFSIZE, GFP_KERNEL); if (!rt->out_buffer) { kfree(rt); return -ENOMEM; } rt->chip = chip; rt->in_received = usb6fire_midi_in_received; rt->out_buffer[0] = 0x80; /* 'send midi' command */ rt->out_buffer[1] = 0x00; /* size of data */ rt->out_buffer[2] = 0x00; /* always 0 */ spin_lock_init(&rt->in_lock); spin_lock_init(&rt->out_lock); comm_rt->init_urb(comm_rt, &rt->out_urb, rt->out_buffer, rt, usb6fire_midi_out_handler); ret = snd_rawmidi_new(chip->card, "6FireUSB", 0, 1, 1, &rt->instance); if (ret < 0) { kfree(rt->out_buffer); kfree(rt); dev_err(&chip->dev->dev, "unable to create midi.\n"); return ret; } rt->instance->private_data = rt; strcpy(rt->instance->name, "DMX6FireUSB MIDI"); rt->instance->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; snd_rawmidi_set_ops(rt->instance, SNDRV_RAWMIDI_STREAM_OUTPUT, &out_ops); snd_rawmidi_set_ops(rt->instance, SNDRV_RAWMIDI_STREAM_INPUT, &in_ops); chip->midi = rt; return 0; } void usb6fire_midi_abort(struct sfire_chip *chip) { struct midi_runtime *rt = chip->midi; if (rt) usb_poison_urb(&rt->out_urb); } void usb6fire_midi_destroy(struct sfire_chip *chip) { struct midi_runtime *rt = chip->midi; kfree(rt->out_buffer); kfree(rt); chip->midi = NULL; }
linux-master
sound/usb/6fire/midi.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux driver for TerraTec DMX 6Fire USB * * Device communications * * Author: Torsten Schenk <[email protected]> * Created: Jan 01, 2011 * Copyright: (C) Torsten Schenk */ #include "comm.h" #include "chip.h" #include "midi.h" enum { COMM_EP = 1, COMM_FPGA_EP = 2 }; static void usb6fire_comm_init_urb(struct comm_runtime *rt, struct urb *urb, u8 *buffer, void *context, void(*handler)(struct urb *urb)) { usb_init_urb(urb); urb->transfer_buffer = buffer; urb->pipe = usb_sndintpipe(rt->chip->dev, COMM_EP); urb->complete = handler; urb->context = context; urb->interval = 1; urb->dev = rt->chip->dev; } static void usb6fire_comm_receiver_handler(struct urb *urb) { struct comm_runtime *rt = urb->context; struct midi_runtime *midi_rt = rt->chip->midi; if (!urb->status) { if (rt->receiver_buffer[0] == 0x10) /* midi in event */ if (midi_rt) midi_rt->in_received(midi_rt, rt->receiver_buffer + 2, rt->receiver_buffer[1]); } if (!rt->chip->shutdown) { urb->status = 0; urb->actual_length = 0; if (usb_submit_urb(urb, GFP_ATOMIC) < 0) dev_warn(&urb->dev->dev, "comm data receiver aborted.\n"); } } static void usb6fire_comm_init_buffer(u8 *buffer, u8 id, u8 request, u8 reg, u8 vl, u8 vh) { buffer[0] = 0x01; buffer[2] = request; buffer[3] = id; switch (request) { case 0x02: buffer[1] = 0x05; /* length (starting at buffer[2]) */ buffer[4] = reg; buffer[5] = vl; buffer[6] = vh; break; case 0x12: buffer[1] = 0x0b; /* length (starting at buffer[2]) */ buffer[4] = 0x00; buffer[5] = 0x18; buffer[6] = 0x05; buffer[7] = 0x00; buffer[8] = 0x01; buffer[9] = 0x00; buffer[10] = 0x9e; buffer[11] = reg; buffer[12] = vl; break; case 0x20: case 0x21: case 0x22: buffer[1] = 0x04; buffer[4] = reg; buffer[5] = vl; break; } } static int usb6fire_comm_send_buffer(u8 *buffer, struct usb_device *dev) { int ret; int actual_len; ret = usb_interrupt_msg(dev, usb_sndintpipe(dev, COMM_EP), buffer, buffer[1] + 2, &actual_len, 1000); if (ret < 0) return ret; else if (actual_len != buffer[1] + 2) return -EIO; return 0; } static int usb6fire_comm_write8(struct comm_runtime *rt, u8 request, u8 reg, u8 value) { u8 *buffer; int ret; /* 13: maximum length of message */ buffer = kmalloc(13, GFP_KERNEL); if (!buffer) return -ENOMEM; usb6fire_comm_init_buffer(buffer, 0x00, request, reg, value, 0x00); ret = usb6fire_comm_send_buffer(buffer, rt->chip->dev); kfree(buffer); return ret; } static int usb6fire_comm_write16(struct comm_runtime *rt, u8 request, u8 reg, u8 vl, u8 vh) { u8 *buffer; int ret; /* 13: maximum length of message */ buffer = kmalloc(13, GFP_KERNEL); if (!buffer) return -ENOMEM; usb6fire_comm_init_buffer(buffer, 0x00, request, reg, vl, vh); ret = usb6fire_comm_send_buffer(buffer, rt->chip->dev); kfree(buffer); return ret; } int usb6fire_comm_init(struct sfire_chip *chip) { struct comm_runtime *rt = kzalloc(sizeof(struct comm_runtime), GFP_KERNEL); struct urb *urb; int ret; if (!rt) return -ENOMEM; rt->receiver_buffer = kzalloc(COMM_RECEIVER_BUFSIZE, GFP_KERNEL); if (!rt->receiver_buffer) { kfree(rt); return -ENOMEM; } urb = &rt->receiver; rt->serial = 1; rt->chip = chip; usb_init_urb(urb); rt->init_urb = usb6fire_comm_init_urb; rt->write8 = usb6fire_comm_write8; rt->write16 = usb6fire_comm_write16; /* submit an urb that receives communication data from device */ urb->transfer_buffer = rt->receiver_buffer; urb->transfer_buffer_length = COMM_RECEIVER_BUFSIZE; urb->pipe = usb_rcvintpipe(chip->dev, COMM_EP); urb->dev = chip->dev; urb->complete = usb6fire_comm_receiver_handler; urb->context = rt; urb->interval = 1; ret = usb_submit_urb(urb, GFP_KERNEL); if (ret < 0) { kfree(rt->receiver_buffer); kfree(rt); dev_err(&chip->dev->dev, "cannot create comm data receiver."); return ret; } chip->comm = rt; return 0; } void usb6fire_comm_abort(struct sfire_chip *chip) { struct comm_runtime *rt = chip->comm; if (rt) usb_poison_urb(&rt->receiver); } void usb6fire_comm_destroy(struct sfire_chip *chip) { struct comm_runtime *rt = chip->comm; kfree(rt->receiver_buffer); kfree(rt); chip->comm = NULL; }
linux-master
sound/usb/6fire/comm.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (c) 2007 Daniel Mack * friendly supported by NI. */ #include <linux/device.h> #include <linux/init.h> #include <linux/usb.h> #include <sound/control.h> #include <sound/core.h> #include <sound/pcm.h> #include "device.h" #include "control.h" #define CNT_INTVAL 0x10000 #define MASCHINE_BANK_SIZE 32 static int control_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol); struct snd_usb_caiaqdev *cdev = caiaqdev(chip->card); int pos = kcontrol->private_value; int is_intval = pos & CNT_INTVAL; int maxval = 63; uinfo->count = 1; pos &= ~CNT_INTVAL; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ): if (pos == 0) { /* current input mode of A8DJ and A4DJ */ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->value.integer.min = 0; uinfo->value.integer.max = 2; return 0; } break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): maxval = 127; break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): maxval = 31; break; } if (is_intval) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->value.integer.min = 0; uinfo->value.integer.max = maxval; } else { uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; uinfo->value.integer.min = 0; uinfo->value.integer.max = 1; } return 0; } static int control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol); struct snd_usb_caiaqdev *cdev = caiaqdev(chip->card); int pos = kcontrol->private_value; if (pos & CNT_INTVAL) ucontrol->value.integer.value[0] = cdev->control_state[pos & ~CNT_INTVAL]; else ucontrol->value.integer.value[0] = !!(cdev->control_state[pos / 8] & (1 << pos % 8)); return 0; } static int control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol); struct snd_usb_caiaqdev *cdev = caiaqdev(chip->card); int pos = kcontrol->private_value; int v = ucontrol->value.integer.value[0]; unsigned char cmd; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): cmd = EP1_CMD_DIMM_LEDS; break; default: cmd = EP1_CMD_WRITE_IO; break; } if (pos & CNT_INTVAL) { int i = pos & ~CNT_INTVAL; cdev->control_state[i] = v; if (cdev->chip.usb_id == USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4)) { int actual_len; cdev->ep8_out_buf[0] = i; cdev->ep8_out_buf[1] = v; usb_bulk_msg(cdev->chip.dev, usb_sndbulkpipe(cdev->chip.dev, 8), cdev->ep8_out_buf, sizeof(cdev->ep8_out_buf), &actual_len, 200); } else if (cdev->chip.usb_id == USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER)) { int bank = 0; int offset = 0; if (i >= MASCHINE_BANK_SIZE) { bank = 0x1e; offset = MASCHINE_BANK_SIZE; } snd_usb_caiaq_send_command_bank(cdev, cmd, bank, cdev->control_state + offset, MASCHINE_BANK_SIZE); } else { snd_usb_caiaq_send_command(cdev, cmd, cdev->control_state, sizeof(cdev->control_state)); } } else { if (v) cdev->control_state[pos / 8] |= 1 << (pos % 8); else cdev->control_state[pos / 8] &= ~(1 << (pos % 8)); snd_usb_caiaq_send_command(cdev, cmd, cdev->control_state, sizeof(cdev->control_state)); } return 1; } static struct snd_kcontrol_new kcontrol_template = { .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .index = 0, .info = control_info, .get = control_get, .put = control_put, /* name and private_value filled later */ }; struct caiaq_controller { char *name; int index; }; static const struct caiaq_controller ak1_controller[] = { { "LED left", 2 }, { "LED middle", 1 }, { "LED right", 0 }, { "LED ring", 3 } }; static const struct caiaq_controller rk2_controller[] = { { "LED 1", 5 }, { "LED 2", 4 }, { "LED 3", 3 }, { "LED 4", 2 }, { "LED 5", 1 }, { "LED 6", 0 }, { "LED pedal", 6 }, { "LED 7seg_1b", 8 }, { "LED 7seg_1c", 9 }, { "LED 7seg_2a", 10 }, { "LED 7seg_2b", 11 }, { "LED 7seg_2c", 12 }, { "LED 7seg_2d", 13 }, { "LED 7seg_2e", 14 }, { "LED 7seg_2f", 15 }, { "LED 7seg_2g", 16 }, { "LED 7seg_3a", 17 }, { "LED 7seg_3b", 18 }, { "LED 7seg_3c", 19 }, { "LED 7seg_3d", 20 }, { "LED 7seg_3e", 21 }, { "LED 7seg_3f", 22 }, { "LED 7seg_3g", 23 } }; static const struct caiaq_controller rk3_controller[] = { { "LED 7seg_1a", 0 + 0 }, { "LED 7seg_1b", 0 + 1 }, { "LED 7seg_1c", 0 + 2 }, { "LED 7seg_1d", 0 + 3 }, { "LED 7seg_1e", 0 + 4 }, { "LED 7seg_1f", 0 + 5 }, { "LED 7seg_1g", 0 + 6 }, { "LED 7seg_1p", 0 + 7 }, { "LED 7seg_2a", 8 + 0 }, { "LED 7seg_2b", 8 + 1 }, { "LED 7seg_2c", 8 + 2 }, { "LED 7seg_2d", 8 + 3 }, { "LED 7seg_2e", 8 + 4 }, { "LED 7seg_2f", 8 + 5 }, { "LED 7seg_2g", 8 + 6 }, { "LED 7seg_2p", 8 + 7 }, { "LED 7seg_3a", 16 + 0 }, { "LED 7seg_3b", 16 + 1 }, { "LED 7seg_3c", 16 + 2 }, { "LED 7seg_3d", 16 + 3 }, { "LED 7seg_3e", 16 + 4 }, { "LED 7seg_3f", 16 + 5 }, { "LED 7seg_3g", 16 + 6 }, { "LED 7seg_3p", 16 + 7 }, { "LED 7seg_4a", 24 + 0 }, { "LED 7seg_4b", 24 + 1 }, { "LED 7seg_4c", 24 + 2 }, { "LED 7seg_4d", 24 + 3 }, { "LED 7seg_4e", 24 + 4 }, { "LED 7seg_4f", 24 + 5 }, { "LED 7seg_4g", 24 + 6 }, { "LED 7seg_4p", 24 + 7 }, { "LED 1", 32 + 0 }, { "LED 2", 32 + 1 }, { "LED 3", 32 + 2 }, { "LED 4", 32 + 3 }, { "LED 5", 32 + 4 }, { "LED 6", 32 + 5 }, { "LED 7", 32 + 6 }, { "LED 8", 32 + 7 }, { "LED pedal", 32 + 8 } }; static const struct caiaq_controller kore_controller[] = { { "LED F1", 8 | CNT_INTVAL }, { "LED F2", 12 | CNT_INTVAL }, { "LED F3", 0 | CNT_INTVAL }, { "LED F4", 4 | CNT_INTVAL }, { "LED F5", 11 | CNT_INTVAL }, { "LED F6", 15 | CNT_INTVAL }, { "LED F7", 3 | CNT_INTVAL }, { "LED F8", 7 | CNT_INTVAL }, { "LED touch1", 10 | CNT_INTVAL }, { "LED touch2", 14 | CNT_INTVAL }, { "LED touch3", 2 | CNT_INTVAL }, { "LED touch4", 6 | CNT_INTVAL }, { "LED touch5", 9 | CNT_INTVAL }, { "LED touch6", 13 | CNT_INTVAL }, { "LED touch7", 1 | CNT_INTVAL }, { "LED touch8", 5 | CNT_INTVAL }, { "LED left", 18 | CNT_INTVAL }, { "LED right", 22 | CNT_INTVAL }, { "LED up", 16 | CNT_INTVAL }, { "LED down", 20 | CNT_INTVAL }, { "LED stop", 23 | CNT_INTVAL }, { "LED play", 21 | CNT_INTVAL }, { "LED record", 19 | CNT_INTVAL }, { "LED listen", 17 | CNT_INTVAL }, { "LED lcd", 30 | CNT_INTVAL }, { "LED menu", 28 | CNT_INTVAL }, { "LED sound", 31 | CNT_INTVAL }, { "LED esc", 29 | CNT_INTVAL }, { "LED view", 27 | CNT_INTVAL }, { "LED enter", 24 | CNT_INTVAL }, { "LED control", 26 | CNT_INTVAL } }; static const struct caiaq_controller a8dj_controller[] = { { "Current input mode", 0 | CNT_INTVAL }, { "GND lift for TC Vinyl mode", 24 + 0 }, { "GND lift for TC CD/Line mode", 24 + 1 }, { "GND lift for phono mode", 24 + 2 }, { "Software lock", 40 } }; static const struct caiaq_controller a4dj_controller[] = { { "Current input mode", 0 | CNT_INTVAL } }; static const struct caiaq_controller kontrolx1_controller[] = { { "LED FX A: ON", 7 | CNT_INTVAL }, { "LED FX A: 1", 6 | CNT_INTVAL }, { "LED FX A: 2", 5 | CNT_INTVAL }, { "LED FX A: 3", 4 | CNT_INTVAL }, { "LED FX B: ON", 3 | CNT_INTVAL }, { "LED FX B: 1", 2 | CNT_INTVAL }, { "LED FX B: 2", 1 | CNT_INTVAL }, { "LED FX B: 3", 0 | CNT_INTVAL }, { "LED Hotcue", 28 | CNT_INTVAL }, { "LED Shift (white)", 29 | CNT_INTVAL }, { "LED Shift (green)", 30 | CNT_INTVAL }, { "LED Deck A: FX1", 24 | CNT_INTVAL }, { "LED Deck A: FX2", 25 | CNT_INTVAL }, { "LED Deck A: IN", 17 | CNT_INTVAL }, { "LED Deck A: OUT", 16 | CNT_INTVAL }, { "LED Deck A: < BEAT", 19 | CNT_INTVAL }, { "LED Deck A: BEAT >", 18 | CNT_INTVAL }, { "LED Deck A: CUE/ABS", 21 | CNT_INTVAL }, { "LED Deck A: CUP/REL", 20 | CNT_INTVAL }, { "LED Deck A: PLAY", 23 | CNT_INTVAL }, { "LED Deck A: SYNC", 22 | CNT_INTVAL }, { "LED Deck B: FX1", 26 | CNT_INTVAL }, { "LED Deck B: FX2", 27 | CNT_INTVAL }, { "LED Deck B: IN", 15 | CNT_INTVAL }, { "LED Deck B: OUT", 14 | CNT_INTVAL }, { "LED Deck B: < BEAT", 13 | CNT_INTVAL }, { "LED Deck B: BEAT >", 12 | CNT_INTVAL }, { "LED Deck B: CUE/ABS", 11 | CNT_INTVAL }, { "LED Deck B: CUP/REL", 10 | CNT_INTVAL }, { "LED Deck B: PLAY", 9 | CNT_INTVAL }, { "LED Deck B: SYNC", 8 | CNT_INTVAL }, }; static const struct caiaq_controller kontrols4_controller[] = { { "LED: Master: Quant", 10 | CNT_INTVAL }, { "LED: Master: Headphone", 11 | CNT_INTVAL }, { "LED: Master: Master", 12 | CNT_INTVAL }, { "LED: Master: Snap", 14 | CNT_INTVAL }, { "LED: Master: Warning", 15 | CNT_INTVAL }, { "LED: Master: Master button", 112 | CNT_INTVAL }, { "LED: Master: Snap button", 113 | CNT_INTVAL }, { "LED: Master: Rec", 118 | CNT_INTVAL }, { "LED: Master: Size", 119 | CNT_INTVAL }, { "LED: Master: Quant button", 120 | CNT_INTVAL }, { "LED: Master: Browser button", 121 | CNT_INTVAL }, { "LED: Master: Play button", 126 | CNT_INTVAL }, { "LED: Master: Undo button", 127 | CNT_INTVAL }, { "LED: Channel A: >", 4 | CNT_INTVAL }, { "LED: Channel A: <", 5 | CNT_INTVAL }, { "LED: Channel A: Meter 1", 97 | CNT_INTVAL }, { "LED: Channel A: Meter 2", 98 | CNT_INTVAL }, { "LED: Channel A: Meter 3", 99 | CNT_INTVAL }, { "LED: Channel A: Meter 4", 100 | CNT_INTVAL }, { "LED: Channel A: Meter 5", 101 | CNT_INTVAL }, { "LED: Channel A: Meter 6", 102 | CNT_INTVAL }, { "LED: Channel A: Meter clip", 103 | CNT_INTVAL }, { "LED: Channel A: Active", 114 | CNT_INTVAL }, { "LED: Channel A: Cue", 116 | CNT_INTVAL }, { "LED: Channel A: FX1", 149 | CNT_INTVAL }, { "LED: Channel A: FX2", 148 | CNT_INTVAL }, { "LED: Channel B: >", 2 | CNT_INTVAL }, { "LED: Channel B: <", 3 | CNT_INTVAL }, { "LED: Channel B: Meter 1", 89 | CNT_INTVAL }, { "LED: Channel B: Meter 2", 90 | CNT_INTVAL }, { "LED: Channel B: Meter 3", 91 | CNT_INTVAL }, { "LED: Channel B: Meter 4", 92 | CNT_INTVAL }, { "LED: Channel B: Meter 5", 93 | CNT_INTVAL }, { "LED: Channel B: Meter 6", 94 | CNT_INTVAL }, { "LED: Channel B: Meter clip", 95 | CNT_INTVAL }, { "LED: Channel B: Active", 122 | CNT_INTVAL }, { "LED: Channel B: Cue", 125 | CNT_INTVAL }, { "LED: Channel B: FX1", 147 | CNT_INTVAL }, { "LED: Channel B: FX2", 146 | CNT_INTVAL }, { "LED: Channel C: >", 6 | CNT_INTVAL }, { "LED: Channel C: <", 7 | CNT_INTVAL }, { "LED: Channel C: Meter 1", 105 | CNT_INTVAL }, { "LED: Channel C: Meter 2", 106 | CNT_INTVAL }, { "LED: Channel C: Meter 3", 107 | CNT_INTVAL }, { "LED: Channel C: Meter 4", 108 | CNT_INTVAL }, { "LED: Channel C: Meter 5", 109 | CNT_INTVAL }, { "LED: Channel C: Meter 6", 110 | CNT_INTVAL }, { "LED: Channel C: Meter clip", 111 | CNT_INTVAL }, { "LED: Channel C: Active", 115 | CNT_INTVAL }, { "LED: Channel C: Cue", 117 | CNT_INTVAL }, { "LED: Channel C: FX1", 151 | CNT_INTVAL }, { "LED: Channel C: FX2", 150 | CNT_INTVAL }, { "LED: Channel D: >", 0 | CNT_INTVAL }, { "LED: Channel D: <", 1 | CNT_INTVAL }, { "LED: Channel D: Meter 1", 81 | CNT_INTVAL }, { "LED: Channel D: Meter 2", 82 | CNT_INTVAL }, { "LED: Channel D: Meter 3", 83 | CNT_INTVAL }, { "LED: Channel D: Meter 4", 84 | CNT_INTVAL }, { "LED: Channel D: Meter 5", 85 | CNT_INTVAL }, { "LED: Channel D: Meter 6", 86 | CNT_INTVAL }, { "LED: Channel D: Meter clip", 87 | CNT_INTVAL }, { "LED: Channel D: Active", 123 | CNT_INTVAL }, { "LED: Channel D: Cue", 124 | CNT_INTVAL }, { "LED: Channel D: FX1", 145 | CNT_INTVAL }, { "LED: Channel D: FX2", 144 | CNT_INTVAL }, { "LED: Deck A: 1 (blue)", 22 | CNT_INTVAL }, { "LED: Deck A: 1 (green)", 23 | CNT_INTVAL }, { "LED: Deck A: 2 (blue)", 20 | CNT_INTVAL }, { "LED: Deck A: 2 (green)", 21 | CNT_INTVAL }, { "LED: Deck A: 3 (blue)", 18 | CNT_INTVAL }, { "LED: Deck A: 3 (green)", 19 | CNT_INTVAL }, { "LED: Deck A: 4 (blue)", 16 | CNT_INTVAL }, { "LED: Deck A: 4 (green)", 17 | CNT_INTVAL }, { "LED: Deck A: Load", 44 | CNT_INTVAL }, { "LED: Deck A: Deck C button", 45 | CNT_INTVAL }, { "LED: Deck A: In", 47 | CNT_INTVAL }, { "LED: Deck A: Out", 46 | CNT_INTVAL }, { "LED: Deck A: Shift", 24 | CNT_INTVAL }, { "LED: Deck A: Sync", 27 | CNT_INTVAL }, { "LED: Deck A: Cue", 26 | CNT_INTVAL }, { "LED: Deck A: Play", 25 | CNT_INTVAL }, { "LED: Deck A: Tempo up", 33 | CNT_INTVAL }, { "LED: Deck A: Tempo down", 32 | CNT_INTVAL }, { "LED: Deck A: Master", 34 | CNT_INTVAL }, { "LED: Deck A: Keylock", 35 | CNT_INTVAL }, { "LED: Deck A: Deck A", 37 | CNT_INTVAL }, { "LED: Deck A: Deck C", 36 | CNT_INTVAL }, { "LED: Deck A: Samples", 38 | CNT_INTVAL }, { "LED: Deck A: On Air", 39 | CNT_INTVAL }, { "LED: Deck A: Sample 1", 31 | CNT_INTVAL }, { "LED: Deck A: Sample 2", 30 | CNT_INTVAL }, { "LED: Deck A: Sample 3", 29 | CNT_INTVAL }, { "LED: Deck A: Sample 4", 28 | CNT_INTVAL }, { "LED: Deck A: Digit 1 - A", 55 | CNT_INTVAL }, { "LED: Deck A: Digit 1 - B", 54 | CNT_INTVAL }, { "LED: Deck A: Digit 1 - C", 53 | CNT_INTVAL }, { "LED: Deck A: Digit 1 - D", 52 | CNT_INTVAL }, { "LED: Deck A: Digit 1 - E", 51 | CNT_INTVAL }, { "LED: Deck A: Digit 1 - F", 50 | CNT_INTVAL }, { "LED: Deck A: Digit 1 - G", 49 | CNT_INTVAL }, { "LED: Deck A: Digit 1 - dot", 48 | CNT_INTVAL }, { "LED: Deck A: Digit 2 - A", 63 | CNT_INTVAL }, { "LED: Deck A: Digit 2 - B", 62 | CNT_INTVAL }, { "LED: Deck A: Digit 2 - C", 61 | CNT_INTVAL }, { "LED: Deck A: Digit 2 - D", 60 | CNT_INTVAL }, { "LED: Deck A: Digit 2 - E", 59 | CNT_INTVAL }, { "LED: Deck A: Digit 2 - F", 58 | CNT_INTVAL }, { "LED: Deck A: Digit 2 - G", 57 | CNT_INTVAL }, { "LED: Deck A: Digit 2 - dot", 56 | CNT_INTVAL }, { "LED: Deck B: 1 (blue)", 78 | CNT_INTVAL }, { "LED: Deck B: 1 (green)", 79 | CNT_INTVAL }, { "LED: Deck B: 2 (blue)", 76 | CNT_INTVAL }, { "LED: Deck B: 2 (green)", 77 | CNT_INTVAL }, { "LED: Deck B: 3 (blue)", 74 | CNT_INTVAL }, { "LED: Deck B: 3 (green)", 75 | CNT_INTVAL }, { "LED: Deck B: 4 (blue)", 72 | CNT_INTVAL }, { "LED: Deck B: 4 (green)", 73 | CNT_INTVAL }, { "LED: Deck B: Load", 180 | CNT_INTVAL }, { "LED: Deck B: Deck D button", 181 | CNT_INTVAL }, { "LED: Deck B: In", 183 | CNT_INTVAL }, { "LED: Deck B: Out", 182 | CNT_INTVAL }, { "LED: Deck B: Shift", 64 | CNT_INTVAL }, { "LED: Deck B: Sync", 67 | CNT_INTVAL }, { "LED: Deck B: Cue", 66 | CNT_INTVAL }, { "LED: Deck B: Play", 65 | CNT_INTVAL }, { "LED: Deck B: Tempo up", 185 | CNT_INTVAL }, { "LED: Deck B: Tempo down", 184 | CNT_INTVAL }, { "LED: Deck B: Master", 186 | CNT_INTVAL }, { "LED: Deck B: Keylock", 187 | CNT_INTVAL }, { "LED: Deck B: Deck B", 189 | CNT_INTVAL }, { "LED: Deck B: Deck D", 188 | CNT_INTVAL }, { "LED: Deck B: Samples", 190 | CNT_INTVAL }, { "LED: Deck B: On Air", 191 | CNT_INTVAL }, { "LED: Deck B: Sample 1", 71 | CNT_INTVAL }, { "LED: Deck B: Sample 2", 70 | CNT_INTVAL }, { "LED: Deck B: Sample 3", 69 | CNT_INTVAL }, { "LED: Deck B: Sample 4", 68 | CNT_INTVAL }, { "LED: Deck B: Digit 1 - A", 175 | CNT_INTVAL }, { "LED: Deck B: Digit 1 - B", 174 | CNT_INTVAL }, { "LED: Deck B: Digit 1 - C", 173 | CNT_INTVAL }, { "LED: Deck B: Digit 1 - D", 172 | CNT_INTVAL }, { "LED: Deck B: Digit 1 - E", 171 | CNT_INTVAL }, { "LED: Deck B: Digit 1 - F", 170 | CNT_INTVAL }, { "LED: Deck B: Digit 1 - G", 169 | CNT_INTVAL }, { "LED: Deck B: Digit 1 - dot", 168 | CNT_INTVAL }, { "LED: Deck B: Digit 2 - A", 167 | CNT_INTVAL }, { "LED: Deck B: Digit 2 - B", 166 | CNT_INTVAL }, { "LED: Deck B: Digit 2 - C", 165 | CNT_INTVAL }, { "LED: Deck B: Digit 2 - D", 164 | CNT_INTVAL }, { "LED: Deck B: Digit 2 - E", 163 | CNT_INTVAL }, { "LED: Deck B: Digit 2 - F", 162 | CNT_INTVAL }, { "LED: Deck B: Digit 2 - G", 161 | CNT_INTVAL }, { "LED: Deck B: Digit 2 - dot", 160 | CNT_INTVAL }, { "LED: FX1: dry/wet", 153 | CNT_INTVAL }, { "LED: FX1: 1", 154 | CNT_INTVAL }, { "LED: FX1: 2", 155 | CNT_INTVAL }, { "LED: FX1: 3", 156 | CNT_INTVAL }, { "LED: FX1: Mode", 157 | CNT_INTVAL }, { "LED: FX2: dry/wet", 129 | CNT_INTVAL }, { "LED: FX2: 1", 130 | CNT_INTVAL }, { "LED: FX2: 2", 131 | CNT_INTVAL }, { "LED: FX2: 3", 132 | CNT_INTVAL }, { "LED: FX2: Mode", 133 | CNT_INTVAL }, }; static const struct caiaq_controller maschine_controller[] = { { "LED: Pad 1", 3 | CNT_INTVAL }, { "LED: Pad 2", 2 | CNT_INTVAL }, { "LED: Pad 3", 1 | CNT_INTVAL }, { "LED: Pad 4", 0 | CNT_INTVAL }, { "LED: Pad 5", 7 | CNT_INTVAL }, { "LED: Pad 6", 6 | CNT_INTVAL }, { "LED: Pad 7", 5 | CNT_INTVAL }, { "LED: Pad 8", 4 | CNT_INTVAL }, { "LED: Pad 9", 11 | CNT_INTVAL }, { "LED: Pad 10", 10 | CNT_INTVAL }, { "LED: Pad 11", 9 | CNT_INTVAL }, { "LED: Pad 12", 8 | CNT_INTVAL }, { "LED: Pad 13", 15 | CNT_INTVAL }, { "LED: Pad 14", 14 | CNT_INTVAL }, { "LED: Pad 15", 13 | CNT_INTVAL }, { "LED: Pad 16", 12 | CNT_INTVAL }, { "LED: Mute", 16 | CNT_INTVAL }, { "LED: Solo", 17 | CNT_INTVAL }, { "LED: Select", 18 | CNT_INTVAL }, { "LED: Duplicate", 19 | CNT_INTVAL }, { "LED: Navigate", 20 | CNT_INTVAL }, { "LED: Pad Mode", 21 | CNT_INTVAL }, { "LED: Pattern", 22 | CNT_INTVAL }, { "LED: Scene", 23 | CNT_INTVAL }, { "LED: Shift", 24 | CNT_INTVAL }, { "LED: Erase", 25 | CNT_INTVAL }, { "LED: Grid", 26 | CNT_INTVAL }, { "LED: Right Bottom", 27 | CNT_INTVAL }, { "LED: Rec", 28 | CNT_INTVAL }, { "LED: Play", 29 | CNT_INTVAL }, { "LED: Left Bottom", 32 | CNT_INTVAL }, { "LED: Restart", 33 | CNT_INTVAL }, { "LED: Group A", 41 | CNT_INTVAL }, { "LED: Group B", 40 | CNT_INTVAL }, { "LED: Group C", 37 | CNT_INTVAL }, { "LED: Group D", 36 | CNT_INTVAL }, { "LED: Group E", 39 | CNT_INTVAL }, { "LED: Group F", 38 | CNT_INTVAL }, { "LED: Group G", 35 | CNT_INTVAL }, { "LED: Group H", 34 | CNT_INTVAL }, { "LED: Auto Write", 42 | CNT_INTVAL }, { "LED: Snap", 43 | CNT_INTVAL }, { "LED: Right Top", 44 | CNT_INTVAL }, { "LED: Left Top", 45 | CNT_INTVAL }, { "LED: Sampling", 46 | CNT_INTVAL }, { "LED: Browse", 47 | CNT_INTVAL }, { "LED: Step", 48 | CNT_INTVAL }, { "LED: Control", 49 | CNT_INTVAL }, { "LED: Top Button 1", 57 | CNT_INTVAL }, { "LED: Top Button 2", 56 | CNT_INTVAL }, { "LED: Top Button 3", 55 | CNT_INTVAL }, { "LED: Top Button 4", 54 | CNT_INTVAL }, { "LED: Top Button 5", 53 | CNT_INTVAL }, { "LED: Top Button 6", 52 | CNT_INTVAL }, { "LED: Top Button 7", 51 | CNT_INTVAL }, { "LED: Top Button 8", 50 | CNT_INTVAL }, { "LED: Note Repeat", 58 | CNT_INTVAL }, { "Backlight Display", 59 | CNT_INTVAL } }; static int add_controls(const struct caiaq_controller *c, int num, struct snd_usb_caiaqdev *cdev) { int i, ret; struct snd_kcontrol *kc; for (i = 0; i < num; i++, c++) { kcontrol_template.name = c->name; kcontrol_template.private_value = c->index; kc = snd_ctl_new1(&kcontrol_template, cdev); ret = snd_ctl_add(cdev->chip.card, kc); if (ret < 0) return ret; } return 0; } int snd_usb_caiaq_control_init(struct snd_usb_caiaqdev *cdev) { int ret = 0; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1): ret = add_controls(ak1_controller, ARRAY_SIZE(ak1_controller), cdev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): ret = add_controls(rk2_controller, ARRAY_SIZE(rk2_controller), cdev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3): ret = add_controls(rk3_controller, ARRAY_SIZE(rk3_controller), cdev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): ret = add_controls(kore_controller, ARRAY_SIZE(kore_controller), cdev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ): ret = add_controls(a8dj_controller, ARRAY_SIZE(a8dj_controller), cdev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ): ret = add_controls(a4dj_controller, ARRAY_SIZE(a4dj_controller), cdev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): ret = add_controls(kontrolx1_controller, ARRAY_SIZE(kontrolx1_controller), cdev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): ret = add_controls(kontrols4_controller, ARRAY_SIZE(kontrols4_controller), cdev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER): ret = add_controls(maschine_controller, ARRAY_SIZE(maschine_controller), cdev); break; } return ret; }
linux-master
sound/usb/caiaq/control.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (c) 2006,2007 Daniel Mack, Tim Ruetz */ #include <linux/device.h> #include <linux/gfp.h> #include <linux/init.h> #include <linux/usb.h> #include <linux/usb/input.h> #include <sound/core.h> #include <sound/pcm.h> #include "device.h" #include "input.h" static const unsigned short keycode_ak1[] = { KEY_C, KEY_B, KEY_A }; static const unsigned short keycode_rk2[] = { KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7 }; static const unsigned short keycode_rk3[] = { KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9 }; static const unsigned short keycode_kore[] = { KEY_FN_F1, /* "menu" */ KEY_FN_F7, /* "lcd backlight */ KEY_FN_F2, /* "control" */ KEY_FN_F3, /* "enter" */ KEY_FN_F4, /* "view" */ KEY_FN_F5, /* "esc" */ KEY_FN_F6, /* "sound" */ KEY_FN_F8, /* array spacer, never triggered. */ KEY_RIGHT, KEY_DOWN, KEY_UP, KEY_LEFT, KEY_SOUND, /* "listen" */ KEY_RECORD, KEY_PLAYPAUSE, KEY_STOP, BTN_4, /* 8 softkeys */ BTN_3, BTN_2, BTN_1, BTN_8, BTN_7, BTN_6, BTN_5, KEY_BRL_DOT4, /* touch sensitive knobs */ KEY_BRL_DOT3, KEY_BRL_DOT2, KEY_BRL_DOT1, KEY_BRL_DOT8, KEY_BRL_DOT7, KEY_BRL_DOT6, KEY_BRL_DOT5 }; #define MASCHINE_BUTTONS (42) #define MASCHINE_BUTTON(X) ((X) + BTN_MISC) #define MASCHINE_PADS (16) #define MASCHINE_PAD(X) ((X) + ABS_PRESSURE) static const unsigned short keycode_maschine[] = { MASCHINE_BUTTON(40), /* mute */ MASCHINE_BUTTON(39), /* solo */ MASCHINE_BUTTON(38), /* select */ MASCHINE_BUTTON(37), /* duplicate */ MASCHINE_BUTTON(36), /* navigate */ MASCHINE_BUTTON(35), /* pad mode */ MASCHINE_BUTTON(34), /* pattern */ MASCHINE_BUTTON(33), /* scene */ KEY_RESERVED, /* spacer */ MASCHINE_BUTTON(30), /* rec */ MASCHINE_BUTTON(31), /* erase */ MASCHINE_BUTTON(32), /* shift */ MASCHINE_BUTTON(28), /* grid */ MASCHINE_BUTTON(27), /* > */ MASCHINE_BUTTON(26), /* < */ MASCHINE_BUTTON(25), /* restart */ MASCHINE_BUTTON(21), /* E */ MASCHINE_BUTTON(22), /* F */ MASCHINE_BUTTON(23), /* G */ MASCHINE_BUTTON(24), /* H */ MASCHINE_BUTTON(20), /* D */ MASCHINE_BUTTON(19), /* C */ MASCHINE_BUTTON(18), /* B */ MASCHINE_BUTTON(17), /* A */ MASCHINE_BUTTON(0), /* control */ MASCHINE_BUTTON(2), /* browse */ MASCHINE_BUTTON(4), /* < */ MASCHINE_BUTTON(6), /* snap */ MASCHINE_BUTTON(7), /* autowrite */ MASCHINE_BUTTON(5), /* > */ MASCHINE_BUTTON(3), /* sampling */ MASCHINE_BUTTON(1), /* step */ MASCHINE_BUTTON(15), /* 8 softkeys */ MASCHINE_BUTTON(14), MASCHINE_BUTTON(13), MASCHINE_BUTTON(12), MASCHINE_BUTTON(11), MASCHINE_BUTTON(10), MASCHINE_BUTTON(9), MASCHINE_BUTTON(8), MASCHINE_BUTTON(16), /* note repeat */ MASCHINE_BUTTON(29) /* play */ }; #define KONTROLX1_INPUTS (40) #define KONTROLS4_BUTTONS (12 * 8) #define KONTROLS4_AXIS (46) #define KONTROLS4_BUTTON(X) ((X) + BTN_MISC) #define KONTROLS4_ABS(X) ((X) + ABS_HAT0X) #define DEG90 (range / 2) #define DEG180 (range) #define DEG270 (DEG90 + DEG180) #define DEG360 (DEG180 * 2) #define HIGH_PEAK (268) #define LOW_PEAK (-7) /* some of these devices have endless rotation potentiometers * built in which use two tapers, 90 degrees phase shifted. * this algorithm decodes them to one single value, ranging * from 0 to 999 */ static unsigned int decode_erp(unsigned char a, unsigned char b) { int weight_a, weight_b; int pos_a, pos_b; int ret; int range = HIGH_PEAK - LOW_PEAK; int mid_value = (HIGH_PEAK + LOW_PEAK) / 2; weight_b = abs(mid_value - a) - (range / 2 - 100) / 2; if (weight_b < 0) weight_b = 0; if (weight_b > 100) weight_b = 100; weight_a = 100 - weight_b; if (a < mid_value) { /* 0..90 and 270..360 degrees */ pos_b = b - LOW_PEAK + DEG270; if (pos_b >= DEG360) pos_b -= DEG360; } else /* 90..270 degrees */ pos_b = HIGH_PEAK - b + DEG90; if (b > mid_value) /* 0..180 degrees */ pos_a = a - LOW_PEAK; else /* 180..360 degrees */ pos_a = HIGH_PEAK - a + DEG180; /* interpolate both slider values, depending on weight factors */ /* 0..99 x DEG360 */ ret = pos_a * weight_a + pos_b * weight_b; /* normalize to 0..999 */ ret *= 10; ret /= DEG360; if (ret < 0) ret += 1000; if (ret >= 1000) ret -= 1000; return ret; } #undef DEG90 #undef DEG180 #undef DEG270 #undef DEG360 #undef HIGH_PEAK #undef LOW_PEAK static inline void snd_caiaq_input_report_abs(struct snd_usb_caiaqdev *cdev, int axis, const unsigned char *buf, int offset) { input_report_abs(cdev->input_dev, axis, (buf[offset * 2] << 8) | buf[offset * 2 + 1]); } static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *cdev, const unsigned char *buf, unsigned int len) { struct input_dev *input_dev = cdev->input_dev; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): snd_caiaq_input_report_abs(cdev, ABS_X, buf, 2); snd_caiaq_input_report_abs(cdev, ABS_Y, buf, 0); snd_caiaq_input_report_abs(cdev, ABS_Z, buf, 1); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): snd_caiaq_input_report_abs(cdev, ABS_X, buf, 0); snd_caiaq_input_report_abs(cdev, ABS_Y, buf, 1); snd_caiaq_input_report_abs(cdev, ABS_Z, buf, 2); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): snd_caiaq_input_report_abs(cdev, ABS_HAT0X, buf, 4); snd_caiaq_input_report_abs(cdev, ABS_HAT0Y, buf, 2); snd_caiaq_input_report_abs(cdev, ABS_HAT1X, buf, 6); snd_caiaq_input_report_abs(cdev, ABS_HAT1Y, buf, 1); snd_caiaq_input_report_abs(cdev, ABS_HAT2X, buf, 7); snd_caiaq_input_report_abs(cdev, ABS_HAT2Y, buf, 0); snd_caiaq_input_report_abs(cdev, ABS_HAT3X, buf, 5); snd_caiaq_input_report_abs(cdev, ABS_HAT3Y, buf, 3); break; } input_sync(input_dev); } static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev *cdev, const char *buf, unsigned int len) { struct input_dev *input_dev = cdev->input_dev; int i; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1): i = decode_erp(buf[0], buf[1]); input_report_abs(input_dev, ABS_X, i); input_sync(input_dev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): i = decode_erp(buf[7], buf[5]); input_report_abs(input_dev, ABS_HAT0X, i); i = decode_erp(buf[12], buf[14]); input_report_abs(input_dev, ABS_HAT0Y, i); i = decode_erp(buf[15], buf[13]); input_report_abs(input_dev, ABS_HAT1X, i); i = decode_erp(buf[0], buf[2]); input_report_abs(input_dev, ABS_HAT1Y, i); i = decode_erp(buf[3], buf[1]); input_report_abs(input_dev, ABS_HAT2X, i); i = decode_erp(buf[8], buf[10]); input_report_abs(input_dev, ABS_HAT2Y, i); i = decode_erp(buf[11], buf[9]); input_report_abs(input_dev, ABS_HAT3X, i); i = decode_erp(buf[4], buf[6]); input_report_abs(input_dev, ABS_HAT3Y, i); input_sync(input_dev); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER): /* 4 under the left screen */ input_report_abs(input_dev, ABS_HAT0X, decode_erp(buf[21], buf[20])); input_report_abs(input_dev, ABS_HAT0Y, decode_erp(buf[15], buf[14])); input_report_abs(input_dev, ABS_HAT1X, decode_erp(buf[9], buf[8])); input_report_abs(input_dev, ABS_HAT1Y, decode_erp(buf[3], buf[2])); /* 4 under the right screen */ input_report_abs(input_dev, ABS_HAT2X, decode_erp(buf[19], buf[18])); input_report_abs(input_dev, ABS_HAT2Y, decode_erp(buf[13], buf[12])); input_report_abs(input_dev, ABS_HAT3X, decode_erp(buf[7], buf[6])); input_report_abs(input_dev, ABS_HAT3Y, decode_erp(buf[1], buf[0])); /* volume */ input_report_abs(input_dev, ABS_RX, decode_erp(buf[17], buf[16])); /* tempo */ input_report_abs(input_dev, ABS_RY, decode_erp(buf[11], buf[10])); /* swing */ input_report_abs(input_dev, ABS_RZ, decode_erp(buf[5], buf[4])); input_sync(input_dev); break; } } static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *cdev, unsigned char *buf, unsigned int len) { struct input_dev *input_dev = cdev->input_dev; unsigned short *keycode = input_dev->keycode; int i; if (!keycode) return; if (input_dev->id.product == USB_PID_RIGKONTROL2) for (i = 0; i < len; i++) buf[i] = ~buf[i]; for (i = 0; i < input_dev->keycodemax && i < len * 8; i++) input_report_key(input_dev, keycode[i], buf[i / 8] & (1 << (i % 8))); switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): input_report_abs(cdev->input_dev, ABS_MISC, 255 - buf[4]); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): /* rotary encoders */ input_report_abs(cdev->input_dev, ABS_X, buf[5] & 0xf); input_report_abs(cdev->input_dev, ABS_Y, buf[5] >> 4); input_report_abs(cdev->input_dev, ABS_Z, buf[6] & 0xf); input_report_abs(cdev->input_dev, ABS_MISC, buf[6] >> 4); break; } input_sync(input_dev); } #define TKS4_MSGBLOCK_SIZE 16 static void snd_usb_caiaq_tks4_dispatch(struct snd_usb_caiaqdev *cdev, const unsigned char *buf, unsigned int len) { struct device *dev = caiaqdev_to_dev(cdev); while (len) { unsigned int i, block_id = (buf[0] << 8) | buf[1]; switch (block_id) { case 0: /* buttons */ for (i = 0; i < KONTROLS4_BUTTONS; i++) input_report_key(cdev->input_dev, KONTROLS4_BUTTON(i), (buf[4 + (i / 8)] >> (i % 8)) & 1); break; case 1: /* left wheel */ input_report_abs(cdev->input_dev, KONTROLS4_ABS(36), buf[9] | ((buf[8] & 0x3) << 8)); /* right wheel */ input_report_abs(cdev->input_dev, KONTROLS4_ABS(37), buf[13] | ((buf[12] & 0x3) << 8)); /* rotary encoders */ input_report_abs(cdev->input_dev, KONTROLS4_ABS(38), buf[3] & 0xf); input_report_abs(cdev->input_dev, KONTROLS4_ABS(39), buf[4] >> 4); input_report_abs(cdev->input_dev, KONTROLS4_ABS(40), buf[4] & 0xf); input_report_abs(cdev->input_dev, KONTROLS4_ABS(41), buf[5] >> 4); input_report_abs(cdev->input_dev, KONTROLS4_ABS(42), buf[5] & 0xf); input_report_abs(cdev->input_dev, KONTROLS4_ABS(43), buf[6] >> 4); input_report_abs(cdev->input_dev, KONTROLS4_ABS(44), buf[6] & 0xf); input_report_abs(cdev->input_dev, KONTROLS4_ABS(45), buf[7] >> 4); input_report_abs(cdev->input_dev, KONTROLS4_ABS(46), buf[7] & 0xf); break; case 2: /* Volume Fader Channel D */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(0), buf, 1); /* Volume Fader Channel B */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(1), buf, 2); /* Volume Fader Channel A */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(2), buf, 3); /* Volume Fader Channel C */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(3), buf, 4); /* Loop Volume */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(4), buf, 6); /* Crossfader */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(7), buf, 7); break; case 3: /* Tempo Fader R */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(6), buf, 3); /* Tempo Fader L */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(5), buf, 4); /* Mic Volume */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(8), buf, 6); /* Cue Mix */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(9), buf, 7); break; case 4: /* Wheel distance sensor L */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(10), buf, 1); /* Wheel distance sensor R */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(11), buf, 2); /* Channel D EQ - Filter */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(12), buf, 3); /* Channel D EQ - Low */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(13), buf, 4); /* Channel D EQ - Mid */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(14), buf, 5); /* Channel D EQ - Hi */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(15), buf, 6); /* FX2 - dry/wet */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(16), buf, 7); break; case 5: /* FX2 - 1 */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(17), buf, 1); /* FX2 - 2 */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(18), buf, 2); /* FX2 - 3 */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(19), buf, 3); /* Channel B EQ - Filter */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(20), buf, 4); /* Channel B EQ - Low */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(21), buf, 5); /* Channel B EQ - Mid */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(22), buf, 6); /* Channel B EQ - Hi */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(23), buf, 7); break; case 6: /* Channel A EQ - Filter */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(24), buf, 1); /* Channel A EQ - Low */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(25), buf, 2); /* Channel A EQ - Mid */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(26), buf, 3); /* Channel A EQ - Hi */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(27), buf, 4); /* Channel C EQ - Filter */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(28), buf, 5); /* Channel C EQ - Low */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(29), buf, 6); /* Channel C EQ - Mid */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(30), buf, 7); break; case 7: /* Channel C EQ - Hi */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(31), buf, 1); /* FX1 - wet/dry */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(32), buf, 2); /* FX1 - 1 */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(33), buf, 3); /* FX1 - 2 */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(34), buf, 4); /* FX1 - 3 */ snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(35), buf, 5); break; default: dev_dbg(dev, "%s(): bogus block (id %d)\n", __func__, block_id); return; } len -= TKS4_MSGBLOCK_SIZE; buf += TKS4_MSGBLOCK_SIZE; } input_sync(cdev->input_dev); } #define MASCHINE_MSGBLOCK_SIZE 2 static void snd_usb_caiaq_maschine_dispatch(struct snd_usb_caiaqdev *cdev, const unsigned char *buf, unsigned int len) { unsigned int i, pad_id; __le16 *pressure = (__le16 *) buf; for (i = 0; i < MASCHINE_PADS; i++) { pad_id = le16_to_cpu(*pressure) >> 12; input_report_abs(cdev->input_dev, MASCHINE_PAD(pad_id), le16_to_cpu(*pressure) & 0xfff); pressure++; } input_sync(cdev->input_dev); } static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb) { struct snd_usb_caiaqdev *cdev = urb->context; unsigned char *buf = urb->transfer_buffer; struct device *dev = &urb->dev->dev; int ret; if (urb->status || !cdev || urb != cdev->ep4_in_urb) return; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): if (urb->actual_length < 24) goto requeue; if (buf[0] & 0x3) snd_caiaq_input_read_io(cdev, buf + 1, 7); if (buf[0] & 0x4) snd_caiaq_input_read_analog(cdev, buf + 8, 16); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): snd_usb_caiaq_tks4_dispatch(cdev, buf, urb->actual_length); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER): if (urb->actual_length < (MASCHINE_PADS * MASCHINE_MSGBLOCK_SIZE)) goto requeue; snd_usb_caiaq_maschine_dispatch(cdev, buf, urb->actual_length); break; } requeue: cdev->ep4_in_urb->actual_length = 0; ret = usb_submit_urb(cdev->ep4_in_urb, GFP_ATOMIC); if (ret < 0) dev_err(dev, "unable to submit urb. OOM!?\n"); } static int snd_usb_caiaq_input_open(struct input_dev *idev) { struct snd_usb_caiaqdev *cdev = input_get_drvdata(idev); if (!cdev) return -EINVAL; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER): if (usb_submit_urb(cdev->ep4_in_urb, GFP_KERNEL) != 0) return -EIO; break; } return 0; } static void snd_usb_caiaq_input_close(struct input_dev *idev) { struct snd_usb_caiaqdev *cdev = input_get_drvdata(idev); if (!cdev) return; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER): usb_kill_urb(cdev->ep4_in_urb); break; } } void snd_usb_caiaq_input_dispatch(struct snd_usb_caiaqdev *cdev, char *buf, unsigned int len) { if (!cdev->input_dev || len < 1) return; switch (buf[0]) { case EP1_CMD_READ_ANALOG: snd_caiaq_input_read_analog(cdev, buf + 1, len - 1); break; case EP1_CMD_READ_ERP: snd_caiaq_input_read_erp(cdev, buf + 1, len - 1); break; case EP1_CMD_READ_IO: snd_caiaq_input_read_io(cdev, buf + 1, len - 1); break; } } int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *cdev) { struct usb_device *usb_dev = cdev->chip.dev; struct input_dev *input; int i, ret = 0; input = input_allocate_device(); if (!input) return -ENOMEM; usb_make_path(usb_dev, cdev->phys, sizeof(cdev->phys)); strlcat(cdev->phys, "/input0", sizeof(cdev->phys)); input->name = cdev->product_name; input->phys = cdev->phys; usb_to_input_id(usb_dev, &input->id); input->dev.parent = &usb_dev->dev; input_set_drvdata(input, cdev); switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) | BIT_MASK(ABS_Z); BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_rk2)); memcpy(cdev->keycode, keycode_rk2, sizeof(keycode_rk2)); input->keycodemax = ARRAY_SIZE(keycode_rk2); input_set_abs_params(input, ABS_X, 0, 4096, 0, 10); input_set_abs_params(input, ABS_Y, 0, 4096, 0, 10); input_set_abs_params(input, ABS_Z, 0, 4096, 0, 10); snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 0); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3): input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) | BIT_MASK(ABS_Z); BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_rk3)); memcpy(cdev->keycode, keycode_rk3, sizeof(keycode_rk3)); input->keycodemax = ARRAY_SIZE(keycode_rk3); input_set_abs_params(input, ABS_X, 0, 1024, 0, 10); input_set_abs_params(input, ABS_Y, 0, 1024, 0, 10); input_set_abs_params(input, ABS_Z, 0, 1024, 0, 10); snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 0); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1): input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); input->absbit[0] = BIT_MASK(ABS_X); BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_ak1)); memcpy(cdev->keycode, keycode_ak1, sizeof(keycode_ak1)); input->keycodemax = ARRAY_SIZE(keycode_ak1); input_set_abs_params(input, ABS_X, 0, 999, 0, 10); snd_usb_caiaq_set_auto_msg(cdev, 1, 0, 5); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) | BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) | BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) | BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) | BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) | BIT_MASK(ABS_Z); input->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC); BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_kore)); memcpy(cdev->keycode, keycode_kore, sizeof(keycode_kore)); input->keycodemax = ARRAY_SIZE(keycode_kore); input_set_abs_params(input, ABS_HAT0X, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT0Y, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT1X, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT1Y, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT2X, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT2Y, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT3X, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT3Y, 0, 999, 0, 10); input_set_abs_params(input, ABS_X, 0, 4096, 0, 10); input_set_abs_params(input, ABS_Y, 0, 4096, 0, 10); input_set_abs_params(input, ABS_Z, 0, 4096, 0, 10); input_set_abs_params(input, ABS_MISC, 0, 255, 0, 1); snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) | BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) | BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) | BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) | BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) | BIT_MASK(ABS_Z); input->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC); BUILD_BUG_ON(sizeof(cdev->keycode) < KONTROLX1_INPUTS); for (i = 0; i < KONTROLX1_INPUTS; i++) cdev->keycode[i] = BTN_MISC + i; input->keycodemax = KONTROLX1_INPUTS; /* analog potentiometers */ input_set_abs_params(input, ABS_HAT0X, 0, 4096, 0, 10); input_set_abs_params(input, ABS_HAT0Y, 0, 4096, 0, 10); input_set_abs_params(input, ABS_HAT1X, 0, 4096, 0, 10); input_set_abs_params(input, ABS_HAT1Y, 0, 4096, 0, 10); input_set_abs_params(input, ABS_HAT2X, 0, 4096, 0, 10); input_set_abs_params(input, ABS_HAT2Y, 0, 4096, 0, 10); input_set_abs_params(input, ABS_HAT3X, 0, 4096, 0, 10); input_set_abs_params(input, ABS_HAT3Y, 0, 4096, 0, 10); /* rotary encoders */ input_set_abs_params(input, ABS_X, 0, 0xf, 0, 1); input_set_abs_params(input, ABS_Y, 0, 0xf, 0, 1); input_set_abs_params(input, ABS_Z, 0, 0xf, 0, 1); input_set_abs_params(input, ABS_MISC, 0, 0xf, 0, 1); cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL); if (!cdev->ep4_in_urb) { ret = -ENOMEM; goto exit_free_idev; } usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev, usb_rcvbulkpipe(usb_dev, 0x4), cdev->ep4_in_buf, EP4_BUFSIZE, snd_usb_caiaq_ep4_reply_dispatch, cdev); ret = usb_urb_ep_type_check(cdev->ep4_in_urb); if (ret < 0) goto exit_free_idev; snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); BUILD_BUG_ON(sizeof(cdev->keycode) < KONTROLS4_BUTTONS); for (i = 0; i < KONTROLS4_BUTTONS; i++) cdev->keycode[i] = KONTROLS4_BUTTON(i); input->keycodemax = KONTROLS4_BUTTONS; for (i = 0; i < KONTROLS4_AXIS; i++) { int axis = KONTROLS4_ABS(i); input->absbit[BIT_WORD(axis)] |= BIT_MASK(axis); } /* 36 analog potentiometers and faders */ for (i = 0; i < 36; i++) input_set_abs_params(input, KONTROLS4_ABS(i), 0, 0xfff, 0, 10); /* 2 encoder wheels */ input_set_abs_params(input, KONTROLS4_ABS(36), 0, 0x3ff, 0, 1); input_set_abs_params(input, KONTROLS4_ABS(37), 0, 0x3ff, 0, 1); /* 9 rotary encoders */ for (i = 0; i < 9; i++) input_set_abs_params(input, KONTROLS4_ABS(38+i), 0, 0xf, 0, 1); cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL); if (!cdev->ep4_in_urb) { ret = -ENOMEM; goto exit_free_idev; } usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev, usb_rcvbulkpipe(usb_dev, 0x4), cdev->ep4_in_buf, EP4_BUFSIZE, snd_usb_caiaq_ep4_reply_dispatch, cdev); ret = usb_urb_ep_type_check(cdev->ep4_in_urb); if (ret < 0) goto exit_free_idev; snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER): input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) | BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) | BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) | BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) | BIT_MASK(ABS_RX) | BIT_MASK(ABS_RY) | BIT_MASK(ABS_RZ); BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_maschine)); memcpy(cdev->keycode, keycode_maschine, sizeof(keycode_maschine)); input->keycodemax = ARRAY_SIZE(keycode_maschine); for (i = 0; i < MASCHINE_PADS; i++) { input->absbit[0] |= MASCHINE_PAD(i); input_set_abs_params(input, MASCHINE_PAD(i), 0, 0xfff, 5, 10); } input_set_abs_params(input, ABS_HAT0X, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT0Y, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT1X, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT1Y, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT2X, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT2Y, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT3X, 0, 999, 0, 10); input_set_abs_params(input, ABS_HAT3Y, 0, 999, 0, 10); input_set_abs_params(input, ABS_RX, 0, 999, 0, 10); input_set_abs_params(input, ABS_RY, 0, 999, 0, 10); input_set_abs_params(input, ABS_RZ, 0, 999, 0, 10); cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL); if (!cdev->ep4_in_urb) { ret = -ENOMEM; goto exit_free_idev; } usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev, usb_rcvbulkpipe(usb_dev, 0x4), cdev->ep4_in_buf, EP4_BUFSIZE, snd_usb_caiaq_ep4_reply_dispatch, cdev); ret = usb_urb_ep_type_check(cdev->ep4_in_urb); if (ret < 0) goto exit_free_idev; snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5); break; default: /* no input methods supported on this device */ ret = -EINVAL; goto exit_free_idev; } input->open = snd_usb_caiaq_input_open; input->close = snd_usb_caiaq_input_close; input->keycode = cdev->keycode; input->keycodesize = sizeof(unsigned short); for (i = 0; i < input->keycodemax; i++) __set_bit(cdev->keycode[i], input->keybit); cdev->input_dev = input; ret = input_register_device(input); if (ret < 0) goto exit_free_idev; return 0; exit_free_idev: input_free_device(input); cdev->input_dev = NULL; return ret; } void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev *cdev) { if (!cdev || !cdev->input_dev) return; usb_kill_urb(cdev->ep4_in_urb); usb_free_urb(cdev->ep4_in_urb); cdev->ep4_in_urb = NULL; input_unregister_device(cdev->input_dev); cdev->input_dev = NULL; }
linux-master
sound/usb/caiaq/input.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (c) 2006,2007 Daniel Mack */ #include <linux/device.h> #include <linux/usb.h> #include <linux/gfp.h> #include <sound/rawmidi.h> #include <sound/core.h> #include <sound/pcm.h> #include "device.h" #include "midi.h" static int snd_usb_caiaq_midi_input_open(struct snd_rawmidi_substream *substream) { return 0; } static int snd_usb_caiaq_midi_input_close(struct snd_rawmidi_substream *substream) { return 0; } static void snd_usb_caiaq_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) { struct snd_usb_caiaqdev *cdev = substream->rmidi->private_data; if (!cdev) return; cdev->midi_receive_substream = up ? substream : NULL; } static int snd_usb_caiaq_midi_output_open(struct snd_rawmidi_substream *substream) { return 0; } static int snd_usb_caiaq_midi_output_close(struct snd_rawmidi_substream *substream) { struct snd_usb_caiaqdev *cdev = substream->rmidi->private_data; if (cdev->midi_out_active) { usb_kill_urb(&cdev->midi_out_urb); cdev->midi_out_active = 0; } return 0; } static void snd_usb_caiaq_midi_send(struct snd_usb_caiaqdev *cdev, struct snd_rawmidi_substream *substream) { int len, ret; struct device *dev = caiaqdev_to_dev(cdev); cdev->midi_out_buf[0] = EP1_CMD_MIDI_WRITE; cdev->midi_out_buf[1] = 0; /* port */ len = snd_rawmidi_transmit(substream, cdev->midi_out_buf + 3, EP1_BUFSIZE - 3); if (len <= 0) return; cdev->midi_out_buf[2] = len; cdev->midi_out_urb.transfer_buffer_length = len+3; ret = usb_submit_urb(&cdev->midi_out_urb, GFP_ATOMIC); if (ret < 0) dev_err(dev, "snd_usb_caiaq_midi_send(%p): usb_submit_urb() failed," "ret=%d, len=%d\n", substream, ret, len); else cdev->midi_out_active = 1; } static void snd_usb_caiaq_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) { struct snd_usb_caiaqdev *cdev = substream->rmidi->private_data; if (up) { cdev->midi_out_substream = substream; if (!cdev->midi_out_active) snd_usb_caiaq_midi_send(cdev, substream); } else { cdev->midi_out_substream = NULL; } } static const struct snd_rawmidi_ops snd_usb_caiaq_midi_output = { .open = snd_usb_caiaq_midi_output_open, .close = snd_usb_caiaq_midi_output_close, .trigger = snd_usb_caiaq_midi_output_trigger, }; static const struct snd_rawmidi_ops snd_usb_caiaq_midi_input = { .open = snd_usb_caiaq_midi_input_open, .close = snd_usb_caiaq_midi_input_close, .trigger = snd_usb_caiaq_midi_input_trigger, }; void snd_usb_caiaq_midi_handle_input(struct snd_usb_caiaqdev *cdev, int port, const char *buf, int len) { if (!cdev->midi_receive_substream) return; snd_rawmidi_receive(cdev->midi_receive_substream, buf, len); } int snd_usb_caiaq_midi_init(struct snd_usb_caiaqdev *device) { int ret; struct snd_rawmidi *rmidi; ret = snd_rawmidi_new(device->chip.card, device->product_name, 0, device->spec.num_midi_out, device->spec.num_midi_in, &rmidi); if (ret < 0) return ret; strscpy(rmidi->name, device->product_name, sizeof(rmidi->name)); rmidi->info_flags = SNDRV_RAWMIDI_INFO_DUPLEX; rmidi->private_data = device; if (device->spec.num_midi_out > 0) { rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT; snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_usb_caiaq_midi_output); } if (device->spec.num_midi_in > 0) { rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT; snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_usb_caiaq_midi_input); } device->rmidi = rmidi; return 0; } void snd_usb_caiaq_midi_output_done(struct urb* urb) { struct snd_usb_caiaqdev *cdev = urb->context; cdev->midi_out_active = 0; if (urb->status != 0) return; if (!cdev->midi_out_substream) return; snd_usb_caiaq_midi_send(cdev, cdev->midi_out_substream); }
linux-master
sound/usb/caiaq/midi.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * caiaq.c: ALSA driver for caiaq/NativeInstruments devices * * Copyright (c) 2007 Daniel Mack <[email protected]> * Karsten Wiese <[email protected]> */ #include <linux/moduleparam.h> #include <linux/device.h> #include <linux/interrupt.h> #include <linux/module.h> #include <linux/init.h> #include <linux/gfp.h> #include <linux/usb.h> #include <sound/initval.h> #include <sound/core.h> #include <sound/pcm.h> #include "device.h" #include "audio.h" #include "midi.h" #include "control.h" #include "input.h" MODULE_AUTHOR("Daniel Mack <[email protected]>"); MODULE_DESCRIPTION("caiaq USB audio"); MODULE_LICENSE("GPL"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */ static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for the caiaq sound device"); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for the caiaq soundcard."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable the caiaq soundcard."); enum { SAMPLERATE_44100 = 0, SAMPLERATE_48000 = 1, SAMPLERATE_96000 = 2, SAMPLERATE_192000 = 3, SAMPLERATE_88200 = 4, SAMPLERATE_INVALID = 0xff }; enum { DEPTH_NONE = 0, DEPTH_16 = 1, DEPTH_24 = 2, DEPTH_32 = 3 }; static const struct usb_device_id snd_usb_id_table[] = { { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_RIGKONTROL2 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_RIGKONTROL3 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_KORECONTROLLER }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_KORECONTROLLER2 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_AK1 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_AUDIO8DJ }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_SESSIONIO }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_GUITARRIGMOBILE }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_AUDIO4DJ }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_AUDIO2DJ }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_TRAKTORKONTROLX1 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_TRAKTORKONTROLS4 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_TRAKTORAUDIO2 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_MASCHINECONTROLLER }, { /* terminator */ } }; static void usb_ep1_command_reply_dispatch (struct urb* urb) { int ret; struct device *dev = &urb->dev->dev; struct snd_usb_caiaqdev *cdev = urb->context; unsigned char *buf = urb->transfer_buffer; if (urb->status || !cdev) { dev_warn(dev, "received EP1 urb->status = %i\n", urb->status); return; } switch(buf[0]) { case EP1_CMD_GET_DEVICE_INFO: memcpy(&cdev->spec, buf+1, sizeof(struct caiaq_device_spec)); cdev->spec.fw_version = le16_to_cpu(cdev->spec.fw_version); dev_dbg(dev, "device spec (firmware %d): audio: %d in, %d out, " "MIDI: %d in, %d out, data alignment %d\n", cdev->spec.fw_version, cdev->spec.num_analog_audio_in, cdev->spec.num_analog_audio_out, cdev->spec.num_midi_in, cdev->spec.num_midi_out, cdev->spec.data_alignment); cdev->spec_received++; wake_up(&cdev->ep1_wait_queue); break; case EP1_CMD_AUDIO_PARAMS: cdev->audio_parm_answer = buf[1]; wake_up(&cdev->ep1_wait_queue); break; case EP1_CMD_MIDI_READ: snd_usb_caiaq_midi_handle_input(cdev, buf[1], buf + 3, buf[2]); break; case EP1_CMD_READ_IO: if (cdev->chip.usb_id == USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ)) { if (urb->actual_length > sizeof(cdev->control_state)) urb->actual_length = sizeof(cdev->control_state); memcpy(cdev->control_state, buf + 1, urb->actual_length); wake_up(&cdev->ep1_wait_queue); break; } #ifdef CONFIG_SND_USB_CAIAQ_INPUT fallthrough; case EP1_CMD_READ_ERP: case EP1_CMD_READ_ANALOG: snd_usb_caiaq_input_dispatch(cdev, buf, urb->actual_length); #endif break; } cdev->ep1_in_urb.actual_length = 0; ret = usb_submit_urb(&cdev->ep1_in_urb, GFP_ATOMIC); if (ret < 0) dev_err(dev, "unable to submit urb. OOM!?\n"); } int snd_usb_caiaq_send_command(struct snd_usb_caiaqdev *cdev, unsigned char command, const unsigned char *buffer, int len) { int actual_len; struct usb_device *usb_dev = cdev->chip.dev; if (!usb_dev) return -EIO; if (len > EP1_BUFSIZE - 1) len = EP1_BUFSIZE - 1; if (buffer && len > 0) memcpy(cdev->ep1_out_buf+1, buffer, len); cdev->ep1_out_buf[0] = command; return usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, 1), cdev->ep1_out_buf, len+1, &actual_len, 200); } int snd_usb_caiaq_send_command_bank(struct snd_usb_caiaqdev *cdev, unsigned char command, unsigned char bank, const unsigned char *buffer, int len) { int actual_len; struct usb_device *usb_dev = cdev->chip.dev; if (!usb_dev) return -EIO; if (len > EP1_BUFSIZE - 2) len = EP1_BUFSIZE - 2; if (buffer && len > 0) memcpy(cdev->ep1_out_buf+2, buffer, len); cdev->ep1_out_buf[0] = command; cdev->ep1_out_buf[1] = bank; return usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, 1), cdev->ep1_out_buf, len+2, &actual_len, 200); } int snd_usb_caiaq_set_audio_params (struct snd_usb_caiaqdev *cdev, int rate, int depth, int bpp) { int ret; char tmp[5]; struct device *dev = caiaqdev_to_dev(cdev); switch (rate) { case 44100: tmp[0] = SAMPLERATE_44100; break; case 48000: tmp[0] = SAMPLERATE_48000; break; case 88200: tmp[0] = SAMPLERATE_88200; break; case 96000: tmp[0] = SAMPLERATE_96000; break; case 192000: tmp[0] = SAMPLERATE_192000; break; default: return -EINVAL; } switch (depth) { case 16: tmp[1] = DEPTH_16; break; case 24: tmp[1] = DEPTH_24; break; default: return -EINVAL; } tmp[2] = bpp & 0xff; tmp[3] = bpp >> 8; tmp[4] = 1; /* packets per microframe */ dev_dbg(dev, "setting audio params: %d Hz, %d bits, %d bpp\n", rate, depth, bpp); cdev->audio_parm_answer = -1; ret = snd_usb_caiaq_send_command(cdev, EP1_CMD_AUDIO_PARAMS, tmp, sizeof(tmp)); if (ret) return ret; if (!wait_event_timeout(cdev->ep1_wait_queue, cdev->audio_parm_answer >= 0, HZ)) return -EPIPE; if (cdev->audio_parm_answer != 1) dev_dbg(dev, "unable to set the device's audio params\n"); else cdev->bpp = bpp; return cdev->audio_parm_answer == 1 ? 0 : -EINVAL; } int snd_usb_caiaq_set_auto_msg(struct snd_usb_caiaqdev *cdev, int digital, int analog, int erp) { char tmp[3] = { digital, analog, erp }; return snd_usb_caiaq_send_command(cdev, EP1_CMD_AUTO_MSG, tmp, sizeof(tmp)); } static void setup_card(struct snd_usb_caiaqdev *cdev) { int ret; char val[4]; struct device *dev = caiaqdev_to_dev(cdev); /* device-specific startup specials */ switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): /* RigKontrol2 - display centered dash ('-') */ val[0] = 0x00; val[1] = 0x00; val[2] = 0x01; snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 3); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3): /* RigKontrol2 - display two centered dashes ('--') */ val[0] = 0x00; val[1] = 0x40; val[2] = 0x40; val[3] = 0x00; snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 4); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1): /* Audio Kontrol 1 - make USB-LED stop blinking */ val[0] = 0x00; snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, val, 1); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ): /* Audio 8 DJ - trigger read of current settings */ cdev->control_state[0] = 0xff; snd_usb_caiaq_set_auto_msg(cdev, 1, 0, 0); snd_usb_caiaq_send_command(cdev, EP1_CMD_READ_IO, NULL, 0); if (!wait_event_timeout(cdev->ep1_wait_queue, cdev->control_state[0] != 0xff, HZ)) return; /* fix up some defaults */ if ((cdev->control_state[1] != 2) || (cdev->control_state[2] != 3) || (cdev->control_state[4] != 2)) { cdev->control_state[1] = 2; cdev->control_state[2] = 3; cdev->control_state[4] = 2; snd_usb_caiaq_send_command(cdev, EP1_CMD_WRITE_IO, cdev->control_state, 6); } break; } if (cdev->spec.num_analog_audio_out + cdev->spec.num_analog_audio_in + cdev->spec.num_digital_audio_out + cdev->spec.num_digital_audio_in > 0) { ret = snd_usb_caiaq_audio_init(cdev); if (ret < 0) dev_err(dev, "Unable to set up audio system (ret=%d)\n", ret); } if (cdev->spec.num_midi_in + cdev->spec.num_midi_out > 0) { ret = snd_usb_caiaq_midi_init(cdev); if (ret < 0) dev_err(dev, "Unable to set up MIDI system (ret=%d)\n", ret); } #ifdef CONFIG_SND_USB_CAIAQ_INPUT ret = snd_usb_caiaq_input_init(cdev); if (ret < 0) dev_err(dev, "Unable to set up input system (ret=%d)\n", ret); #endif /* finally, register the card and all its sub-instances */ ret = snd_card_register(cdev->chip.card); if (ret < 0) { dev_err(dev, "snd_card_register() returned %d\n", ret); snd_card_free(cdev->chip.card); } ret = snd_usb_caiaq_control_init(cdev); if (ret < 0) dev_err(dev, "Unable to set up control system (ret=%d)\n", ret); } static int create_card(struct usb_device *usb_dev, struct usb_interface *intf, struct snd_card **cardp) { int devnum; int err; struct snd_card *card; struct snd_usb_caiaqdev *cdev; for (devnum = 0; devnum < SNDRV_CARDS; devnum++) if (enable[devnum]) break; if (devnum >= SNDRV_CARDS) return -ENODEV; err = snd_card_new(&intf->dev, index[devnum], id[devnum], THIS_MODULE, sizeof(struct snd_usb_caiaqdev), &card); if (err < 0) return err; cdev = caiaqdev(card); cdev->chip.dev = usb_dev; cdev->chip.card = card; cdev->chip.usb_id = USB_ID(le16_to_cpu(usb_dev->descriptor.idVendor), le16_to_cpu(usb_dev->descriptor.idProduct)); spin_lock_init(&cdev->spinlock); *cardp = card; return 0; } static int init_card(struct snd_usb_caiaqdev *cdev) { char *c, usbpath[32]; struct usb_device *usb_dev = cdev->chip.dev; struct snd_card *card = cdev->chip.card; struct device *dev = caiaqdev_to_dev(cdev); int err, len; if (usb_set_interface(usb_dev, 0, 1) != 0) { dev_err(dev, "can't set alt interface.\n"); return -EIO; } usb_init_urb(&cdev->ep1_in_urb); usb_init_urb(&cdev->midi_out_urb); usb_fill_bulk_urb(&cdev->ep1_in_urb, usb_dev, usb_rcvbulkpipe(usb_dev, 0x1), cdev->ep1_in_buf, EP1_BUFSIZE, usb_ep1_command_reply_dispatch, cdev); usb_fill_bulk_urb(&cdev->midi_out_urb, usb_dev, usb_sndbulkpipe(usb_dev, 0x1), cdev->midi_out_buf, EP1_BUFSIZE, snd_usb_caiaq_midi_output_done, cdev); /* sanity checks of EPs before actually submitting */ if (usb_urb_ep_type_check(&cdev->ep1_in_urb) || usb_urb_ep_type_check(&cdev->midi_out_urb)) { dev_err(dev, "invalid EPs\n"); return -EINVAL; } init_waitqueue_head(&cdev->ep1_wait_queue); init_waitqueue_head(&cdev->prepare_wait_queue); if (usb_submit_urb(&cdev->ep1_in_urb, GFP_KERNEL) != 0) return -EIO; err = snd_usb_caiaq_send_command(cdev, EP1_CMD_GET_DEVICE_INFO, NULL, 0); if (err) goto err_kill_urb; if (!wait_event_timeout(cdev->ep1_wait_queue, cdev->spec_received, HZ)) { err = -ENODEV; goto err_kill_urb; } usb_string(usb_dev, usb_dev->descriptor.iManufacturer, cdev->vendor_name, CAIAQ_USB_STR_LEN); usb_string(usb_dev, usb_dev->descriptor.iProduct, cdev->product_name, CAIAQ_USB_STR_LEN); strscpy(card->driver, MODNAME, sizeof(card->driver)); strscpy(card->shortname, cdev->product_name, sizeof(card->shortname)); strscpy(card->mixername, cdev->product_name, sizeof(card->mixername)); /* if the id was not passed as module option, fill it with a shortened * version of the product string which does not contain any * whitespaces */ if (*card->id == '\0') { char id[sizeof(card->id)]; memset(id, 0, sizeof(id)); for (c = card->shortname, len = 0; *c && len < sizeof(card->id); c++) if (*c != ' ') id[len++] = *c; snd_card_set_id(card, id); } usb_make_path(usb_dev, usbpath, sizeof(usbpath)); scnprintf(card->longname, sizeof(card->longname), "%s %s (%s)", cdev->vendor_name, cdev->product_name, usbpath); setup_card(cdev); return 0; err_kill_urb: usb_kill_urb(&cdev->ep1_in_urb); return err; } static int snd_probe(struct usb_interface *intf, const struct usb_device_id *id) { int ret; struct snd_card *card = NULL; struct usb_device *usb_dev = interface_to_usbdev(intf); ret = create_card(usb_dev, intf, &card); if (ret < 0) return ret; usb_set_intfdata(intf, card); ret = init_card(caiaqdev(card)); if (ret < 0) { dev_err(&usb_dev->dev, "unable to init card! (ret=%d)\n", ret); snd_card_free(card); return ret; } return 0; } static void snd_disconnect(struct usb_interface *intf) { struct snd_card *card = usb_get_intfdata(intf); struct device *dev = intf->usb_dev; struct snd_usb_caiaqdev *cdev; if (!card) return; cdev = caiaqdev(card); dev_dbg(dev, "%s(%p)\n", __func__, intf); snd_card_disconnect(card); #ifdef CONFIG_SND_USB_CAIAQ_INPUT snd_usb_caiaq_input_free(cdev); #endif snd_usb_caiaq_audio_free(cdev); usb_kill_urb(&cdev->ep1_in_urb); usb_kill_urb(&cdev->midi_out_urb); snd_card_free(card); usb_reset_device(interface_to_usbdev(intf)); } MODULE_DEVICE_TABLE(usb, snd_usb_id_table); static struct usb_driver snd_usb_driver = { .name = MODNAME, .probe = snd_probe, .disconnect = snd_disconnect, .id_table = snd_usb_id_table, }; module_usb_driver(snd_usb_driver);
linux-master
sound/usb/caiaq/device.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (c) 2006-2008 Daniel Mack, Karsten Wiese */ #include <linux/device.h> #include <linux/spinlock.h> #include <linux/slab.h> #include <linux/init.h> #include <linux/usb.h> #include <sound/core.h> #include <sound/pcm.h> #include "device.h" #include "audio.h" #define N_URBS 32 #define CLOCK_DRIFT_TOLERANCE 5 #define FRAMES_PER_URB 8 #define BYTES_PER_FRAME 512 #define CHANNELS_PER_STREAM 2 #define BYTES_PER_SAMPLE 3 #define BYTES_PER_SAMPLE_USB 4 #define MAX_BUFFER_SIZE (128*1024) #define MAX_ENDPOINT_SIZE 512 #define ENDPOINT_CAPTURE 2 #define ENDPOINT_PLAYBACK 6 #define MAKE_CHECKBYTE(cdev,stream,i) \ (stream << 1) | (~(i / (cdev->n_streams * BYTES_PER_SAMPLE_USB)) & 1) static const struct snd_pcm_hardware snd_usb_caiaq_pcm_hardware = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER), .formats = SNDRV_PCM_FMTBIT_S24_3BE, .rates = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000), .rate_min = 44100, .rate_max = 0, /* will overwrite later */ .channels_min = CHANNELS_PER_STREAM, .channels_max = CHANNELS_PER_STREAM, .buffer_bytes_max = MAX_BUFFER_SIZE, .period_bytes_min = 128, .period_bytes_max = MAX_BUFFER_SIZE, .periods_min = 1, .periods_max = 1024, }; static void activate_substream(struct snd_usb_caiaqdev *cdev, struct snd_pcm_substream *sub) { spin_lock(&cdev->spinlock); if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) cdev->sub_playback[sub->number] = sub; else cdev->sub_capture[sub->number] = sub; spin_unlock(&cdev->spinlock); } static void deactivate_substream(struct snd_usb_caiaqdev *cdev, struct snd_pcm_substream *sub) { unsigned long flags; spin_lock_irqsave(&cdev->spinlock, flags); if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) cdev->sub_playback[sub->number] = NULL; else cdev->sub_capture[sub->number] = NULL; spin_unlock_irqrestore(&cdev->spinlock, flags); } static int all_substreams_zero(struct snd_pcm_substream **subs) { int i; for (i = 0; i < MAX_STREAMS; i++) if (subs[i] != NULL) return 0; return 1; } static int stream_start(struct snd_usb_caiaqdev *cdev) { int i, ret; struct device *dev = caiaqdev_to_dev(cdev); dev_dbg(dev, "%s(%p)\n", __func__, cdev); if (cdev->streaming) return -EINVAL; memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback)); memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture)); cdev->input_panic = 0; cdev->output_panic = 0; cdev->first_packet = 4; cdev->streaming = 1; cdev->warned = 0; for (i = 0; i < N_URBS; i++) { ret = usb_submit_urb(cdev->data_urbs_in[i], GFP_ATOMIC); if (ret) { dev_err(dev, "unable to trigger read #%d! (ret %d)\n", i, ret); cdev->streaming = 0; return -EPIPE; } } return 0; } static void stream_stop(struct snd_usb_caiaqdev *cdev) { int i; struct device *dev = caiaqdev_to_dev(cdev); dev_dbg(dev, "%s(%p)\n", __func__, cdev); if (!cdev->streaming) return; cdev->streaming = 0; for (i = 0; i < N_URBS; i++) { usb_kill_urb(cdev->data_urbs_in[i]); if (test_bit(i, &cdev->outurb_active_mask)) usb_kill_urb(cdev->data_urbs_out[i]); } cdev->outurb_active_mask = 0; } static int snd_usb_caiaq_substream_open(struct snd_pcm_substream *substream) { struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream); struct device *dev = caiaqdev_to_dev(cdev); dev_dbg(dev, "%s(%p)\n", __func__, substream); substream->runtime->hw = cdev->pcm_info; snd_pcm_limit_hw_rates(substream->runtime); return 0; } static int snd_usb_caiaq_substream_close(struct snd_pcm_substream *substream) { struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream); struct device *dev = caiaqdev_to_dev(cdev); dev_dbg(dev, "%s(%p)\n", __func__, substream); if (all_substreams_zero(cdev->sub_playback) && all_substreams_zero(cdev->sub_capture)) { /* when the last client has stopped streaming, * all sample rates are allowed again */ stream_stop(cdev); cdev->pcm_info.rates = cdev->samplerates; } return 0; } static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream *sub) { struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub); deactivate_substream(cdev, sub); return 0; } /* this should probably go upstream */ #if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12 #error "Change this table" #endif static const unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000, 88200, 96000, 176400, 192000 }; static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream) { int bytes_per_sample, bpp, ret, i; int index = substream->number; struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; struct device *dev = caiaqdev_to_dev(cdev); dev_dbg(dev, "%s(%p)\n", __func__, substream); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { int out_pos; switch (cdev->spec.data_alignment) { case 0: case 2: out_pos = BYTES_PER_SAMPLE + 1; break; case 3: default: out_pos = 0; break; } cdev->period_out_count[index] = out_pos; cdev->audio_out_buf_pos[index] = out_pos; } else { int in_pos; switch (cdev->spec.data_alignment) { case 0: in_pos = BYTES_PER_SAMPLE + 2; break; case 2: in_pos = BYTES_PER_SAMPLE; break; case 3: default: in_pos = 0; break; } cdev->period_in_count[index] = in_pos; cdev->audio_in_buf_pos[index] = in_pos; } if (cdev->streaming) return 0; /* the first client that opens a stream defines the sample rate * setting for all subsequent calls, until the last client closed. */ for (i=0; i < ARRAY_SIZE(rates); i++) if (runtime->rate == rates[i]) cdev->pcm_info.rates = 1 << i; snd_pcm_limit_hw_rates(runtime); bytes_per_sample = BYTES_PER_SAMPLE; if (cdev->spec.data_alignment >= 2) bytes_per_sample++; bpp = ((runtime->rate / 8000) + CLOCK_DRIFT_TOLERANCE) * bytes_per_sample * CHANNELS_PER_STREAM * cdev->n_streams; if (bpp > MAX_ENDPOINT_SIZE) bpp = MAX_ENDPOINT_SIZE; ret = snd_usb_caiaq_set_audio_params(cdev, runtime->rate, runtime->sample_bits, bpp); if (ret) return ret; ret = stream_start(cdev); if (ret) return ret; cdev->output_running = 0; wait_event_timeout(cdev->prepare_wait_queue, cdev->output_running, HZ); if (!cdev->output_running) { stream_stop(cdev); return -EPIPE; } return 0; } static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream *sub, int cmd) { struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub); struct device *dev = caiaqdev_to_dev(cdev); dev_dbg(dev, "%s(%p) cmd %d\n", __func__, sub, cmd); switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: activate_substream(cdev, sub); break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: deactivate_substream(cdev, sub); break; default: return -EINVAL; } return 0; } static snd_pcm_uframes_t snd_usb_caiaq_pcm_pointer(struct snd_pcm_substream *sub) { int index = sub->number; struct snd_usb_caiaqdev *cdev = snd_pcm_substream_chip(sub); snd_pcm_uframes_t ptr; spin_lock(&cdev->spinlock); if (cdev->input_panic || cdev->output_panic) { ptr = SNDRV_PCM_POS_XRUN; goto unlock; } if (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) ptr = bytes_to_frames(sub->runtime, cdev->audio_out_buf_pos[index]); else ptr = bytes_to_frames(sub->runtime, cdev->audio_in_buf_pos[index]); unlock: spin_unlock(&cdev->spinlock); return ptr; } /* operators for both playback and capture */ static const struct snd_pcm_ops snd_usb_caiaq_ops = { .open = snd_usb_caiaq_substream_open, .close = snd_usb_caiaq_substream_close, .hw_free = snd_usb_caiaq_pcm_hw_free, .prepare = snd_usb_caiaq_pcm_prepare, .trigger = snd_usb_caiaq_pcm_trigger, .pointer = snd_usb_caiaq_pcm_pointer, }; static void check_for_elapsed_periods(struct snd_usb_caiaqdev *cdev, struct snd_pcm_substream **subs) { int stream, pb, *cnt; struct snd_pcm_substream *sub; for (stream = 0; stream < cdev->n_streams; stream++) { sub = subs[stream]; if (!sub) continue; pb = snd_pcm_lib_period_bytes(sub); cnt = (sub->stream == SNDRV_PCM_STREAM_PLAYBACK) ? &cdev->period_out_count[stream] : &cdev->period_in_count[stream]; if (*cnt >= pb) { snd_pcm_period_elapsed(sub); *cnt %= pb; } } } static void read_in_urb_mode0(struct snd_usb_caiaqdev *cdev, const struct urb *urb, const struct usb_iso_packet_descriptor *iso) { unsigned char *usb_buf = urb->transfer_buffer + iso->offset; struct snd_pcm_substream *sub; int stream, i; if (all_substreams_zero(cdev->sub_capture)) return; for (i = 0; i < iso->actual_length;) { for (stream = 0; stream < cdev->n_streams; stream++, i++) { sub = cdev->sub_capture[stream]; if (sub) { struct snd_pcm_runtime *rt = sub->runtime; char *audio_buf = rt->dma_area; int sz = frames_to_bytes(rt, rt->buffer_size); audio_buf[cdev->audio_in_buf_pos[stream]++] = usb_buf[i]; cdev->period_in_count[stream]++; if (cdev->audio_in_buf_pos[stream] == sz) cdev->audio_in_buf_pos[stream] = 0; } } } } static void read_in_urb_mode2(struct snd_usb_caiaqdev *cdev, const struct urb *urb, const struct usb_iso_packet_descriptor *iso) { unsigned char *usb_buf = urb->transfer_buffer + iso->offset; unsigned char check_byte; struct snd_pcm_substream *sub; int stream, i; for (i = 0; i < iso->actual_length;) { if (i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) == 0) { for (stream = 0; stream < cdev->n_streams; stream++, i++) { if (cdev->first_packet) continue; check_byte = MAKE_CHECKBYTE(cdev, stream, i); if ((usb_buf[i] & 0x3f) != check_byte) cdev->input_panic = 1; if (usb_buf[i] & 0x80) cdev->output_panic = 1; } } cdev->first_packet = 0; for (stream = 0; stream < cdev->n_streams; stream++, i++) { sub = cdev->sub_capture[stream]; if (cdev->input_panic) usb_buf[i] = 0; if (sub) { struct snd_pcm_runtime *rt = sub->runtime; char *audio_buf = rt->dma_area; int sz = frames_to_bytes(rt, rt->buffer_size); audio_buf[cdev->audio_in_buf_pos[stream]++] = usb_buf[i]; cdev->period_in_count[stream]++; if (cdev->audio_in_buf_pos[stream] == sz) cdev->audio_in_buf_pos[stream] = 0; } } } } static void read_in_urb_mode3(struct snd_usb_caiaqdev *cdev, const struct urb *urb, const struct usb_iso_packet_descriptor *iso) { unsigned char *usb_buf = urb->transfer_buffer + iso->offset; struct device *dev = caiaqdev_to_dev(cdev); int stream, i; /* paranoia check */ if (iso->actual_length % (BYTES_PER_SAMPLE_USB * CHANNELS_PER_STREAM)) return; for (i = 0; i < iso->actual_length;) { for (stream = 0; stream < cdev->n_streams; stream++) { struct snd_pcm_substream *sub = cdev->sub_capture[stream]; char *audio_buf = NULL; int c, n, sz = 0; if (sub && !cdev->input_panic) { struct snd_pcm_runtime *rt = sub->runtime; audio_buf = rt->dma_area; sz = frames_to_bytes(rt, rt->buffer_size); } for (c = 0; c < CHANNELS_PER_STREAM; c++) { /* 3 audio data bytes, followed by 1 check byte */ if (audio_buf) { for (n = 0; n < BYTES_PER_SAMPLE; n++) { audio_buf[cdev->audio_in_buf_pos[stream]++] = usb_buf[i+n]; if (cdev->audio_in_buf_pos[stream] == sz) cdev->audio_in_buf_pos[stream] = 0; } cdev->period_in_count[stream] += BYTES_PER_SAMPLE; } i += BYTES_PER_SAMPLE; if (usb_buf[i] != ((stream << 1) | c) && !cdev->first_packet) { if (!cdev->input_panic) dev_warn(dev, " EXPECTED: %02x got %02x, c %d, stream %d, i %d\n", ((stream << 1) | c), usb_buf[i], c, stream, i); cdev->input_panic = 1; } i++; } } } if (cdev->first_packet > 0) cdev->first_packet--; } static void read_in_urb(struct snd_usb_caiaqdev *cdev, const struct urb *urb, const struct usb_iso_packet_descriptor *iso) { struct device *dev = caiaqdev_to_dev(cdev); if (!cdev->streaming) return; if (iso->actual_length < cdev->bpp) return; switch (cdev->spec.data_alignment) { case 0: read_in_urb_mode0(cdev, urb, iso); break; case 2: read_in_urb_mode2(cdev, urb, iso); break; case 3: read_in_urb_mode3(cdev, urb, iso); break; } if ((cdev->input_panic || cdev->output_panic) && !cdev->warned) { dev_warn(dev, "streaming error detected %s %s\n", cdev->input_panic ? "(input)" : "", cdev->output_panic ? "(output)" : ""); cdev->warned = 1; } } static void fill_out_urb_mode_0(struct snd_usb_caiaqdev *cdev, struct urb *urb, const struct usb_iso_packet_descriptor *iso) { unsigned char *usb_buf = urb->transfer_buffer + iso->offset; struct snd_pcm_substream *sub; int stream, i; for (i = 0; i < iso->length;) { for (stream = 0; stream < cdev->n_streams; stream++, i++) { sub = cdev->sub_playback[stream]; if (sub) { struct snd_pcm_runtime *rt = sub->runtime; char *audio_buf = rt->dma_area; int sz = frames_to_bytes(rt, rt->buffer_size); usb_buf[i] = audio_buf[cdev->audio_out_buf_pos[stream]]; cdev->period_out_count[stream]++; cdev->audio_out_buf_pos[stream]++; if (cdev->audio_out_buf_pos[stream] == sz) cdev->audio_out_buf_pos[stream] = 0; } else usb_buf[i] = 0; } /* fill in the check bytes */ if (cdev->spec.data_alignment == 2 && i % (cdev->n_streams * BYTES_PER_SAMPLE_USB) == (cdev->n_streams * CHANNELS_PER_STREAM)) for (stream = 0; stream < cdev->n_streams; stream++, i++) usb_buf[i] = MAKE_CHECKBYTE(cdev, stream, i); } } static void fill_out_urb_mode_3(struct snd_usb_caiaqdev *cdev, struct urb *urb, const struct usb_iso_packet_descriptor *iso) { unsigned char *usb_buf = urb->transfer_buffer + iso->offset; int stream, i; for (i = 0; i < iso->length;) { for (stream = 0; stream < cdev->n_streams; stream++) { struct snd_pcm_substream *sub = cdev->sub_playback[stream]; char *audio_buf = NULL; int c, n, sz = 0; if (sub) { struct snd_pcm_runtime *rt = sub->runtime; audio_buf = rt->dma_area; sz = frames_to_bytes(rt, rt->buffer_size); } for (c = 0; c < CHANNELS_PER_STREAM; c++) { for (n = 0; n < BYTES_PER_SAMPLE; n++) { if (audio_buf) { usb_buf[i+n] = audio_buf[cdev->audio_out_buf_pos[stream]++]; if (cdev->audio_out_buf_pos[stream] == sz) cdev->audio_out_buf_pos[stream] = 0; } else { usb_buf[i+n] = 0; } } if (audio_buf) cdev->period_out_count[stream] += BYTES_PER_SAMPLE; i += BYTES_PER_SAMPLE; /* fill in the check byte pattern */ usb_buf[i++] = (stream << 1) | c; } } } } static inline void fill_out_urb(struct snd_usb_caiaqdev *cdev, struct urb *urb, const struct usb_iso_packet_descriptor *iso) { switch (cdev->spec.data_alignment) { case 0: case 2: fill_out_urb_mode_0(cdev, urb, iso); break; case 3: fill_out_urb_mode_3(cdev, urb, iso); break; } } static void read_completed(struct urb *urb) { struct snd_usb_caiaq_cb_info *info = urb->context; struct snd_usb_caiaqdev *cdev; struct device *dev; struct urb *out = NULL; int i, frame, len, send_it = 0, outframe = 0; unsigned long flags; size_t offset = 0; if (urb->status || !info) return; cdev = info->cdev; dev = caiaqdev_to_dev(cdev); if (!cdev->streaming) return; /* find an unused output urb that is unused */ for (i = 0; i < N_URBS; i++) if (test_and_set_bit(i, &cdev->outurb_active_mask) == 0) { out = cdev->data_urbs_out[i]; break; } if (!out) { dev_err(dev, "Unable to find an output urb to use\n"); goto requeue; } /* read the recently received packet and send back one which has * the same layout */ for (frame = 0; frame < FRAMES_PER_URB; frame++) { if (urb->iso_frame_desc[frame].status) continue; len = urb->iso_frame_desc[outframe].actual_length; out->iso_frame_desc[outframe].length = len; out->iso_frame_desc[outframe].actual_length = 0; out->iso_frame_desc[outframe].offset = offset; offset += len; if (len > 0) { spin_lock_irqsave(&cdev->spinlock, flags); fill_out_urb(cdev, out, &out->iso_frame_desc[outframe]); read_in_urb(cdev, urb, &urb->iso_frame_desc[frame]); spin_unlock_irqrestore(&cdev->spinlock, flags); check_for_elapsed_periods(cdev, cdev->sub_playback); check_for_elapsed_periods(cdev, cdev->sub_capture); send_it = 1; } outframe++; } if (send_it) { out->number_of_packets = outframe; usb_submit_urb(out, GFP_ATOMIC); } else { struct snd_usb_caiaq_cb_info *oinfo = out->context; clear_bit(oinfo->index, &cdev->outurb_active_mask); } requeue: /* re-submit inbound urb */ for (frame = 0; frame < FRAMES_PER_URB; frame++) { urb->iso_frame_desc[frame].offset = BYTES_PER_FRAME * frame; urb->iso_frame_desc[frame].length = BYTES_PER_FRAME; urb->iso_frame_desc[frame].actual_length = 0; } urb->number_of_packets = FRAMES_PER_URB; usb_submit_urb(urb, GFP_ATOMIC); } static void write_completed(struct urb *urb) { struct snd_usb_caiaq_cb_info *info = urb->context; struct snd_usb_caiaqdev *cdev = info->cdev; if (!cdev->output_running) { cdev->output_running = 1; wake_up(&cdev->prepare_wait_queue); } clear_bit(info->index, &cdev->outurb_active_mask); } static struct urb **alloc_urbs(struct snd_usb_caiaqdev *cdev, int dir, int *ret) { int i, frame; struct urb **urbs; struct usb_device *usb_dev = cdev->chip.dev; unsigned int pipe; pipe = (dir == SNDRV_PCM_STREAM_PLAYBACK) ? usb_sndisocpipe(usb_dev, ENDPOINT_PLAYBACK) : usb_rcvisocpipe(usb_dev, ENDPOINT_CAPTURE); urbs = kmalloc_array(N_URBS, sizeof(*urbs), GFP_KERNEL); if (!urbs) { *ret = -ENOMEM; return NULL; } for (i = 0; i < N_URBS; i++) { urbs[i] = usb_alloc_urb(FRAMES_PER_URB, GFP_KERNEL); if (!urbs[i]) { *ret = -ENOMEM; return urbs; } urbs[i]->transfer_buffer = kmalloc_array(BYTES_PER_FRAME, FRAMES_PER_URB, GFP_KERNEL); if (!urbs[i]->transfer_buffer) { *ret = -ENOMEM; return urbs; } for (frame = 0; frame < FRAMES_PER_URB; frame++) { struct usb_iso_packet_descriptor *iso = &urbs[i]->iso_frame_desc[frame]; iso->offset = BYTES_PER_FRAME * frame; iso->length = BYTES_PER_FRAME; } urbs[i]->dev = usb_dev; urbs[i]->pipe = pipe; urbs[i]->transfer_buffer_length = FRAMES_PER_URB * BYTES_PER_FRAME; urbs[i]->context = &cdev->data_cb_info[i]; urbs[i]->interval = 1; urbs[i]->number_of_packets = FRAMES_PER_URB; urbs[i]->complete = (dir == SNDRV_PCM_STREAM_CAPTURE) ? read_completed : write_completed; } *ret = 0; return urbs; } static void free_urbs(struct urb **urbs) { int i; if (!urbs) return; for (i = 0; i < N_URBS; i++) { if (!urbs[i]) continue; usb_kill_urb(urbs[i]); kfree(urbs[i]->transfer_buffer); usb_free_urb(urbs[i]); } kfree(urbs); } int snd_usb_caiaq_audio_init(struct snd_usb_caiaqdev *cdev) { int i, ret; struct device *dev = caiaqdev_to_dev(cdev); cdev->n_audio_in = max(cdev->spec.num_analog_audio_in, cdev->spec.num_digital_audio_in) / CHANNELS_PER_STREAM; cdev->n_audio_out = max(cdev->spec.num_analog_audio_out, cdev->spec.num_digital_audio_out) / CHANNELS_PER_STREAM; cdev->n_streams = max(cdev->n_audio_in, cdev->n_audio_out); dev_dbg(dev, "cdev->n_audio_in = %d\n", cdev->n_audio_in); dev_dbg(dev, "cdev->n_audio_out = %d\n", cdev->n_audio_out); dev_dbg(dev, "cdev->n_streams = %d\n", cdev->n_streams); if (cdev->n_streams > MAX_STREAMS) { dev_err(dev, "unable to initialize device, too many streams.\n"); return -EINVAL; } if (cdev->n_streams < 1) { dev_err(dev, "bogus number of streams: %d\n", cdev->n_streams); return -EINVAL; } ret = snd_pcm_new(cdev->chip.card, cdev->product_name, 0, cdev->n_audio_out, cdev->n_audio_in, &cdev->pcm); if (ret < 0) { dev_err(dev, "snd_pcm_new() returned %d\n", ret); return ret; } cdev->pcm->private_data = cdev; strscpy(cdev->pcm->name, cdev->product_name, sizeof(cdev->pcm->name)); memset(cdev->sub_playback, 0, sizeof(cdev->sub_playback)); memset(cdev->sub_capture, 0, sizeof(cdev->sub_capture)); memcpy(&cdev->pcm_info, &snd_usb_caiaq_pcm_hardware, sizeof(snd_usb_caiaq_pcm_hardware)); /* setup samplerates */ cdev->samplerates = cdev->pcm_info.rates; switch (cdev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_SESSIONIO): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_GUITARRIGMOBILE): cdev->samplerates |= SNDRV_PCM_RATE_192000; fallthrough; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO2DJ): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO4DJ): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AUDIO8DJ): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORAUDIO2): cdev->samplerates |= SNDRV_PCM_RATE_88200; break; } snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usb_caiaq_ops); snd_pcm_set_ops(cdev->pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usb_caiaq_ops); snd_pcm_set_managed_buffer_all(cdev->pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0); cdev->data_cb_info = kmalloc_array(N_URBS, sizeof(struct snd_usb_caiaq_cb_info), GFP_KERNEL); if (!cdev->data_cb_info) return -ENOMEM; cdev->outurb_active_mask = 0; BUILD_BUG_ON(N_URBS > (sizeof(cdev->outurb_active_mask) * 8)); for (i = 0; i < N_URBS; i++) { cdev->data_cb_info[i].cdev = cdev; cdev->data_cb_info[i].index = i; } cdev->data_urbs_in = alloc_urbs(cdev, SNDRV_PCM_STREAM_CAPTURE, &ret); if (ret < 0) { kfree(cdev->data_cb_info); free_urbs(cdev->data_urbs_in); return ret; } cdev->data_urbs_out = alloc_urbs(cdev, SNDRV_PCM_STREAM_PLAYBACK, &ret); if (ret < 0) { kfree(cdev->data_cb_info); free_urbs(cdev->data_urbs_in); free_urbs(cdev->data_urbs_out); return ret; } return 0; } void snd_usb_caiaq_audio_free(struct snd_usb_caiaqdev *cdev) { struct device *dev = caiaqdev_to_dev(cdev); dev_dbg(dev, "%s(%p)\n", __func__, cdev); stream_stop(cdev); free_urbs(cdev->data_urbs_in); free_urbs(cdev->data_urbs_out); kfree(cdev->data_cb_info); }
linux-master
sound/usb/caiaq/audio.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux driver for M2Tech hiFace compatible devices * * Copyright 2012-2013 (C) M2TECH S.r.l and Amarula Solutions B.V. * * Authors: Michael Trimarchi <[email protected]> * Antonio Ospite <[email protected]> * * The driver is based on the work done in TerraTec DMX 6Fire USB */ #include <linux/module.h> #include <linux/slab.h> #include <sound/initval.h> #include "chip.h" #include "pcm.h" MODULE_AUTHOR("Michael Trimarchi <[email protected]>"); MODULE_AUTHOR("Antonio Ospite <[email protected]>"); MODULE_DESCRIPTION("M2Tech hiFace USB-SPDIF audio driver"); MODULE_LICENSE("GPL v2"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ #define DRIVER_NAME "snd-usb-hiface" #define CARD_NAME "hiFace" module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard."); static DEFINE_MUTEX(register_mutex); struct hiface_vendor_quirk { const char *device_name; u8 extra_freq; }; static int hiface_chip_create(struct usb_interface *intf, struct usb_device *device, int idx, const struct hiface_vendor_quirk *quirk, struct hiface_chip **rchip) { struct snd_card *card = NULL; struct hiface_chip *chip; int ret; int len; *rchip = NULL; /* if we are here, card can be registered in alsa. */ ret = snd_card_new(&intf->dev, index[idx], id[idx], THIS_MODULE, sizeof(*chip), &card); if (ret < 0) { dev_err(&device->dev, "cannot create alsa card.\n"); return ret; } strscpy(card->driver, DRIVER_NAME, sizeof(card->driver)); if (quirk && quirk->device_name) strscpy(card->shortname, quirk->device_name, sizeof(card->shortname)); else strscpy(card->shortname, "M2Tech generic audio", sizeof(card->shortname)); strlcat(card->longname, card->shortname, sizeof(card->longname)); len = strlcat(card->longname, " at ", sizeof(card->longname)); if (len < sizeof(card->longname)) usb_make_path(device, card->longname + len, sizeof(card->longname) - len); chip = card->private_data; chip->dev = device; chip->card = card; *rchip = chip; return 0; } static int hiface_chip_probe(struct usb_interface *intf, const struct usb_device_id *usb_id) { const struct hiface_vendor_quirk *quirk = (struct hiface_vendor_quirk *)usb_id->driver_info; int ret; int i; struct hiface_chip *chip; struct usb_device *device = interface_to_usbdev(intf); ret = usb_set_interface(device, 0, 0); if (ret != 0) { dev_err(&device->dev, "can't set first interface for " CARD_NAME " device.\n"); return -EIO; } /* check whether the card is already registered */ chip = NULL; mutex_lock(&register_mutex); for (i = 0; i < SNDRV_CARDS; i++) if (enable[i]) break; if (i >= SNDRV_CARDS) { dev_err(&device->dev, "no available " CARD_NAME " audio device\n"); ret = -ENODEV; goto err; } ret = hiface_chip_create(intf, device, i, quirk, &chip); if (ret < 0) goto err; ret = hiface_pcm_init(chip, quirk ? quirk->extra_freq : 0); if (ret < 0) goto err_chip_destroy; ret = snd_card_register(chip->card); if (ret < 0) { dev_err(&device->dev, "cannot register " CARD_NAME " card\n"); goto err_chip_destroy; } mutex_unlock(&register_mutex); usb_set_intfdata(intf, chip); return 0; err_chip_destroy: snd_card_free(chip->card); err: mutex_unlock(&register_mutex); return ret; } static void hiface_chip_disconnect(struct usb_interface *intf) { struct hiface_chip *chip; struct snd_card *card; chip = usb_get_intfdata(intf); if (!chip) return; card = chip->card; /* Make sure that the userspace cannot create new request */ snd_card_disconnect(card); hiface_pcm_abort(chip); snd_card_free_when_closed(card); } static const struct usb_device_id device_table[] = { { USB_DEVICE(0x04b4, 0x0384), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Young", .extra_freq = 1, } }, { USB_DEVICE(0x04b4, 0x930b), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "hiFace", } }, { USB_DEVICE(0x04b4, 0x931b), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "North Star", } }, { USB_DEVICE(0x04b4, 0x931c), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "W4S Young", } }, { USB_DEVICE(0x04b4, 0x931d), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Corrson", } }, { USB_DEVICE(0x04b4, 0x931e), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "AUDIA", } }, { USB_DEVICE(0x04b4, 0x931f), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "SL Audio", } }, { USB_DEVICE(0x04b4, 0x9320), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Empirical", } }, { USB_DEVICE(0x04b4, 0x9321), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Rockna", } }, { USB_DEVICE(0x249c, 0x9001), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Pathos", } }, { USB_DEVICE(0x249c, 0x9002), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Metronome", } }, { USB_DEVICE(0x249c, 0x9006), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "CAD", } }, { USB_DEVICE(0x249c, 0x9008), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Audio Esclusive", } }, { USB_DEVICE(0x249c, 0x931c), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Rotel", } }, { USB_DEVICE(0x249c, 0x932c), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Eeaudio", } }, { USB_DEVICE(0x245f, 0x931c), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "CHORD", } }, { USB_DEVICE(0x25c6, 0x9002), .driver_info = (unsigned long)&(const struct hiface_vendor_quirk) { .device_name = "Vitus", } }, {} }; MODULE_DEVICE_TABLE(usb, device_table); static struct usb_driver hiface_usb_driver = { .name = DRIVER_NAME, .probe = hiface_chip_probe, .disconnect = hiface_chip_disconnect, .id_table = device_table, }; module_usb_driver(hiface_usb_driver);
linux-master
sound/usb/hiface/chip.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Linux driver for M2Tech hiFace compatible devices * * Copyright 2012-2013 (C) M2TECH S.r.l and Amarula Solutions B.V. * * Authors: Michael Trimarchi <[email protected]> * Antonio Ospite <[email protected]> * * The driver is based on the work done in TerraTec DMX 6Fire USB */ #include <linux/slab.h> #include <sound/pcm.h> #include "pcm.h" #include "chip.h" #define OUT_EP 0x2 #define PCM_N_URBS 8 #define PCM_PACKET_SIZE 4096 #define PCM_BUFFER_SIZE (2 * PCM_N_URBS * PCM_PACKET_SIZE) struct pcm_urb { struct hiface_chip *chip; struct urb instance; struct usb_anchor submitted; u8 *buffer; }; struct pcm_substream { spinlock_t lock; struct snd_pcm_substream *instance; bool active; snd_pcm_uframes_t dma_off; /* current position in alsa dma_area */ snd_pcm_uframes_t period_off; /* current position in current period */ }; 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 }; struct pcm_runtime { struct hiface_chip *chip; struct snd_pcm *instance; struct pcm_substream playback; bool panic; /* if set driver won't do anymore pcm on device */ struct pcm_urb out_urbs[PCM_N_URBS]; struct mutex stream_mutex; u8 stream_state; /* one of STREAM_XXX */ u8 extra_freq; wait_queue_head_t stream_wait_queue; bool stream_wait_cond; }; static const unsigned int rates[] = { 44100, 48000, 88200, 96000, 176400, 192000, 352800, 384000 }; static const struct snd_pcm_hw_constraint_list constraints_extra_rates = { .count = ARRAY_SIZE(rates), .list = rates, .mask = 0, }; 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_PAUSE | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BATCH, .formats = 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, /* changes in hiface_pcm_open to support extra rates */ .channels_min = 2, .channels_max = 2, .buffer_bytes_max = PCM_BUFFER_SIZE, .period_bytes_min = PCM_PACKET_SIZE, .period_bytes_max = PCM_BUFFER_SIZE, .periods_min = 2, .periods_max = 1024 }; /* message values used to change the sample rate */ #define HIFACE_SET_RATE_REQUEST 0xb0 #define HIFACE_RATE_44100 0x43 #define HIFACE_RATE_48000 0x4b #define HIFACE_RATE_88200 0x42 #define HIFACE_RATE_96000 0x4a #define HIFACE_RATE_176400 0x40 #define HIFACE_RATE_192000 0x48 #define HIFACE_RATE_352800 0x58 #define HIFACE_RATE_384000 0x68 static int hiface_pcm_set_rate(struct pcm_runtime *rt, unsigned int rate) { struct usb_device *device = rt->chip->dev; u16 rate_value; int ret; /* We are already sure that the rate is supported here thanks to * ALSA constraints */ switch (rate) { case 44100: rate_value = HIFACE_RATE_44100; break; case 48000: rate_value = HIFACE_RATE_48000; break; case 88200: rate_value = HIFACE_RATE_88200; break; case 96000: rate_value = HIFACE_RATE_96000; break; case 176400: rate_value = HIFACE_RATE_176400; break; case 192000: rate_value = HIFACE_RATE_192000; break; case 352800: rate_value = HIFACE_RATE_352800; break; case 384000: rate_value = HIFACE_RATE_384000; break; default: dev_err(&device->dev, "Unsupported rate %d\n", rate); return -EINVAL; } /* * USBIO: Vendor 0xb0(wValue=0x0043, wIndex=0x0000) * 43 b0 43 00 00 00 00 00 * USBIO: Vendor 0xb0(wValue=0x004b, wIndex=0x0000) * 43 b0 4b 00 00 00 00 00 * This control message doesn't have any ack from the * other side */ ret = usb_control_msg_send(device, 0, HIFACE_SET_RATE_REQUEST, USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER, rate_value, 0, NULL, 0, 100, GFP_KERNEL); if (ret) dev_err(&device->dev, "Error setting samplerate %d.\n", rate); return ret; } static struct pcm_substream *hiface_pcm_get_substream(struct snd_pcm_substream *alsa_sub) { struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub); struct device *device = &rt->chip->dev->dev; if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK) return &rt->playback; dev_err(device, "Error getting pcm substream slot.\n"); return NULL; } /* call with stream_mutex locked */ static void hiface_pcm_stream_stop(struct pcm_runtime *rt) { int i, time; if (rt->stream_state != STREAM_DISABLED) { rt->stream_state = STREAM_STOPPING; for (i = 0; i < PCM_N_URBS; i++) { time = usb_wait_anchor_empty_timeout( &rt->out_urbs[i].submitted, 100); if (!time) usb_kill_anchored_urbs( &rt->out_urbs[i].submitted); usb_kill_urb(&rt->out_urbs[i].instance); } rt->stream_state = STREAM_DISABLED; } } /* call with stream_mutex locked */ static int hiface_pcm_stream_start(struct pcm_runtime *rt) { int ret = 0; int i; if (rt->stream_state == STREAM_DISABLED) { /* reset panic state when starting a new stream */ rt->panic = false; /* submit our out urbs zero init */ rt->stream_state = STREAM_STARTING; for (i = 0; i < PCM_N_URBS; i++) { memset(rt->out_urbs[i].buffer, 0, PCM_PACKET_SIZE); usb_anchor_urb(&rt->out_urbs[i].instance, &rt->out_urbs[i].submitted); ret = usb_submit_urb(&rt->out_urbs[i].instance, GFP_ATOMIC); if (ret) { hiface_pcm_stream_stop(rt); return ret; } } /* wait for first out urb to return (sent in urb handler) */ wait_event_timeout(rt->stream_wait_queue, rt->stream_wait_cond, HZ); if (rt->stream_wait_cond) { struct device *device = &rt->chip->dev->dev; dev_dbg(device, "%s: Stream is running wakeup event\n", __func__); rt->stream_state = STREAM_RUNNING; } else { hiface_pcm_stream_stop(rt); return -EIO; } } return ret; } /* The hardware wants word-swapped 32-bit values */ static void memcpy_swahw32(u8 *dest, u8 *src, unsigned int n) { unsigned int i; for (i = 0; i < n / 4; i++) ((u32 *)dest)[i] = swahw32(((u32 *)src)[i]); } /* call with substream locked */ /* returns true if a period elapsed */ static bool hiface_pcm_playback(struct pcm_substream *sub, struct pcm_urb *urb) { struct snd_pcm_runtime *alsa_rt = sub->instance->runtime; struct device *device = &urb->chip->dev->dev; u8 *source; unsigned int pcm_buffer_size; WARN_ON(alsa_rt->format != SNDRV_PCM_FORMAT_S32_LE); pcm_buffer_size = snd_pcm_lib_buffer_bytes(sub->instance); if (sub->dma_off + PCM_PACKET_SIZE <= pcm_buffer_size) { dev_dbg(device, "%s: (1) buffer_size %#x dma_offset %#x\n", __func__, (unsigned int) pcm_buffer_size, (unsigned int) sub->dma_off); source = alsa_rt->dma_area + sub->dma_off; memcpy_swahw32(urb->buffer, source, PCM_PACKET_SIZE); } else { /* wrap around at end of ring buffer */ unsigned int len; dev_dbg(device, "%s: (2) buffer_size %#x dma_offset %#x\n", __func__, (unsigned int) pcm_buffer_size, (unsigned int) sub->dma_off); len = pcm_buffer_size - sub->dma_off; source = alsa_rt->dma_area + sub->dma_off; memcpy_swahw32(urb->buffer, source, len); source = alsa_rt->dma_area; memcpy_swahw32(urb->buffer + len, source, PCM_PACKET_SIZE - len); } sub->dma_off += PCM_PACKET_SIZE; if (sub->dma_off >= pcm_buffer_size) sub->dma_off -= pcm_buffer_size; sub->period_off += PCM_PACKET_SIZE; if (sub->period_off >= alsa_rt->period_size) { sub->period_off %= alsa_rt->period_size; return true; } return false; } static void hiface_pcm_out_urb_handler(struct urb *usb_urb) { struct pcm_urb *out_urb = usb_urb->context; struct pcm_runtime *rt = out_urb->chip->pcm; struct pcm_substream *sub; bool do_period_elapsed = false; unsigned long flags; int ret; if (rt->panic || rt->stream_state == STREAM_STOPPING) return; if (unlikely(usb_urb->status == -ENOENT || /* unlinked */ usb_urb->status == -ENODEV || /* device removed */ usb_urb->status == -ECONNRESET || /* unlinked */ usb_urb->status == -ESHUTDOWN)) { /* device disabled */ goto out_fail; } if (rt->stream_state == STREAM_STARTING) { rt->stream_wait_cond = true; wake_up(&rt->stream_wait_queue); } /* now send our playback data (if a free out urb was found) */ sub = &rt->playback; spin_lock_irqsave(&sub->lock, flags); if (sub->active) do_period_elapsed = hiface_pcm_playback(sub, out_urb); else memset(out_urb->buffer, 0, PCM_PACKET_SIZE); spin_unlock_irqrestore(&sub->lock, flags); if (do_period_elapsed) snd_pcm_period_elapsed(sub->instance); ret = usb_submit_urb(&out_urb->instance, GFP_ATOMIC); if (ret < 0) goto out_fail; return; out_fail: rt->panic = true; } static int hiface_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; int ret; if (rt->panic) return -EPIPE; mutex_lock(&rt->stream_mutex); alsa_rt->hw = pcm_hw; if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK) sub = &rt->playback; if (!sub) { struct device *device = &rt->chip->dev->dev; mutex_unlock(&rt->stream_mutex); dev_err(device, "Invalid stream type\n"); return -EINVAL; } if (rt->extra_freq) { alsa_rt->hw.rates |= SNDRV_PCM_RATE_KNOT; alsa_rt->hw.rate_max = 384000; /* explicit constraints needed as we added SNDRV_PCM_RATE_KNOT */ ret = snd_pcm_hw_constraint_list(alsa_sub->runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &constraints_extra_rates); if (ret < 0) { mutex_unlock(&rt->stream_mutex); return ret; } } sub->instance = alsa_sub; sub->active = false; mutex_unlock(&rt->stream_mutex); return 0; } static int hiface_pcm_close(struct snd_pcm_substream *alsa_sub) { struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub); struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub); unsigned long flags; if (rt->panic) return 0; mutex_lock(&rt->stream_mutex); if (sub) { hiface_pcm_stream_stop(rt); /* deactivate substream */ spin_lock_irqsave(&sub->lock, flags); sub->instance = NULL; sub->active = false; spin_unlock_irqrestore(&sub->lock, flags); } mutex_unlock(&rt->stream_mutex); return 0; } static int hiface_pcm_prepare(struct snd_pcm_substream *alsa_sub) { struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub); struct pcm_substream *sub = hiface_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); hiface_pcm_stream_stop(rt); sub->dma_off = 0; sub->period_off = 0; if (rt->stream_state == STREAM_DISABLED) { ret = hiface_pcm_set_rate(rt, alsa_rt->rate); if (ret) { mutex_unlock(&rt->stream_mutex); return ret; } ret = hiface_pcm_stream_start(rt); if (ret) { mutex_unlock(&rt->stream_mutex); return ret; } } mutex_unlock(&rt->stream_mutex); return 0; } static int hiface_pcm_trigger(struct snd_pcm_substream *alsa_sub, int cmd) { struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub); struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub); if (rt->panic) return -EPIPE; if (!sub) return -ENODEV; switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: spin_lock_irq(&sub->lock); sub->active = true; spin_unlock_irq(&sub->lock); return 0; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: spin_lock_irq(&sub->lock); sub->active = false; spin_unlock_irq(&sub->lock); return 0; default: return -EINVAL; } } static snd_pcm_uframes_t hiface_pcm_pointer(struct snd_pcm_substream *alsa_sub) { struct pcm_substream *sub = hiface_pcm_get_substream(alsa_sub); struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub); unsigned long flags; snd_pcm_uframes_t dma_offset; if (rt->panic || !sub) return SNDRV_PCM_POS_XRUN; spin_lock_irqsave(&sub->lock, flags); dma_offset = sub->dma_off; spin_unlock_irqrestore(&sub->lock, flags); return bytes_to_frames(alsa_sub->runtime, dma_offset); } static const struct snd_pcm_ops pcm_ops = { .open = hiface_pcm_open, .close = hiface_pcm_close, .prepare = hiface_pcm_prepare, .trigger = hiface_pcm_trigger, .pointer = hiface_pcm_pointer, }; static int hiface_pcm_init_urb(struct pcm_urb *urb, struct hiface_chip *chip, unsigned int ep, void (*handler)(struct urb *)) { urb->chip = chip; usb_init_urb(&urb->instance); urb->buffer = kzalloc(PCM_PACKET_SIZE, GFP_KERNEL); if (!urb->buffer) return -ENOMEM; usb_fill_bulk_urb(&urb->instance, chip->dev, usb_sndbulkpipe(chip->dev, ep), (void *)urb->buffer, PCM_PACKET_SIZE, handler, urb); if (usb_urb_ep_type_check(&urb->instance)) return -EINVAL; init_usb_anchor(&urb->submitted); return 0; } void hiface_pcm_abort(struct hiface_chip *chip) { struct pcm_runtime *rt = chip->pcm; if (rt) { rt->panic = true; mutex_lock(&rt->stream_mutex); hiface_pcm_stream_stop(rt); mutex_unlock(&rt->stream_mutex); } } static void hiface_pcm_destroy(struct hiface_chip *chip) { struct pcm_runtime *rt = chip->pcm; int i; for (i = 0; i < PCM_N_URBS; i++) kfree(rt->out_urbs[i].buffer); kfree(chip->pcm); chip->pcm = NULL; } static void hiface_pcm_free(struct snd_pcm *pcm) { struct pcm_runtime *rt = pcm->private_data; if (rt) hiface_pcm_destroy(rt->chip); } int hiface_pcm_init(struct hiface_chip *chip, u8 extra_freq) { int i; int ret; struct snd_pcm *pcm; struct pcm_runtime *rt; rt = kzalloc(sizeof(*rt), GFP_KERNEL); if (!rt) return -ENOMEM; rt->chip = chip; rt->stream_state = STREAM_DISABLED; if (extra_freq) rt->extra_freq = 1; init_waitqueue_head(&rt->stream_wait_queue); mutex_init(&rt->stream_mutex); spin_lock_init(&rt->playback.lock); for (i = 0; i < PCM_N_URBS; i++) { ret = hiface_pcm_init_urb(&rt->out_urbs[i], chip, OUT_EP, hiface_pcm_out_urb_handler); if (ret < 0) goto error; } ret = snd_pcm_new(chip->card, "USB-SPDIF Audio", 0, 1, 0, &pcm); if (ret < 0) { dev_err(&chip->dev->dev, "Cannot create pcm instance\n"); goto error; } pcm->private_data = rt; pcm->private_free = hiface_pcm_free; strscpy(pcm->name, "USB-SPDIF Audio", sizeof(pcm->name)); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops); snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0); rt->instance = pcm; chip->pcm = rt; return 0; error: for (i = 0; i < PCM_N_URBS; i++) kfree(rt->out_urbs[i].buffer); kfree(rt); return ret; }
linux-master
sound/usb/hiface/pcm.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (C) 2007, 2008 Karsten Wiese <[email protected]> */ #include <linux/slab.h> #include <linux/usb.h> #include <linux/usb/audio.h> #include <linux/module.h> #include <sound/core.h> #include <sound/hwdep.h> #include <sound/pcm.h> #include <sound/initval.h> #define MODNAME "US122L" #include "usb_stream.c" #include "../usbaudio.h" #include "../midi.h" #include "us122l.h" MODULE_AUTHOR("Karsten Wiese <[email protected]>"); MODULE_DESCRIPTION("TASCAM "NAME_ALLCAPS" Version 0.5"); MODULE_LICENSE("GPL"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */ /* Enable this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for "NAME_ALLCAPS"."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for "NAME_ALLCAPS"."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable "NAME_ALLCAPS"."); /* driver_info flags */ #define US122L_FLAG_US144 BIT(0) static int snd_us122l_card_used[SNDRV_CARDS]; static int us122l_create_usbmidi(struct snd_card *card) { static const struct snd_usb_midi_endpoint_info quirk_data = { .out_ep = 4, .in_ep = 3, .out_cables = 0x001, .in_cables = 0x001 }; static const struct snd_usb_audio_quirk quirk = { .vendor_name = "US122L", .product_name = NAME_ALLCAPS, .ifnum = 1, .type = QUIRK_MIDI_US122L, .data = &quirk_data }; struct usb_device *dev = US122L(card)->dev; struct usb_interface *iface = usb_ifnum_to_if(dev, 1); return snd_usbmidi_create(card, iface, &US122L(card)->midi_list, &quirk); } static int us144_create_usbmidi(struct snd_card *card) { static const struct snd_usb_midi_endpoint_info quirk_data = { .out_ep = 4, .in_ep = 3, .out_cables = 0x001, .in_cables = 0x001 }; static const struct snd_usb_audio_quirk quirk = { .vendor_name = "US144", .product_name = NAME_ALLCAPS, .ifnum = 0, .type = QUIRK_MIDI_US122L, .data = &quirk_data }; struct usb_device *dev = US122L(card)->dev; struct usb_interface *iface = usb_ifnum_to_if(dev, 0); return snd_usbmidi_create(card, iface, &US122L(card)->midi_list, &quirk); } static void pt_info_set(struct usb_device *dev, u8 v) { int ret; ret = usb_control_msg_send(dev, 0, 'I', USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, v, 0, NULL, 0, 1000, GFP_NOIO); snd_printdd(KERN_DEBUG "%i\n", ret); } static void usb_stream_hwdep_vm_open(struct vm_area_struct *area) { struct us122l *us122l = area->vm_private_data; atomic_inc(&us122l->mmap_count); snd_printdd(KERN_DEBUG "%i\n", atomic_read(&us122l->mmap_count)); } static vm_fault_t usb_stream_hwdep_vm_fault(struct vm_fault *vmf) { unsigned long offset; struct page *page; void *vaddr; struct us122l *us122l = vmf->vma->vm_private_data; struct usb_stream *s; mutex_lock(&us122l->mutex); s = us122l->sk.s; if (!s) goto unlock; offset = vmf->pgoff << PAGE_SHIFT; if (offset < PAGE_ALIGN(s->read_size)) { vaddr = (char *)s + offset; } else { offset -= PAGE_ALIGN(s->read_size); if (offset >= PAGE_ALIGN(s->write_size)) goto unlock; vaddr = us122l->sk.write_page + offset; } page = virt_to_page(vaddr); get_page(page); mutex_unlock(&us122l->mutex); vmf->page = page; return 0; unlock: mutex_unlock(&us122l->mutex); return VM_FAULT_SIGBUS; } static void usb_stream_hwdep_vm_close(struct vm_area_struct *area) { struct us122l *us122l = area->vm_private_data; atomic_dec(&us122l->mmap_count); snd_printdd(KERN_DEBUG "%i\n", atomic_read(&us122l->mmap_count)); } static const struct vm_operations_struct usb_stream_hwdep_vm_ops = { .open = usb_stream_hwdep_vm_open, .fault = usb_stream_hwdep_vm_fault, .close = usb_stream_hwdep_vm_close, }; static int usb_stream_hwdep_open(struct snd_hwdep *hw, struct file *file) { struct us122l *us122l = hw->private_data; struct usb_interface *iface; snd_printdd(KERN_DEBUG "%p %p\n", hw, file); if (hw->used >= 2) return -EBUSY; if (!us122l->first) us122l->first = file; if (us122l->is_us144) { iface = usb_ifnum_to_if(us122l->dev, 0); usb_autopm_get_interface(iface); } iface = usb_ifnum_to_if(us122l->dev, 1); usb_autopm_get_interface(iface); return 0; } static int usb_stream_hwdep_release(struct snd_hwdep *hw, struct file *file) { struct us122l *us122l = hw->private_data; struct usb_interface *iface; snd_printdd(KERN_DEBUG "%p %p\n", hw, file); if (us122l->is_us144) { iface = usb_ifnum_to_if(us122l->dev, 0); usb_autopm_put_interface(iface); } iface = usb_ifnum_to_if(us122l->dev, 1); usb_autopm_put_interface(iface); if (us122l->first == file) us122l->first = NULL; mutex_lock(&us122l->mutex); if (us122l->master == file) us122l->master = us122l->slave; us122l->slave = NULL; mutex_unlock(&us122l->mutex); return 0; } static int usb_stream_hwdep_mmap(struct snd_hwdep *hw, struct file *filp, struct vm_area_struct *area) { unsigned long size = area->vm_end - area->vm_start; struct us122l *us122l = hw->private_data; unsigned long offset; struct usb_stream *s; int err = 0; bool read; offset = area->vm_pgoff << PAGE_SHIFT; mutex_lock(&us122l->mutex); s = us122l->sk.s; read = offset < s->read_size; if (read && area->vm_flags & VM_WRITE) { err = -EPERM; goto out; } snd_printdd(KERN_DEBUG "%lu %u\n", size, read ? s->read_size : s->write_size); /* if userspace tries to mmap beyond end of our buffer, fail */ if (size > PAGE_ALIGN(read ? s->read_size : s->write_size)) { snd_printk(KERN_WARNING "%lu > %u\n", size, read ? s->read_size : s->write_size); err = -EINVAL; goto out; } area->vm_ops = &usb_stream_hwdep_vm_ops; vm_flags_set(area, VM_DONTDUMP); if (!read) vm_flags_set(area, VM_DONTEXPAND); area->vm_private_data = us122l; atomic_inc(&us122l->mmap_count); out: mutex_unlock(&us122l->mutex); return err; } static __poll_t usb_stream_hwdep_poll(struct snd_hwdep *hw, struct file *file, poll_table *wait) { struct us122l *us122l = hw->private_data; unsigned int *polled; __poll_t mask; poll_wait(file, &us122l->sk.sleep, wait); mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM | EPOLLERR; if (mutex_trylock(&us122l->mutex)) { struct usb_stream *s = us122l->sk.s; if (s && s->state == usb_stream_ready) { if (us122l->first == file) polled = &s->periods_polled; else polled = &us122l->second_periods_polled; if (*polled != s->periods_done) { *polled = s->periods_done; mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM; } else { mask = 0; } } mutex_unlock(&us122l->mutex); } return mask; } static void us122l_stop(struct us122l *us122l) { struct list_head *p; list_for_each(p, &us122l->midi_list) snd_usbmidi_input_stop(p); usb_stream_stop(&us122l->sk); usb_stream_free(&us122l->sk); } static int us122l_set_sample_rate(struct usb_device *dev, int rate) { unsigned int ep = 0x81; unsigned char data[3]; int err; data[0] = rate; data[1] = rate >> 8; data[2] = rate >> 16; err = usb_control_msg_send(dev, 0, UAC_SET_CUR, USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT, UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000, GFP_NOIO); if (err) snd_printk(KERN_ERR "%d: cannot set freq %d to ep 0x%x\n", dev->devnum, rate, ep); return err; } static bool us122l_start(struct us122l *us122l, unsigned int rate, unsigned int period_frames) { struct list_head *p; int err; unsigned int use_packsize = 0; bool success = false; if (us122l->dev->speed == USB_SPEED_HIGH) { /* The us-122l's descriptor defaults to iso max_packsize 78, which isn't needed for samplerates <= 48000. Lets save some memory: */ switch (rate) { case 44100: use_packsize = 36; break; case 48000: use_packsize = 42; break; case 88200: use_packsize = 72; break; } } if (!usb_stream_new(&us122l->sk, us122l->dev, 1, 2, rate, use_packsize, period_frames, 6)) goto out; err = us122l_set_sample_rate(us122l->dev, rate); if (err < 0) { us122l_stop(us122l); snd_printk(KERN_ERR "us122l_set_sample_rate error\n"); goto out; } err = usb_stream_start(&us122l->sk); if (err < 0) { us122l_stop(us122l); snd_printk(KERN_ERR "%s error %i\n", __func__, err); goto out; } list_for_each(p, &us122l->midi_list) snd_usbmidi_input_start(p); success = true; out: return success; } static int usb_stream_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigned int cmd, unsigned long arg) { struct usb_stream_config cfg; struct us122l *us122l = hw->private_data; struct usb_stream *s; unsigned int min_period_frames; int err = 0; bool high_speed; if (cmd != SNDRV_USB_STREAM_IOCTL_SET_PARAMS) return -ENOTTY; if (copy_from_user(&cfg, (void __user *)arg, sizeof(cfg))) return -EFAULT; if (cfg.version != USB_STREAM_INTERFACE_VERSION) return -ENXIO; high_speed = us122l->dev->speed == USB_SPEED_HIGH; if ((cfg.sample_rate != 44100 && cfg.sample_rate != 48000 && (!high_speed || (cfg.sample_rate != 88200 && cfg.sample_rate != 96000))) || cfg.frame_size != 6 || cfg.period_frames > 0x3000) return -EINVAL; switch (cfg.sample_rate) { case 44100: min_period_frames = 48; break; case 48000: min_period_frames = 52; break; default: min_period_frames = 104; break; } if (!high_speed) min_period_frames <<= 1; if (cfg.period_frames < min_period_frames) return -EINVAL; snd_power_wait(hw->card); mutex_lock(&us122l->mutex); s = us122l->sk.s; if (!us122l->master) { us122l->master = file; } else if (us122l->master != file) { if (!s || memcmp(&cfg, &s->cfg, sizeof(cfg))) { err = -EIO; goto unlock; } us122l->slave = file; } if (!s || memcmp(&cfg, &s->cfg, sizeof(cfg)) || s->state == usb_stream_xrun) { us122l_stop(us122l); if (!us122l_start(us122l, cfg.sample_rate, cfg.period_frames)) err = -EIO; else err = 1; } unlock: mutex_unlock(&us122l->mutex); wake_up_all(&us122l->sk.sleep); return err; } #define SND_USB_STREAM_ID "USB STREAM" static int usb_stream_hwdep_new(struct snd_card *card) { int err; struct snd_hwdep *hw; struct usb_device *dev = US122L(card)->dev; err = snd_hwdep_new(card, SND_USB_STREAM_ID, 0, &hw); if (err < 0) return err; hw->iface = SNDRV_HWDEP_IFACE_USB_STREAM; hw->private_data = US122L(card); hw->ops.open = usb_stream_hwdep_open; hw->ops.release = usb_stream_hwdep_release; hw->ops.ioctl = usb_stream_hwdep_ioctl; hw->ops.ioctl_compat = usb_stream_hwdep_ioctl; hw->ops.mmap = usb_stream_hwdep_mmap; hw->ops.poll = usb_stream_hwdep_poll; sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum); return 0; } static bool us122l_create_card(struct snd_card *card) { int err; struct us122l *us122l = US122L(card); if (us122l->is_us144) { err = usb_set_interface(us122l->dev, 0, 1); if (err) { snd_printk(KERN_ERR "usb_set_interface error\n"); return false; } } err = usb_set_interface(us122l->dev, 1, 1); if (err) { snd_printk(KERN_ERR "usb_set_interface error\n"); return false; } pt_info_set(us122l->dev, 0x11); pt_info_set(us122l->dev, 0x10); if (!us122l_start(us122l, 44100, 256)) return false; if (us122l->is_us144) err = us144_create_usbmidi(card); else err = us122l_create_usbmidi(card); if (err < 0) { snd_printk(KERN_ERR "us122l_create_usbmidi error %i\n", err); goto stop; } err = usb_stream_hwdep_new(card); if (err < 0) { /* release the midi resources */ struct list_head *p; list_for_each(p, &us122l->midi_list) snd_usbmidi_disconnect(p); goto stop; } return true; stop: us122l_stop(us122l); return false; } static void snd_us122l_free(struct snd_card *card) { struct us122l *us122l = US122L(card); int index = us122l->card_index; if (index >= 0 && index < SNDRV_CARDS) snd_us122l_card_used[index] = 0; } static int usx2y_create_card(struct usb_device *device, struct usb_interface *intf, struct snd_card **cardp, unsigned long flags) { int dev; struct snd_card *card; int err; for (dev = 0; dev < SNDRV_CARDS; ++dev) if (enable[dev] && !snd_us122l_card_used[dev]) break; if (dev >= SNDRV_CARDS) return -ENODEV; err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE, sizeof(struct us122l), &card); if (err < 0) return err; snd_us122l_card_used[US122L(card)->card_index = dev] = 1; card->private_free = snd_us122l_free; US122L(card)->dev = device; mutex_init(&US122L(card)->mutex); init_waitqueue_head(&US122L(card)->sk.sleep); US122L(card)->is_us144 = flags & US122L_FLAG_US144; INIT_LIST_HEAD(&US122L(card)->midi_list); strcpy(card->driver, "USB "NAME_ALLCAPS""); sprintf(card->shortname, "TASCAM "NAME_ALLCAPS""); sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)", card->shortname, le16_to_cpu(device->descriptor.idVendor), le16_to_cpu(device->descriptor.idProduct), 0, US122L(card)->dev->bus->busnum, US122L(card)->dev->devnum ); *cardp = card; return 0; } static int us122l_usb_probe(struct usb_interface *intf, const struct usb_device_id *device_id, struct snd_card **cardp) { struct usb_device *device = interface_to_usbdev(intf); struct snd_card *card; int err; err = usx2y_create_card(device, intf, &card, device_id->driver_info); if (err < 0) return err; if (!us122l_create_card(card)) { snd_card_free(card); return -EINVAL; } err = snd_card_register(card); if (err < 0) { snd_card_free(card); return err; } usb_get_intf(usb_ifnum_to_if(device, 0)); usb_get_dev(device); *cardp = card; return 0; } static int snd_us122l_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_device *device = interface_to_usbdev(intf); struct snd_card *card; int err; if (id->driver_info & US122L_FLAG_US144 && device->speed == USB_SPEED_HIGH) { snd_printk(KERN_ERR "disable ehci-hcd to run US-144\n"); return -ENODEV; } snd_printdd(KERN_DEBUG"%p:%i\n", intf, intf->cur_altsetting->desc.bInterfaceNumber); if (intf->cur_altsetting->desc.bInterfaceNumber != 1) return 0; err = us122l_usb_probe(usb_get_intf(intf), id, &card); if (err < 0) { usb_put_intf(intf); return err; } usb_set_intfdata(intf, card); return 0; } static void snd_us122l_disconnect(struct usb_interface *intf) { struct snd_card *card; struct us122l *us122l; struct list_head *p; card = usb_get_intfdata(intf); if (!card) return; snd_card_disconnect(card); us122l = US122L(card); mutex_lock(&us122l->mutex); us122l_stop(us122l); mutex_unlock(&us122l->mutex); /* release the midi resources */ list_for_each(p, &us122l->midi_list) { snd_usbmidi_disconnect(p); } usb_put_intf(usb_ifnum_to_if(us122l->dev, 0)); usb_put_intf(usb_ifnum_to_if(us122l->dev, 1)); usb_put_dev(us122l->dev); while (atomic_read(&us122l->mmap_count)) msleep(500); snd_card_free(card); } static int snd_us122l_suspend(struct usb_interface *intf, pm_message_t message) { struct snd_card *card; struct us122l *us122l; struct list_head *p; card = usb_get_intfdata(intf); if (!card) return 0; snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); us122l = US122L(card); if (!us122l) return 0; list_for_each(p, &us122l->midi_list) snd_usbmidi_input_stop(p); mutex_lock(&us122l->mutex); usb_stream_stop(&us122l->sk); mutex_unlock(&us122l->mutex); return 0; } static int snd_us122l_resume(struct usb_interface *intf) { struct snd_card *card; struct us122l *us122l; struct list_head *p; int err; card = usb_get_intfdata(intf); if (!card) return 0; us122l = US122L(card); if (!us122l) return 0; mutex_lock(&us122l->mutex); /* needed, doesn't restart without: */ if (us122l->is_us144) { err = usb_set_interface(us122l->dev, 0, 1); if (err) { snd_printk(KERN_ERR "usb_set_interface error\n"); goto unlock; } } err = usb_set_interface(us122l->dev, 1, 1); if (err) { snd_printk(KERN_ERR "usb_set_interface error\n"); goto unlock; } pt_info_set(us122l->dev, 0x11); pt_info_set(us122l->dev, 0x10); err = us122l_set_sample_rate(us122l->dev, us122l->sk.s->cfg.sample_rate); if (err < 0) { snd_printk(KERN_ERR "us122l_set_sample_rate error\n"); goto unlock; } err = usb_stream_start(&us122l->sk); if (err) goto unlock; list_for_each(p, &us122l->midi_list) snd_usbmidi_input_start(p); unlock: mutex_unlock(&us122l->mutex); snd_power_change_state(card, SNDRV_CTL_POWER_D0); return err; } static const struct usb_device_id snd_us122l_usb_id_table[] = { { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = 0x0644, .idProduct = USB_ID_US122L }, { /* US-144 only works at USB1.1! Disable module ehci-hcd. */ .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = 0x0644, .idProduct = USB_ID_US144, .driver_info = US122L_FLAG_US144 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = 0x0644, .idProduct = USB_ID_US122MKII }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = 0x0644, .idProduct = USB_ID_US144MKII, .driver_info = US122L_FLAG_US144 }, { /* terminator */ } }; MODULE_DEVICE_TABLE(usb, snd_us122l_usb_id_table); static struct usb_driver snd_us122l_usb_driver = { .name = "snd-usb-us122l", .probe = snd_us122l_probe, .disconnect = snd_us122l_disconnect, .suspend = snd_us122l_suspend, .resume = snd_us122l_resume, .reset_resume = snd_us122l_resume, .id_table = snd_us122l_usb_id_table, .supports_autosuspend = 1 }; module_usb_driver(snd_us122l_usb_driver);
linux-master
sound/usb/usx2y/us122l.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (C) 2007, 2008 Karsten Wiese <[email protected]> */ #include <linux/usb.h> #include <linux/gfp.h> #include "usb_stream.h" /* setup */ static unsigned int usb_stream_next_packet_size(struct usb_stream_kernel *sk) { struct usb_stream *s = sk->s; sk->out_phase_peeked = (sk->out_phase & 0xffff) + sk->freqn; return (sk->out_phase_peeked >> 16) * s->cfg.frame_size; } static void playback_prep_freqn(struct usb_stream_kernel *sk, struct urb *urb) { struct usb_stream *s = sk->s; int pack, lb = 0; for (pack = 0; pack < sk->n_o_ps; pack++) { int l = usb_stream_next_packet_size(sk); if (s->idle_outsize + lb + l > s->period_size) goto check; sk->out_phase = sk->out_phase_peeked; urb->iso_frame_desc[pack].offset = lb; urb->iso_frame_desc[pack].length = l; lb += l; } snd_printdd(KERN_DEBUG "%i\n", lb); check: urb->number_of_packets = pack; urb->transfer_buffer_length = lb; s->idle_outsize += lb - s->period_size; snd_printdd(KERN_DEBUG "idle=%i ul=%i ps=%i\n", s->idle_outsize, lb, s->period_size); } static int init_pipe_urbs(struct usb_stream_kernel *sk, unsigned int use_packsize, struct urb **urbs, char *transfer, struct usb_device *dev, int pipe) { int u, p; int maxpacket = use_packsize ? use_packsize : usb_maxpacket(dev, pipe); int transfer_length = maxpacket * sk->n_o_ps; for (u = 0; u < USB_STREAM_NURBS; ++u, transfer += transfer_length) { struct urb *urb = urbs[u]; struct usb_iso_packet_descriptor *desc; urb->transfer_buffer = transfer; urb->dev = dev; urb->pipe = pipe; urb->number_of_packets = sk->n_o_ps; urb->context = sk; urb->interval = 1; if (usb_pipeout(pipe)) continue; if (usb_urb_ep_type_check(urb)) return -EINVAL; urb->transfer_buffer_length = transfer_length; desc = urb->iso_frame_desc; desc->offset = 0; desc->length = maxpacket; for (p = 1; p < sk->n_o_ps; ++p) { desc[p].offset = desc[p - 1].offset + maxpacket; desc[p].length = maxpacket; } } return 0; } static int init_urbs(struct usb_stream_kernel *sk, unsigned int use_packsize, struct usb_device *dev, int in_pipe, int out_pipe) { struct usb_stream *s = sk->s; char *indata = (char *)s + sizeof(*s) + sizeof(struct usb_stream_packet) * s->inpackets; int u; for (u = 0; u < USB_STREAM_NURBS; ++u) { sk->inurb[u] = usb_alloc_urb(sk->n_o_ps, GFP_KERNEL); if (!sk->inurb[u]) return -ENOMEM; sk->outurb[u] = usb_alloc_urb(sk->n_o_ps, GFP_KERNEL); if (!sk->outurb[u]) return -ENOMEM; } if (init_pipe_urbs(sk, use_packsize, sk->inurb, indata, dev, in_pipe) || init_pipe_urbs(sk, use_packsize, sk->outurb, sk->write_page, dev, out_pipe)) return -EINVAL; return 0; } /* * convert a sampling rate into our full speed format (fs/1000 in Q16.16) * this will overflow at approx 524 kHz */ static inline unsigned int get_usb_full_speed_rate(unsigned int rate) { return ((rate << 13) + 62) / 125; } /* * convert a sampling rate into USB high speed format (fs/8000 in Q16.16) * this will overflow at approx 4 MHz */ static inline unsigned int get_usb_high_speed_rate(unsigned int rate) { return ((rate << 10) + 62) / 125; } void usb_stream_free(struct usb_stream_kernel *sk) { struct usb_stream *s; unsigned int u; for (u = 0; u < USB_STREAM_NURBS; ++u) { usb_free_urb(sk->inurb[u]); sk->inurb[u] = NULL; usb_free_urb(sk->outurb[u]); sk->outurb[u] = NULL; } s = sk->s; if (!s) return; if (sk->write_page) { free_pages_exact(sk->write_page, s->write_size); sk->write_page = NULL; } free_pages_exact(s, s->read_size); sk->s = NULL; } struct usb_stream *usb_stream_new(struct usb_stream_kernel *sk, struct usb_device *dev, unsigned int in_endpoint, unsigned int out_endpoint, unsigned int sample_rate, unsigned int use_packsize, unsigned int period_frames, unsigned int frame_size) { int packets, max_packsize; int in_pipe, out_pipe; int read_size = sizeof(struct usb_stream); int write_size; int usb_frames = dev->speed == USB_SPEED_HIGH ? 8000 : 1000; in_pipe = usb_rcvisocpipe(dev, in_endpoint); out_pipe = usb_sndisocpipe(dev, out_endpoint); max_packsize = use_packsize ? use_packsize : usb_maxpacket(dev, in_pipe); /* t_period = period_frames / sample_rate iso_packs = t_period / t_iso_frame = (period_frames / sample_rate) * (1 / t_iso_frame) */ packets = period_frames * usb_frames / sample_rate + 1; if (dev->speed == USB_SPEED_HIGH) packets = (packets + 7) & ~7; read_size += packets * USB_STREAM_URBDEPTH * (max_packsize + sizeof(struct usb_stream_packet)); max_packsize = usb_maxpacket(dev, out_pipe); write_size = max_packsize * packets * USB_STREAM_URBDEPTH; if (read_size >= 256*PAGE_SIZE || write_size >= 256*PAGE_SIZE) { snd_printk(KERN_WARNING "a size exceeds 128*PAGE_SIZE\n"); goto out; } sk->s = alloc_pages_exact(read_size, GFP_KERNEL | __GFP_ZERO | __GFP_NOWARN); if (!sk->s) { pr_warn("us122l: couldn't allocate read buffer\n"); goto out; } sk->s->cfg.version = USB_STREAM_INTERFACE_VERSION; sk->s->read_size = read_size; sk->s->cfg.sample_rate = sample_rate; sk->s->cfg.frame_size = frame_size; sk->n_o_ps = packets; sk->s->inpackets = packets * USB_STREAM_URBDEPTH; sk->s->cfg.period_frames = period_frames; sk->s->period_size = frame_size * period_frames; sk->s->write_size = write_size; sk->write_page = alloc_pages_exact(write_size, GFP_KERNEL | __GFP_ZERO | __GFP_NOWARN); if (!sk->write_page) { pr_warn("us122l: couldn't allocate write buffer\n"); usb_stream_free(sk); return NULL; } /* calculate the frequency in 16.16 format */ if (dev->speed == USB_SPEED_FULL) sk->freqn = get_usb_full_speed_rate(sample_rate); else sk->freqn = get_usb_high_speed_rate(sample_rate); if (init_urbs(sk, use_packsize, dev, in_pipe, out_pipe) < 0) { usb_stream_free(sk); return NULL; } sk->s->state = usb_stream_stopped; out: return sk->s; } /* start */ static bool balance_check(struct usb_stream_kernel *sk, struct urb *urb) { bool r; if (unlikely(urb->status)) { if (urb->status != -ESHUTDOWN && urb->status != -ENOENT) snd_printk(KERN_WARNING "status=%i\n", urb->status); sk->iso_frame_balance = 0x7FFFFFFF; return false; } r = sk->iso_frame_balance == 0; if (!r) sk->i_urb = urb; return r; } static bool balance_playback(struct usb_stream_kernel *sk, struct urb *urb) { sk->iso_frame_balance += urb->number_of_packets; return balance_check(sk, urb); } static bool balance_capture(struct usb_stream_kernel *sk, struct urb *urb) { sk->iso_frame_balance -= urb->number_of_packets; return balance_check(sk, urb); } static void subs_set_complete(struct urb **urbs, void (*complete)(struct urb *)) { int u; for (u = 0; u < USB_STREAM_NURBS; u++) { struct urb *urb = urbs[u]; urb->complete = complete; } } static int usb_stream_prepare_playback(struct usb_stream_kernel *sk, struct urb *inurb) { struct usb_stream *s = sk->s; struct urb *io; struct usb_iso_packet_descriptor *id, *od; int p = 0, lb = 0, l = 0; io = sk->idle_outurb; od = io->iso_frame_desc; for (; s->sync_packet < 0; ++p, ++s->sync_packet) { struct urb *ii = sk->completed_inurb; id = ii->iso_frame_desc + ii->number_of_packets + s->sync_packet; l = id->actual_length; od[p].length = l; od[p].offset = lb; lb += l; } for (; s->sync_packet < inurb->number_of_packets && p < sk->n_o_ps; ++p, ++s->sync_packet) { l = inurb->iso_frame_desc[s->sync_packet].actual_length; if (s->idle_outsize + lb + l > s->period_size) goto check_ok; od[p].length = l; od[p].offset = lb; lb += l; } check_ok: s->sync_packet -= inurb->number_of_packets; if (unlikely(s->sync_packet < -2 || s->sync_packet > 0)) { snd_printk(KERN_WARNING "invalid sync_packet = %i;" " p=%i nop=%i %i %x %x %x > %x\n", s->sync_packet, p, inurb->number_of_packets, s->idle_outsize + lb + l, s->idle_outsize, lb, l, s->period_size); return -1; } if (unlikely(lb % s->cfg.frame_size)) { snd_printk(KERN_WARNING"invalid outsize = %i\n", lb); return -1; } s->idle_outsize += lb - s->period_size; io->number_of_packets = p; io->transfer_buffer_length = lb; if (s->idle_outsize <= 0) return 0; snd_printk(KERN_WARNING "idle=%i\n", s->idle_outsize); return -1; } static void prepare_inurb(int number_of_packets, struct urb *iu) { struct usb_iso_packet_descriptor *id; int p; iu->number_of_packets = number_of_packets; id = iu->iso_frame_desc; id->offset = 0; for (p = 0; p < iu->number_of_packets - 1; ++p) id[p + 1].offset = id[p].offset + id[p].length; iu->transfer_buffer_length = id[0].length * iu->number_of_packets; } static int submit_urbs(struct usb_stream_kernel *sk, struct urb *inurb, struct urb *outurb) { int err; prepare_inurb(sk->idle_outurb->number_of_packets, sk->idle_inurb); err = usb_submit_urb(sk->idle_inurb, GFP_ATOMIC); if (err < 0) goto report_failure; sk->idle_inurb = sk->completed_inurb; sk->completed_inurb = inurb; err = usb_submit_urb(sk->idle_outurb, GFP_ATOMIC); if (err < 0) goto report_failure; sk->idle_outurb = sk->completed_outurb; sk->completed_outurb = outurb; return 0; report_failure: snd_printk(KERN_ERR "%i\n", err); return err; } #ifdef DEBUG_LOOP_BACK /* This loop_back() shows how to read/write the period data. */ static void loop_back(struct usb_stream *s) { char *i, *o; int il, ol, l, p; struct urb *iu; struct usb_iso_packet_descriptor *id; o = s->playback1st_to; ol = s->playback1st_size; l = 0; if (s->insplit_pack >= 0) { iu = sk->idle_inurb; id = iu->iso_frame_desc; p = s->insplit_pack; } else goto second; loop: for (; p < iu->number_of_packets && l < s->period_size; ++p) { i = iu->transfer_buffer + id[p].offset; il = id[p].actual_length; if (l + il > s->period_size) il = s->period_size - l; if (il <= ol) { memcpy(o, i, il); o += il; ol -= il; } else { memcpy(o, i, ol); singen_6pack(o, ol); o = s->playback_to; memcpy(o, i + ol, il - ol); o += il - ol; ol = s->period_size - s->playback1st_size; } l += il; } if (iu == sk->completed_inurb) { if (l != s->period_size) printk(KERN_DEBUG"%s:%i %i\n", __func__, __LINE__, l/(int)s->cfg.frame_size); return; } second: iu = sk->completed_inurb; id = iu->iso_frame_desc; p = 0; goto loop; } #else static void loop_back(struct usb_stream *s) { } #endif static void stream_idle(struct usb_stream_kernel *sk, struct urb *inurb, struct urb *outurb) { struct usb_stream *s = sk->s; int l, p; int insize = s->idle_insize; int urb_size = 0; s->inpacket_split = s->next_inpacket_split; s->inpacket_split_at = s->next_inpacket_split_at; s->next_inpacket_split = -1; s->next_inpacket_split_at = 0; for (p = 0; p < inurb->number_of_packets; ++p) { struct usb_iso_packet_descriptor *id = inurb->iso_frame_desc; l = id[p].actual_length; if (unlikely(l == 0 || id[p].status)) { snd_printk(KERN_WARNING "underrun, status=%u\n", id[p].status); goto err_out; } s->inpacket_head++; s->inpacket_head %= s->inpackets; if (s->inpacket_split == -1) s->inpacket_split = s->inpacket_head; s->inpacket[s->inpacket_head].offset = id[p].offset + (inurb->transfer_buffer - (void *)s); s->inpacket[s->inpacket_head].length = l; if (insize + l > s->period_size && s->next_inpacket_split == -1) { s->next_inpacket_split = s->inpacket_head; s->next_inpacket_split_at = s->period_size - insize; } insize += l; urb_size += l; } s->idle_insize += urb_size - s->period_size; if (s->idle_insize < 0) { snd_printk(KERN_WARNING "%i\n", (s->idle_insize)/(int)s->cfg.frame_size); goto err_out; } s->insize_done += urb_size; l = s->idle_outsize; s->outpacket[0].offset = (sk->idle_outurb->transfer_buffer - sk->write_page) - l; if (usb_stream_prepare_playback(sk, inurb) < 0) goto err_out; s->outpacket[0].length = sk->idle_outurb->transfer_buffer_length + l; s->outpacket[1].offset = sk->completed_outurb->transfer_buffer - sk->write_page; if (submit_urbs(sk, inurb, outurb) < 0) goto err_out; loop_back(s); s->periods_done++; wake_up_all(&sk->sleep); return; err_out: s->state = usb_stream_xrun; wake_up_all(&sk->sleep); } static void i_capture_idle(struct urb *urb) { struct usb_stream_kernel *sk = urb->context; if (balance_capture(sk, urb)) stream_idle(sk, urb, sk->i_urb); } static void i_playback_idle(struct urb *urb) { struct usb_stream_kernel *sk = urb->context; if (balance_playback(sk, urb)) stream_idle(sk, sk->i_urb, urb); } static void stream_start(struct usb_stream_kernel *sk, struct urb *inurb, struct urb *outurb) { struct usb_stream *s = sk->s; if (s->state >= usb_stream_sync1) { int l, p, max_diff, max_diff_0; int urb_size = 0; unsigned int frames_per_packet, min_frames = 0; frames_per_packet = (s->period_size - s->idle_insize); frames_per_packet <<= 8; frames_per_packet /= s->cfg.frame_size * inurb->number_of_packets; frames_per_packet++; max_diff_0 = s->cfg.frame_size; if (s->cfg.period_frames >= 256) max_diff_0 <<= 1; if (s->cfg.period_frames >= 1024) max_diff_0 <<= 1; max_diff = max_diff_0; for (p = 0; p < inurb->number_of_packets; ++p) { int diff; l = inurb->iso_frame_desc[p].actual_length; urb_size += l; min_frames += frames_per_packet; diff = urb_size - (min_frames >> 8) * s->cfg.frame_size; if (diff < max_diff) { snd_printdd(KERN_DEBUG "%i %i %i %i\n", s->insize_done, urb_size / (int)s->cfg.frame_size, inurb->number_of_packets, diff); max_diff = diff; } } s->idle_insize -= max_diff - max_diff_0; s->idle_insize += urb_size - s->period_size; if (s->idle_insize < 0) { snd_printk(KERN_WARNING "%i %i %i\n", s->idle_insize, urb_size, s->period_size); return; } else if (s->idle_insize == 0) { s->next_inpacket_split = (s->inpacket_head + 1) % s->inpackets; s->next_inpacket_split_at = 0; } else { unsigned int split = s->inpacket_head; l = s->idle_insize; while (l > s->inpacket[split].length) { l -= s->inpacket[split].length; if (split == 0) split = s->inpackets - 1; else split--; } s->next_inpacket_split = split; s->next_inpacket_split_at = s->inpacket[split].length - l; } s->insize_done += urb_size; if (usb_stream_prepare_playback(sk, inurb) < 0) return; } else playback_prep_freqn(sk, sk->idle_outurb); if (submit_urbs(sk, inurb, outurb) < 0) return; if (s->state == usb_stream_sync1 && s->insize_done > 360000) { /* just guesswork ^^^^^^ */ s->state = usb_stream_ready; subs_set_complete(sk->inurb, i_capture_idle); subs_set_complete(sk->outurb, i_playback_idle); } } static void i_capture_start(struct urb *urb) { struct usb_iso_packet_descriptor *id = urb->iso_frame_desc; struct usb_stream_kernel *sk = urb->context; struct usb_stream *s = sk->s; int p; int empty = 0; if (urb->status) { snd_printk(KERN_WARNING "status=%i\n", urb->status); return; } for (p = 0; p < urb->number_of_packets; ++p) { int l = id[p].actual_length; if (l < s->cfg.frame_size) { ++empty; if (s->state >= usb_stream_sync0) { snd_printk(KERN_WARNING "%i\n", l); return; } } s->inpacket_head++; s->inpacket_head %= s->inpackets; s->inpacket[s->inpacket_head].offset = id[p].offset + (urb->transfer_buffer - (void *)s); s->inpacket[s->inpacket_head].length = l; } #ifdef SHOW_EMPTY if (empty) { printk(KERN_DEBUG"%s:%i: %i", __func__, __LINE__, urb->iso_frame_desc[0].actual_length); for (pack = 1; pack < urb->number_of_packets; ++pack) { int l = urb->iso_frame_desc[pack].actual_length; printk(KERN_CONT " %i", l); } printk(KERN_CONT "\n"); } #endif if (!empty && s->state < usb_stream_sync1) ++s->state; if (balance_capture(sk, urb)) stream_start(sk, urb, sk->i_urb); } static void i_playback_start(struct urb *urb) { struct usb_stream_kernel *sk = urb->context; if (balance_playback(sk, urb)) stream_start(sk, sk->i_urb, urb); } int usb_stream_start(struct usb_stream_kernel *sk) { struct usb_stream *s = sk->s; int frame = 0, iters = 0; int u, err; int try = 0; if (s->state != usb_stream_stopped) return -EAGAIN; subs_set_complete(sk->inurb, i_capture_start); subs_set_complete(sk->outurb, i_playback_start); memset(sk->write_page, 0, s->write_size); dotry: s->insize_done = 0; s->idle_insize = 0; s->idle_outsize = 0; s->sync_packet = -1; s->inpacket_head = -1; sk->iso_frame_balance = 0; ++try; for (u = 0; u < 2; u++) { struct urb *inurb = sk->inurb[u]; struct urb *outurb = sk->outurb[u]; playback_prep_freqn(sk, outurb); inurb->number_of_packets = outurb->number_of_packets; inurb->transfer_buffer_length = inurb->number_of_packets * inurb->iso_frame_desc[0].length; if (u == 0) { int now; struct usb_device *dev = inurb->dev; frame = usb_get_current_frame_number(dev); do { now = usb_get_current_frame_number(dev); ++iters; } while (now > -1 && now == frame); } err = usb_submit_urb(inurb, GFP_ATOMIC); if (err < 0) { snd_printk(KERN_ERR "usb_submit_urb(sk->inurb[%i]) returned %i\n", u, err); return err; } err = usb_submit_urb(outurb, GFP_ATOMIC); if (err < 0) { snd_printk(KERN_ERR "usb_submit_urb(sk->outurb[%i]) returned %i\n", u, err); return err; } if (inurb->start_frame != outurb->start_frame) { snd_printd(KERN_DEBUG "u[%i] start_frames differ in:%u out:%u\n", u, inurb->start_frame, outurb->start_frame); goto check_retry; } } snd_printdd(KERN_DEBUG "%i %i\n", frame, iters); try = 0; check_retry: if (try) { usb_stream_stop(sk); if (try < 5) { msleep(1500); snd_printd(KERN_DEBUG "goto dotry;\n"); goto dotry; } snd_printk(KERN_WARNING "couldn't start all urbs on the same start_frame.\n"); return -EFAULT; } sk->idle_inurb = sk->inurb[USB_STREAM_NURBS - 2]; sk->idle_outurb = sk->outurb[USB_STREAM_NURBS - 2]; sk->completed_inurb = sk->inurb[USB_STREAM_NURBS - 1]; sk->completed_outurb = sk->outurb[USB_STREAM_NURBS - 1]; /* wait, check */ { int wait_ms = 3000; while (s->state != usb_stream_ready && wait_ms > 0) { snd_printdd(KERN_DEBUG "%i\n", s->state); msleep(200); wait_ms -= 200; } } return s->state == usb_stream_ready ? 0 : -EFAULT; } /* stop */ void usb_stream_stop(struct usb_stream_kernel *sk) { int u; if (!sk->s) return; for (u = 0; u < USB_STREAM_NURBS; ++u) { usb_kill_urb(sk->inurb[u]); usb_kill_urb(sk->outurb[u]); } sk->s->state = usb_stream_stopped; msleep(400); }
linux-master
sound/usb/usx2y/usb_stream.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Driver for Tascam US-X2Y USB soundcards * * FPGA Loader + ALSA Startup * * Copyright (c) 2003 by Karsten Wiese <[email protected]> */ #include <linux/interrupt.h> #include <linux/slab.h> #include <linux/usb.h> #include <sound/core.h> #include <sound/memalloc.h> #include <sound/pcm.h> #include <sound/hwdep.h> #include "usx2y.h" #include "usbusx2y.h" #include "usX2Yhwdep.h" static vm_fault_t snd_us428ctls_vm_fault(struct vm_fault *vmf) { unsigned long offset; struct page *page; void *vaddr; snd_printdd("ENTER, start %lXh, pgoff %ld\n", vmf->vma->vm_start, vmf->pgoff); offset = vmf->pgoff << PAGE_SHIFT; vaddr = (char *)((struct usx2ydev *)vmf->vma->vm_private_data)->us428ctls_sharedmem + offset; page = virt_to_page(vaddr); get_page(page); vmf->page = page; snd_printdd("vaddr=%p made us428ctls_vm_fault() page %p\n", vaddr, page); return 0; } static const struct vm_operations_struct us428ctls_vm_ops = { .fault = snd_us428ctls_vm_fault, }; static int snd_us428ctls_mmap(struct snd_hwdep *hw, struct file *filp, struct vm_area_struct *area) { unsigned long size = (unsigned long)(area->vm_end - area->vm_start); struct usx2ydev *us428 = hw->private_data; // FIXME this hwdep interface is used twice: fpga download and mmap for controlling Lights etc. Maybe better using 2 hwdep devs? // so as long as the device isn't fully initialised yet we return -EBUSY here. if (!(us428->chip_status & USX2Y_STAT_CHIP_INIT)) return -EBUSY; /* if userspace tries to mmap beyond end of our buffer, fail */ if (size > US428_SHAREDMEM_PAGES) { snd_printd("%lu > %lu\n", size, (unsigned long)US428_SHAREDMEM_PAGES); return -EINVAL; } area->vm_ops = &us428ctls_vm_ops; vm_flags_set(area, VM_DONTEXPAND | VM_DONTDUMP); area->vm_private_data = hw->private_data; return 0; } static __poll_t snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file, poll_table *wait) { __poll_t mask = 0; struct usx2ydev *us428 = hw->private_data; struct us428ctls_sharedmem *shm = us428->us428ctls_sharedmem; if (us428->chip_status & USX2Y_STAT_CHIP_HUP) return EPOLLHUP; poll_wait(file, &us428->us428ctls_wait_queue_head, wait); if (shm && shm->ctl_snapshot_last != shm->ctl_snapshot_red) mask |= EPOLLIN; return mask; } static int snd_usx2y_hwdep_dsp_status(struct snd_hwdep *hw, struct snd_hwdep_dsp_status *info) { static const char * const type_ids[USX2Y_TYPE_NUMS] = { [USX2Y_TYPE_122] = "us122", [USX2Y_TYPE_224] = "us224", [USX2Y_TYPE_428] = "us428", }; struct usx2ydev *us428 = hw->private_data; int id = -1; switch (le16_to_cpu(us428->dev->descriptor.idProduct)) { case USB_ID_US122: id = USX2Y_TYPE_122; break; case USB_ID_US224: id = USX2Y_TYPE_224; break; case USB_ID_US428: id = USX2Y_TYPE_428; break; } if (id < 0) return -ENODEV; strcpy(info->id, type_ids[id]); info->num_dsps = 2; // 0: Prepad Data, 1: FPGA Code if (us428->chip_status & USX2Y_STAT_CHIP_INIT) info->chip_ready = 1; info->version = USX2Y_DRIVER_VERSION; return 0; } static int usx2y_create_usbmidi(struct snd_card *card) { static const struct snd_usb_midi_endpoint_info quirk_data_1 = { .out_ep = 0x06, .in_ep = 0x06, .out_cables = 0x001, .in_cables = 0x001 }; static const struct snd_usb_audio_quirk quirk_1 = { .vendor_name = "TASCAM", .product_name = NAME_ALLCAPS, .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = &quirk_data_1 }; static const struct snd_usb_midi_endpoint_info quirk_data_2 = { .out_ep = 0x06, .in_ep = 0x06, .out_cables = 0x003, .in_cables = 0x003 }; static const struct snd_usb_audio_quirk quirk_2 = { .vendor_name = "TASCAM", .product_name = "US428", .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = &quirk_data_2 }; struct usb_device *dev = usx2y(card)->dev; struct usb_interface *iface = usb_ifnum_to_if(dev, 0); const struct snd_usb_audio_quirk *quirk = le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ? &quirk_2 : &quirk_1; snd_printdd("%s\n", __func__); return snd_usbmidi_create(card, iface, &usx2y(card)->midi_list, quirk); } static int usx2y_create_alsa_devices(struct snd_card *card) { int err; err = usx2y_create_usbmidi(card); if (err < 0) { snd_printk(KERN_ERR "%s: usx2y_create_usbmidi error %i\n", __func__, err); return err; } err = usx2y_audio_create(card); if (err < 0) return err; err = usx2y_hwdep_pcm_new(card); if (err < 0) return err; err = snd_card_register(card); if (err < 0) return err; return 0; } static int snd_usx2y_hwdep_dsp_load(struct snd_hwdep *hw, struct snd_hwdep_dsp_image *dsp) { struct usx2ydev *priv = hw->private_data; struct usb_device *dev = priv->dev; int lret, err; char *buf; snd_printdd("dsp_load %s\n", dsp->name); buf = memdup_user(dsp->image, dsp->length); if (IS_ERR(buf)) return PTR_ERR(buf); err = usb_set_interface(dev, 0, 1); if (err) snd_printk(KERN_ERR "usb_set_interface error\n"); else err = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 2), buf, dsp->length, &lret, 6000); kfree(buf); if (err) return err; if (dsp->index == 1) { msleep(250); // give the device some time err = usx2y_async_seq04_init(priv); if (err) { snd_printk(KERN_ERR "usx2y_async_seq04_init error\n"); return err; } err = usx2y_in04_init(priv); if (err) { snd_printk(KERN_ERR "usx2y_in04_init error\n"); return err; } err = usx2y_create_alsa_devices(hw->card); if (err) { snd_printk(KERN_ERR "usx2y_create_alsa_devices error %i\n", err); return err; } priv->chip_status |= USX2Y_STAT_CHIP_INIT; snd_printdd("%s: alsa all started\n", hw->name); } return err; } int usx2y_hwdep_new(struct snd_card *card, struct usb_device *device) { int err; struct snd_hwdep *hw; struct usx2ydev *us428 = usx2y(card); err = snd_hwdep_new(card, SND_USX2Y_LOADER_ID, 0, &hw); if (err < 0) return err; hw->iface = SNDRV_HWDEP_IFACE_USX2Y; hw->private_data = us428; hw->ops.dsp_status = snd_usx2y_hwdep_dsp_status; hw->ops.dsp_load = snd_usx2y_hwdep_dsp_load; hw->ops.mmap = snd_us428ctls_mmap; hw->ops.poll = snd_us428ctls_poll; hw->exclusive = 1; sprintf(hw->name, "/dev/bus/usb/%03d/%03d", device->bus->busnum, device->devnum); us428->us428ctls_sharedmem = alloc_pages_exact(US428_SHAREDMEM_PAGES, GFP_KERNEL); if (!us428->us428ctls_sharedmem) return -ENOMEM; memset(us428->us428ctls_sharedmem, -1, US428_SHAREDMEM_PAGES); us428->us428ctls_sharedmem->ctl_snapshot_last = -2; return 0; }
linux-master
sound/usb/usx2y/usX2Yhwdep.c
// SPDX-License-Identifier: GPL-2.0-or-later /* */ /* USX2Y "rawusb" aka hwdep_pcm implementation Its usb's unableness to atomically handle power of 2 period sized data chuncs at standard samplerates, what led to this part of the usx2y module: It provides the alsa kernel half of the usx2y-alsa-jack driver pair. The pair uses a hardware dependent alsa-device for mmaped pcm transport. Advantage achieved: The usb_hc moves pcm data from/into memory via DMA. That memory is mmaped by jack's usx2y driver. Jack's usx2y driver is the first/last to read/write pcm data. Read/write is a combination of power of 2 period shaping and float/int conversation. Compared to mainline alsa/jack we leave out power of 2 period shaping inside snd-usb-usx2y which needs memcpy() and additional buffers. As a side effect possible unwanted pcm-data coruption resulting of standard alsa's snd-usb-usx2y period shaping scheme falls away. Result is sane jack operation at buffering schemes down to 128frames, 2 periods. plain usx2y alsa mode is able to achieve 64frames, 4periods, but only at the cost of easier triggered i.e. aeolus xruns (128 or 256frames, 2periods works but is useless cause of crackling). This is a first "proof of concept" implementation. Later, functionalities should migrate to more appropriate places: Userland: - The jackd could mmap its float-pcm buffers directly from alsa-lib. - alsa-lib could provide power of 2 period sized shaping combined with int/float conversation. Currently the usx2y jack driver provides above 2 services. Kernel: - rawusb dma pcm buffer transport should go to snd-usb-lib, so also snd-usb-audio devices can use it. Currently rawusb dma pcm buffer transport (this file) is only available to snd-usb-usx2y. */ #include <linux/delay.h> #include <linux/gfp.h> #include "usbusx2yaudio.c" #if defined(USX2Y_NRPACKS_VARIABLE) || USX2Y_NRPACKS == 1 #include <sound/hwdep.h> static int usx2y_usbpcm_urb_capt_retire(struct snd_usx2y_substream *subs) { struct urb *urb = subs->completed_urb; struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; int i, lens = 0, hwptr_done = subs->hwptr_done; struct usx2ydev *usx2y = subs->usx2y; int head; if (usx2y->hwdep_pcm_shm->capture_iso_start < 0) { //FIXME head = usx2y->hwdep_pcm_shm->captured_iso_head + 1; if (head >= ARRAY_SIZE(usx2y->hwdep_pcm_shm->captured_iso)) head = 0; usx2y->hwdep_pcm_shm->capture_iso_start = head; snd_printdd("cap start %i\n", head); } for (i = 0; i < nr_of_packs(); i++) { if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */ snd_printk(KERN_ERR "active frame status %i. Most probably some hardware problem.\n", urb->iso_frame_desc[i].status); return urb->iso_frame_desc[i].status; } lens += urb->iso_frame_desc[i].actual_length / usx2y->stride; } hwptr_done += lens; if (hwptr_done >= runtime->buffer_size) hwptr_done -= runtime->buffer_size; subs->hwptr_done = hwptr_done; subs->transfer_done += lens; /* update the pointer, call callback if necessary */ if (subs->transfer_done >= runtime->period_size) { subs->transfer_done -= runtime->period_size; snd_pcm_period_elapsed(subs->pcm_substream); } return 0; } static int usx2y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, struct usx2ydev *usx2y) { return (runtime->buffer_size * 1000) / usx2y->rate + 1; //FIXME: so far only correct period_size == 2^x ? } /* * prepare urb for playback data pipe * * we copy the data directly from the pcm buffer. * the current position to be copied is held in hwptr field. * since a urb can handle only a single linear buffer, if the total * transferred area overflows the buffer boundary, we cannot send * it directly from the buffer. thus the data is once copied to * a temporary buffer and urb points to that. */ static int usx2y_hwdep_urb_play_prepare(struct snd_usx2y_substream *subs, struct urb *urb) { int count, counts, pack; struct usx2ydev *usx2y = subs->usx2y; struct snd_usx2y_hwdep_pcm_shm *shm = usx2y->hwdep_pcm_shm; struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; if (shm->playback_iso_start < 0) { shm->playback_iso_start = shm->captured_iso_head - usx2y_iso_frames_per_buffer(runtime, usx2y); if (shm->playback_iso_start < 0) shm->playback_iso_start += ARRAY_SIZE(shm->captured_iso); shm->playback_iso_head = shm->playback_iso_start; } count = 0; for (pack = 0; pack < nr_of_packs(); pack++) { /* calculate the size of a packet */ counts = shm->captured_iso[shm->playback_iso_head].length / usx2y->stride; if (counts < 43 || counts > 50) { snd_printk(KERN_ERR "should not be here with counts=%i\n", counts); return -EPIPE; } /* set up descriptor */ urb->iso_frame_desc[pack].offset = shm->captured_iso[shm->playback_iso_head].offset; urb->iso_frame_desc[pack].length = shm->captured_iso[shm->playback_iso_head].length; if (atomic_read(&subs->state) != STATE_RUNNING) memset((char *)urb->transfer_buffer + urb->iso_frame_desc[pack].offset, 0, urb->iso_frame_desc[pack].length); if (++shm->playback_iso_head >= ARRAY_SIZE(shm->captured_iso)) shm->playback_iso_head = 0; count += counts; } urb->transfer_buffer_length = count * usx2y->stride; return 0; } static void usx2y_usbpcm_urb_capt_iso_advance(struct snd_usx2y_substream *subs, struct urb *urb) { struct usb_iso_packet_descriptor *desc; struct snd_usx2y_hwdep_pcm_shm *shm; int pack, head; for (pack = 0; pack < nr_of_packs(); ++pack) { desc = urb->iso_frame_desc + pack; if (subs) { shm = subs->usx2y->hwdep_pcm_shm; head = shm->captured_iso_head + 1; if (head >= ARRAY_SIZE(shm->captured_iso)) head = 0; shm->captured_iso[head].frame = urb->start_frame + pack; shm->captured_iso[head].offset = desc->offset; shm->captured_iso[head].length = desc->actual_length; shm->captured_iso_head = head; shm->captured_iso_frames++; } desc->offset += desc->length * NRURBS * nr_of_packs(); if (desc->offset + desc->length >= SSS) desc->offset -= (SSS - desc->length); } } static int usx2y_usbpcm_usbframe_complete(struct snd_usx2y_substream *capsubs, struct snd_usx2y_substream *capsubs2, struct snd_usx2y_substream *playbacksubs, int frame) { int err, state; struct urb *urb = playbacksubs->completed_urb; state = atomic_read(&playbacksubs->state); if (urb) { if (state == STATE_RUNNING) usx2y_urb_play_retire(playbacksubs, urb); else if (state >= STATE_PRERUNNING) atomic_inc(&playbacksubs->state); } else { switch (state) { case STATE_STARTING1: urb = playbacksubs->urb[0]; atomic_inc(&playbacksubs->state); break; case STATE_STARTING2: urb = playbacksubs->urb[1]; atomic_inc(&playbacksubs->state); break; } } if (urb) { err = usx2y_hwdep_urb_play_prepare(playbacksubs, urb); if (err) return err; err = usx2y_hwdep_urb_play_prepare(playbacksubs, urb); if (err) return err; } playbacksubs->completed_urb = NULL; state = atomic_read(&capsubs->state); if (state >= STATE_PREPARED) { if (state == STATE_RUNNING) { err = usx2y_usbpcm_urb_capt_retire(capsubs); if (err) return err; } else if (state >= STATE_PRERUNNING) { atomic_inc(&capsubs->state); } usx2y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb); if (capsubs2) usx2y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb); err = usx2y_urb_submit(capsubs, capsubs->completed_urb, frame); if (err) return err; if (capsubs2) { err = usx2y_urb_submit(capsubs2, capsubs2->completed_urb, frame); if (err) return err; } } capsubs->completed_urb = NULL; if (capsubs2) capsubs2->completed_urb = NULL; return 0; } static void i_usx2y_usbpcm_urb_complete(struct urb *urb) { struct snd_usx2y_substream *subs = urb->context; struct usx2ydev *usx2y = subs->usx2y; struct snd_usx2y_substream *capsubs, *capsubs2, *playbacksubs; if (unlikely(atomic_read(&subs->state) < STATE_PREPARED)) { snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", usb_get_current_frame_number(usx2y->dev), subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", urb->status, urb->start_frame); return; } if (unlikely(urb->status)) { usx2y_error_urb_status(usx2y, subs, urb); return; } subs->completed_urb = urb; capsubs = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; capsubs2 = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; playbacksubs = usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; if (capsubs->completed_urb && atomic_read(&capsubs->state) >= STATE_PREPARED && (!capsubs2 || capsubs2->completed_urb) && (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < STATE_PREPARED)) { if (!usx2y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame)) { usx2y->wait_iso_frame += nr_of_packs(); } else { snd_printdd("\n"); usx2y_clients_stop(usx2y); } } } static void usx2y_hwdep_urb_release(struct urb **urb) { usb_kill_urb(*urb); usb_free_urb(*urb); *urb = NULL; } /* * release a substream */ static void usx2y_usbpcm_urbs_release(struct snd_usx2y_substream *subs) { int i; snd_printdd("snd_usx2y_urbs_release() %i\n", subs->endpoint); for (i = 0; i < NRURBS; i++) usx2y_hwdep_urb_release(subs->urb + i); } static void usx2y_usbpcm_subs_startup_finish(struct usx2ydev *usx2y) { usx2y_urbs_set_complete(usx2y, i_usx2y_usbpcm_urb_complete); usx2y->prepare_subs = NULL; } static void i_usx2y_usbpcm_subs_startup(struct urb *urb) { struct snd_usx2y_substream *subs = urb->context; struct usx2ydev *usx2y = subs->usx2y; struct snd_usx2y_substream *prepare_subs = usx2y->prepare_subs; struct snd_usx2y_substream *cap_subs2; if (prepare_subs && urb->start_frame == prepare_subs->urb[0]->start_frame) { atomic_inc(&prepare_subs->state); if (prepare_subs == usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]) { cap_subs2 = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; if (cap_subs2) atomic_inc(&cap_subs2->state); } usx2y_usbpcm_subs_startup_finish(usx2y); wake_up(&usx2y->prepare_wait_queue); } i_usx2y_usbpcm_urb_complete(urb); } /* * initialize a substream's urbs */ static int usx2y_usbpcm_urbs_allocate(struct snd_usx2y_substream *subs) { int i; unsigned int pipe; int is_playback = subs == subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; struct usb_device *dev = subs->usx2y->dev; struct urb **purb; pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) : usb_rcvisocpipe(dev, subs->endpoint); subs->maxpacksize = usb_maxpacket(dev, pipe); if (!subs->maxpacksize) return -EINVAL; /* allocate and initialize data urbs */ for (i = 0; i < NRURBS; i++) { purb = subs->urb + i; if (*purb) { usb_kill_urb(*purb); continue; } *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL); if (!*purb) { usx2y_usbpcm_urbs_release(subs); return -ENOMEM; } (*purb)->transfer_buffer = is_playback ? subs->usx2y->hwdep_pcm_shm->playback : ( subs->endpoint == 0x8 ? subs->usx2y->hwdep_pcm_shm->capture0x8 : subs->usx2y->hwdep_pcm_shm->capture0xA); (*purb)->dev = dev; (*purb)->pipe = pipe; (*purb)->number_of_packets = nr_of_packs(); (*purb)->context = subs; (*purb)->interval = 1; (*purb)->complete = i_usx2y_usbpcm_subs_startup; } return 0; } /* * free the buffer */ static int snd_usx2y_usbpcm_hw_free(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usx2y_substream *subs = runtime->private_data; struct snd_usx2y_substream *cap_subs; struct snd_usx2y_substream *playback_subs; struct snd_usx2y_substream *cap_subs2; mutex_lock(&subs->usx2y->pcm_mutex); snd_printdd("%s(%p)\n", __func__, substream); cap_subs2 = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { cap_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; atomic_set(&subs->state, STATE_STOPPED); usx2y_usbpcm_urbs_release(subs); if (!cap_subs->pcm_substream || !cap_subs->pcm_substream->runtime || cap_subs->pcm_substream->runtime->state < SNDRV_PCM_STATE_PREPARED) { atomic_set(&cap_subs->state, STATE_STOPPED); if (cap_subs2) atomic_set(&cap_subs2->state, STATE_STOPPED); usx2y_usbpcm_urbs_release(cap_subs); if (cap_subs2) usx2y_usbpcm_urbs_release(cap_subs2); } } else { playback_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; if (atomic_read(&playback_subs->state) < STATE_PREPARED) { atomic_set(&subs->state, STATE_STOPPED); if (cap_subs2) atomic_set(&cap_subs2->state, STATE_STOPPED); usx2y_usbpcm_urbs_release(subs); if (cap_subs2) usx2y_usbpcm_urbs_release(cap_subs2); } } mutex_unlock(&subs->usx2y->pcm_mutex); return 0; } static void usx2y_usbpcm_subs_startup(struct snd_usx2y_substream *subs) { struct usx2ydev *usx2y = subs->usx2y; usx2y->prepare_subs = subs; subs->urb[0]->start_frame = -1; smp_wmb(); // Make sure above modifications are seen by i_usx2y_subs_startup() usx2y_urbs_set_complete(usx2y, i_usx2y_usbpcm_subs_startup); } static int usx2y_usbpcm_urbs_start(struct snd_usx2y_substream *subs) { int p, u, err, stream = subs->pcm_substream->stream; struct usx2ydev *usx2y = subs->usx2y; struct urb *urb; unsigned long pack; if (stream == SNDRV_PCM_STREAM_CAPTURE) { usx2y->hwdep_pcm_shm->captured_iso_head = -1; usx2y->hwdep_pcm_shm->captured_iso_frames = 0; } for (p = 0; 3 >= (stream + p); p += 2) { struct snd_usx2y_substream *subs = usx2y->subs[stream + p]; if (subs) { err = usx2y_usbpcm_urbs_allocate(subs); if (err < 0) return err; subs->completed_urb = NULL; } } for (p = 0; p < 4; p++) { struct snd_usx2y_substream *subs = usx2y->subs[p]; if (subs && atomic_read(&subs->state) >= STATE_PREPARED) goto start; } start: usx2y_usbpcm_subs_startup(subs); for (u = 0; u < NRURBS; u++) { for (p = 0; 3 >= (stream + p); p += 2) { struct snd_usx2y_substream *subs = usx2y->subs[stream + p]; if (!subs) continue; urb = subs->urb[u]; if (usb_pipein(urb->pipe)) { if (!u) atomic_set(&subs->state, STATE_STARTING3); urb->dev = usx2y->dev; for (pack = 0; pack < nr_of_packs(); pack++) { urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs()); urb->iso_frame_desc[pack].length = subs->maxpacksize; } urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs(); err = usb_submit_urb(urb, GFP_KERNEL); if (err < 0) { snd_printk(KERN_ERR "cannot usb_submit_urb() for urb %d, err = %d\n", u, err); err = -EPIPE; goto cleanup; } else { snd_printdd("%i\n", urb->start_frame); if (!u) usx2y->wait_iso_frame = urb->start_frame; } urb->transfer_flags = 0; } else { atomic_set(&subs->state, STATE_STARTING1); break; } } } err = 0; wait_event(usx2y->prepare_wait_queue, !usx2y->prepare_subs); if (atomic_read(&subs->state) != STATE_PREPARED) err = -EPIPE; cleanup: if (err) { usx2y_subs_startup_finish(usx2y); // Call it now usx2y_clients_stop(usx2y); // something is completely wrong > stop everything } return err; } #define USX2Y_HWDEP_PCM_PAGES \ PAGE_ALIGN(sizeof(struct snd_usx2y_hwdep_pcm_shm)) /* * prepare callback * * set format and initialize urbs */ static int snd_usx2y_usbpcm_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usx2y_substream *subs = runtime->private_data; struct usx2ydev *usx2y = subs->usx2y; struct snd_usx2y_substream *capsubs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; int err = 0; snd_printdd("snd_usx2y_pcm_prepare(%p)\n", substream); mutex_lock(&usx2y->pcm_mutex); if (!usx2y->hwdep_pcm_shm) { usx2y->hwdep_pcm_shm = alloc_pages_exact(USX2Y_HWDEP_PCM_PAGES, GFP_KERNEL); if (!usx2y->hwdep_pcm_shm) { err = -ENOMEM; goto up_prepare_mutex; } memset(usx2y->hwdep_pcm_shm, 0, USX2Y_HWDEP_PCM_PAGES); } usx2y_subs_prepare(subs); // Start hardware streams // SyncStream first.... if (atomic_read(&capsubs->state) < STATE_PREPARED) { if (usx2y->format != runtime->format) { err = usx2y_format_set(usx2y, runtime->format); if (err < 0) goto up_prepare_mutex; } if (usx2y->rate != runtime->rate) { err = usx2y_rate_set(usx2y, runtime->rate); if (err < 0) goto up_prepare_mutex; } snd_printdd("starting capture pipe for %s\n", subs == capsubs ? "self" : "playpipe"); err = usx2y_usbpcm_urbs_start(capsubs); if (err < 0) goto up_prepare_mutex; } if (subs != capsubs) { usx2y->hwdep_pcm_shm->playback_iso_start = -1; if (atomic_read(&subs->state) < STATE_PREPARED) { while (usx2y_iso_frames_per_buffer(runtime, usx2y) > usx2y->hwdep_pcm_shm->captured_iso_frames) { snd_printdd("Wait: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", usx2y_iso_frames_per_buffer(runtime, usx2y), usx2y->hwdep_pcm_shm->captured_iso_frames); if (msleep_interruptible(10)) { err = -ERESTARTSYS; goto up_prepare_mutex; } } err = usx2y_usbpcm_urbs_start(subs); if (err < 0) goto up_prepare_mutex; } snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", usx2y_iso_frames_per_buffer(runtime, usx2y), usx2y->hwdep_pcm_shm->captured_iso_frames); } else { usx2y->hwdep_pcm_shm->capture_iso_start = -1; } up_prepare_mutex: mutex_unlock(&usx2y->pcm_mutex); return err; } static const struct snd_pcm_hardware snd_usx2y_4c = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .rate_min = 44100, .rate_max = 48000, .channels_min = 2, .channels_max = 4, .buffer_bytes_max = (2*128*1024), .period_bytes_min = 64, .period_bytes_max = (128*1024), .periods_min = 2, .periods_max = 1024, .fifo_size = 0 }; static int snd_usx2y_usbpcm_open(struct snd_pcm_substream *substream) { struct snd_usx2y_substream *subs = ((struct snd_usx2y_substream **) snd_pcm_substream_chip(substream))[substream->stream]; struct snd_pcm_runtime *runtime = substream->runtime; if (!(subs->usx2y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)) return -EBUSY; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) runtime->hw = snd_usx2y_2c; else runtime->hw = (subs->usx2y->subs[3] ? snd_usx2y_4c : snd_usx2y_2c); runtime->private_data = subs; subs->pcm_substream = substream; snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000); return 0; } static int snd_usx2y_usbpcm_close(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usx2y_substream *subs = runtime->private_data; subs->pcm_substream = NULL; return 0; } static const struct snd_pcm_ops snd_usx2y_usbpcm_ops = { .open = snd_usx2y_usbpcm_open, .close = snd_usx2y_usbpcm_close, .hw_params = snd_usx2y_pcm_hw_params, .hw_free = snd_usx2y_usbpcm_hw_free, .prepare = snd_usx2y_usbpcm_prepare, .trigger = snd_usx2y_pcm_trigger, .pointer = snd_usx2y_pcm_pointer, }; static int usx2y_pcms_busy_check(struct snd_card *card) { struct usx2ydev *dev = usx2y(card); struct snd_usx2y_substream *subs; int i; for (i = 0; i < dev->pcm_devs * 2; i++) { subs = dev->subs[i]; if (subs && subs->pcm_substream && SUBSTREAM_BUSY(subs->pcm_substream)) return -EBUSY; } return 0; } static int snd_usx2y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file) { struct snd_card *card = hw->card; int err; mutex_lock(&usx2y(card)->pcm_mutex); err = usx2y_pcms_busy_check(card); if (!err) usx2y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS; mutex_unlock(&usx2y(card)->pcm_mutex); return err; } static int snd_usx2y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file) { struct snd_card *card = hw->card; int err; mutex_lock(&usx2y(card)->pcm_mutex); err = usx2y_pcms_busy_check(card); if (!err) usx2y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS; mutex_unlock(&usx2y(card)->pcm_mutex); return err; } static void snd_usx2y_hwdep_pcm_vm_open(struct vm_area_struct *area) { } static void snd_usx2y_hwdep_pcm_vm_close(struct vm_area_struct *area) { } static vm_fault_t snd_usx2y_hwdep_pcm_vm_fault(struct vm_fault *vmf) { unsigned long offset; void *vaddr; offset = vmf->pgoff << PAGE_SHIFT; vaddr = (char *)((struct usx2ydev *)vmf->vma->vm_private_data)->hwdep_pcm_shm + offset; vmf->page = virt_to_page(vaddr); get_page(vmf->page); return 0; } static const struct vm_operations_struct snd_usx2y_hwdep_pcm_vm_ops = { .open = snd_usx2y_hwdep_pcm_vm_open, .close = snd_usx2y_hwdep_pcm_vm_close, .fault = snd_usx2y_hwdep_pcm_vm_fault, }; static int snd_usx2y_hwdep_pcm_mmap(struct snd_hwdep *hw, struct file *filp, struct vm_area_struct *area) { unsigned long size = (unsigned long)(area->vm_end - area->vm_start); struct usx2ydev *usx2y = hw->private_data; if (!(usx2y->chip_status & USX2Y_STAT_CHIP_INIT)) return -EBUSY; /* if userspace tries to mmap beyond end of our buffer, fail */ if (size > USX2Y_HWDEP_PCM_PAGES) { snd_printd("%lu > %lu\n", size, (unsigned long)USX2Y_HWDEP_PCM_PAGES); return -EINVAL; } if (!usx2y->hwdep_pcm_shm) return -ENODEV; area->vm_ops = &snd_usx2y_hwdep_pcm_vm_ops; vm_flags_set(area, VM_DONTEXPAND | VM_DONTDUMP); area->vm_private_data = hw->private_data; return 0; } static void snd_usx2y_hwdep_pcm_private_free(struct snd_hwdep *hwdep) { struct usx2ydev *usx2y = hwdep->private_data; if (usx2y->hwdep_pcm_shm) free_pages_exact(usx2y->hwdep_pcm_shm, USX2Y_HWDEP_PCM_PAGES); } int usx2y_hwdep_pcm_new(struct snd_card *card) { int err; struct snd_hwdep *hw; struct snd_pcm *pcm; struct usb_device *dev = usx2y(card)->dev; if (nr_of_packs() != 1) return 0; err = snd_hwdep_new(card, SND_USX2Y_USBPCM_ID, 1, &hw); if (err < 0) return err; hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM; hw->private_data = usx2y(card); hw->private_free = snd_usx2y_hwdep_pcm_private_free; hw->ops.open = snd_usx2y_hwdep_pcm_open; hw->ops.release = snd_usx2y_hwdep_pcm_release; hw->ops.mmap = snd_usx2y_hwdep_pcm_mmap; hw->exclusive = 1; sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum); err = snd_pcm_new(card, NAME_ALLCAPS" hwdep Audio", 2, 1, 1, &pcm); if (err < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usx2y_usbpcm_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usx2y_usbpcm_ops); pcm->private_data = usx2y(card)->subs; pcm->info_flags = 0; sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio"); snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream, SNDRV_DMA_TYPE_CONTINUOUS, NULL, 64*1024, 128*1024); snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, SNDRV_DMA_TYPE_CONTINUOUS, NULL, 64*1024, 128*1024); return 0; } #else int usx2y_hwdep_pcm_new(struct snd_card *card) { return 0; } #endif
linux-master
sound/usb/usx2y/usx2yhwdeppcm.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * usbusx2y.c - ALSA USB US-428 Driver * 2005-04-14 Karsten Wiese Version 0.8.7.2: Call snd_card_free() instead of snd_card_free_in_thread() to prevent oops with dead keyboard symptom. Tested ok with kernel 2.6.12-rc2. 2004-12-14 Karsten Wiese Version 0.8.7.1: snd_pcm_open for rawusb pcm-devices now returns -EBUSY if called without rawusb's hwdep device being open. 2004-12-02 Karsten Wiese Version 0.8.7: Use macro usb_maxpacket() for portability. 2004-10-26 Karsten Wiese Version 0.8.6: wake_up() process waiting in usx2y_urbs_start() on error. 2004-10-21 Karsten Wiese Version 0.8.5: nrpacks is runtime or compiletime configurable now with tested values from 1 to 4. 2004-10-03 Karsten Wiese Version 0.8.2: Avoid any possible racing while in prepare callback. 2004-09-30 Karsten Wiese Version 0.8.0: Simplified things and made ohci work again. 2004-09-20 Karsten Wiese Version 0.7.3: Use usb_kill_urb() instead of deprecated (kernel 2.6.9) usb_unlink_urb(). 2004-07-13 Karsten Wiese Version 0.7.1: Don't sleep in START/STOP callbacks anymore. us428 channels C/D not handled just for this version, sorry. 2004-06-21 Karsten Wiese Version 0.6.4: Temporarely suspend midi input to sanely call usb_set_interface() when setting format. 2004-06-12 Karsten Wiese Version 0.6.3: Made it thus the following rule is enforced: "All pcm substreams of one usx2y have to operate at the same rate & format." 2004-04-06 Karsten Wiese Version 0.6.0: Runs on 2.6.5 kernel without any "--with-debug=" things. us224 reported running. 2004-01-14 Karsten Wiese Version 0.5.1: Runs with 2.6.1 kernel. 2003-12-30 Karsten Wiese Version 0.4.1: Fix 24Bit 4Channel capturing for the us428. 2003-11-27 Karsten Wiese, Martin Langer Version 0.4: us122 support. us224 could be tested by uncommenting the sections containing USB_ID_US224 2003-11-03 Karsten Wiese Version 0.3: 24Bit support. "arecord -D hw:1 -c 2 -r 48000 -M -f S24_3LE|aplay -D hw:1 -c 2 -r 48000 -M -f S24_3LE" works. 2003-08-22 Karsten Wiese Version 0.0.8: Removed EZUSB Firmware. First Stage Firmwaredownload is now done by tascam-firmware downloader. See: http://usb-midi-fw.sourceforge.net/tascam-firmware.tar.gz 2003-06-18 Karsten Wiese Version 0.0.5: changed to compile with kernel 2.4.21 and alsa 0.9.4 2002-10-16 Karsten Wiese Version 0.0.4: compiles again with alsa-current. USB_ISO_ASAP not used anymore (most of the time), instead urb->start_frame is calculated here now, some calls inside usb-driver don't need to happen anymore. To get the best out of this: Disable APM-support in the kernel as APM-BIOS calls (once each second) hard disable interrupt for many precious milliseconds. This helped me much on my slowish PII 400 & PIII 500. ACPI yet untested but might cause the same bad behaviour. Use a kernel with lowlatency and preemptiv patches applied. To autoload snd-usb-midi append a line post-install snd-usb-us428 modprobe snd-usb-midi to /etc/modules.conf. known problems: sliders, knobs, lights not yet handled except MASTER Volume slider. "pcm -c 2" doesn't work. "pcm -c 2 -m direct_interleaved" does. KDE3: "Enable full duplex operation" deadlocks. 2002-08-31 Karsten Wiese Version 0.0.3: audio also simplex; simplifying: iso urbs only 1 packet, melted structs. ASYNC_UNLINK not used anymore: no more crashes so far..... for alsa 0.9 rc3. 2002-08-09 Karsten Wiese Version 0.0.2: midi works with snd-usb-midi, audio (only fullduplex now) with i.e. bristol. The firmware has been sniffed from win2k us-428 driver 3.09. * Copyright (c) 2002 - 2004 Karsten Wiese */ #include <linux/init.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/slab.h> #include <linux/interrupt.h> #include <linux/usb.h> #include <sound/core.h> #include <sound/initval.h> #include <sound/pcm.h> #include <sound/rawmidi.h> #include "usx2y.h" #include "usbusx2y.h" #include "usX2Yhwdep.h" MODULE_AUTHOR("Karsten Wiese <[email protected]>"); MODULE_DESCRIPTION("TASCAM "NAME_ALLCAPS" Version 0.8.7.2"); MODULE_LICENSE("GPL"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for "NAME_ALLCAPS"."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for "NAME_ALLCAPS"."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable "NAME_ALLCAPS"."); static int snd_usx2y_card_used[SNDRV_CARDS]; static void snd_usx2y_card_private_free(struct snd_card *card); static void usx2y_unlinkseq(struct snd_usx2y_async_seq *s); /* * pipe 4 is used for switching the lamps, setting samplerate, volumes .... */ static void i_usx2y_out04_int(struct urb *urb) { #ifdef CONFIG_SND_DEBUG if (urb->status) { int i; struct usx2ydev *usx2y = urb->context; for (i = 0; i < 10 && usx2y->as04.urb[i] != urb; i++) ; snd_printdd("%s urb %i status=%i\n", __func__, i, urb->status); } #endif } static void i_usx2y_in04_int(struct urb *urb) { int err = 0; struct usx2ydev *usx2y = urb->context; struct us428ctls_sharedmem *us428ctls = usx2y->us428ctls_sharedmem; struct us428_p4out *p4out; int i, j, n, diff, send; usx2y->in04_int_calls++; if (urb->status) { snd_printdd("Interrupt Pipe 4 came back with status=%i\n", urb->status); return; } // printk("%i:0x%02X ", 8, (int)((unsigned char*)usx2y->in04_buf)[8]); Master volume shows 0 here if fader is at max during boot ?!? if (us428ctls) { diff = -1; if (us428ctls->ctl_snapshot_last == -2) { diff = 0; memcpy(usx2y->in04_last, usx2y->in04_buf, sizeof(usx2y->in04_last)); us428ctls->ctl_snapshot_last = -1; } else { for (i = 0; i < 21; i++) { if (usx2y->in04_last[i] != ((char *)usx2y->in04_buf)[i]) { if (diff < 0) diff = i; usx2y->in04_last[i] = ((char *)usx2y->in04_buf)[i]; } } } if (diff >= 0) { n = us428ctls->ctl_snapshot_last + 1; if (n >= N_US428_CTL_BUFS || n < 0) n = 0; memcpy(us428ctls->ctl_snapshot + n, usx2y->in04_buf, sizeof(us428ctls->ctl_snapshot[0])); us428ctls->ctl_snapshot_differs_at[n] = diff; us428ctls->ctl_snapshot_last = n; wake_up(&usx2y->us428ctls_wait_queue_head); } } if (usx2y->us04) { if (!usx2y->us04->submitted) { do { err = usb_submit_urb(usx2y->us04->urb[usx2y->us04->submitted++], GFP_ATOMIC); } while (!err && usx2y->us04->submitted < usx2y->us04->len); } } else { if (us428ctls && us428ctls->p4out_last >= 0 && us428ctls->p4out_last < N_US428_P4OUT_BUFS) { if (us428ctls->p4out_last != us428ctls->p4out_sent) { send = us428ctls->p4out_sent + 1; if (send >= N_US428_P4OUT_BUFS) send = 0; for (j = 0; j < URBS_ASYNC_SEQ && !err; ++j) { if (!usx2y->as04.urb[j]->status) { p4out = us428ctls->p4out + send; // FIXME if more than 1 p4out is new, 1 gets lost. usb_fill_bulk_urb(usx2y->as04.urb[j], usx2y->dev, usb_sndbulkpipe(usx2y->dev, 0x04), &p4out->val.vol, p4out->type == ELT_LIGHT ? sizeof(struct us428_lights) : 5, i_usx2y_out04_int, usx2y); err = usb_submit_urb(usx2y->as04.urb[j], GFP_ATOMIC); us428ctls->p4out_sent = send; break; } } } } } if (err) snd_printk(KERN_ERR "in04_int() usb_submit_urb err=%i\n", err); urb->dev = usx2y->dev; usb_submit_urb(urb, GFP_ATOMIC); } /* * Prepare some urbs */ int usx2y_async_seq04_init(struct usx2ydev *usx2y) { int err = 0, i; if (WARN_ON(usx2y->as04.buffer)) return -EBUSY; usx2y->as04.buffer = kmalloc_array(URBS_ASYNC_SEQ, URB_DATA_LEN_ASYNC_SEQ, GFP_KERNEL); if (!usx2y->as04.buffer) { err = -ENOMEM; } else { for (i = 0; i < URBS_ASYNC_SEQ; ++i) { usx2y->as04.urb[i] = usb_alloc_urb(0, GFP_KERNEL); if (!usx2y->as04.urb[i]) { err = -ENOMEM; break; } usb_fill_bulk_urb(usx2y->as04.urb[i], usx2y->dev, usb_sndbulkpipe(usx2y->dev, 0x04), usx2y->as04.buffer + URB_DATA_LEN_ASYNC_SEQ * i, 0, i_usx2y_out04_int, usx2y); err = usb_urb_ep_type_check(usx2y->as04.urb[i]); if (err < 0) break; } } if (err) usx2y_unlinkseq(&usx2y->as04); return err; } int usx2y_in04_init(struct usx2ydev *usx2y) { int err; if (WARN_ON(usx2y->in04_urb)) return -EBUSY; usx2y->in04_urb = usb_alloc_urb(0, GFP_KERNEL); if (!usx2y->in04_urb) { err = -ENOMEM; goto error; } usx2y->in04_buf = kmalloc(21, GFP_KERNEL); if (!usx2y->in04_buf) { err = -ENOMEM; goto error; } init_waitqueue_head(&usx2y->in04_wait_queue); usb_fill_int_urb(usx2y->in04_urb, usx2y->dev, usb_rcvintpipe(usx2y->dev, 0x4), usx2y->in04_buf, 21, i_usx2y_in04_int, usx2y, 10); if (usb_urb_ep_type_check(usx2y->in04_urb)) { err = -EINVAL; goto error; } return usb_submit_urb(usx2y->in04_urb, GFP_KERNEL); error: kfree(usx2y->in04_buf); usb_free_urb(usx2y->in04_urb); usx2y->in04_buf = NULL; usx2y->in04_urb = NULL; return err; } static void usx2y_unlinkseq(struct snd_usx2y_async_seq *s) { int i; for (i = 0; i < URBS_ASYNC_SEQ; ++i) { if (!s->urb[i]) continue; usb_kill_urb(s->urb[i]); usb_free_urb(s->urb[i]); s->urb[i] = NULL; } kfree(s->buffer); s->buffer = NULL; } static const struct usb_device_id snd_usx2y_usb_id_table[] = { { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = 0x1604, .idProduct = USB_ID_US428 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = 0x1604, .idProduct = USB_ID_US122 }, { .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = 0x1604, .idProduct = USB_ID_US224 }, { /* terminator */ } }; MODULE_DEVICE_TABLE(usb, snd_usx2y_usb_id_table); static int usx2y_create_card(struct usb_device *device, struct usb_interface *intf, struct snd_card **cardp) { int dev; struct snd_card *card; int err; for (dev = 0; dev < SNDRV_CARDS; ++dev) if (enable[dev] && !snd_usx2y_card_used[dev]) break; if (dev >= SNDRV_CARDS) return -ENODEV; err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE, sizeof(struct usx2ydev), &card); if (err < 0) return err; snd_usx2y_card_used[usx2y(card)->card_index = dev] = 1; card->private_free = snd_usx2y_card_private_free; usx2y(card)->dev = device; init_waitqueue_head(&usx2y(card)->prepare_wait_queue); init_waitqueue_head(&usx2y(card)->us428ctls_wait_queue_head); mutex_init(&usx2y(card)->pcm_mutex); INIT_LIST_HEAD(&usx2y(card)->midi_list); strcpy(card->driver, "USB "NAME_ALLCAPS""); sprintf(card->shortname, "TASCAM "NAME_ALLCAPS""); sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)", card->shortname, le16_to_cpu(device->descriptor.idVendor), le16_to_cpu(device->descriptor.idProduct), 0,//us428(card)->usbmidi.ifnum, usx2y(card)->dev->bus->busnum, usx2y(card)->dev->devnum); *cardp = card; return 0; } static void snd_usx2y_card_private_free(struct snd_card *card) { struct usx2ydev *usx2y = usx2y(card); kfree(usx2y->in04_buf); usb_free_urb(usx2y->in04_urb); if (usx2y->us428ctls_sharedmem) free_pages_exact(usx2y->us428ctls_sharedmem, US428_SHAREDMEM_PAGES); if (usx2y->card_index >= 0 && usx2y->card_index < SNDRV_CARDS) snd_usx2y_card_used[usx2y->card_index] = 0; } static void snd_usx2y_disconnect(struct usb_interface *intf) { struct snd_card *card; struct usx2ydev *usx2y; struct list_head *p; card = usb_get_intfdata(intf); if (!card) return; usx2y = usx2y(card); usx2y->chip_status = USX2Y_STAT_CHIP_HUP; usx2y_unlinkseq(&usx2y->as04); usb_kill_urb(usx2y->in04_urb); snd_card_disconnect(card); /* release the midi resources */ list_for_each(p, &usx2y->midi_list) { snd_usbmidi_disconnect(p); } if (usx2y->us428ctls_sharedmem) wake_up(&usx2y->us428ctls_wait_queue_head); snd_card_free(card); } static int snd_usx2y_probe(struct usb_interface *intf, const struct usb_device_id *id) { struct usb_device *device = interface_to_usbdev(intf); struct snd_card *card; int err; if (le16_to_cpu(device->descriptor.idVendor) != 0x1604 || (le16_to_cpu(device->descriptor.idProduct) != USB_ID_US122 && le16_to_cpu(device->descriptor.idProduct) != USB_ID_US224 && le16_to_cpu(device->descriptor.idProduct) != USB_ID_US428)) return -EINVAL; err = usx2y_create_card(device, intf, &card); if (err < 0) return err; err = usx2y_hwdep_new(card, device); if (err < 0) goto error; err = snd_card_register(card); if (err < 0) goto error; dev_set_drvdata(&intf->dev, card); return 0; error: snd_card_free(card); return err; } static struct usb_driver snd_usx2y_usb_driver = { .name = "snd-usb-usx2y", .probe = snd_usx2y_probe, .disconnect = snd_usx2y_disconnect, .id_table = snd_usx2y_usb_id_table, }; module_usb_driver(snd_usx2y_usb_driver);
linux-master
sound/usb/usx2y/usbusx2y.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * US-X2Y AUDIO * Copyright (c) 2002-2004 by Karsten Wiese * * based on * * (Tentative) USB Audio Driver for ALSA * * Main and PCM part * * Copyright (c) 2002 by Takashi Iwai <[email protected]> * * Many codes borrowed from audio.c by * Alan Cox ([email protected]) * Thomas Sailer ([email protected]) */ #include <linux/interrupt.h> #include <linux/slab.h> #include <linux/usb.h> #include <linux/moduleparam.h> #include <sound/core.h> #include <sound/info.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "usx2y.h" #include "usbusx2y.h" /* Default value used for nr of packs per urb. * 1 to 4 have been tested ok on uhci. * To use 3 on ohci, you'd need a patch: * look for "0000425-linux-2.6.9-rc4-mm1_ohci-hcd.patch.gz" on * "https://bugtrack.alsa-project.org/alsa-bug/bug_view_page.php?bug_id=0000425" * * 1, 2 and 4 work out of the box on ohci, if I recall correctly. * Bigger is safer operation, smaller gives lower latencies. */ #define USX2Y_NRPACKS 4 /* If your system works ok with this module's parameter * nrpacks set to 1, you might as well comment * this define out, and thereby produce smaller, faster code. * You'd also set USX2Y_NRPACKS to 1 then. */ #define USX2Y_NRPACKS_VARIABLE 1 #ifdef USX2Y_NRPACKS_VARIABLE static int nrpacks = USX2Y_NRPACKS; /* number of packets per urb */ #define nr_of_packs() nrpacks module_param(nrpacks, int, 0444); MODULE_PARM_DESC(nrpacks, "Number of packets per URB."); #else #define nr_of_packs() USX2Y_NRPACKS #endif static int usx2y_urb_capt_retire(struct snd_usx2y_substream *subs) { struct urb *urb = subs->completed_urb; struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; unsigned char *cp; int i, len, lens = 0, hwptr_done = subs->hwptr_done; int cnt, blen; struct usx2ydev *usx2y = subs->usx2y; for (i = 0; i < nr_of_packs(); i++) { cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset; if (urb->iso_frame_desc[i].status) { /* active? hmm, skip this */ snd_printk(KERN_ERR "active frame status %i. Most probably some hardware problem.\n", urb->iso_frame_desc[i].status); return urb->iso_frame_desc[i].status; } len = urb->iso_frame_desc[i].actual_length / usx2y->stride; if (!len) { snd_printd("0 == len ERROR!\n"); continue; } /* copy a data chunk */ if ((hwptr_done + len) > runtime->buffer_size) { cnt = runtime->buffer_size - hwptr_done; blen = cnt * usx2y->stride; memcpy(runtime->dma_area + hwptr_done * usx2y->stride, cp, blen); memcpy(runtime->dma_area, cp + blen, len * usx2y->stride - blen); } else { memcpy(runtime->dma_area + hwptr_done * usx2y->stride, cp, len * usx2y->stride); } lens += len; hwptr_done += len; if (hwptr_done >= runtime->buffer_size) hwptr_done -= runtime->buffer_size; } subs->hwptr_done = hwptr_done; subs->transfer_done += lens; /* update the pointer, call callback if necessary */ if (subs->transfer_done >= runtime->period_size) { subs->transfer_done -= runtime->period_size; snd_pcm_period_elapsed(subs->pcm_substream); } return 0; } /* * prepare urb for playback data pipe * * we copy the data directly from the pcm buffer. * the current position to be copied is held in hwptr field. * since a urb can handle only a single linear buffer, if the total * transferred area overflows the buffer boundary, we cannot send * it directly from the buffer. thus the data is once copied to * a temporary buffer and urb points to that. */ static int usx2y_urb_play_prepare(struct snd_usx2y_substream *subs, struct urb *cap_urb, struct urb *urb) { struct usx2ydev *usx2y = subs->usx2y; struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; int count, counts, pack, len; count = 0; for (pack = 0; pack < nr_of_packs(); pack++) { /* calculate the size of a packet */ counts = cap_urb->iso_frame_desc[pack].actual_length / usx2y->stride; count += counts; if (counts < 43 || counts > 50) { snd_printk(KERN_ERR "should not be here with counts=%i\n", counts); return -EPIPE; } /* set up descriptor */ urb->iso_frame_desc[pack].offset = pack ? urb->iso_frame_desc[pack - 1].offset + urb->iso_frame_desc[pack - 1].length : 0; urb->iso_frame_desc[pack].length = cap_urb->iso_frame_desc[pack].actual_length; } if (atomic_read(&subs->state) >= STATE_PRERUNNING) { if (subs->hwptr + count > runtime->buffer_size) { /* err, the transferred area goes over buffer boundary. * copy the data to the temp buffer. */ len = runtime->buffer_size - subs->hwptr; urb->transfer_buffer = subs->tmpbuf; memcpy(subs->tmpbuf, runtime->dma_area + subs->hwptr * usx2y->stride, len * usx2y->stride); memcpy(subs->tmpbuf + len * usx2y->stride, runtime->dma_area, (count - len) * usx2y->stride); subs->hwptr += count; subs->hwptr -= runtime->buffer_size; } else { /* set the buffer pointer */ urb->transfer_buffer = runtime->dma_area + subs->hwptr * usx2y->stride; subs->hwptr += count; if (subs->hwptr >= runtime->buffer_size) subs->hwptr -= runtime->buffer_size; } } else { urb->transfer_buffer = subs->tmpbuf; } urb->transfer_buffer_length = count * usx2y->stride; return 0; } /* * process after playback data complete * * update the current position and call callback if a period is processed. */ static void usx2y_urb_play_retire(struct snd_usx2y_substream *subs, struct urb *urb) { struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; int len = urb->actual_length / subs->usx2y->stride; subs->transfer_done += len; subs->hwptr_done += len; if (subs->hwptr_done >= runtime->buffer_size) subs->hwptr_done -= runtime->buffer_size; if (subs->transfer_done >= runtime->period_size) { subs->transfer_done -= runtime->period_size; snd_pcm_period_elapsed(subs->pcm_substream); } } static int usx2y_urb_submit(struct snd_usx2y_substream *subs, struct urb *urb, int frame) { int err; if (!urb) return -ENODEV; urb->start_frame = frame + NRURBS * nr_of_packs(); // let hcd do rollover sanity checks urb->hcpriv = NULL; urb->dev = subs->usx2y->dev; /* we need to set this at each time */ err = usb_submit_urb(urb, GFP_ATOMIC); if (err < 0) { snd_printk(KERN_ERR "usb_submit_urb() returned %i\n", err); return err; } return 0; } static int usx2y_usbframe_complete(struct snd_usx2y_substream *capsubs, struct snd_usx2y_substream *playbacksubs, int frame) { int err, state; struct urb *urb = playbacksubs->completed_urb; state = atomic_read(&playbacksubs->state); if (urb) { if (state == STATE_RUNNING) usx2y_urb_play_retire(playbacksubs, urb); else if (state >= STATE_PRERUNNING) atomic_inc(&playbacksubs->state); } else { switch (state) { case STATE_STARTING1: urb = playbacksubs->urb[0]; atomic_inc(&playbacksubs->state); break; case STATE_STARTING2: urb = playbacksubs->urb[1]; atomic_inc(&playbacksubs->state); break; } } if (urb) { err = usx2y_urb_play_prepare(playbacksubs, capsubs->completed_urb, urb); if (err) return err; err = usx2y_urb_submit(playbacksubs, urb, frame); if (err) return err; } playbacksubs->completed_urb = NULL; state = atomic_read(&capsubs->state); if (state >= STATE_PREPARED) { if (state == STATE_RUNNING) { err = usx2y_urb_capt_retire(capsubs); if (err) return err; } else if (state >= STATE_PRERUNNING) { atomic_inc(&capsubs->state); } err = usx2y_urb_submit(capsubs, capsubs->completed_urb, frame); if (err) return err; } capsubs->completed_urb = NULL; return 0; } static void usx2y_clients_stop(struct usx2ydev *usx2y) { struct snd_usx2y_substream *subs; struct urb *urb; int s, u; for (s = 0; s < 4; s++) { subs = usx2y->subs[s]; if (subs) { snd_printdd("%i %p state=%i\n", s, subs, atomic_read(&subs->state)); atomic_set(&subs->state, STATE_STOPPED); } } for (s = 0; s < 4; s++) { subs = usx2y->subs[s]; if (subs) { if (atomic_read(&subs->state) >= STATE_PRERUNNING) snd_pcm_stop_xrun(subs->pcm_substream); for (u = 0; u < NRURBS; u++) { urb = subs->urb[u]; if (urb) snd_printdd("%i status=%i start_frame=%i\n", u, urb->status, urb->start_frame); } } } usx2y->prepare_subs = NULL; wake_up(&usx2y->prepare_wait_queue); } static void usx2y_error_urb_status(struct usx2ydev *usx2y, struct snd_usx2y_substream *subs, struct urb *urb) { snd_printk(KERN_ERR "ep=%i stalled with status=%i\n", subs->endpoint, urb->status); urb->status = 0; usx2y_clients_stop(usx2y); } static void i_usx2y_urb_complete(struct urb *urb) { struct snd_usx2y_substream *subs = urb->context; struct usx2ydev *usx2y = subs->usx2y; struct snd_usx2y_substream *capsubs, *playbacksubs; if (unlikely(atomic_read(&subs->state) < STATE_PREPARED)) { snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", usb_get_current_frame_number(usx2y->dev), subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", urb->status, urb->start_frame); return; } if (unlikely(urb->status)) { usx2y_error_urb_status(usx2y, subs, urb); return; } subs->completed_urb = urb; capsubs = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; playbacksubs = usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; if (capsubs->completed_urb && atomic_read(&capsubs->state) >= STATE_PREPARED && (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < STATE_PREPARED)) { if (!usx2y_usbframe_complete(capsubs, playbacksubs, urb->start_frame)) { usx2y->wait_iso_frame += nr_of_packs(); } else { snd_printdd("\n"); usx2y_clients_stop(usx2y); } } } static void usx2y_urbs_set_complete(struct usx2ydev *usx2y, void (*complete)(struct urb *)) { struct snd_usx2y_substream *subs; struct urb *urb; int s, u; for (s = 0; s < 4; s++) { subs = usx2y->subs[s]; if (subs) { for (u = 0; u < NRURBS; u++) { urb = subs->urb[u]; if (urb) urb->complete = complete; } } } } static void usx2y_subs_startup_finish(struct usx2ydev *usx2y) { usx2y_urbs_set_complete(usx2y, i_usx2y_urb_complete); usx2y->prepare_subs = NULL; } static void i_usx2y_subs_startup(struct urb *urb) { struct snd_usx2y_substream *subs = urb->context; struct usx2ydev *usx2y = subs->usx2y; struct snd_usx2y_substream *prepare_subs = usx2y->prepare_subs; if (prepare_subs) { if (urb->start_frame == prepare_subs->urb[0]->start_frame) { usx2y_subs_startup_finish(usx2y); atomic_inc(&prepare_subs->state); wake_up(&usx2y->prepare_wait_queue); } } i_usx2y_urb_complete(urb); } static void usx2y_subs_prepare(struct snd_usx2y_substream *subs) { snd_printdd("usx2y_substream_prepare(%p) ep=%i urb0=%p urb1=%p\n", subs, subs->endpoint, subs->urb[0], subs->urb[1]); /* reset the pointer */ subs->hwptr = 0; subs->hwptr_done = 0; subs->transfer_done = 0; } static void usx2y_urb_release(struct urb **urb, int free_tb) { if (*urb) { usb_kill_urb(*urb); if (free_tb) kfree((*urb)->transfer_buffer); usb_free_urb(*urb); *urb = NULL; } } /* * release a substreams urbs */ static void usx2y_urbs_release(struct snd_usx2y_substream *subs) { int i; snd_printdd("%s %i\n", __func__, subs->endpoint); for (i = 0; i < NRURBS; i++) usx2y_urb_release(subs->urb + i, subs != subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]); kfree(subs->tmpbuf); subs->tmpbuf = NULL; } /* * initialize a substream's urbs */ static int usx2y_urbs_allocate(struct snd_usx2y_substream *subs) { int i; unsigned int pipe; int is_playback = subs == subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; struct usb_device *dev = subs->usx2y->dev; struct urb **purb; pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) : usb_rcvisocpipe(dev, subs->endpoint); subs->maxpacksize = usb_maxpacket(dev, pipe); if (!subs->maxpacksize) return -EINVAL; if (is_playback && !subs->tmpbuf) { /* allocate a temporary buffer for playback */ subs->tmpbuf = kcalloc(nr_of_packs(), subs->maxpacksize, GFP_KERNEL); if (!subs->tmpbuf) return -ENOMEM; } /* allocate and initialize data urbs */ for (i = 0; i < NRURBS; i++) { purb = subs->urb + i; if (*purb) { usb_kill_urb(*purb); continue; } *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL); if (!*purb) { usx2y_urbs_release(subs); return -ENOMEM; } if (!is_playback && !(*purb)->transfer_buffer) { /* allocate a capture buffer per urb */ (*purb)->transfer_buffer = kmalloc_array(subs->maxpacksize, nr_of_packs(), GFP_KERNEL); if (!(*purb)->transfer_buffer) { usx2y_urbs_release(subs); return -ENOMEM; } } (*purb)->dev = dev; (*purb)->pipe = pipe; (*purb)->number_of_packets = nr_of_packs(); (*purb)->context = subs; (*purb)->interval = 1; (*purb)->complete = i_usx2y_subs_startup; } return 0; } static void usx2y_subs_startup(struct snd_usx2y_substream *subs) { struct usx2ydev *usx2y = subs->usx2y; usx2y->prepare_subs = subs; subs->urb[0]->start_frame = -1; wmb(); usx2y_urbs_set_complete(usx2y, i_usx2y_subs_startup); } static int usx2y_urbs_start(struct snd_usx2y_substream *subs) { int i, err; struct usx2ydev *usx2y = subs->usx2y; struct urb *urb; unsigned long pack; err = usx2y_urbs_allocate(subs); if (err < 0) return err; subs->completed_urb = NULL; for (i = 0; i < 4; i++) { struct snd_usx2y_substream *subs = usx2y->subs[i]; if (subs && atomic_read(&subs->state) >= STATE_PREPARED) goto start; } start: usx2y_subs_startup(subs); for (i = 0; i < NRURBS; i++) { urb = subs->urb[i]; if (usb_pipein(urb->pipe)) { if (!i) atomic_set(&subs->state, STATE_STARTING3); urb->dev = usx2y->dev; for (pack = 0; pack < nr_of_packs(); pack++) { urb->iso_frame_desc[pack].offset = subs->maxpacksize * pack; urb->iso_frame_desc[pack].length = subs->maxpacksize; } urb->transfer_buffer_length = subs->maxpacksize * nr_of_packs(); err = usb_submit_urb(urb, GFP_ATOMIC); if (err < 0) { snd_printk(KERN_ERR "cannot submit datapipe for urb %d, err = %d\n", i, err); err = -EPIPE; goto cleanup; } else { if (!i) usx2y->wait_iso_frame = urb->start_frame; } urb->transfer_flags = 0; } else { atomic_set(&subs->state, STATE_STARTING1); break; } } err = 0; wait_event(usx2y->prepare_wait_queue, !usx2y->prepare_subs); if (atomic_read(&subs->state) != STATE_PREPARED) err = -EPIPE; cleanup: if (err) { usx2y_subs_startup_finish(usx2y); usx2y_clients_stop(usx2y); // something is completely wrong > stop everything } return err; } /* * return the current pcm pointer. just return the hwptr_done value. */ static snd_pcm_uframes_t snd_usx2y_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_usx2y_substream *subs = substream->runtime->private_data; return subs->hwptr_done; } /* * start/stop substream */ static int snd_usx2y_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_usx2y_substream *subs = substream->runtime->private_data; switch (cmd) { case SNDRV_PCM_TRIGGER_START: snd_printdd("%s(START)\n", __func__); if (atomic_read(&subs->state) == STATE_PREPARED && atomic_read(&subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]->state) >= STATE_PREPARED) { atomic_set(&subs->state, STATE_PRERUNNING); } else { snd_printdd("\n"); return -EPIPE; } break; case SNDRV_PCM_TRIGGER_STOP: snd_printdd("%s(STOP)\n", __func__); if (atomic_read(&subs->state) >= STATE_PRERUNNING) atomic_set(&subs->state, STATE_PREPARED); break; default: return -EINVAL; } return 0; } /* * allocate a buffer, setup samplerate * * so far we use a physically linear buffer although packetize transfer * doesn't need a continuous area. * if sg buffer is supported on the later version of alsa, we'll follow * that. */ struct s_c2 { char c1, c2; }; static const struct s_c2 setrate_44100[] = { { 0x14, 0x08}, // this line sets 44100, well actually a little less { 0x18, 0x40}, // only tascam / frontier design knows the further lines ....... { 0x18, 0x42}, { 0x18, 0x45}, { 0x18, 0x46}, { 0x18, 0x48}, { 0x18, 0x4A}, { 0x18, 0x4C}, { 0x18, 0x4E}, { 0x18, 0x50}, { 0x18, 0x52}, { 0x18, 0x54}, { 0x18, 0x56}, { 0x18, 0x58}, { 0x18, 0x5A}, { 0x18, 0x5C}, { 0x18, 0x5E}, { 0x18, 0x60}, { 0x18, 0x62}, { 0x18, 0x64}, { 0x18, 0x66}, { 0x18, 0x68}, { 0x18, 0x6A}, { 0x18, 0x6C}, { 0x18, 0x6E}, { 0x18, 0x70}, { 0x18, 0x72}, { 0x18, 0x74}, { 0x18, 0x76}, { 0x18, 0x78}, { 0x18, 0x7A}, { 0x18, 0x7C}, { 0x18, 0x7E} }; static const struct s_c2 setrate_48000[] = { { 0x14, 0x09}, // this line sets 48000, well actually a little less { 0x18, 0x40}, // only tascam / frontier design knows the further lines ....... { 0x18, 0x42}, { 0x18, 0x45}, { 0x18, 0x46}, { 0x18, 0x48}, { 0x18, 0x4A}, { 0x18, 0x4C}, { 0x18, 0x4E}, { 0x18, 0x50}, { 0x18, 0x52}, { 0x18, 0x54}, { 0x18, 0x56}, { 0x18, 0x58}, { 0x18, 0x5A}, { 0x18, 0x5C}, { 0x18, 0x5E}, { 0x18, 0x60}, { 0x18, 0x62}, { 0x18, 0x64}, { 0x18, 0x66}, { 0x18, 0x68}, { 0x18, 0x6A}, { 0x18, 0x6C}, { 0x18, 0x6E}, { 0x18, 0x70}, { 0x18, 0x73}, { 0x18, 0x74}, { 0x18, 0x76}, { 0x18, 0x78}, { 0x18, 0x7A}, { 0x18, 0x7C}, { 0x18, 0x7E} }; #define NOOF_SETRATE_URBS ARRAY_SIZE(setrate_48000) static void i_usx2y_04int(struct urb *urb) { struct usx2ydev *usx2y = urb->context; if (urb->status) snd_printk(KERN_ERR "snd_usx2y_04int() urb->status=%i\n", urb->status); if (!--usx2y->us04->len) wake_up(&usx2y->in04_wait_queue); } static int usx2y_rate_set(struct usx2ydev *usx2y, int rate) { int err = 0, i; struct snd_usx2y_urb_seq *us = NULL; int *usbdata = NULL; const struct s_c2 *ra = rate == 48000 ? setrate_48000 : setrate_44100; struct urb *urb; if (usx2y->rate != rate) { us = kzalloc(struct_size(us, urb, NOOF_SETRATE_URBS), GFP_KERNEL); if (!us) { err = -ENOMEM; goto cleanup; } usbdata = kmalloc_array(NOOF_SETRATE_URBS, sizeof(int), GFP_KERNEL); if (!usbdata) { err = -ENOMEM; goto cleanup; } for (i = 0; i < NOOF_SETRATE_URBS; ++i) { us->urb[i] = usb_alloc_urb(0, GFP_KERNEL); if (!us->urb[i]) { err = -ENOMEM; goto cleanup; } ((char *)(usbdata + i))[0] = ra[i].c1; ((char *)(usbdata + i))[1] = ra[i].c2; usb_fill_bulk_urb(us->urb[i], usx2y->dev, usb_sndbulkpipe(usx2y->dev, 4), usbdata + i, 2, i_usx2y_04int, usx2y); } err = usb_urb_ep_type_check(us->urb[0]); if (err < 0) goto cleanup; us->submitted = 0; us->len = NOOF_SETRATE_URBS; usx2y->us04 = us; wait_event_timeout(usx2y->in04_wait_queue, !us->len, HZ); usx2y->us04 = NULL; if (us->len) err = -ENODEV; cleanup: if (us) { us->submitted = 2*NOOF_SETRATE_URBS; for (i = 0; i < NOOF_SETRATE_URBS; ++i) { urb = us->urb[i]; if (!urb) continue; if (urb->status) { if (!err) err = -ENODEV; usb_kill_urb(urb); } usb_free_urb(urb); } usx2y->us04 = NULL; kfree(usbdata); kfree(us); if (!err) usx2y->rate = rate; } } return err; } static int usx2y_format_set(struct usx2ydev *usx2y, snd_pcm_format_t format) { int alternate, err; struct list_head *p; if (format == SNDRV_PCM_FORMAT_S24_3LE) { alternate = 2; usx2y->stride = 6; } else { alternate = 1; usx2y->stride = 4; } list_for_each(p, &usx2y->midi_list) { snd_usbmidi_input_stop(p); } usb_kill_urb(usx2y->in04_urb); err = usb_set_interface(usx2y->dev, 0, alternate); if (err) { snd_printk(KERN_ERR "usb_set_interface error\n"); return err; } usx2y->in04_urb->dev = usx2y->dev; err = usb_submit_urb(usx2y->in04_urb, GFP_KERNEL); list_for_each(p, &usx2y->midi_list) { snd_usbmidi_input_start(p); } usx2y->format = format; usx2y->rate = 0; return err; } static int snd_usx2y_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { int err = 0; unsigned int rate = params_rate(hw_params); snd_pcm_format_t format = params_format(hw_params); struct snd_card *card = substream->pstr->pcm->card; struct usx2ydev *dev = usx2y(card); struct snd_usx2y_substream *subs; struct snd_pcm_substream *test_substream; int i; mutex_lock(&usx2y(card)->pcm_mutex); snd_printdd("snd_usx2y_hw_params(%p, %p)\n", substream, hw_params); /* all pcm substreams off one usx2y have to operate at the same * rate & format */ for (i = 0; i < dev->pcm_devs * 2; i++) { subs = dev->subs[i]; if (!subs) continue; test_substream = subs->pcm_substream; if (!test_substream || test_substream == substream || !test_substream->runtime) continue; if ((test_substream->runtime->format && test_substream->runtime->format != format) || (test_substream->runtime->rate && test_substream->runtime->rate != rate)) { err = -EINVAL; goto error; } } error: mutex_unlock(&usx2y(card)->pcm_mutex); return err; } /* * free the buffer */ static int snd_usx2y_pcm_hw_free(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usx2y_substream *subs = runtime->private_data; struct snd_usx2y_substream *cap_subs, *playback_subs; mutex_lock(&subs->usx2y->pcm_mutex); snd_printdd("snd_usx2y_hw_free(%p)\n", substream); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { cap_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; atomic_set(&subs->state, STATE_STOPPED); usx2y_urbs_release(subs); if (!cap_subs->pcm_substream || !cap_subs->pcm_substream->runtime || cap_subs->pcm_substream->runtime->state < SNDRV_PCM_STATE_PREPARED) { atomic_set(&cap_subs->state, STATE_STOPPED); usx2y_urbs_release(cap_subs); } } else { playback_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; if (atomic_read(&playback_subs->state) < STATE_PREPARED) { atomic_set(&subs->state, STATE_STOPPED); usx2y_urbs_release(subs); } } mutex_unlock(&subs->usx2y->pcm_mutex); return 0; } /* * prepare callback * * set format and initialize urbs */ static int snd_usx2y_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usx2y_substream *subs = runtime->private_data; struct usx2ydev *usx2y = subs->usx2y; struct snd_usx2y_substream *capsubs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; int err = 0; snd_printdd("%s(%p)\n", __func__, substream); mutex_lock(&usx2y->pcm_mutex); usx2y_subs_prepare(subs); // Start hardware streams // SyncStream first.... if (atomic_read(&capsubs->state) < STATE_PREPARED) { if (usx2y->format != runtime->format) { err = usx2y_format_set(usx2y, runtime->format); if (err < 0) goto up_prepare_mutex; } if (usx2y->rate != runtime->rate) { err = usx2y_rate_set(usx2y, runtime->rate); if (err < 0) goto up_prepare_mutex; } snd_printdd("starting capture pipe for %s\n", subs == capsubs ? "self" : "playpipe"); err = usx2y_urbs_start(capsubs); if (err < 0) goto up_prepare_mutex; } if (subs != capsubs && atomic_read(&subs->state) < STATE_PREPARED) err = usx2y_urbs_start(subs); up_prepare_mutex: mutex_unlock(&usx2y->pcm_mutex); return err; } static const struct snd_pcm_hardware snd_usx2y_2c = { .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_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .rate_min = 44100, .rate_max = 48000, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = (2*128*1024), .period_bytes_min = 64, .period_bytes_max = (128*1024), .periods_min = 2, .periods_max = 1024, .fifo_size = 0 }; static int snd_usx2y_pcm_open(struct snd_pcm_substream *substream) { struct snd_usx2y_substream *subs = ((struct snd_usx2y_substream **) snd_pcm_substream_chip(substream))[substream->stream]; struct snd_pcm_runtime *runtime = substream->runtime; if (subs->usx2y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS) return -EBUSY; runtime->hw = snd_usx2y_2c; runtime->private_data = subs; subs->pcm_substream = substream; snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000); return 0; } static int snd_usx2y_pcm_close(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_usx2y_substream *subs = runtime->private_data; subs->pcm_substream = NULL; return 0; } static const struct snd_pcm_ops snd_usx2y_pcm_ops = { .open = snd_usx2y_pcm_open, .close = snd_usx2y_pcm_close, .hw_params = snd_usx2y_pcm_hw_params, .hw_free = snd_usx2y_pcm_hw_free, .prepare = snd_usx2y_pcm_prepare, .trigger = snd_usx2y_pcm_trigger, .pointer = snd_usx2y_pcm_pointer, }; /* * free a usb stream instance */ static void usx2y_audio_stream_free(struct snd_usx2y_substream **usx2y_substream) { int stream; for_each_pcm_streams(stream) { kfree(usx2y_substream[stream]); usx2y_substream[stream] = NULL; } } static void snd_usx2y_pcm_private_free(struct snd_pcm *pcm) { struct snd_usx2y_substream **usx2y_stream = pcm->private_data; if (usx2y_stream) usx2y_audio_stream_free(usx2y_stream); } static int usx2y_audio_stream_new(struct snd_card *card, int playback_endpoint, int capture_endpoint) { struct snd_pcm *pcm; int err, i; struct snd_usx2y_substream **usx2y_substream = usx2y(card)->subs + 2 * usx2y(card)->pcm_devs; for (i = playback_endpoint ? SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE; i <= SNDRV_PCM_STREAM_CAPTURE; ++i) { usx2y_substream[i] = kzalloc(sizeof(struct snd_usx2y_substream), GFP_KERNEL); if (!usx2y_substream[i]) return -ENOMEM; usx2y_substream[i]->usx2y = usx2y(card); } if (playback_endpoint) usx2y_substream[SNDRV_PCM_STREAM_PLAYBACK]->endpoint = playback_endpoint; usx2y_substream[SNDRV_PCM_STREAM_CAPTURE]->endpoint = capture_endpoint; err = snd_pcm_new(card, NAME_ALLCAPS" Audio", usx2y(card)->pcm_devs, playback_endpoint ? 1 : 0, 1, &pcm); if (err < 0) { usx2y_audio_stream_free(usx2y_substream); return err; } if (playback_endpoint) snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usx2y_pcm_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usx2y_pcm_ops); pcm->private_data = usx2y_substream; pcm->private_free = snd_usx2y_pcm_private_free; pcm->info_flags = 0; sprintf(pcm->name, NAME_ALLCAPS" Audio #%d", usx2y(card)->pcm_devs); if (playback_endpoint) { snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream, SNDRV_DMA_TYPE_CONTINUOUS, NULL, 64*1024, 128*1024); } snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream, SNDRV_DMA_TYPE_CONTINUOUS, NULL, 64*1024, 128*1024); usx2y(card)->pcm_devs++; return 0; } /* * create a chip instance and set its names. */ int usx2y_audio_create(struct snd_card *card) { int err; err = usx2y_audio_stream_new(card, 0xA, 0x8); if (err < 0) return err; if (le16_to_cpu(usx2y(card)->dev->descriptor.idProduct) == USB_ID_US428) { err = usx2y_audio_stream_new(card, 0, 0xA); if (err < 0) return err; } if (le16_to_cpu(usx2y(card)->dev->descriptor.idProduct) != USB_ID_US122) err = usx2y_rate_set(usx2y(card), 44100); // Lets us428 recognize output-volume settings, disturbs us122. return err; }
linux-master
sound/usb/usx2y/usbusx2yaudio.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Pod HD * * Copyright (C) 2011 Stefan Hajnoczi <[email protected]> * Copyright (C) 2015 Andrej Krutak <[email protected]> * Copyright (C) 2017 Hans P. Moller <[email protected]> */ #include <linux/usb.h> #include <linux/slab.h> #include <linux/module.h> #include <sound/core.h> #include <sound/control.h> #include <sound/pcm.h> #include "driver.h" #include "pcm.h" #define PODHD_STARTUP_DELAY 500 enum { LINE6_PODHD300, LINE6_PODHD400, LINE6_PODHD500, LINE6_PODX3, LINE6_PODX3LIVE, LINE6_PODHD500X, LINE6_PODHDDESKTOP }; struct usb_line6_podhd { /* Generic Line 6 USB data */ struct usb_line6 line6; /* Serial number of device */ u32 serial_number; /* Firmware version */ int firmware_version; /* Monitor level */ int monitor_level; }; #define line6_to_podhd(x) container_of(x, struct usb_line6_podhd, line6) static const struct snd_ratden podhd_ratden = { .num_min = 48000, .num_max = 48000, .num_step = 1, .den = 1, }; static struct line6_pcm_properties podhd_pcm_properties = { .playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_SYNC_START), .formats = SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_48000, .rate_min = 48000, .rate_max = 48000, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 60000, .period_bytes_min = 64, .period_bytes_max = 8192, .periods_min = 1, .periods_max = 1024}, .capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START), .formats = SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_48000, .rate_min = 48000, .rate_max = 48000, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 60000, .period_bytes_min = 64, .period_bytes_max = 8192, .periods_min = 1, .periods_max = 1024}, .rates = { .nrats = 1, .rats = &podhd_ratden}, .bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */ }; static struct line6_pcm_properties podx3_pcm_properties = { .playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_SYNC_START), .formats = SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_48000, .rate_min = 48000, .rate_max = 48000, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 60000, .period_bytes_min = 64, .period_bytes_max = 8192, .periods_min = 1, .periods_max = 1024}, .capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START), .formats = SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_48000, .rate_min = 48000, .rate_max = 48000, /* 1+2: Main signal (out), 3+4: Tone 1, * 5+6: Tone 2, 7+8: raw */ .channels_min = 8, .channels_max = 8, .buffer_bytes_max = 60000, .period_bytes_min = 64, .period_bytes_max = 8192, .periods_min = 1, .periods_max = 1024}, .rates = { .nrats = 1, .rats = &podhd_ratden}, .bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */ }; static struct usb_driver podhd_driver; static ssize_t serial_number_show(struct device *dev, struct device_attribute *attr, char *buf) { struct snd_card *card = dev_to_snd_card(dev); struct usb_line6_podhd *pod = card->private_data; return sysfs_emit(buf, "%u\n", pod->serial_number); } static ssize_t firmware_version_show(struct device *dev, struct device_attribute *attr, char *buf) { struct snd_card *card = dev_to_snd_card(dev); struct usb_line6_podhd *pod = card->private_data; return sysfs_emit(buf, "%06x\n", pod->firmware_version); } static DEVICE_ATTR_RO(firmware_version); static DEVICE_ATTR_RO(serial_number); static struct attribute *podhd_dev_attrs[] = { &dev_attr_firmware_version.attr, &dev_attr_serial_number.attr, NULL }; static const struct attribute_group podhd_dev_attr_group = { .name = "podhd", .attrs = podhd_dev_attrs, }; /* * POD X3 startup procedure. * * May be compatible with other POD HD's, since it's also similar to the * previous POD setup. In any case, it doesn't seem to be required for the * audio nor bulk interfaces to work. */ static int podhd_dev_start(struct usb_line6_podhd *pod) { int ret; u8 init_bytes[8]; int i; struct usb_device *usbdev = pod->line6.usbdev; ret = usb_control_msg_send(usbdev, 0, 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 0x11, 0, NULL, 0, LINE6_TIMEOUT, GFP_KERNEL); if (ret) { dev_err(pod->line6.ifcdev, "read request failed (error %d)\n", ret); goto exit; } /* NOTE: looks like some kind of ping message */ ret = usb_control_msg_recv(usbdev, 0, 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 0x11, 0x0, init_bytes, 3, LINE6_TIMEOUT, GFP_KERNEL); if (ret) { dev_err(pod->line6.ifcdev, "receive length failed (error %d)\n", ret); goto exit; } pod->firmware_version = (init_bytes[0] << 16) | (init_bytes[1] << 8) | (init_bytes[2] << 0); for (i = 0; i <= 16; i++) { ret = line6_read_data(&pod->line6, 0xf000 + 0x08 * i, init_bytes, 8); if (ret < 0) goto exit; } ret = usb_control_msg_send(usbdev, 0, USB_REQ_SET_FEATURE, USB_TYPE_STANDARD | USB_RECIP_DEVICE | USB_DIR_OUT, 1, 0, NULL, 0, LINE6_TIMEOUT, GFP_KERNEL); exit: return ret; } static void podhd_startup(struct usb_line6 *line6) { struct usb_line6_podhd *pod = line6_to_podhd(line6); podhd_dev_start(pod); line6_read_serial_number(&pod->line6, &pod->serial_number); if (snd_card_register(line6->card)) dev_err(line6->ifcdev, "Failed to register POD HD card.\n"); } static void podhd_disconnect(struct usb_line6 *line6) { struct usb_line6_podhd *pod = line6_to_podhd(line6); if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO) { struct usb_interface *intf; intf = usb_ifnum_to_if(line6->usbdev, pod->line6.properties->ctrl_if); if (intf) usb_driver_release_interface(&podhd_driver, intf); } } static const unsigned int float_zero_to_one_lookup[] = { 0x00000000, 0x3c23d70a, 0x3ca3d70a, 0x3cf5c28f, 0x3d23d70a, 0x3d4ccccd, 0x3d75c28f, 0x3d8f5c29, 0x3da3d70a, 0x3db851ec, 0x3dcccccd, 0x3de147ae, 0x3df5c28f, 0x3e051eb8, 0x3e0f5c29, 0x3e19999a, 0x3e23d70a, 0x3e2e147b, 0x3e3851ec, 0x3e428f5c, 0x3e4ccccd, 0x3e570a3d, 0x3e6147ae, 0x3e6b851f, 0x3e75c28f, 0x3e800000, 0x3e851eb8, 0x3e8a3d71, 0x3e8f5c29, 0x3e947ae1, 0x3e99999a, 0x3e9eb852, 0x3ea3d70a, 0x3ea8f5c3, 0x3eae147b, 0x3eb33333, 0x3eb851ec, 0x3ebd70a4, 0x3ec28f5c, 0x3ec7ae14, 0x3ecccccd, 0x3ed1eb85, 0x3ed70a3d, 0x3edc28f6, 0x3ee147ae, 0x3ee66666, 0x3eeb851f, 0x3ef0a3d7, 0x3ef5c28f, 0x3efae148, 0x3f000000, 0x3f028f5c, 0x3f051eb8, 0x3f07ae14, 0x3f0a3d71, 0x3f0ccccd, 0x3f0f5c29, 0x3f11eb85, 0x3f147ae1, 0x3f170a3d, 0x3f19999a, 0x3f1c28f6, 0x3f1eb852, 0x3f2147ae, 0x3f23d70a, 0x3f266666, 0x3f28f5c3, 0x3f2b851f, 0x3f2e147b, 0x3f30a3d7, 0x3f333333, 0x3f35c28f, 0x3f3851ec, 0x3f3ae148, 0x3f3d70a4, 0x3f400000, 0x3f428f5c, 0x3f451eb8, 0x3f47ae14, 0x3f4a3d71, 0x3f4ccccd, 0x3f4f5c29, 0x3f51eb85, 0x3f547ae1, 0x3f570a3d, 0x3f59999a, 0x3f5c28f6, 0x3f5eb852, 0x3f6147ae, 0x3f63d70a, 0x3f666666, 0x3f68f5c3, 0x3f6b851f, 0x3f6e147b, 0x3f70a3d7, 0x3f733333, 0x3f75c28f, 0x3f7851ec, 0x3f7ae148, 0x3f7d70a4, 0x3f800000 }; static void podhd_set_monitor_level(struct usb_line6_podhd *podhd, int value) { unsigned int fl; static const unsigned char msg[16] = { /* Chunk is 0xc bytes (without first word) */ 0x0c, 0x00, /* First chunk in the message */ 0x01, 0x00, /* Message size is 2 4-byte words */ 0x02, 0x00, /* Unknown */ 0x04, 0x41, /* Unknown */ 0x04, 0x00, 0x13, 0x00, /* Volume, LE float32, 0.0 - 1.0 */ 0x00, 0x00, 0x00, 0x00 }; unsigned char *buf; buf = kmemdup(msg, sizeof(msg), GFP_KERNEL); if (!buf) return; if (value < 0) value = 0; if (value >= ARRAY_SIZE(float_zero_to_one_lookup)) value = ARRAY_SIZE(float_zero_to_one_lookup) - 1; fl = float_zero_to_one_lookup[value]; buf[12] = (fl >> 0) & 0xff; buf[13] = (fl >> 8) & 0xff; buf[14] = (fl >> 16) & 0xff; buf[15] = (fl >> 24) & 0xff; line6_send_raw_message(&podhd->line6, buf, sizeof(msg)); kfree(buf); podhd->monitor_level = value; } /* control info callback */ static int snd_podhd_control_monitor_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = 100; uinfo->value.integer.step = 1; return 0; } /* control get callback */ static int snd_podhd_control_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); struct usb_line6_podhd *podhd = line6_to_podhd(line6pcm->line6); ucontrol->value.integer.value[0] = podhd->monitor_level; return 0; } /* control put callback */ static int snd_podhd_control_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); struct usb_line6_podhd *podhd = line6_to_podhd(line6pcm->line6); if (ucontrol->value.integer.value[0] == podhd->monitor_level) return 0; podhd_set_monitor_level(podhd, ucontrol->value.integer.value[0]); return 1; } /* control definition */ static const struct snd_kcontrol_new podhd_control_monitor = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitor Playback Volume", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_podhd_control_monitor_info, .get = snd_podhd_control_monitor_get, .put = snd_podhd_control_monitor_put }; /* Try to init POD HD device. */ static int podhd_init(struct usb_line6 *line6, const struct usb_device_id *id) { int err; struct usb_line6_podhd *pod = line6_to_podhd(line6); struct usb_interface *intf; line6->disconnect = podhd_disconnect; line6->startup = podhd_startup; if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) { /* claim the data interface */ intf = usb_ifnum_to_if(line6->usbdev, pod->line6.properties->ctrl_if); if (!intf) { dev_err(pod->line6.ifcdev, "interface %d not found\n", pod->line6.properties->ctrl_if); return -ENODEV; } err = usb_driver_claim_interface(&podhd_driver, intf, NULL); if (err != 0) { dev_err(pod->line6.ifcdev, "can't claim interface %d, error %d\n", pod->line6.properties->ctrl_if, err); return err; } } if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO) { /* create sysfs entries: */ err = snd_card_add_dev_attr(line6->card, &podhd_dev_attr_group); if (err < 0) return err; } if (pod->line6.properties->capabilities & LINE6_CAP_PCM) { /* initialize PCM subsystem: */ err = line6_init_pcm(line6, (id->driver_info == LINE6_PODX3 || id->driver_info == LINE6_PODX3LIVE) ? &podx3_pcm_properties : &podhd_pcm_properties); if (err < 0) return err; } if (pod->line6.properties->capabilities & LINE6_CAP_HWMON_CTL) { podhd_set_monitor_level(pod, 100); err = snd_ctl_add(line6->card, snd_ctl_new1(&podhd_control_monitor, line6->line6pcm)); if (err < 0) return err; } if (!(pod->line6.properties->capabilities & LINE6_CAP_CONTROL_INFO)) { /* register USB audio system directly */ return snd_card_register(line6->card); } /* init device and delay registering */ schedule_delayed_work(&line6->startup_work, msecs_to_jiffies(PODHD_STARTUP_DELAY)); return 0; } #define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod) #define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n) /* table of devices that work with this driver */ static const struct usb_device_id podhd_id_table[] = { /* TODO: no need to alloc data interfaces when only audio is used */ { LINE6_DEVICE(0x5057), .driver_info = LINE6_PODHD300 }, { LINE6_DEVICE(0x5058), .driver_info = LINE6_PODHD400 }, { LINE6_IF_NUM(0x414D, 0), .driver_info = LINE6_PODHD500 }, { LINE6_IF_NUM(0x414A, 0), .driver_info = LINE6_PODX3 }, { LINE6_IF_NUM(0x414B, 0), .driver_info = LINE6_PODX3LIVE }, { LINE6_IF_NUM(0x4159, 0), .driver_info = LINE6_PODHD500X }, { LINE6_IF_NUM(0x4156, 0), .driver_info = LINE6_PODHDDESKTOP }, {} }; MODULE_DEVICE_TABLE(usb, podhd_id_table); static const struct line6_properties podhd_properties_table[] = { [LINE6_PODHD300] = { .id = "PODHD300", .name = "POD HD300", .capabilities = LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 5, .ep_ctrl_r = 0x84, .ep_ctrl_w = 0x03, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_PODHD400] = { .id = "PODHD400", .name = "POD HD400", .capabilities = LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 5, .ep_ctrl_r = 0x84, .ep_ctrl_w = 0x03, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_PODHD500] = { .id = "PODHD500", .name = "POD HD500", .capabilities = LINE6_CAP_PCM | LINE6_CAP_CONTROL | LINE6_CAP_HWMON | LINE6_CAP_HWMON_CTL, .altsetting = 1, .ctrl_if = 1, .ep_ctrl_r = 0x81, .ep_ctrl_w = 0x01, .ep_audio_r = 0x86, .ep_audio_w = 0x02, }, [LINE6_PODX3] = { .id = "PODX3", .name = "POD X3", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_INFO | LINE6_CAP_PCM | LINE6_CAP_HWMON | LINE6_CAP_IN_NEEDS_OUT, .altsetting = 1, .ep_ctrl_r = 0x81, .ep_ctrl_w = 0x01, .ctrl_if = 1, .ep_audio_r = 0x86, .ep_audio_w = 0x02, }, [LINE6_PODX3LIVE] = { .id = "PODX3LIVE", .name = "POD X3 LIVE", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_INFO | LINE6_CAP_PCM | LINE6_CAP_HWMON | LINE6_CAP_IN_NEEDS_OUT, .altsetting = 1, .ep_ctrl_r = 0x81, .ep_ctrl_w = 0x01, .ctrl_if = 1, .ep_audio_r = 0x86, .ep_audio_w = 0x02, }, [LINE6_PODHD500X] = { .id = "PODHD500X", .name = "POD HD500X", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 1, .ep_ctrl_r = 0x81, .ep_ctrl_w = 0x01, .ctrl_if = 1, .ep_audio_r = 0x86, .ep_audio_w = 0x02, }, [LINE6_PODHDDESKTOP] = { .id = "PODHDDESKTOP", .name = "POD HDDESKTOP", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 1, .ep_ctrl_r = 0x81, .ep_ctrl_w = 0x01, .ctrl_if = 1, .ep_audio_r = 0x86, .ep_audio_w = 0x02, }, }; /* Probe USB device. */ static int podhd_probe(struct usb_interface *interface, const struct usb_device_id *id) { return line6_probe(interface, id, "Line6-PODHD", &podhd_properties_table[id->driver_info], podhd_init, sizeof(struct usb_line6_podhd)); } static struct usb_driver podhd_driver = { .name = KBUILD_MODNAME, .probe = podhd_probe, .disconnect = line6_disconnect, #ifdef CONFIG_PM .suspend = line6_suspend, .resume = line6_resume, .reset_resume = line6_resume, #endif .id_table = podhd_id_table, }; module_usb_driver(podhd_driver); MODULE_DESCRIPTION("Line 6 PODHD USB driver"); MODULE_LICENSE("GPL");
linux-master
sound/usb/line6/podhd.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) */ #include <linux/slab.h> #include <linux/export.h> #include <sound/core.h> #include <sound/control.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "capture.h" #include "driver.h" #include "playback.h" /* impulse response volume controls */ static int snd_line6_impulse_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = 255; return 0; } static int snd_line6_impulse_volume_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = line6pcm->impulse_volume; return 0; } static int snd_line6_impulse_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); int value = ucontrol->value.integer.value[0]; int err; if (line6pcm->impulse_volume == value) return 0; line6pcm->impulse_volume = value; if (value > 0) { err = line6_pcm_acquire(line6pcm, LINE6_STREAM_IMPULSE, true); if (err < 0) { line6pcm->impulse_volume = 0; return err; } } else { line6_pcm_release(line6pcm, LINE6_STREAM_IMPULSE); } return 1; } /* impulse response period controls */ static int snd_line6_impulse_period_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = 2000; return 0; } static int snd_line6_impulse_period_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = line6pcm->impulse_period; return 0; } static int snd_line6_impulse_period_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); int value = ucontrol->value.integer.value[0]; if (line6pcm->impulse_period == value) return 0; line6pcm->impulse_period = value; return 1; } /* Unlink all currently active URBs. */ static void line6_unlink_audio_urbs(struct snd_line6_pcm *line6pcm, struct line6_pcm_stream *pcms) { int i; for (i = 0; i < line6pcm->line6->iso_buffers; i++) { if (test_bit(i, &pcms->active_urbs)) { if (!test_and_set_bit(i, &pcms->unlink_urbs)) usb_unlink_urb(pcms->urbs[i]); } } } /* Wait until unlinking of all currently active URBs has been finished. */ static void line6_wait_clear_audio_urbs(struct snd_line6_pcm *line6pcm, struct line6_pcm_stream *pcms) { int timeout = HZ; int i; int alive; do { alive = 0; for (i = 0; i < line6pcm->line6->iso_buffers; i++) { if (test_bit(i, &pcms->active_urbs)) alive++; } if (!alive) break; set_current_state(TASK_UNINTERRUPTIBLE); schedule_timeout(1); } while (--timeout > 0); if (alive) dev_err(line6pcm->line6->ifcdev, "timeout: still %d active urbs..\n", alive); } static inline struct line6_pcm_stream * get_stream(struct snd_line6_pcm *line6pcm, int direction) { return (direction == SNDRV_PCM_STREAM_PLAYBACK) ? &line6pcm->out : &line6pcm->in; } /* allocate a buffer if not opened yet; * call this in line6pcm.state_mutex */ static int line6_buffer_acquire(struct snd_line6_pcm *line6pcm, struct line6_pcm_stream *pstr, int direction, int type) { const int pkt_size = (direction == SNDRV_PCM_STREAM_PLAYBACK) ? line6pcm->max_packet_size_out : line6pcm->max_packet_size_in; /* Invoked multiple times in a row so allocate once only */ if (!test_and_set_bit(type, &pstr->opened) && !pstr->buffer) { pstr->buffer = kmalloc(array3_size(line6pcm->line6->iso_buffers, LINE6_ISO_PACKETS, pkt_size), GFP_KERNEL); if (!pstr->buffer) return -ENOMEM; } return 0; } /* free a buffer if all streams are closed; * call this in line6pcm.state_mutex */ static void line6_buffer_release(struct snd_line6_pcm *line6pcm, struct line6_pcm_stream *pstr, int type) { clear_bit(type, &pstr->opened); if (!pstr->opened) { line6_wait_clear_audio_urbs(line6pcm, pstr); kfree(pstr->buffer); pstr->buffer = NULL; } } /* start a PCM stream */ static int line6_stream_start(struct snd_line6_pcm *line6pcm, int direction, int type) { unsigned long flags; struct line6_pcm_stream *pstr = get_stream(line6pcm, direction); int ret = 0; spin_lock_irqsave(&pstr->lock, flags); if (!test_and_set_bit(type, &pstr->running) && !(pstr->active_urbs || pstr->unlink_urbs)) { pstr->count = 0; /* Submit all currently available URBs */ if (direction == SNDRV_PCM_STREAM_PLAYBACK) ret = line6_submit_audio_out_all_urbs(line6pcm); else ret = line6_submit_audio_in_all_urbs(line6pcm); } if (ret < 0) clear_bit(type, &pstr->running); spin_unlock_irqrestore(&pstr->lock, flags); return ret; } /* stop a PCM stream; this doesn't sync with the unlinked URBs */ static void line6_stream_stop(struct snd_line6_pcm *line6pcm, int direction, int type) { unsigned long flags; struct line6_pcm_stream *pstr = get_stream(line6pcm, direction); spin_lock_irqsave(&pstr->lock, flags); clear_bit(type, &pstr->running); if (!pstr->running) { spin_unlock_irqrestore(&pstr->lock, flags); line6_unlink_audio_urbs(line6pcm, pstr); spin_lock_irqsave(&pstr->lock, flags); if (direction == SNDRV_PCM_STREAM_CAPTURE) { line6pcm->prev_fbuf = NULL; line6pcm->prev_fsize = 0; } } spin_unlock_irqrestore(&pstr->lock, flags); } /* common PCM trigger callback */ int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); struct snd_pcm_substream *s; int err; clear_bit(LINE6_FLAG_PREPARED, &line6pcm->flags); snd_pcm_group_for_each_entry(s, substream) { if (s->pcm->card != substream->pcm->card) continue; switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_RESUME: if (s->stream == SNDRV_PCM_STREAM_CAPTURE && (line6pcm->line6->properties->capabilities & LINE6_CAP_IN_NEEDS_OUT)) { err = line6_stream_start(line6pcm, SNDRV_PCM_STREAM_PLAYBACK, LINE6_STREAM_CAPTURE_HELPER); if (err < 0) return err; } err = line6_stream_start(line6pcm, s->stream, LINE6_STREAM_PCM); if (err < 0) return err; break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_SUSPEND: if (s->stream == SNDRV_PCM_STREAM_CAPTURE && (line6pcm->line6->properties->capabilities & LINE6_CAP_IN_NEEDS_OUT)) { line6_stream_stop(line6pcm, SNDRV_PCM_STREAM_PLAYBACK, LINE6_STREAM_CAPTURE_HELPER); } line6_stream_stop(line6pcm, s->stream, LINE6_STREAM_PCM); break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: if (s->stream != SNDRV_PCM_STREAM_PLAYBACK) return -EINVAL; set_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags); break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: if (s->stream != SNDRV_PCM_STREAM_PLAYBACK) return -EINVAL; clear_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags); break; default: return -EINVAL; } } return 0; } /* common PCM pointer callback */ snd_pcm_uframes_t snd_line6_pointer(struct snd_pcm_substream *substream) { struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); return pstr->pos_done; } /* Acquire and optionally start duplex streams: * type is either LINE6_STREAM_IMPULSE or LINE6_STREAM_MONITOR */ int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int type, bool start) { struct line6_pcm_stream *pstr; int ret = 0, dir; /* TODO: We should assert SNDRV_PCM_STREAM_PLAYBACK/CAPTURE == 0/1 */ mutex_lock(&line6pcm->state_mutex); for (dir = 0; dir < 2; dir++) { pstr = get_stream(line6pcm, dir); ret = line6_buffer_acquire(line6pcm, pstr, dir, type); if (ret < 0) goto error; if (!pstr->running) line6_wait_clear_audio_urbs(line6pcm, pstr); } if (start) { for (dir = 0; dir < 2; dir++) { ret = line6_stream_start(line6pcm, dir, type); if (ret < 0) goto error; } } error: mutex_unlock(&line6pcm->state_mutex); if (ret < 0) line6_pcm_release(line6pcm, type); return ret; } EXPORT_SYMBOL_GPL(line6_pcm_acquire); /* Stop and release duplex streams */ void line6_pcm_release(struct snd_line6_pcm *line6pcm, int type) { struct line6_pcm_stream *pstr; int dir; mutex_lock(&line6pcm->state_mutex); for (dir = 0; dir < 2; dir++) line6_stream_stop(line6pcm, dir, type); for (dir = 0; dir < 2; dir++) { pstr = get_stream(line6pcm, dir); line6_buffer_release(line6pcm, pstr, type); } mutex_unlock(&line6pcm->state_mutex); } EXPORT_SYMBOL_GPL(line6_pcm_release); /* common PCM hw_params callback */ int snd_line6_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { int ret; struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); mutex_lock(&line6pcm->state_mutex); ret = line6_buffer_acquire(line6pcm, pstr, substream->stream, LINE6_STREAM_PCM); if (ret < 0) goto error; pstr->period = params_period_bytes(hw_params); error: mutex_unlock(&line6pcm->state_mutex); return ret; } /* common PCM hw_free callback */ int snd_line6_hw_free(struct snd_pcm_substream *substream) { struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); mutex_lock(&line6pcm->state_mutex); line6_buffer_release(line6pcm, pstr, LINE6_STREAM_PCM); mutex_unlock(&line6pcm->state_mutex); return 0; } /* control info callback */ static int snd_line6_control_playback_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; uinfo->value.integer.max = 256; return 0; } /* control get callback */ static int snd_line6_control_playback_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int i; struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); for (i = 0; i < 2; i++) ucontrol->value.integer.value[i] = line6pcm->volume_playback[i]; return 0; } /* control put callback */ static int snd_line6_control_playback_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int i, changed = 0; struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); for (i = 0; i < 2; i++) if (line6pcm->volume_playback[i] != ucontrol->value.integer.value[i]) { line6pcm->volume_playback[i] = ucontrol->value.integer.value[i]; changed = 1; } return changed; } /* control definition */ static const struct snd_kcontrol_new line6_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Playback Volume", .info = snd_line6_control_playback_info, .get = snd_line6_control_playback_get, .put = snd_line6_control_playback_put }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Impulse Response Volume", .info = snd_line6_impulse_volume_info, .get = snd_line6_impulse_volume_get, .put = snd_line6_impulse_volume_put }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Impulse Response Period", .info = snd_line6_impulse_period_info, .get = snd_line6_impulse_period_get, .put = snd_line6_impulse_period_put }, }; /* Cleanup the PCM device. */ static void cleanup_urbs(struct line6_pcm_stream *pcms, int iso_buffers) { int i; /* Most likely impossible in current code... */ if (pcms->urbs == NULL) return; for (i = 0; i < iso_buffers; i++) { if (pcms->urbs[i]) { usb_kill_urb(pcms->urbs[i]); usb_free_urb(pcms->urbs[i]); } } kfree(pcms->urbs); pcms->urbs = NULL; } static void line6_cleanup_pcm(struct snd_pcm *pcm) { struct snd_line6_pcm *line6pcm = snd_pcm_chip(pcm); cleanup_urbs(&line6pcm->out, line6pcm->line6->iso_buffers); cleanup_urbs(&line6pcm->in, line6pcm->line6->iso_buffers); kfree(line6pcm); } /* create a PCM device */ static int snd_line6_new_pcm(struct usb_line6 *line6, struct snd_pcm **pcm_ret) { struct snd_pcm *pcm; int err; err = snd_pcm_new(line6->card, (char *)line6->properties->name, 0, 1, 1, pcm_ret); if (err < 0) return err; pcm = *pcm_ret; strcpy(pcm->name, line6->properties->name); /* set operators */ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_line6_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_line6_capture_ops); /* pre-allocation of buffers */ snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, NULL, 64 * 1024, 128 * 1024); return 0; } /* Sync with PCM stream stops. */ void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm) { line6_unlink_audio_urbs(line6pcm, &line6pcm->out); line6_unlink_audio_urbs(line6pcm, &line6pcm->in); line6_wait_clear_audio_urbs(line6pcm, &line6pcm->out); line6_wait_clear_audio_urbs(line6pcm, &line6pcm->in); } /* Create and register the PCM device and mixer entries. Create URBs for playback and capture. */ int line6_init_pcm(struct usb_line6 *line6, struct line6_pcm_properties *properties) { int i, err; unsigned ep_read = line6->properties->ep_audio_r; unsigned ep_write = line6->properties->ep_audio_w; struct snd_pcm *pcm; struct snd_line6_pcm *line6pcm; if (!(line6->properties->capabilities & LINE6_CAP_PCM)) return 0; /* skip PCM initialization and report success */ err = snd_line6_new_pcm(line6, &pcm); if (err < 0) return err; line6pcm = kzalloc(sizeof(*line6pcm), GFP_KERNEL); if (!line6pcm) return -ENOMEM; mutex_init(&line6pcm->state_mutex); line6pcm->pcm = pcm; line6pcm->properties = properties; line6pcm->volume_playback[0] = line6pcm->volume_playback[1] = 255; line6pcm->volume_monitor = 255; line6pcm->line6 = line6; spin_lock_init(&line6pcm->out.lock); spin_lock_init(&line6pcm->in.lock); line6pcm->impulse_period = LINE6_IMPULSE_DEFAULT_PERIOD; line6->line6pcm = line6pcm; pcm->private_data = line6pcm; pcm->private_free = line6_cleanup_pcm; line6pcm->max_packet_size_in = usb_maxpacket(line6->usbdev, usb_rcvisocpipe(line6->usbdev, ep_read)); line6pcm->max_packet_size_out = usb_maxpacket(line6->usbdev, usb_sndisocpipe(line6->usbdev, ep_write)); if (!line6pcm->max_packet_size_in || !line6pcm->max_packet_size_out) { dev_err(line6pcm->line6->ifcdev, "cannot get proper max packet size\n"); return -EINVAL; } err = line6_create_audio_out_urbs(line6pcm); if (err < 0) return err; err = line6_create_audio_in_urbs(line6pcm); if (err < 0) return err; /* mixer: */ for (i = 0; i < ARRAY_SIZE(line6_controls); i++) { err = snd_ctl_add(line6->card, snd_ctl_new1(&line6_controls[i], line6pcm)); if (err < 0) return err; } return 0; } EXPORT_SYMBOL_GPL(line6_init_pcm); /* prepare pcm callback */ int snd_line6_prepare(struct snd_pcm_substream *substream) { struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream); mutex_lock(&line6pcm->state_mutex); if (!pstr->running) line6_wait_clear_audio_urbs(line6pcm, pstr); if (!test_and_set_bit(LINE6_FLAG_PREPARED, &line6pcm->flags)) { line6pcm->out.count = 0; line6pcm->out.pos = 0; line6pcm->out.pos_done = 0; line6pcm->out.bytes = 0; line6pcm->in.count = 0; line6pcm->in.pos_done = 0; line6pcm->in.bytes = 0; } mutex_unlock(&line6pcm->state_mutex); return 0; }
linux-master
sound/usb/line6/pcm.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) */ #include <linux/slab.h> #include <linux/spinlock.h> #include <linux/usb.h> #include <linux/wait.h> #include <linux/module.h> #include <sound/core.h> #include "driver.h" #define VARIAX_STARTUP_DELAY1 1000 #define VARIAX_STARTUP_DELAY3 100 #define VARIAX_STARTUP_DELAY4 100 /* Stages of Variax startup procedure */ enum { VARIAX_STARTUP_VERSIONREQ, VARIAX_STARTUP_ACTIVATE, VARIAX_STARTUP_SETUP, }; enum { LINE6_PODXTLIVE_VARIAX, LINE6_VARIAX }; struct usb_line6_variax { /* Generic Line 6 USB data */ struct usb_line6 line6; /* Buffer for activation code */ unsigned char *buffer_activate; /* Current progress in startup procedure */ int startup_progress; }; #define line6_to_variax(x) container_of(x, struct usb_line6_variax, line6) #define VARIAX_OFFSET_ACTIVATE 7 /* This message is sent by the device during initialization and identifies the connected guitar version. */ static const char variax_init_version[] = { 0xf0, 0x7e, 0x7f, 0x06, 0x02, 0x00, 0x01, 0x0c, 0x07, 0x00, 0x00, 0x00 }; /* This message is the last one sent by the device during initialization. */ static const char variax_init_done[] = { 0xf0, 0x00, 0x01, 0x0c, 0x07, 0x00, 0x6b }; static const char variax_activate[] = { 0xf0, 0x00, 0x01, 0x0c, 0x07, 0x00, 0x2a, 0x01, 0xf7 }; static void variax_activate_async(struct usb_line6_variax *variax, int a) { variax->buffer_activate[VARIAX_OFFSET_ACTIVATE] = a; line6_send_raw_message_async(&variax->line6, variax->buffer_activate, sizeof(variax_activate)); } /* Variax startup procedure. This is a sequence of functions with special requirements (e.g., must not run immediately after initialization, must not run in interrupt context). After the last one has finished, the device is ready to use. */ static void variax_startup(struct usb_line6 *line6) { struct usb_line6_variax *variax = line6_to_variax(line6); switch (variax->startup_progress) { case VARIAX_STARTUP_VERSIONREQ: /* repeat request until getting the response */ schedule_delayed_work(&line6->startup_work, msecs_to_jiffies(VARIAX_STARTUP_DELAY1)); /* request firmware version: */ line6_version_request_async(line6); break; case VARIAX_STARTUP_ACTIVATE: /* activate device: */ variax_activate_async(variax, 1); variax->startup_progress = VARIAX_STARTUP_SETUP; schedule_delayed_work(&line6->startup_work, msecs_to_jiffies(VARIAX_STARTUP_DELAY4)); break; case VARIAX_STARTUP_SETUP: /* ALSA audio interface: */ snd_card_register(variax->line6.card); break; } } /* Process a completely received message. */ static void line6_variax_process_message(struct usb_line6 *line6) { struct usb_line6_variax *variax = line6_to_variax(line6); const unsigned char *buf = variax->line6.buffer_message; switch (buf[0]) { case LINE6_RESET: dev_info(variax->line6.ifcdev, "VARIAX reset\n"); break; case LINE6_SYSEX_BEGIN: if (memcmp(buf + 1, variax_init_version + 1, sizeof(variax_init_version) - 1) == 0) { if (variax->startup_progress >= VARIAX_STARTUP_ACTIVATE) break; variax->startup_progress = VARIAX_STARTUP_ACTIVATE; cancel_delayed_work(&line6->startup_work); schedule_delayed_work(&line6->startup_work, msecs_to_jiffies(VARIAX_STARTUP_DELAY3)); } else if (memcmp(buf + 1, variax_init_done + 1, sizeof(variax_init_done) - 1) == 0) { /* notify of complete initialization: */ if (variax->startup_progress >= VARIAX_STARTUP_SETUP) break; cancel_delayed_work(&line6->startup_work); schedule_delayed_work(&line6->startup_work, 0); } break; } } /* Variax destructor. */ static void line6_variax_disconnect(struct usb_line6 *line6) { struct usb_line6_variax *variax = line6_to_variax(line6); kfree(variax->buffer_activate); } /* Try to init workbench device. */ static int variax_init(struct usb_line6 *line6, const struct usb_device_id *id) { struct usb_line6_variax *variax = line6_to_variax(line6); line6->process_message = line6_variax_process_message; line6->disconnect = line6_variax_disconnect; line6->startup = variax_startup; /* initialize USB buffers: */ variax->buffer_activate = kmemdup(variax_activate, sizeof(variax_activate), GFP_KERNEL); if (variax->buffer_activate == NULL) return -ENOMEM; /* initiate startup procedure: */ schedule_delayed_work(&line6->startup_work, msecs_to_jiffies(VARIAX_STARTUP_DELAY1)); return 0; } #define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod) #define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n) /* table of devices that work with this driver */ static const struct usb_device_id variax_id_table[] = { { LINE6_IF_NUM(0x4650, 1), .driver_info = LINE6_PODXTLIVE_VARIAX }, { LINE6_DEVICE(0x534d), .driver_info = LINE6_VARIAX }, {} }; MODULE_DEVICE_TABLE(usb, variax_id_table); static const struct line6_properties variax_properties_table[] = { [LINE6_PODXTLIVE_VARIAX] = { .id = "PODxtLive", .name = "PODxt Live", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI, .altsetting = 1, .ep_ctrl_r = 0x86, .ep_ctrl_w = 0x05, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_VARIAX] = { .id = "Variax", .name = "Variax Workbench", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI, .altsetting = 1, .ep_ctrl_r = 0x82, .ep_ctrl_w = 0x01, /* no audio channel */ } }; /* Probe USB device. */ static int variax_probe(struct usb_interface *interface, const struct usb_device_id *id) { return line6_probe(interface, id, "Line6-Variax", &variax_properties_table[id->driver_info], variax_init, sizeof(struct usb_line6_variax)); } static struct usb_driver variax_driver = { .name = KBUILD_MODNAME, .probe = variax_probe, .disconnect = line6_disconnect, #ifdef CONFIG_PM .suspend = line6_suspend, .resume = line6_resume, .reset_resume = line6_resume, #endif .id_table = variax_id_table, }; module_usb_driver(variax_driver); MODULE_DESCRIPTION("Variax Workbench USB driver"); MODULE_LICENSE("GPL");
linux-master
sound/usb/line6/variax.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) */ #include <linux/slab.h> #include <linux/wait.h> #include <linux/interrupt.h> #include <linux/module.h> #include <linux/usb.h> #include <sound/core.h> #include <sound/control.h> #include "capture.h" #include "driver.h" #include "playback.h" /* Locate name in binary program dump */ #define POD_NAME_OFFSET 0 #define POD_NAME_LENGTH 16 /* Other constants */ #define POD_CONTROL_SIZE 0x80 #define POD_BUFSIZE_DUMPREQ 7 #define POD_STARTUP_DELAY 1000 /* Stages of POD startup procedure */ enum { POD_STARTUP_VERSIONREQ, POD_STARTUP_SETUP, POD_STARTUP_DONE, }; enum { LINE6_BASSPODXT, LINE6_BASSPODXTLIVE, LINE6_BASSPODXTPRO, LINE6_POCKETPOD, LINE6_PODXT, LINE6_PODXTLIVE_POD, LINE6_PODXTPRO, }; struct usb_line6_pod { /* Generic Line 6 USB data */ struct usb_line6 line6; /* Instrument monitor level */ int monitor_level; /* Current progress in startup procedure */ int startup_progress; /* Serial number of device */ u32 serial_number; /* Firmware version (x 100) */ int firmware_version; /* Device ID */ int device_id; }; #define line6_to_pod(x) container_of(x, struct usb_line6_pod, line6) #define POD_SYSEX_CODE 3 /* *INDENT-OFF* */ enum { POD_SYSEX_SAVE = 0x24, POD_SYSEX_SYSTEM = 0x56, POD_SYSEX_SYSTEMREQ = 0x57, /* POD_SYSEX_UPDATE = 0x6c, */ /* software update! */ POD_SYSEX_STORE = 0x71, POD_SYSEX_FINISH = 0x72, POD_SYSEX_DUMPMEM = 0x73, POD_SYSEX_DUMP = 0x74, POD_SYSEX_DUMPREQ = 0x75 /* dumps entire internal memory of PODxt Pro */ /* POD_SYSEX_DUMPMEM2 = 0x76 */ }; enum { POD_MONITOR_LEVEL = 0x04, POD_SYSTEM_INVALID = 0x10000 }; /* *INDENT-ON* */ enum { POD_DUMP_MEMORY = 2 }; enum { POD_BUSY_READ, POD_BUSY_WRITE, POD_CHANNEL_DIRTY, POD_SAVE_PRESSED, POD_BUSY_MIDISEND }; static const struct snd_ratden pod_ratden = { .num_min = 78125, .num_max = 78125, .num_step = 1, .den = 2 }; static struct line6_pcm_properties pod_pcm_properties = { .playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_SYNC_START), .formats = SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_KNOT, .rate_min = 39062, .rate_max = 39063, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 60000, .period_bytes_min = 64, .period_bytes_max = 8192, .periods_min = 1, .periods_max = 1024}, .capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START), .formats = SNDRV_PCM_FMTBIT_S24_3LE, .rates = SNDRV_PCM_RATE_KNOT, .rate_min = 39062, .rate_max = 39063, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 60000, .period_bytes_min = 64, .period_bytes_max = 8192, .periods_min = 1, .periods_max = 1024}, .rates = { .nrats = 1, .rats = &pod_ratden}, .bytes_per_channel = 3 /* SNDRV_PCM_FMTBIT_S24_3LE */ }; static const char pod_version_header[] = { 0xf0, 0x7e, 0x7f, 0x06, 0x02 }; static char *pod_alloc_sysex_buffer(struct usb_line6_pod *pod, int code, int size) { return line6_alloc_sysex_buffer(&pod->line6, POD_SYSEX_CODE, code, size); } /* Process a completely received message. */ static void line6_pod_process_message(struct usb_line6 *line6) { struct usb_line6_pod *pod = line6_to_pod(line6); const unsigned char *buf = pod->line6.buffer_message; if (memcmp(buf, pod_version_header, sizeof(pod_version_header)) == 0) { pod->firmware_version = buf[13] * 100 + buf[14] * 10 + buf[15]; pod->device_id = ((int)buf[8] << 16) | ((int)buf[9] << 8) | (int) buf[10]; if (pod->startup_progress == POD_STARTUP_VERSIONREQ) { pod->startup_progress = POD_STARTUP_SETUP; schedule_delayed_work(&line6->startup_work, 0); } return; } /* Only look for sysex messages from this device */ if (buf[0] != (LINE6_SYSEX_BEGIN | LINE6_CHANNEL_DEVICE) && buf[0] != (LINE6_SYSEX_BEGIN | LINE6_CHANNEL_UNKNOWN)) { return; } if (memcmp(buf + 1, line6_midi_id, sizeof(line6_midi_id)) != 0) return; if (buf[5] == POD_SYSEX_SYSTEM && buf[6] == POD_MONITOR_LEVEL) { short value = ((int)buf[7] << 12) | ((int)buf[8] << 8) | ((int)buf[9] << 4) | (int)buf[10]; pod->monitor_level = value; } } /* Send system parameter (from integer). */ static int pod_set_system_param_int(struct usb_line6_pod *pod, int value, int code) { char *sysex; static const int size = 5; sysex = pod_alloc_sysex_buffer(pod, POD_SYSEX_SYSTEM, size); if (!sysex) return -ENOMEM; sysex[SYSEX_DATA_OFS] = code; sysex[SYSEX_DATA_OFS + 1] = (value >> 12) & 0x0f; sysex[SYSEX_DATA_OFS + 2] = (value >> 8) & 0x0f; sysex[SYSEX_DATA_OFS + 3] = (value >> 4) & 0x0f; sysex[SYSEX_DATA_OFS + 4] = (value) & 0x0f; line6_send_sysex_message(&pod->line6, sysex, size); kfree(sysex); return 0; } /* "read" request on "serial_number" special file. */ static ssize_t serial_number_show(struct device *dev, struct device_attribute *attr, char *buf) { struct snd_card *card = dev_to_snd_card(dev); struct usb_line6_pod *pod = card->private_data; return sysfs_emit(buf, "%u\n", pod->serial_number); } /* "read" request on "firmware_version" special file. */ static ssize_t firmware_version_show(struct device *dev, struct device_attribute *attr, char *buf) { struct snd_card *card = dev_to_snd_card(dev); struct usb_line6_pod *pod = card->private_data; return sysfs_emit(buf, "%d.%02d\n", pod->firmware_version / 100, pod->firmware_version % 100); } /* "read" request on "device_id" special file. */ static ssize_t device_id_show(struct device *dev, struct device_attribute *attr, char *buf) { struct snd_card *card = dev_to_snd_card(dev); struct usb_line6_pod *pod = card->private_data; return sysfs_emit(buf, "%d\n", pod->device_id); } /* POD startup procedure. This is a sequence of functions with special requirements (e.g., must not run immediately after initialization, must not run in interrupt context). After the last one has finished, the device is ready to use. */ static void pod_startup(struct usb_line6 *line6) { struct usb_line6_pod *pod = line6_to_pod(line6); switch (pod->startup_progress) { case POD_STARTUP_VERSIONREQ: /* request firmware version: */ line6_version_request_async(line6); break; case POD_STARTUP_SETUP: /* serial number: */ line6_read_serial_number(&pod->line6, &pod->serial_number); /* ALSA audio interface: */ if (snd_card_register(line6->card)) dev_err(line6->ifcdev, "Failed to register POD card.\n"); pod->startup_progress = POD_STARTUP_DONE; break; default: break; } } /* POD special files: */ static DEVICE_ATTR_RO(device_id); static DEVICE_ATTR_RO(firmware_version); static DEVICE_ATTR_RO(serial_number); static struct attribute *pod_dev_attrs[] = { &dev_attr_device_id.attr, &dev_attr_firmware_version.attr, &dev_attr_serial_number.attr, NULL }; static const struct attribute_group pod_dev_attr_group = { .name = "pod", .attrs = pod_dev_attrs, }; /* control info callback */ static int snd_pod_control_monitor_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = 65535; return 0; } /* control get callback */ static int snd_pod_control_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); struct usb_line6_pod *pod = line6_to_pod(line6pcm->line6); ucontrol->value.integer.value[0] = pod->monitor_level; return 0; } /* control put callback */ static int snd_pod_control_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); struct usb_line6_pod *pod = line6_to_pod(line6pcm->line6); if (ucontrol->value.integer.value[0] == pod->monitor_level) return 0; pod->monitor_level = ucontrol->value.integer.value[0]; pod_set_system_param_int(pod, ucontrol->value.integer.value[0], POD_MONITOR_LEVEL); return 1; } /* control definition */ static const struct snd_kcontrol_new pod_control_monitor = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitor Playback Volume", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_pod_control_monitor_info, .get = snd_pod_control_monitor_get, .put = snd_pod_control_monitor_put }; /* Try to init POD device. */ static int pod_init(struct usb_line6 *line6, const struct usb_device_id *id) { int err; struct usb_line6_pod *pod = line6_to_pod(line6); line6->process_message = line6_pod_process_message; line6->startup = pod_startup; /* create sysfs entries: */ err = snd_card_add_dev_attr(line6->card, &pod_dev_attr_group); if (err < 0) return err; /* initialize PCM subsystem: */ err = line6_init_pcm(line6, &pod_pcm_properties); if (err < 0) return err; /* register monitor control: */ err = snd_ctl_add(line6->card, snd_ctl_new1(&pod_control_monitor, line6->line6pcm)); if (err < 0) return err; /* When the sound card is registered at this point, the PODxt Live displays "Invalid Code Error 07", so we do it later in the event handler. */ if (pod->line6.properties->capabilities & LINE6_CAP_CONTROL) { pod->monitor_level = POD_SYSTEM_INVALID; /* initiate startup procedure: */ schedule_delayed_work(&line6->startup_work, msecs_to_jiffies(POD_STARTUP_DELAY)); } return 0; } #define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod) #define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n) /* table of devices that work with this driver */ static const struct usb_device_id pod_id_table[] = { { LINE6_DEVICE(0x4250), .driver_info = LINE6_BASSPODXT }, { LINE6_DEVICE(0x4642), .driver_info = LINE6_BASSPODXTLIVE }, { LINE6_DEVICE(0x4252), .driver_info = LINE6_BASSPODXTPRO }, { LINE6_IF_NUM(0x5051, 1), .driver_info = LINE6_POCKETPOD }, { LINE6_DEVICE(0x5044), .driver_info = LINE6_PODXT }, { LINE6_IF_NUM(0x4650, 0), .driver_info = LINE6_PODXTLIVE_POD }, { LINE6_DEVICE(0x5050), .driver_info = LINE6_PODXTPRO }, {} }; MODULE_DEVICE_TABLE(usb, pod_id_table); static const struct line6_properties pod_properties_table[] = { [LINE6_BASSPODXT] = { .id = "BassPODxt", .name = "BassPODxt", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI | LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 5, .ep_ctrl_r = 0x84, .ep_ctrl_w = 0x03, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_BASSPODXTLIVE] = { .id = "BassPODxtLive", .name = "BassPODxt Live", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI | LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 1, .ep_ctrl_r = 0x84, .ep_ctrl_w = 0x03, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_BASSPODXTPRO] = { .id = "BassPODxtPro", .name = "BassPODxt Pro", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI | LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 5, .ep_ctrl_r = 0x84, .ep_ctrl_w = 0x03, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_POCKETPOD] = { .id = "PocketPOD", .name = "Pocket POD", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI, .altsetting = 0, .ep_ctrl_r = 0x82, .ep_ctrl_w = 0x02, /* no audio channel */ }, [LINE6_PODXT] = { .id = "PODxt", .name = "PODxt", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI | LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 5, .ep_ctrl_r = 0x84, .ep_ctrl_w = 0x03, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_PODXTLIVE_POD] = { .id = "PODxtLive", .name = "PODxt Live", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI | LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 1, .ep_ctrl_r = 0x84, .ep_ctrl_w = 0x03, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_PODXTPRO] = { .id = "PODxtPro", .name = "PODxt Pro", .capabilities = LINE6_CAP_CONTROL | LINE6_CAP_CONTROL_MIDI | LINE6_CAP_PCM | LINE6_CAP_HWMON, .altsetting = 5, .ep_ctrl_r = 0x84, .ep_ctrl_w = 0x03, .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, }; /* Probe USB device. */ static int pod_probe(struct usb_interface *interface, const struct usb_device_id *id) { return line6_probe(interface, id, "Line6-POD", &pod_properties_table[id->driver_info], pod_init, sizeof(struct usb_line6_pod)); } static struct usb_driver pod_driver = { .name = KBUILD_MODNAME, .probe = pod_probe, .disconnect = line6_disconnect, #ifdef CONFIG_PM .suspend = line6_suspend, .resume = line6_resume, .reset_resume = line6_resume, #endif .id_table = pod_id_table, }; module_usb_driver(pod_driver); MODULE_DESCRIPTION("Line 6 POD USB driver"); MODULE_LICENSE("GPL");
linux-master
sound/usb/line6/pod.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) */ #include <linux/slab.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "capture.h" #include "driver.h" #include "pcm.h" /* Find a free URB and submit it. must be called in line6pcm->in.lock context */ static int submit_audio_in_urb(struct snd_line6_pcm *line6pcm) { int index; int i, urb_size; int ret; struct urb *urb_in; index = find_first_zero_bit(&line6pcm->in.active_urbs, line6pcm->line6->iso_buffers); if (index < 0 || index >= line6pcm->line6->iso_buffers) { dev_err(line6pcm->line6->ifcdev, "no free URB found\n"); return -EINVAL; } urb_in = line6pcm->in.urbs[index]; urb_size = 0; for (i = 0; i < LINE6_ISO_PACKETS; ++i) { struct usb_iso_packet_descriptor *fin = &urb_in->iso_frame_desc[i]; fin->offset = urb_size; fin->length = line6pcm->max_packet_size_in; urb_size += line6pcm->max_packet_size_in; } urb_in->transfer_buffer = line6pcm->in.buffer + index * LINE6_ISO_PACKETS * line6pcm->max_packet_size_in; urb_in->transfer_buffer_length = urb_size; urb_in->context = line6pcm; ret = usb_submit_urb(urb_in, GFP_ATOMIC); if (ret == 0) set_bit(index, &line6pcm->in.active_urbs); else dev_err(line6pcm->line6->ifcdev, "URB in #%d submission failed (%d)\n", index, ret); return 0; } /* Submit all currently available capture URBs. must be called in line6pcm->in.lock context */ int line6_submit_audio_in_all_urbs(struct snd_line6_pcm *line6pcm) { int ret = 0, i; for (i = 0; i < line6pcm->line6->iso_buffers; ++i) { ret = submit_audio_in_urb(line6pcm); if (ret < 0) break; } return ret; } /* Copy data into ALSA capture buffer. */ void line6_capture_copy(struct snd_line6_pcm *line6pcm, char *fbuf, int fsize) { struct snd_pcm_substream *substream = get_substream(line6pcm, SNDRV_PCM_STREAM_CAPTURE); struct snd_pcm_runtime *runtime = substream->runtime; const int bytes_per_frame = line6pcm->properties->bytes_per_channel * line6pcm->properties->capture_hw.channels_max; int frames = fsize / bytes_per_frame; if (runtime == NULL) return; if (line6pcm->in.pos_done + frames > runtime->buffer_size) { /* The transferred area goes over buffer boundary, copy two separate chunks. */ int len; len = runtime->buffer_size - line6pcm->in.pos_done; if (len > 0) { memcpy(runtime->dma_area + line6pcm->in.pos_done * bytes_per_frame, fbuf, len * bytes_per_frame); memcpy(runtime->dma_area, fbuf + len * bytes_per_frame, (frames - len) * bytes_per_frame); } else { /* this is somewhat paranoid */ dev_err(line6pcm->line6->ifcdev, "driver bug: len = %d\n", len); } } else { /* copy single chunk */ memcpy(runtime->dma_area + line6pcm->in.pos_done * bytes_per_frame, fbuf, fsize); } line6pcm->in.pos_done += frames; if (line6pcm->in.pos_done >= runtime->buffer_size) line6pcm->in.pos_done -= runtime->buffer_size; } void line6_capture_check_period(struct snd_line6_pcm *line6pcm, int length) { struct snd_pcm_substream *substream = get_substream(line6pcm, SNDRV_PCM_STREAM_CAPTURE); line6pcm->in.bytes += length; if (line6pcm->in.bytes >= line6pcm->in.period) { line6pcm->in.bytes %= line6pcm->in.period; spin_unlock(&line6pcm->in.lock); snd_pcm_period_elapsed(substream); spin_lock(&line6pcm->in.lock); } } /* * Callback for completed capture URB. */ static void audio_in_callback(struct urb *urb) { int i, index, length = 0, shutdown = 0; unsigned long flags; struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context; line6pcm->in.last_frame = urb->start_frame; /* find index of URB */ for (index = 0; index < line6pcm->line6->iso_buffers; ++index) if (urb == line6pcm->in.urbs[index]) break; spin_lock_irqsave(&line6pcm->in.lock, flags); for (i = 0; i < LINE6_ISO_PACKETS; ++i) { char *fbuf; int fsize; struct usb_iso_packet_descriptor *fin = &urb->iso_frame_desc[i]; if (fin->status == -EXDEV) { shutdown = 1; break; } fbuf = urb->transfer_buffer + fin->offset; fsize = fin->actual_length; if (fsize > line6pcm->max_packet_size_in) { dev_err(line6pcm->line6->ifcdev, "driver and/or device bug: packet too large (%d > %d)\n", fsize, line6pcm->max_packet_size_in); } length += fsize; BUILD_BUG_ON_MSG(LINE6_ISO_PACKETS != 1, "The following code assumes LINE6_ISO_PACKETS == 1"); /* TODO: * Also, if iso_buffers != 2, the prev frame is almost random at * playback side. * This needs to be redesigned. It should be "stable", but we may * experience sync problems on such high-speed configs. */ line6pcm->prev_fbuf = fbuf; line6pcm->prev_fsize = fsize / (line6pcm->properties->bytes_per_channel * line6pcm->properties->capture_hw.channels_max); if (!test_bit(LINE6_STREAM_IMPULSE, &line6pcm->in.running) && test_bit(LINE6_STREAM_PCM, &line6pcm->in.running) && fsize > 0) line6_capture_copy(line6pcm, fbuf, fsize); } clear_bit(index, &line6pcm->in.active_urbs); if (test_and_clear_bit(index, &line6pcm->in.unlink_urbs)) shutdown = 1; if (!shutdown) { submit_audio_in_urb(line6pcm); if (!test_bit(LINE6_STREAM_IMPULSE, &line6pcm->in.running) && test_bit(LINE6_STREAM_PCM, &line6pcm->in.running)) line6_capture_check_period(line6pcm, length); } spin_unlock_irqrestore(&line6pcm->in.lock, flags); } /* open capture callback */ static int snd_line6_capture_open(struct snd_pcm_substream *substream) { int err; struct snd_pcm_runtime *runtime = substream->runtime; struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); err = snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &line6pcm->properties->rates); if (err < 0) return err; line6_pcm_acquire(line6pcm, LINE6_STREAM_CAPTURE_HELPER, false); runtime->hw = line6pcm->properties->capture_hw; return 0; } /* close capture callback */ static int snd_line6_capture_close(struct snd_pcm_substream *substream) { struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); line6_pcm_release(line6pcm, LINE6_STREAM_CAPTURE_HELPER); return 0; } /* capture operators */ const struct snd_pcm_ops snd_line6_capture_ops = { .open = snd_line6_capture_open, .close = snd_line6_capture_close, .hw_params = snd_line6_hw_params, .hw_free = snd_line6_hw_free, .prepare = snd_line6_prepare, .trigger = snd_line6_trigger, .pointer = snd_line6_pointer, }; int line6_create_audio_in_urbs(struct snd_line6_pcm *line6pcm) { struct usb_line6 *line6 = line6pcm->line6; int i; line6pcm->in.urbs = kcalloc(line6->iso_buffers, sizeof(struct urb *), GFP_KERNEL); if (line6pcm->in.urbs == NULL) return -ENOMEM; /* create audio URBs and fill in constant values: */ for (i = 0; i < line6->iso_buffers; ++i) { struct urb *urb; /* URB for audio in: */ urb = line6pcm->in.urbs[i] = usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL); if (urb == NULL) return -ENOMEM; urb->dev = line6->usbdev; urb->pipe = usb_rcvisocpipe(line6->usbdev, line6->properties->ep_audio_r & USB_ENDPOINT_NUMBER_MASK); urb->transfer_flags = URB_ISO_ASAP; urb->start_frame = -1; urb->number_of_packets = LINE6_ISO_PACKETS; urb->interval = LINE6_ISO_INTERVAL; urb->error_count = 0; urb->complete = audio_in_callback; if (usb_urb_ep_type_check(urb)) return -EINVAL; } return 0; }
linux-master
sound/usb/line6/capture.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) * Emil Myhrman ([email protected]) */ #include <linux/wait.h> #include <linux/usb.h> #include <linux/slab.h> #include <linux/module.h> #include <linux/leds.h> #include <sound/core.h> #include <sound/control.h> #include "capture.h" #include "driver.h" #include "playback.h" enum line6_device_type { LINE6_GUITARPORT, LINE6_PODSTUDIO_GX, LINE6_PODSTUDIO_UX1, LINE6_PODSTUDIO_UX2, LINE6_TONEPORT_GX, LINE6_TONEPORT_UX1, LINE6_TONEPORT_UX2, }; struct usb_line6_toneport; struct toneport_led { struct led_classdev dev; char name[64]; struct usb_line6_toneport *toneport; bool registered; }; struct usb_line6_toneport { /* Generic Line 6 USB data */ struct usb_line6 line6; /* Source selector */ int source; /* Serial number of device */ u32 serial_number; /* Firmware version (x 100) */ u8 firmware_version; /* Device type */ enum line6_device_type type; /* LED instances */ struct toneport_led leds[2]; }; #define line6_to_toneport(x) container_of(x, struct usb_line6_toneport, line6) static int toneport_send_cmd(struct usb_device *usbdev, int cmd1, int cmd2); #define TONEPORT_PCM_DELAY 1 static const struct snd_ratden toneport_ratden = { .num_min = 44100, .num_max = 44100, .num_step = 1, .den = 1 }; static struct line6_pcm_properties toneport_pcm_properties = { .playback_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_SYNC_START), .formats = SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_KNOT, .rate_min = 44100, .rate_max = 44100, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 60000, .period_bytes_min = 64, .period_bytes_max = 8192, .periods_min = 1, .periods_max = 1024}, .capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START), .formats = SNDRV_PCM_FMTBIT_S16_LE, .rates = SNDRV_PCM_RATE_KNOT, .rate_min = 44100, .rate_max = 44100, .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 60000, .period_bytes_min = 64, .period_bytes_max = 8192, .periods_min = 1, .periods_max = 1024}, .rates = { .nrats = 1, .rats = &toneport_ratden}, .bytes_per_channel = 2 }; static const struct { const char *name; int code; } toneport_source_info[] = { {"Microphone", 0x0a01}, {"Line", 0x0801}, {"Instrument", 0x0b01}, {"Inst & Mic", 0x0901} }; static int toneport_send_cmd(struct usb_device *usbdev, int cmd1, int cmd2) { int ret; ret = usb_control_msg_send(usbdev, 0, 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, cmd1, cmd2, NULL, 0, LINE6_TIMEOUT, GFP_KERNEL); if (ret) { dev_err(&usbdev->dev, "send failed (error %d)\n", ret); return ret; } return 0; } /* monitor info callback */ static int snd_toneport_monitor_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = 256; return 0; } /* monitor get callback */ static int snd_toneport_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); ucontrol->value.integer.value[0] = line6pcm->volume_monitor; return 0; } /* monitor put callback */ static int snd_toneport_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); int err; if (ucontrol->value.integer.value[0] == line6pcm->volume_monitor) return 0; line6pcm->volume_monitor = ucontrol->value.integer.value[0]; if (line6pcm->volume_monitor > 0) { err = line6_pcm_acquire(line6pcm, LINE6_STREAM_MONITOR, true); if (err < 0) { line6pcm->volume_monitor = 0; line6_pcm_release(line6pcm, LINE6_STREAM_MONITOR); return err; } } else { line6_pcm_release(line6pcm, LINE6_STREAM_MONITOR); } return 1; } /* source info callback */ static int snd_toneport_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { const int size = ARRAY_SIZE(toneport_source_info); uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; uinfo->value.enumerated.items = size; if (uinfo->value.enumerated.item >= size) uinfo->value.enumerated.item = size - 1; strcpy(uinfo->value.enumerated.name, toneport_source_info[uinfo->value.enumerated.item].name); return 0; } /* source get callback */ static int snd_toneport_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); struct usb_line6_toneport *toneport = line6_to_toneport(line6pcm->line6); ucontrol->value.enumerated.item[0] = toneport->source; return 0; } /* source put callback */ static int snd_toneport_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol); struct usb_line6_toneport *toneport = line6_to_toneport(line6pcm->line6); unsigned int source; source = ucontrol->value.enumerated.item[0]; if (source >= ARRAY_SIZE(toneport_source_info)) return -EINVAL; if (source == toneport->source) return 0; toneport->source = source; toneport_send_cmd(toneport->line6.usbdev, toneport_source_info[source].code, 0x0000); return 1; } static void toneport_startup(struct usb_line6 *line6) { line6_pcm_acquire(line6->line6pcm, LINE6_STREAM_MONITOR, true); } /* control definition */ static const struct snd_kcontrol_new toneport_control_monitor = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitor Playback Volume", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_toneport_monitor_info, .get = snd_toneport_monitor_get, .put = snd_toneport_monitor_put }; /* source selector definition */ static const struct snd_kcontrol_new toneport_control_source = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PCM Capture Source", .index = 0, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = snd_toneport_source_info, .get = snd_toneport_source_get, .put = snd_toneport_source_put }; /* For the led on Guitarport. Brightness goes from 0x00 to 0x26. Set a value above this to have led blink. (void cmd_0x02(byte red, byte green) */ static bool toneport_has_led(struct usb_line6_toneport *toneport) { switch (toneport->type) { case LINE6_GUITARPORT: case LINE6_TONEPORT_GX: /* add your device here if you are missing support for the LEDs */ return true; default: return false; } } static const char * const toneport_led_colors[2] = { "red", "green" }; static const int toneport_led_init_vals[2] = { 0x00, 0x26 }; static void toneport_update_led(struct usb_line6_toneport *toneport) { toneport_send_cmd(toneport->line6.usbdev, (toneport->leds[0].dev.brightness << 8) | 0x0002, toneport->leds[1].dev.brightness); } static void toneport_led_brightness_set(struct led_classdev *led_cdev, enum led_brightness brightness) { struct toneport_led *leds = container_of(led_cdev, struct toneport_led, dev); toneport_update_led(leds->toneport); } static int toneport_init_leds(struct usb_line6_toneport *toneport) { struct device *dev = &toneport->line6.usbdev->dev; int i, err; for (i = 0; i < 2; i++) { struct toneport_led *led = &toneport->leds[i]; struct led_classdev *leddev = &led->dev; led->toneport = toneport; snprintf(led->name, sizeof(led->name), "%s::%s", dev_name(dev), toneport_led_colors[i]); leddev->name = led->name; leddev->brightness = toneport_led_init_vals[i]; leddev->max_brightness = 0x26; leddev->brightness_set = toneport_led_brightness_set; err = led_classdev_register(dev, leddev); if (err) return err; led->registered = true; } return 0; } static void toneport_remove_leds(struct usb_line6_toneport *toneport) { struct toneport_led *led; int i; for (i = 0; i < 2; i++) { led = &toneport->leds[i]; if (!led->registered) break; led_classdev_unregister(&led->dev); led->registered = false; } } static bool toneport_has_source_select(struct usb_line6_toneport *toneport) { switch (toneport->type) { case LINE6_TONEPORT_UX1: case LINE6_TONEPORT_UX2: case LINE6_PODSTUDIO_UX1: case LINE6_PODSTUDIO_UX2: return true; default: return false; } } /* Setup Toneport device. */ static int toneport_setup(struct usb_line6_toneport *toneport) { u32 *ticks; struct usb_line6 *line6 = &toneport->line6; struct usb_device *usbdev = line6->usbdev; ticks = kmalloc(sizeof(*ticks), GFP_KERNEL); if (!ticks) return -ENOMEM; /* sync time on device with host: */ /* note: 32-bit timestamps overflow in year 2106 */ *ticks = (u32)ktime_get_real_seconds(); line6_write_data(line6, 0x80c6, ticks, 4); kfree(ticks); /* enable device: */ toneport_send_cmd(usbdev, 0x0301, 0x0000); /* initialize source select: */ if (toneport_has_source_select(toneport)) toneport_send_cmd(usbdev, toneport_source_info[toneport->source].code, 0x0000); if (toneport_has_led(toneport)) toneport_update_led(toneport); schedule_delayed_work(&toneport->line6.startup_work, msecs_to_jiffies(TONEPORT_PCM_DELAY * 1000)); return 0; } /* Toneport device disconnected. */ static void line6_toneport_disconnect(struct usb_line6 *line6) { struct usb_line6_toneport *toneport = line6_to_toneport(line6); if (toneport_has_led(toneport)) toneport_remove_leds(toneport); } /* Try to init Toneport device. */ static int toneport_init(struct usb_line6 *line6, const struct usb_device_id *id) { int err; struct usb_line6_toneport *toneport = line6_to_toneport(line6); toneport->type = id->driver_info; line6->disconnect = line6_toneport_disconnect; line6->startup = toneport_startup; /* initialize PCM subsystem: */ err = line6_init_pcm(line6, &toneport_pcm_properties); if (err < 0) return err; /* register monitor control: */ err = snd_ctl_add(line6->card, snd_ctl_new1(&toneport_control_monitor, line6->line6pcm)); if (err < 0) return err; /* register source select control: */ if (toneport_has_source_select(toneport)) { err = snd_ctl_add(line6->card, snd_ctl_new1(&toneport_control_source, line6->line6pcm)); if (err < 0) return err; } line6_read_serial_number(line6, &toneport->serial_number); line6_read_data(line6, 0x80c2, &toneport->firmware_version, 1); if (toneport_has_led(toneport)) { err = toneport_init_leds(toneport); if (err < 0) return err; } err = toneport_setup(toneport); if (err) return err; /* register audio system: */ return snd_card_register(line6->card); } #ifdef CONFIG_PM /* Resume Toneport device after reset. */ static int toneport_reset_resume(struct usb_interface *interface) { int err; err = toneport_setup(usb_get_intfdata(interface)); if (err) return err; return line6_resume(interface); } #endif #define LINE6_DEVICE(prod) USB_DEVICE(0x0e41, prod) #define LINE6_IF_NUM(prod, n) USB_DEVICE_INTERFACE_NUMBER(0x0e41, prod, n) /* table of devices that work with this driver */ static const struct usb_device_id toneport_id_table[] = { { LINE6_DEVICE(0x4750), .driver_info = LINE6_GUITARPORT }, { LINE6_DEVICE(0x4153), .driver_info = LINE6_PODSTUDIO_GX }, { LINE6_DEVICE(0x4150), .driver_info = LINE6_PODSTUDIO_UX1 }, { LINE6_IF_NUM(0x4151, 0), .driver_info = LINE6_PODSTUDIO_UX2 }, { LINE6_DEVICE(0x4147), .driver_info = LINE6_TONEPORT_GX }, { LINE6_DEVICE(0x4141), .driver_info = LINE6_TONEPORT_UX1 }, { LINE6_IF_NUM(0x4142, 0), .driver_info = LINE6_TONEPORT_UX2 }, {} }; MODULE_DEVICE_TABLE(usb, toneport_id_table); static const struct line6_properties toneport_properties_table[] = { [LINE6_GUITARPORT] = { .id = "GuitarPort", .name = "GuitarPort", .capabilities = LINE6_CAP_PCM, .altsetting = 2, /* 1..4 seem to be ok */ /* no control channel */ .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_PODSTUDIO_GX] = { .id = "PODStudioGX", .name = "POD Studio GX", .capabilities = LINE6_CAP_PCM, .altsetting = 2, /* 1..4 seem to be ok */ /* no control channel */ .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_PODSTUDIO_UX1] = { .id = "PODStudioUX1", .name = "POD Studio UX1", .capabilities = LINE6_CAP_PCM, .altsetting = 2, /* 1..4 seem to be ok */ /* no control channel */ .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_PODSTUDIO_UX2] = { .id = "PODStudioUX2", .name = "POD Studio UX2", .capabilities = LINE6_CAP_PCM, .altsetting = 2, /* defaults to 44.1kHz, 16-bit */ /* no control channel */ .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_TONEPORT_GX] = { .id = "TonePortGX", .name = "TonePort GX", .capabilities = LINE6_CAP_PCM, .altsetting = 2, /* 1..4 seem to be ok */ /* no control channel */ .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_TONEPORT_UX1] = { .id = "TonePortUX1", .name = "TonePort UX1", .capabilities = LINE6_CAP_PCM, .altsetting = 2, /* 1..4 seem to be ok */ /* no control channel */ .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, [LINE6_TONEPORT_UX2] = { .id = "TonePortUX2", .name = "TonePort UX2", .capabilities = LINE6_CAP_PCM, .altsetting = 2, /* defaults to 44.1kHz, 16-bit */ /* no control channel */ .ep_audio_r = 0x82, .ep_audio_w = 0x01, }, }; /* Probe USB device. */ static int toneport_probe(struct usb_interface *interface, const struct usb_device_id *id) { return line6_probe(interface, id, "Line6-TonePort", &toneport_properties_table[id->driver_info], toneport_init, sizeof(struct usb_line6_toneport)); } static struct usb_driver toneport_driver = { .name = KBUILD_MODNAME, .probe = toneport_probe, .disconnect = line6_disconnect, #ifdef CONFIG_PM .suspend = line6_suspend, .resume = line6_resume, .reset_resume = toneport_reset_resume, #endif .id_table = toneport_id_table, }; module_usb_driver(toneport_driver); MODULE_DESCRIPTION("TonePort USB driver"); MODULE_LICENSE("GPL");
linux-master
sound/usb/line6/toneport.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) */ #include <linux/slab.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "capture.h" #include "driver.h" #include "pcm.h" #include "playback.h" /* Software stereo volume control. */ static void change_volume(struct urb *urb_out, int volume[], int bytes_per_frame) { int chn = 0; if (volume[0] == 256 && volume[1] == 256) return; /* maximum volume - no change */ if (bytes_per_frame == 4) { __le16 *p, *buf_end; p = (__le16 *)urb_out->transfer_buffer; buf_end = p + urb_out->transfer_buffer_length / sizeof(*p); for (; p < buf_end; ++p) { short pv = le16_to_cpu(*p); int val = (pv * volume[chn & 1]) >> 8; pv = clamp(val, -0x8000, 0x7fff); *p = cpu_to_le16(pv); ++chn; } } else if (bytes_per_frame == 6) { unsigned char *p, *buf_end; p = (unsigned char *)urb_out->transfer_buffer; buf_end = p + urb_out->transfer_buffer_length; for (; p < buf_end; p += 3) { int val; val = p[0] + (p[1] << 8) + ((signed char)p[2] << 16); val = (val * volume[chn & 1]) >> 8; val = clamp(val, -0x800000, 0x7fffff); p[0] = val; p[1] = val >> 8; p[2] = val >> 16; ++chn; } } } /* Create signal for impulse response test. */ static void create_impulse_test_signal(struct snd_line6_pcm *line6pcm, struct urb *urb_out, int bytes_per_frame) { int frames = urb_out->transfer_buffer_length / bytes_per_frame; if (bytes_per_frame == 4) { int i; short *pi = (short *)line6pcm->prev_fbuf; short *po = (short *)urb_out->transfer_buffer; for (i = 0; i < frames; ++i) { po[0] = pi[0]; po[1] = 0; pi += 2; po += 2; } } else if (bytes_per_frame == 6) { int i, j; unsigned char *pi = line6pcm->prev_fbuf; unsigned char *po = urb_out->transfer_buffer; for (i = 0; i < frames; ++i) { for (j = 0; j < bytes_per_frame / 2; ++j) po[j] = pi[j]; for (; j < bytes_per_frame; ++j) po[j] = 0; pi += bytes_per_frame; po += bytes_per_frame; } } if (--line6pcm->impulse_count <= 0) { ((unsigned char *)(urb_out->transfer_buffer))[bytes_per_frame - 1] = line6pcm->impulse_volume; line6pcm->impulse_count = line6pcm->impulse_period; } } /* Add signal to buffer for software monitoring. */ static void add_monitor_signal(struct urb *urb_out, unsigned char *signal, int volume, int bytes_per_frame) { if (volume == 0) return; /* zero volume - no change */ if (bytes_per_frame == 4) { __le16 *pi, *po, *buf_end; pi = (__le16 *)signal; po = (__le16 *)urb_out->transfer_buffer; buf_end = po + urb_out->transfer_buffer_length / sizeof(*po); for (; po < buf_end; ++pi, ++po) { short pov = le16_to_cpu(*po); short piv = le16_to_cpu(*pi); int val = pov + ((piv * volume) >> 8); pov = clamp(val, -0x8000, 0x7fff); *po = cpu_to_le16(pov); } } /* We don't need to handle devices with 6 bytes per frame here since they all support hardware monitoring. */ } /* Find a free URB, prepare audio data, and submit URB. must be called in line6pcm->out.lock context */ static int submit_audio_out_urb(struct snd_line6_pcm *line6pcm) { int index; int i, urb_size, urb_frames; int ret; const int bytes_per_frame = line6pcm->properties->bytes_per_channel * line6pcm->properties->playback_hw.channels_max; const int frame_increment = line6pcm->properties->rates.rats[0].num_min; const int frame_factor = line6pcm->properties->rates.rats[0].den * (line6pcm->line6->intervals_per_second / LINE6_ISO_INTERVAL); struct urb *urb_out; index = find_first_zero_bit(&line6pcm->out.active_urbs, line6pcm->line6->iso_buffers); if (index < 0 || index >= line6pcm->line6->iso_buffers) { dev_err(line6pcm->line6->ifcdev, "no free URB found\n"); return -EINVAL; } urb_out = line6pcm->out.urbs[index]; urb_size = 0; /* TODO: this may not work for LINE6_ISO_PACKETS != 1 */ for (i = 0; i < LINE6_ISO_PACKETS; ++i) { /* compute frame size for given sampling rate */ int fsize = 0; struct usb_iso_packet_descriptor *fout = &urb_out->iso_frame_desc[i]; fsize = line6pcm->prev_fsize; if (fsize == 0) { int n; line6pcm->out.count += frame_increment; n = line6pcm->out.count / frame_factor; line6pcm->out.count -= n * frame_factor; fsize = n; } fsize *= bytes_per_frame; fout->offset = urb_size; fout->length = fsize; urb_size += fsize; } if (urb_size == 0) { /* can't determine URB size */ dev_err(line6pcm->line6->ifcdev, "driver bug: urb_size = 0\n"); return -EINVAL; } urb_frames = urb_size / bytes_per_frame; urb_out->transfer_buffer = line6pcm->out.buffer + index * LINE6_ISO_PACKETS * line6pcm->max_packet_size_out; urb_out->transfer_buffer_length = urb_size; urb_out->context = line6pcm; if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running) && !test_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags)) { struct snd_pcm_runtime *runtime = get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK)->runtime; if (line6pcm->out.pos + urb_frames > runtime->buffer_size) { /* The transferred area goes over buffer boundary, copy the data to the temp buffer. */ int len; len = runtime->buffer_size - line6pcm->out.pos; if (len > 0) { memcpy(urb_out->transfer_buffer, runtime->dma_area + line6pcm->out.pos * bytes_per_frame, len * bytes_per_frame); memcpy(urb_out->transfer_buffer + len * bytes_per_frame, runtime->dma_area, (urb_frames - len) * bytes_per_frame); } else dev_err(line6pcm->line6->ifcdev, "driver bug: len = %d\n", len); } else { memcpy(urb_out->transfer_buffer, runtime->dma_area + line6pcm->out.pos * bytes_per_frame, urb_out->transfer_buffer_length); } line6pcm->out.pos += urb_frames; if (line6pcm->out.pos >= runtime->buffer_size) line6pcm->out.pos -= runtime->buffer_size; change_volume(urb_out, line6pcm->volume_playback, bytes_per_frame); } else { memset(urb_out->transfer_buffer, 0, urb_out->transfer_buffer_length); } spin_lock_nested(&line6pcm->in.lock, SINGLE_DEPTH_NESTING); if (line6pcm->prev_fbuf) { if (test_bit(LINE6_STREAM_IMPULSE, &line6pcm->out.running)) { create_impulse_test_signal(line6pcm, urb_out, bytes_per_frame); if (test_bit(LINE6_STREAM_PCM, &line6pcm->in.running)) { line6_capture_copy(line6pcm, urb_out->transfer_buffer, urb_out-> transfer_buffer_length); line6_capture_check_period(line6pcm, urb_out->transfer_buffer_length); } } else { if (!(line6pcm->line6->properties->capabilities & LINE6_CAP_HWMON) && line6pcm->out.running && line6pcm->in.running) add_monitor_signal(urb_out, line6pcm->prev_fbuf, line6pcm->volume_monitor, bytes_per_frame); } line6pcm->prev_fbuf = NULL; line6pcm->prev_fsize = 0; } spin_unlock(&line6pcm->in.lock); ret = usb_submit_urb(urb_out, GFP_ATOMIC); if (ret == 0) set_bit(index, &line6pcm->out.active_urbs); else dev_err(line6pcm->line6->ifcdev, "URB out #%d submission failed (%d)\n", index, ret); return 0; } /* Submit all currently available playback URBs. must be called in line6pcm->out.lock context */ int line6_submit_audio_out_all_urbs(struct snd_line6_pcm *line6pcm) { int ret = 0, i; for (i = 0; i < line6pcm->line6->iso_buffers; ++i) { ret = submit_audio_out_urb(line6pcm); if (ret < 0) break; } return ret; } /* Callback for completed playback URB. */ static void audio_out_callback(struct urb *urb) { int i, index, length = 0, shutdown = 0; unsigned long flags; struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context; struct snd_pcm_substream *substream = get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK); const int bytes_per_frame = line6pcm->properties->bytes_per_channel * line6pcm->properties->playback_hw.channels_max; #if USE_CLEAR_BUFFER_WORKAROUND memset(urb->transfer_buffer, 0, urb->transfer_buffer_length); #endif line6pcm->out.last_frame = urb->start_frame; /* find index of URB */ for (index = 0; index < line6pcm->line6->iso_buffers; index++) if (urb == line6pcm->out.urbs[index]) break; if (index >= line6pcm->line6->iso_buffers) return; /* URB has been unlinked asynchronously */ for (i = 0; i < LINE6_ISO_PACKETS; i++) length += urb->iso_frame_desc[i].length; spin_lock_irqsave(&line6pcm->out.lock, flags); if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running)) { struct snd_pcm_runtime *runtime = substream->runtime; line6pcm->out.pos_done += length / bytes_per_frame; if (line6pcm->out.pos_done >= runtime->buffer_size) line6pcm->out.pos_done -= runtime->buffer_size; } clear_bit(index, &line6pcm->out.active_urbs); for (i = 0; i < LINE6_ISO_PACKETS; i++) if (urb->iso_frame_desc[i].status == -EXDEV) { shutdown = 1; break; } if (test_and_clear_bit(index, &line6pcm->out.unlink_urbs)) shutdown = 1; if (!shutdown) { submit_audio_out_urb(line6pcm); if (test_bit(LINE6_STREAM_PCM, &line6pcm->out.running)) { line6pcm->out.bytes += length; if (line6pcm->out.bytes >= line6pcm->out.period) { line6pcm->out.bytes %= line6pcm->out.period; spin_unlock(&line6pcm->out.lock); snd_pcm_period_elapsed(substream); spin_lock(&line6pcm->out.lock); } } } spin_unlock_irqrestore(&line6pcm->out.lock, flags); } /* open playback callback */ static int snd_line6_playback_open(struct snd_pcm_substream *substream) { int err; struct snd_pcm_runtime *runtime = substream->runtime; struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream); err = snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &line6pcm->properties->rates); if (err < 0) return err; runtime->hw = line6pcm->properties->playback_hw; return 0; } /* close playback callback */ static int snd_line6_playback_close(struct snd_pcm_substream *substream) { return 0; } /* playback operators */ const struct snd_pcm_ops snd_line6_playback_ops = { .open = snd_line6_playback_open, .close = snd_line6_playback_close, .hw_params = snd_line6_hw_params, .hw_free = snd_line6_hw_free, .prepare = snd_line6_prepare, .trigger = snd_line6_trigger, .pointer = snd_line6_pointer, }; int line6_create_audio_out_urbs(struct snd_line6_pcm *line6pcm) { struct usb_line6 *line6 = line6pcm->line6; int i; line6pcm->out.urbs = kcalloc(line6->iso_buffers, sizeof(struct urb *), GFP_KERNEL); if (line6pcm->out.urbs == NULL) return -ENOMEM; /* create audio URBs and fill in constant values: */ for (i = 0; i < line6->iso_buffers; ++i) { struct urb *urb; /* URB for audio out: */ urb = line6pcm->out.urbs[i] = usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL); if (urb == NULL) return -ENOMEM; urb->dev = line6->usbdev; urb->pipe = usb_sndisocpipe(line6->usbdev, line6->properties->ep_audio_w & USB_ENDPOINT_NUMBER_MASK); urb->transfer_flags = URB_ISO_ASAP; urb->start_frame = -1; urb->number_of_packets = LINE6_ISO_PACKETS; urb->interval = LINE6_ISO_INTERVAL; urb->error_count = 0; urb->complete = audio_out_callback; if (usb_urb_ep_type_check(urb)) return -EINVAL; } return 0; }
linux-master
sound/usb/line6/playback.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) */ #include <linux/slab.h> #include <linux/usb.h> #include <linux/export.h> #include <sound/core.h> #include <sound/rawmidi.h> #include "driver.h" #include "midi.h" #define line6_rawmidi_substream_midi(substream) \ ((struct snd_line6_midi *)((substream)->rmidi->private_data)) static int send_midi_async(struct usb_line6 *line6, unsigned char *data, int length); /* Pass data received via USB to MIDI. */ void line6_midi_receive(struct usb_line6 *line6, unsigned char *data, int length) { if (line6->line6midi->substream_receive) snd_rawmidi_receive(line6->line6midi->substream_receive, data, length); } /* Read data from MIDI buffer and transmit them via USB. */ static void line6_midi_transmit(struct snd_rawmidi_substream *substream) { struct usb_line6 *line6 = line6_rawmidi_substream_midi(substream)->line6; struct snd_line6_midi *line6midi = line6->line6midi; struct midi_buffer *mb = &line6midi->midibuf_out; unsigned char chunk[LINE6_FALLBACK_MAXPACKETSIZE]; int req, done; for (;;) { req = min3(line6_midibuf_bytes_free(mb), line6->max_packet_size, LINE6_FALLBACK_MAXPACKETSIZE); done = snd_rawmidi_transmit_peek(substream, chunk, req); if (done == 0) break; line6_midibuf_write(mb, chunk, done); snd_rawmidi_transmit_ack(substream, done); } for (;;) { done = line6_midibuf_read(mb, chunk, LINE6_FALLBACK_MAXPACKETSIZE, LINE6_MIDIBUF_READ_TX); if (done == 0) break; send_midi_async(line6, chunk, done); } } /* Notification of completion of MIDI transmission. */ static void midi_sent(struct urb *urb) { unsigned long flags; int status; int num; struct usb_line6 *line6 = (struct usb_line6 *)urb->context; status = urb->status; kfree(urb->transfer_buffer); usb_free_urb(urb); if (status == -ESHUTDOWN) return; spin_lock_irqsave(&line6->line6midi->lock, flags); num = --line6->line6midi->num_active_send_urbs; if (num == 0) { line6_midi_transmit(line6->line6midi->substream_transmit); num = line6->line6midi->num_active_send_urbs; } if (num == 0) wake_up(&line6->line6midi->send_wait); spin_unlock_irqrestore(&line6->line6midi->lock, flags); } /* Send an asynchronous MIDI message. Assumes that line6->line6midi->lock is held (i.e., this function is serialized). */ static int send_midi_async(struct usb_line6 *line6, unsigned char *data, int length) { struct urb *urb; int retval; unsigned char *transfer_buffer; urb = usb_alloc_urb(0, GFP_ATOMIC); if (urb == NULL) return -ENOMEM; transfer_buffer = kmemdup(data, length, GFP_ATOMIC); if (transfer_buffer == NULL) { usb_free_urb(urb); return -ENOMEM; } usb_fill_int_urb(urb, line6->usbdev, usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w), transfer_buffer, length, midi_sent, line6, line6->interval); urb->actual_length = 0; retval = usb_urb_ep_type_check(urb); if (retval < 0) goto error; retval = usb_submit_urb(urb, GFP_ATOMIC); if (retval < 0) goto error; ++line6->line6midi->num_active_send_urbs; return 0; error: dev_err(line6->ifcdev, "usb_submit_urb failed\n"); usb_free_urb(urb); return retval; } static int line6_midi_output_open(struct snd_rawmidi_substream *substream) { return 0; } static int line6_midi_output_close(struct snd_rawmidi_substream *substream) { return 0; } static void line6_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) { unsigned long flags; struct usb_line6 *line6 = line6_rawmidi_substream_midi(substream)->line6; line6->line6midi->substream_transmit = substream; spin_lock_irqsave(&line6->line6midi->lock, flags); if (line6->line6midi->num_active_send_urbs == 0) line6_midi_transmit(substream); spin_unlock_irqrestore(&line6->line6midi->lock, flags); } static void line6_midi_output_drain(struct snd_rawmidi_substream *substream) { struct usb_line6 *line6 = line6_rawmidi_substream_midi(substream)->line6; struct snd_line6_midi *midi = line6->line6midi; wait_event_interruptible(midi->send_wait, midi->num_active_send_urbs == 0); } static int line6_midi_input_open(struct snd_rawmidi_substream *substream) { return 0; } static int line6_midi_input_close(struct snd_rawmidi_substream *substream) { return 0; } static void line6_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) { struct usb_line6 *line6 = line6_rawmidi_substream_midi(substream)->line6; if (up) line6->line6midi->substream_receive = substream; else line6->line6midi->substream_receive = NULL; } static const struct snd_rawmidi_ops line6_midi_output_ops = { .open = line6_midi_output_open, .close = line6_midi_output_close, .trigger = line6_midi_output_trigger, .drain = line6_midi_output_drain, }; static const struct snd_rawmidi_ops line6_midi_input_ops = { .open = line6_midi_input_open, .close = line6_midi_input_close, .trigger = line6_midi_input_trigger, }; /* Create a MIDI device */ static int snd_line6_new_midi(struct usb_line6 *line6, struct snd_rawmidi **rmidi_ret) { struct snd_rawmidi *rmidi; int err; err = snd_rawmidi_new(line6->card, "Line 6 MIDI", 0, 1, 1, rmidi_ret); if (err < 0) return err; rmidi = *rmidi_ret; strcpy(rmidi->id, line6->properties->id); strcpy(rmidi->name, line6->properties->name); rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &line6_midi_output_ops); snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &line6_midi_input_ops); return 0; } /* MIDI device destructor */ static void snd_line6_midi_free(struct snd_rawmidi *rmidi) { struct snd_line6_midi *line6midi = rmidi->private_data; line6_midibuf_destroy(&line6midi->midibuf_in); line6_midibuf_destroy(&line6midi->midibuf_out); kfree(line6midi); } /* Initialize the Line 6 MIDI subsystem. */ int line6_init_midi(struct usb_line6 *line6) { int err; struct snd_rawmidi *rmidi; struct snd_line6_midi *line6midi; if (!(line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI)) { /* skip MIDI initialization and report success */ return 0; } err = snd_line6_new_midi(line6, &rmidi); if (err < 0) return err; line6midi = kzalloc(sizeof(struct snd_line6_midi), GFP_KERNEL); if (!line6midi) return -ENOMEM; rmidi->private_data = line6midi; rmidi->private_free = snd_line6_midi_free; init_waitqueue_head(&line6midi->send_wait); spin_lock_init(&line6midi->lock); line6midi->line6 = line6; err = line6_midibuf_init(&line6midi->midibuf_in, MIDI_BUFFER_SIZE, 0); if (err < 0) return err; err = line6_midibuf_init(&line6midi->midibuf_out, MIDI_BUFFER_SIZE, 1); if (err < 0) return err; line6->line6midi = line6midi; return 0; } EXPORT_SYMBOL_GPL(line6_init_midi);
linux-master
sound/usb/line6/midi.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/export.h> #include <linux/slab.h> #include <linux/usb.h> #include <sound/core.h> #include <sound/initval.h> #include <sound/hwdep.h> #include "capture.h" #include "driver.h" #include "midi.h" #include "playback.h" #define DRIVER_AUTHOR "Markus Grabner <[email protected]>" #define DRIVER_DESC "Line 6 USB Driver" /* This is Line 6's MIDI manufacturer ID. */ const unsigned char line6_midi_id[3] = { 0x00, 0x01, 0x0c }; EXPORT_SYMBOL_GPL(line6_midi_id); /* Code to request version of POD, Variax interface (and maybe other devices). */ static const char line6_request_version[] = { 0xf0, 0x7e, 0x7f, 0x06, 0x01, 0xf7 }; /* Class for asynchronous messages. */ struct message { struct usb_line6 *line6; const char *buffer; int size; int done; }; /* Forward declarations. */ static void line6_data_received(struct urb *urb); static int line6_send_raw_message_async_part(struct message *msg, struct urb *urb); /* Start to listen on endpoint. */ static int line6_start_listen(struct usb_line6 *line6) { int err; if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) { usb_fill_int_urb(line6->urb_listen, line6->usbdev, usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r), line6->buffer_listen, LINE6_BUFSIZE_LISTEN, line6_data_received, line6, line6->interval); } else { usb_fill_bulk_urb(line6->urb_listen, line6->usbdev, usb_rcvbulkpipe(line6->usbdev, line6->properties->ep_ctrl_r), line6->buffer_listen, LINE6_BUFSIZE_LISTEN, line6_data_received, line6); } /* sanity checks of EP before actually submitting */ if (usb_urb_ep_type_check(line6->urb_listen)) { dev_err(line6->ifcdev, "invalid control EP\n"); return -EINVAL; } line6->urb_listen->actual_length = 0; err = usb_submit_urb(line6->urb_listen, GFP_ATOMIC); return err; } /* Stop listening on endpoint. */ static void line6_stop_listen(struct usb_line6 *line6) { usb_kill_urb(line6->urb_listen); } /* Send raw message in pieces of wMaxPacketSize bytes. */ int line6_send_raw_message(struct usb_line6 *line6, const char *buffer, int size) { int i, done = 0; const struct line6_properties *properties = line6->properties; for (i = 0; i < size; i += line6->max_packet_size) { int partial; const char *frag_buf = buffer + i; int frag_size = min(line6->max_packet_size, size - i); int retval; if (properties->capabilities & LINE6_CAP_CONTROL_MIDI) { retval = usb_interrupt_msg(line6->usbdev, usb_sndintpipe(line6->usbdev, properties->ep_ctrl_w), (char *)frag_buf, frag_size, &partial, LINE6_TIMEOUT); } else { retval = usb_bulk_msg(line6->usbdev, usb_sndbulkpipe(line6->usbdev, properties->ep_ctrl_w), (char *)frag_buf, frag_size, &partial, LINE6_TIMEOUT); } if (retval) { dev_err(line6->ifcdev, "usb_bulk_msg failed (%d)\n", retval); break; } done += frag_size; } return done; } EXPORT_SYMBOL_GPL(line6_send_raw_message); /* Notification of completion of asynchronous request transmission. */ static void line6_async_request_sent(struct urb *urb) { struct message *msg = (struct message *)urb->context; if (msg->done >= msg->size) { usb_free_urb(urb); kfree(msg); } else line6_send_raw_message_async_part(msg, urb); } /* Asynchronously send part of a raw message. */ static int line6_send_raw_message_async_part(struct message *msg, struct urb *urb) { int retval; struct usb_line6 *line6 = msg->line6; int done = msg->done; int bytes = min(msg->size - done, line6->max_packet_size); if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) { usb_fill_int_urb(urb, line6->usbdev, usb_sndintpipe(line6->usbdev, line6->properties->ep_ctrl_w), (char *)msg->buffer + done, bytes, line6_async_request_sent, msg, line6->interval); } else { usb_fill_bulk_urb(urb, line6->usbdev, usb_sndbulkpipe(line6->usbdev, line6->properties->ep_ctrl_w), (char *)msg->buffer + done, bytes, line6_async_request_sent, msg); } msg->done += bytes; /* sanity checks of EP before actually submitting */ retval = usb_urb_ep_type_check(urb); if (retval < 0) goto error; retval = usb_submit_urb(urb, GFP_ATOMIC); if (retval < 0) goto error; return 0; error: dev_err(line6->ifcdev, "%s: usb_submit_urb failed (%d)\n", __func__, retval); usb_free_urb(urb); kfree(msg); return retval; } /* Asynchronously send raw message. */ int line6_send_raw_message_async(struct usb_line6 *line6, const char *buffer, int size) { struct message *msg; struct urb *urb; /* create message: */ msg = kmalloc(sizeof(struct message), GFP_ATOMIC); if (msg == NULL) return -ENOMEM; /* create URB: */ urb = usb_alloc_urb(0, GFP_ATOMIC); if (urb == NULL) { kfree(msg); return -ENOMEM; } /* set message data: */ msg->line6 = line6; msg->buffer = buffer; msg->size = size; msg->done = 0; /* start sending: */ return line6_send_raw_message_async_part(msg, urb); } EXPORT_SYMBOL_GPL(line6_send_raw_message_async); /* Send asynchronous device version request. */ int line6_version_request_async(struct usb_line6 *line6) { char *buffer; int retval; buffer = kmemdup(line6_request_version, sizeof(line6_request_version), GFP_ATOMIC); if (buffer == NULL) return -ENOMEM; retval = line6_send_raw_message_async(line6, buffer, sizeof(line6_request_version)); kfree(buffer); return retval; } EXPORT_SYMBOL_GPL(line6_version_request_async); /* Send sysex message in pieces of wMaxPacketSize bytes. */ int line6_send_sysex_message(struct usb_line6 *line6, const char *buffer, int size) { return line6_send_raw_message(line6, buffer, size + SYSEX_EXTRA_SIZE) - SYSEX_EXTRA_SIZE; } EXPORT_SYMBOL_GPL(line6_send_sysex_message); /* Allocate buffer for sysex message and prepare header. @param code sysex message code @param size number of bytes between code and sysex end */ char *line6_alloc_sysex_buffer(struct usb_line6 *line6, int code1, int code2, int size) { char *buffer = kmalloc(size + SYSEX_EXTRA_SIZE, GFP_ATOMIC); if (!buffer) return NULL; buffer[0] = LINE6_SYSEX_BEGIN; memcpy(buffer + 1, line6_midi_id, sizeof(line6_midi_id)); buffer[sizeof(line6_midi_id) + 1] = code1; buffer[sizeof(line6_midi_id) + 2] = code2; buffer[sizeof(line6_midi_id) + 3 + size] = LINE6_SYSEX_END; return buffer; } EXPORT_SYMBOL_GPL(line6_alloc_sysex_buffer); /* Notification of data received from the Line 6 device. */ static void line6_data_received(struct urb *urb) { struct usb_line6 *line6 = (struct usb_line6 *)urb->context; struct midi_buffer *mb = &line6->line6midi->midibuf_in; int done; if (urb->status == -ESHUTDOWN) return; if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) { done = line6_midibuf_write(mb, urb->transfer_buffer, urb->actual_length); if (done < urb->actual_length) { line6_midibuf_ignore(mb, done); dev_dbg(line6->ifcdev, "%d %d buffer overflow - message skipped\n", done, urb->actual_length); } for (;;) { done = line6_midibuf_read(mb, line6->buffer_message, LINE6_MIDI_MESSAGE_MAXLEN, LINE6_MIDIBUF_READ_RX); if (done <= 0) break; line6->message_length = done; line6_midi_receive(line6, line6->buffer_message, done); if (line6->process_message) line6->process_message(line6); } } else { line6->buffer_message = urb->transfer_buffer; line6->message_length = urb->actual_length; if (line6->process_message) line6->process_message(line6); line6->buffer_message = NULL; } line6_start_listen(line6); } #define LINE6_READ_WRITE_STATUS_DELAY 2 /* milliseconds */ #define LINE6_READ_WRITE_MAX_RETRIES 50 /* Read data from device. */ int line6_read_data(struct usb_line6 *line6, unsigned address, void *data, unsigned datalen) { struct usb_device *usbdev = line6->usbdev; int ret; u8 len; unsigned count; if (address > 0xffff || datalen > 0xff) return -EINVAL; /* query the serial number: */ ret = usb_control_msg_send(usbdev, 0, 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, (datalen << 8) | 0x21, address, NULL, 0, LINE6_TIMEOUT, GFP_KERNEL); if (ret) { dev_err(line6->ifcdev, "read request failed (error %d)\n", ret); goto exit; } /* Wait for data length. We'll get 0xff until length arrives. */ for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) { mdelay(LINE6_READ_WRITE_STATUS_DELAY); ret = usb_control_msg_recv(usbdev, 0, 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 0x0012, 0x0000, &len, 1, LINE6_TIMEOUT, GFP_KERNEL); if (ret) { dev_err(line6->ifcdev, "receive length failed (error %d)\n", ret); goto exit; } if (len != 0xff) break; } ret = -EIO; if (len == 0xff) { dev_err(line6->ifcdev, "read failed after %d retries\n", count); goto exit; } else if (len != datalen) { /* should be equal or something went wrong */ dev_err(line6->ifcdev, "length mismatch (expected %d, got %d)\n", (int)datalen, len); goto exit; } /* receive the result: */ ret = usb_control_msg_recv(usbdev, 0, 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 0x0013, 0x0000, data, datalen, LINE6_TIMEOUT, GFP_KERNEL); if (ret) dev_err(line6->ifcdev, "read failed (error %d)\n", ret); exit: return ret; } EXPORT_SYMBOL_GPL(line6_read_data); /* Write data to device. */ int line6_write_data(struct usb_line6 *line6, unsigned address, void *data, unsigned datalen) { struct usb_device *usbdev = line6->usbdev; int ret; unsigned char *status; int count; if (address > 0xffff || datalen > 0xffff) return -EINVAL; status = kmalloc(1, GFP_KERNEL); if (!status) return -ENOMEM; ret = usb_control_msg_send(usbdev, 0, 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 0x0022, address, data, datalen, LINE6_TIMEOUT, GFP_KERNEL); if (ret) { dev_err(line6->ifcdev, "write request failed (error %d)\n", ret); goto exit; } for (count = 0; count < LINE6_READ_WRITE_MAX_RETRIES; count++) { mdelay(LINE6_READ_WRITE_STATUS_DELAY); ret = usb_control_msg_recv(usbdev, 0, 0x67, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 0x0012, 0x0000, status, 1, LINE6_TIMEOUT, GFP_KERNEL); if (ret) { dev_err(line6->ifcdev, "receiving status failed (error %d)\n", ret); goto exit; } if (*status != 0xff) break; } if (*status == 0xff) { dev_err(line6->ifcdev, "write failed after %d retries\n", count); ret = -EIO; } else if (*status != 0) { dev_err(line6->ifcdev, "write failed (error %d)\n", ret); ret = -EIO; } exit: kfree(status); return ret; } EXPORT_SYMBOL_GPL(line6_write_data); /* Read Line 6 device serial number. (POD, TonePort, GuitarPort) */ int line6_read_serial_number(struct usb_line6 *line6, u32 *serial_number) { return line6_read_data(line6, 0x80d0, serial_number, sizeof(*serial_number)); } EXPORT_SYMBOL_GPL(line6_read_serial_number); /* Card destructor. */ static void line6_destruct(struct snd_card *card) { struct usb_line6 *line6 = card->private_data; struct usb_device *usbdev = line6->usbdev; /* Free buffer memory first. We cannot depend on the existence of private * data from the (podhd) module, it may be gone already during this call */ kfree(line6->buffer_message); kfree(line6->buffer_listen); /* then free URBs: */ usb_free_urb(line6->urb_listen); line6->urb_listen = NULL; /* decrement reference counters: */ usb_put_dev(usbdev); } static void line6_get_usb_properties(struct usb_line6 *line6) { struct usb_device *usbdev = line6->usbdev; const struct line6_properties *properties = line6->properties; int pipe; struct usb_host_endpoint *ep = NULL; if (properties->capabilities & LINE6_CAP_CONTROL) { if (properties->capabilities & LINE6_CAP_CONTROL_MIDI) { pipe = usb_rcvintpipe(line6->usbdev, line6->properties->ep_ctrl_r); } else { pipe = usb_rcvbulkpipe(line6->usbdev, line6->properties->ep_ctrl_r); } ep = usbdev->ep_in[usb_pipeendpoint(pipe)]; } /* Control data transfer properties */ if (ep) { line6->interval = ep->desc.bInterval; line6->max_packet_size = le16_to_cpu(ep->desc.wMaxPacketSize); } else { if (properties->capabilities & LINE6_CAP_CONTROL) { dev_err(line6->ifcdev, "endpoint not available, using fallback values"); } line6->interval = LINE6_FALLBACK_INTERVAL; line6->max_packet_size = LINE6_FALLBACK_MAXPACKETSIZE; } /* Isochronous transfer properties */ if (usbdev->speed == USB_SPEED_LOW) { line6->intervals_per_second = USB_LOW_INTERVALS_PER_SECOND; line6->iso_buffers = USB_LOW_ISO_BUFFERS; } else { line6->intervals_per_second = USB_HIGH_INTERVALS_PER_SECOND; line6->iso_buffers = USB_HIGH_ISO_BUFFERS; } } /* Enable buffering of incoming messages, flush the buffer */ static int line6_hwdep_open(struct snd_hwdep *hw, struct file *file) { struct usb_line6 *line6 = hw->private_data; /* NOTE: hwdep layer provides atomicity here */ line6->messages.active = 1; line6->messages.nonblock = file->f_flags & O_NONBLOCK ? 1 : 0; return 0; } /* Stop buffering */ static int line6_hwdep_release(struct snd_hwdep *hw, struct file *file) { struct usb_line6 *line6 = hw->private_data; line6->messages.active = 0; return 0; } /* Read from circular buffer, return to user */ static long line6_hwdep_read(struct snd_hwdep *hwdep, char __user *buf, long count, loff_t *offset) { struct usb_line6 *line6 = hwdep->private_data; long rv = 0; unsigned int out_count; if (mutex_lock_interruptible(&line6->messages.read_lock)) return -ERESTARTSYS; while (kfifo_len(&line6->messages.fifo) == 0) { mutex_unlock(&line6->messages.read_lock); if (line6->messages.nonblock) return -EAGAIN; rv = wait_event_interruptible( line6->messages.wait_queue, kfifo_len(&line6->messages.fifo) != 0); if (rv < 0) return rv; if (mutex_lock_interruptible(&line6->messages.read_lock)) return -ERESTARTSYS; } if (kfifo_peek_len(&line6->messages.fifo) > count) { /* Buffer too small; allow re-read of the current item... */ rv = -EINVAL; } else { rv = kfifo_to_user(&line6->messages.fifo, buf, count, &out_count); if (rv == 0) rv = out_count; } mutex_unlock(&line6->messages.read_lock); return rv; } /* Write directly (no buffering) to device by user*/ static long line6_hwdep_write(struct snd_hwdep *hwdep, const char __user *data, long count, loff_t *offset) { struct usb_line6 *line6 = hwdep->private_data; int rv; char *data_copy; if (count > line6->max_packet_size * LINE6_RAW_MESSAGES_MAXCOUNT) { /* This is an arbitrary limit - still better than nothing... */ return -EINVAL; } data_copy = memdup_user(data, count); if (IS_ERR(data_copy)) return PTR_ERR(data_copy); rv = line6_send_raw_message(line6, data_copy, count); kfree(data_copy); return rv; } static __poll_t line6_hwdep_poll(struct snd_hwdep *hwdep, struct file *file, poll_table *wait) { __poll_t rv; struct usb_line6 *line6 = hwdep->private_data; poll_wait(file, &line6->messages.wait_queue, wait); mutex_lock(&line6->messages.read_lock); rv = kfifo_len(&line6->messages.fifo) == 0 ? 0 : EPOLLIN | EPOLLRDNORM; mutex_unlock(&line6->messages.read_lock); return rv; } static const struct snd_hwdep_ops hwdep_ops = { .open = line6_hwdep_open, .release = line6_hwdep_release, .read = line6_hwdep_read, .write = line6_hwdep_write, .poll = line6_hwdep_poll, }; /* Insert into circular buffer */ static void line6_hwdep_push_message(struct usb_line6 *line6) { if (!line6->messages.active) return; if (kfifo_avail(&line6->messages.fifo) >= line6->message_length) { /* No race condition here, there's only one writer */ kfifo_in(&line6->messages.fifo, line6->buffer_message, line6->message_length); } /* else TODO: signal overflow */ wake_up_interruptible(&line6->messages.wait_queue); } static int line6_hwdep_init(struct usb_line6 *line6) { int err; struct snd_hwdep *hwdep; /* TODO: usb_driver_claim_interface(); */ line6->process_message = line6_hwdep_push_message; line6->messages.active = 0; init_waitqueue_head(&line6->messages.wait_queue); mutex_init(&line6->messages.read_lock); INIT_KFIFO(line6->messages.fifo); err = snd_hwdep_new(line6->card, "config", 0, &hwdep); if (err < 0) goto end; strcpy(hwdep->name, "config"); hwdep->iface = SNDRV_HWDEP_IFACE_LINE6; hwdep->ops = hwdep_ops; hwdep->private_data = line6; hwdep->exclusive = true; end: return err; } static int line6_init_cap_control(struct usb_line6 *line6) { int ret; /* initialize USB buffers: */ line6->buffer_listen = kmalloc(LINE6_BUFSIZE_LISTEN, GFP_KERNEL); if (!line6->buffer_listen) return -ENOMEM; line6->urb_listen = usb_alloc_urb(0, GFP_KERNEL); if (!line6->urb_listen) return -ENOMEM; if (line6->properties->capabilities & LINE6_CAP_CONTROL_MIDI) { line6->buffer_message = kmalloc(LINE6_MIDI_MESSAGE_MAXLEN, GFP_KERNEL); if (!line6->buffer_message) return -ENOMEM; ret = line6_init_midi(line6); if (ret < 0) return ret; } else { ret = line6_hwdep_init(line6); if (ret < 0) return ret; } ret = line6_start_listen(line6); if (ret < 0) { dev_err(line6->ifcdev, "cannot start listening: %d\n", ret); return ret; } return 0; } static void line6_startup_work(struct work_struct *work) { struct usb_line6 *line6 = container_of(work, struct usb_line6, startup_work.work); if (line6->startup) line6->startup(line6); } /* Probe USB device. */ int line6_probe(struct usb_interface *interface, const struct usb_device_id *id, const char *driver_name, const struct line6_properties *properties, int (*private_init)(struct usb_line6 *, const struct usb_device_id *id), size_t data_size) { struct usb_device *usbdev = interface_to_usbdev(interface); struct snd_card *card; struct usb_line6 *line6; int interface_number; int ret; if (WARN_ON(data_size < sizeof(*line6))) return -EINVAL; /* we don't handle multiple configurations */ if (usbdev->descriptor.bNumConfigurations != 1) return -ENODEV; ret = snd_card_new(&interface->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, THIS_MODULE, data_size, &card); if (ret < 0) return ret; /* store basic data: */ line6 = card->private_data; line6->card = card; line6->properties = properties; line6->usbdev = usbdev; line6->ifcdev = &interface->dev; INIT_DELAYED_WORK(&line6->startup_work, line6_startup_work); strcpy(card->id, properties->id); strcpy(card->driver, driver_name); strcpy(card->shortname, properties->name); sprintf(card->longname, "Line 6 %s at USB %s", properties->name, dev_name(line6->ifcdev)); card->private_free = line6_destruct; usb_set_intfdata(interface, line6); /* increment reference counters: */ usb_get_dev(usbdev); /* initialize device info: */ dev_info(&interface->dev, "Line 6 %s found\n", properties->name); /* query interface number */ interface_number = interface->cur_altsetting->desc.bInterfaceNumber; /* TODO reserves the bus bandwidth even without actual transfer */ ret = usb_set_interface(usbdev, interface_number, properties->altsetting); if (ret < 0) { dev_err(&interface->dev, "set_interface failed\n"); goto error; } line6_get_usb_properties(line6); if (properties->capabilities & LINE6_CAP_CONTROL) { ret = line6_init_cap_control(line6); if (ret < 0) goto error; } /* initialize device data based on device: */ ret = private_init(line6, id); if (ret < 0) goto error; /* creation of additional special files should go here */ dev_info(&interface->dev, "Line 6 %s now attached\n", properties->name); return 0; error: /* we can call disconnect callback here because no close-sync is * needed yet at this point */ line6_disconnect(interface); return ret; } EXPORT_SYMBOL_GPL(line6_probe); /* Line 6 device disconnected. */ void line6_disconnect(struct usb_interface *interface) { struct usb_line6 *line6 = usb_get_intfdata(interface); struct usb_device *usbdev = interface_to_usbdev(interface); if (!line6) return; if (WARN_ON(usbdev != line6->usbdev)) return; cancel_delayed_work_sync(&line6->startup_work); if (line6->urb_listen != NULL) line6_stop_listen(line6); snd_card_disconnect(line6->card); if (line6->line6pcm) line6_pcm_disconnect(line6->line6pcm); if (line6->disconnect) line6->disconnect(line6); dev_info(&interface->dev, "Line 6 %s now disconnected\n", line6->properties->name); /* make sure the device isn't destructed twice: */ usb_set_intfdata(interface, NULL); snd_card_free_when_closed(line6->card); } EXPORT_SYMBOL_GPL(line6_disconnect); #ifdef CONFIG_PM /* Suspend Line 6 device. */ int line6_suspend(struct usb_interface *interface, pm_message_t message) { struct usb_line6 *line6 = usb_get_intfdata(interface); struct snd_line6_pcm *line6pcm = line6->line6pcm; snd_power_change_state(line6->card, SNDRV_CTL_POWER_D3hot); if (line6->properties->capabilities & LINE6_CAP_CONTROL) line6_stop_listen(line6); if (line6pcm != NULL) line6pcm->flags = 0; return 0; } EXPORT_SYMBOL_GPL(line6_suspend); /* Resume Line 6 device. */ int line6_resume(struct usb_interface *interface) { struct usb_line6 *line6 = usb_get_intfdata(interface); if (line6->properties->capabilities & LINE6_CAP_CONTROL) line6_start_listen(line6); snd_power_change_state(line6->card, SNDRV_CTL_POWER_D0); return 0; } EXPORT_SYMBOL_GPL(line6_resume); #endif /* CONFIG_PM */ MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); MODULE_LICENSE("GPL");
linux-master
sound/usb/line6/driver.c
// SPDX-License-Identifier: GPL-2.0-only /* * Line 6 Linux USB driver * * Copyright (C) 2004-2010 Markus Grabner ([email protected]) */ #include <linux/slab.h> #include "midibuf.h" static int midibuf_message_length(unsigned char code) { int message_length; if (code < 0x80) message_length = -1; else if (code < 0xf0) { static const int length[] = { 3, 3, 3, 3, 2, 2, 3 }; message_length = length[(code >> 4) - 8]; } else { static const int length[] = { -1, 2, 2, 2, -1, -1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1 }; message_length = length[code & 0x0f]; } return message_length; } static int midibuf_is_empty(struct midi_buffer *this) { return (this->pos_read == this->pos_write) && !this->full; } static int midibuf_is_full(struct midi_buffer *this) { return this->full; } void line6_midibuf_reset(struct midi_buffer *this) { this->pos_read = this->pos_write = this->full = 0; this->command_prev = -1; } int line6_midibuf_init(struct midi_buffer *this, int size, int split) { this->buf = kmalloc(size, GFP_KERNEL); if (this->buf == NULL) return -ENOMEM; this->size = size; this->split = split; line6_midibuf_reset(this); return 0; } int line6_midibuf_bytes_free(struct midi_buffer *this) { return midibuf_is_full(this) ? 0 : (this->pos_read - this->pos_write + this->size - 1) % this->size + 1; } int line6_midibuf_bytes_used(struct midi_buffer *this) { return midibuf_is_empty(this) ? 0 : (this->pos_write - this->pos_read + this->size - 1) % this->size + 1; } int line6_midibuf_write(struct midi_buffer *this, unsigned char *data, int length) { int bytes_free; int length1, length2; int skip_active_sense = 0; if (midibuf_is_full(this) || (length <= 0)) return 0; /* skip trailing active sense */ if (data[length - 1] == 0xfe) { --length; skip_active_sense = 1; } bytes_free = line6_midibuf_bytes_free(this); if (length > bytes_free) length = bytes_free; if (length > 0) { length1 = this->size - this->pos_write; if (length < length1) { /* no buffer wraparound */ memcpy(this->buf + this->pos_write, data, length); this->pos_write += length; } else { /* buffer wraparound */ length2 = length - length1; memcpy(this->buf + this->pos_write, data, length1); memcpy(this->buf, data + length1, length2); this->pos_write = length2; } if (this->pos_write == this->pos_read) this->full = 1; } return length + skip_active_sense; } int line6_midibuf_read(struct midi_buffer *this, unsigned char *data, int length, int read_type) { int bytes_used; int length1, length2; int command; int midi_length; int repeat = 0; int i; /* we need to be able to store at least a 3 byte MIDI message */ if (length < 3) return -EINVAL; if (midibuf_is_empty(this)) return 0; bytes_used = line6_midibuf_bytes_used(this); if (length > bytes_used) length = bytes_used; length1 = this->size - this->pos_read; command = this->buf[this->pos_read]; /* PODxt always has status byte lower nibble set to 0010, when it means to send 0000, so we correct if here so that control/program changes come on channel 1 and sysex message status byte is correct */ if (read_type == LINE6_MIDIBUF_READ_RX) { if (command == 0xb2 || command == 0xc2 || command == 0xf2) { unsigned char fixed = command & 0xf0; this->buf[this->pos_read] = fixed; command = fixed; } } /* check MIDI command length */ if (command & 0x80) { midi_length = midibuf_message_length(command); this->command_prev = command; } else { if (this->command_prev > 0) { int midi_length_prev = midibuf_message_length(this->command_prev); if (midi_length_prev > 1) { midi_length = midi_length_prev - 1; repeat = 1; } else midi_length = -1; } else midi_length = -1; } if (midi_length < 0) { /* search for end of message */ if (length < length1) { /* no buffer wraparound */ for (i = 1; i < length; ++i) if (this->buf[this->pos_read + i] & 0x80) break; midi_length = i; } else { /* buffer wraparound */ length2 = length - length1; for (i = 1; i < length1; ++i) if (this->buf[this->pos_read + i] & 0x80) break; if (i < length1) midi_length = i; else { for (i = 0; i < length2; ++i) if (this->buf[i] & 0x80) break; midi_length = length1 + i; } } if (midi_length == length) midi_length = -1; /* end of message not found */ } if (midi_length < 0) { if (!this->split) return 0; /* command is not yet complete */ } else { if (length < midi_length) return 0; /* command is not yet complete */ length = midi_length; } if (length < length1) { /* no buffer wraparound */ memcpy(data + repeat, this->buf + this->pos_read, length); this->pos_read += length; } else { /* buffer wraparound */ length2 = length - length1; memcpy(data + repeat, this->buf + this->pos_read, length1); memcpy(data + repeat + length1, this->buf, length2); this->pos_read = length2; } if (repeat) data[0] = this->command_prev; this->full = 0; return length + repeat; } int line6_midibuf_ignore(struct midi_buffer *this, int length) { int bytes_used = line6_midibuf_bytes_used(this); if (length > bytes_used) length = bytes_used; this->pos_read = (this->pos_read + length) % this->size; this->full = 0; return length; } void line6_midibuf_destroy(struct midi_buffer *this) { kfree(this->buf); this->buf = NULL; }
linux-master
sound/usb/line6/midibuf.c
// SPDX-License-Identifier: GPL-2.0-only /* * Driver for AT73C213 16-bit stereo DAC connected to Atmel SSC * * Copyright (C) 2006-2007 Atmel Norway */ /*#define DEBUG*/ #include <linux/clk.h> #include <linux/err.h> #include <linux/delay.h> #include <linux/device.h> #include <linux/dma-mapping.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/platform_device.h> #include <linux/io.h> #include <sound/initval.h> #include <sound/control.h> #include <sound/core.h> #include <sound/pcm.h> #include <linux/atmel-ssc.h> #include <linux/spi/spi.h> #include <linux/spi/at73c213.h> #include "at73c213.h" #define BITRATE_MIN 8000 /* Hardware limit? */ #define BITRATE_TARGET CONFIG_SND_AT73C213_TARGET_BITRATE #define BITRATE_MAX 50000 /* Hardware limit. */ /* Initial (hardware reset) AT73C213 register values. */ static const u8 snd_at73c213_original_image[18] = { 0x00, /* 00 - CTRL */ 0x05, /* 01 - LLIG */ 0x05, /* 02 - RLIG */ 0x08, /* 03 - LPMG */ 0x08, /* 04 - RPMG */ 0x00, /* 05 - LLOG */ 0x00, /* 06 - RLOG */ 0x22, /* 07 - OLC */ 0x09, /* 08 - MC */ 0x00, /* 09 - CSFC */ 0x00, /* 0A - MISC */ 0x00, /* 0B - */ 0x00, /* 0C - PRECH */ 0x05, /* 0D - AUXG */ 0x00, /* 0E - */ 0x00, /* 0F - */ 0x00, /* 10 - RST */ 0x00, /* 11 - PA_CTRL */ }; struct snd_at73c213 { struct snd_card *card; struct snd_pcm *pcm; struct snd_pcm_substream *substream; struct at73c213_board_info *board; int irq; int period; unsigned long bitrate; struct ssc_device *ssc; struct spi_device *spi; u8 spi_wbuffer[2]; u8 spi_rbuffer[2]; /* Image of the SPI registers in AT73C213. */ u8 reg_image[18]; /* Protect SSC registers against concurrent access. */ spinlock_t lock; /* Protect mixer registers against concurrent access. */ struct mutex mixer_lock; }; #define get_chip(card) ((struct snd_at73c213 *)card->private_data) static int snd_at73c213_write_reg(struct snd_at73c213 *chip, u8 reg, u8 val) { struct spi_message msg; struct spi_transfer msg_xfer = { .len = 2, .cs_change = 0, }; int retval; spi_message_init(&msg); chip->spi_wbuffer[0] = reg; chip->spi_wbuffer[1] = val; msg_xfer.tx_buf = chip->spi_wbuffer; msg_xfer.rx_buf = chip->spi_rbuffer; spi_message_add_tail(&msg_xfer, &msg); retval = spi_sync(chip->spi, &msg); if (!retval) chip->reg_image[reg] = val; return retval; } static struct snd_pcm_hardware snd_at73c213_playback_hw = { .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER, .formats = SNDRV_PCM_FMTBIT_S16_BE, .rates = SNDRV_PCM_RATE_CONTINUOUS, .rate_min = 8000, /* Replaced by chip->bitrate later. */ .rate_max = 50000, /* Replaced by chip->bitrate later. */ .channels_min = 1, .channels_max = 2, .buffer_bytes_max = 64 * 1024 - 1, .period_bytes_min = 512, .period_bytes_max = 64 * 1024 - 1, .periods_min = 4, .periods_max = 1024, }; /* * Calculate and set bitrate and divisions. */ static int snd_at73c213_set_bitrate(struct snd_at73c213 *chip) { unsigned long ssc_rate = clk_get_rate(chip->ssc->clk); unsigned long dac_rate_new, ssc_div; int status; unsigned long ssc_div_max, ssc_div_min; int max_tries; /* * We connect two clocks here, picking divisors so the I2S clocks * out data at the same rate the DAC clocks it in ... and as close * as practical to the desired target rate. * * The DAC master clock (MCLK) is programmable, and is either 256 * or (not here) 384 times the I2S output clock (BCLK). */ /* SSC clock / (bitrate * stereo * 16-bit). */ ssc_div = ssc_rate / (BITRATE_TARGET * 2 * 16); ssc_div_min = ssc_rate / (BITRATE_MAX * 2 * 16); ssc_div_max = ssc_rate / (BITRATE_MIN * 2 * 16); max_tries = (ssc_div_max - ssc_div_min) / 2; if (max_tries < 1) max_tries = 1; /* ssc_div must be even. */ ssc_div = (ssc_div + 1) & ~1UL; if ((ssc_rate / (ssc_div * 2 * 16)) < BITRATE_MIN) { ssc_div -= 2; if ((ssc_rate / (ssc_div * 2 * 16)) > BITRATE_MAX) return -ENXIO; } /* Search for a possible bitrate. */ do { /* SSC clock / (ssc divider * 16-bit * stereo). */ if ((ssc_rate / (ssc_div * 2 * 16)) < BITRATE_MIN) return -ENXIO; /* 256 / (2 * 16) = 8 */ dac_rate_new = 8 * (ssc_rate / ssc_div); status = clk_round_rate(chip->board->dac_clk, dac_rate_new); if (status <= 0) return status; /* Ignore difference smaller than 256 Hz. */ if ((status/256) == (dac_rate_new/256)) goto set_rate; ssc_div += 2; } while (--max_tries); /* Not able to find a valid bitrate. */ return -ENXIO; set_rate: status = clk_set_rate(chip->board->dac_clk, status); if (status < 0) return status; /* Set divider in SSC device. */ ssc_writel(chip->ssc->regs, CMR, ssc_div/2); /* SSC clock / (ssc divider * 16-bit * stereo). */ chip->bitrate = ssc_rate / (ssc_div * 16 * 2); dev_info(&chip->spi->dev, "at73c213: supported bitrate is %lu (%lu divider)\n", chip->bitrate, ssc_div); return 0; } static int snd_at73c213_pcm_open(struct snd_pcm_substream *substream) { struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; int err; /* ensure buffer_size is a multiple of period_size */ err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); if (err < 0) return err; snd_at73c213_playback_hw.rate_min = chip->bitrate; snd_at73c213_playback_hw.rate_max = chip->bitrate; runtime->hw = snd_at73c213_playback_hw; chip->substream = substream; err = clk_enable(chip->ssc->clk); if (err) return err; return 0; } static int snd_at73c213_pcm_close(struct snd_pcm_substream *substream) { struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); chip->substream = NULL; clk_disable(chip->ssc->clk); return 0; } static int snd_at73c213_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); int channels = params_channels(hw_params); int val; val = ssc_readl(chip->ssc->regs, TFMR); val = SSC_BFINS(TFMR_DATNB, channels - 1, val); ssc_writel(chip->ssc->regs, TFMR, val); return 0; } static int snd_at73c213_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; int block_size; block_size = frames_to_bytes(runtime, runtime->period_size); chip->period = 0; ssc_writel(chip->ssc->regs, PDC_TPR, (long)runtime->dma_addr); ssc_writel(chip->ssc->regs, PDC_TCR, runtime->period_size * runtime->channels); ssc_writel(chip->ssc->regs, PDC_TNPR, (long)runtime->dma_addr + block_size); ssc_writel(chip->ssc->regs, PDC_TNCR, runtime->period_size * runtime->channels); return 0; } static int snd_at73c213_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); int retval = 0; spin_lock(&chip->lock); switch (cmd) { case SNDRV_PCM_TRIGGER_START: ssc_writel(chip->ssc->regs, IER, SSC_BIT(IER_ENDTX)); ssc_writel(chip->ssc->regs, PDC_PTCR, SSC_BIT(PDC_PTCR_TXTEN)); break; case SNDRV_PCM_TRIGGER_STOP: ssc_writel(chip->ssc->regs, PDC_PTCR, SSC_BIT(PDC_PTCR_TXTDIS)); ssc_writel(chip->ssc->regs, IDR, SSC_BIT(IDR_ENDTX)); break; default: dev_dbg(&chip->spi->dev, "spurious command %x\n", cmd); retval = -EINVAL; break; } spin_unlock(&chip->lock); return retval; } static snd_pcm_uframes_t snd_at73c213_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_at73c213 *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_uframes_t pos; unsigned long bytes; bytes = ssc_readl(chip->ssc->regs, PDC_TPR) - (unsigned long)runtime->dma_addr; pos = bytes_to_frames(runtime, bytes); if (pos >= runtime->buffer_size) pos -= runtime->buffer_size; return pos; } static const struct snd_pcm_ops at73c213_playback_ops = { .open = snd_at73c213_pcm_open, .close = snd_at73c213_pcm_close, .hw_params = snd_at73c213_pcm_hw_params, .prepare = snd_at73c213_pcm_prepare, .trigger = snd_at73c213_pcm_trigger, .pointer = snd_at73c213_pcm_pointer, }; static int snd_at73c213_pcm_new(struct snd_at73c213 *chip, int device) { struct snd_pcm *pcm; int retval; retval = snd_pcm_new(chip->card, chip->card->shortname, device, 1, 0, &pcm); if (retval < 0) goto out; pcm->private_data = chip; pcm->info_flags = SNDRV_PCM_INFO_BLOCK_TRANSFER; strcpy(pcm->name, "at73c213"); chip->pcm = pcm; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &at73c213_playback_ops); snd_pcm_set_managed_buffer_all(chip->pcm, SNDRV_DMA_TYPE_DEV, &chip->ssc->pdev->dev, 64 * 1024, 64 * 1024); out: return retval; } static irqreturn_t snd_at73c213_interrupt(int irq, void *dev_id) { struct snd_at73c213 *chip = dev_id; struct snd_pcm_runtime *runtime = chip->substream->runtime; u32 status; int offset; int block_size; int next_period; int retval = IRQ_NONE; spin_lock(&chip->lock); block_size = frames_to_bytes(runtime, runtime->period_size); status = ssc_readl(chip->ssc->regs, IMR); if (status & SSC_BIT(IMR_ENDTX)) { chip->period++; if (chip->period == runtime->periods) chip->period = 0; next_period = chip->period + 1; if (next_period == runtime->periods) next_period = 0; offset = block_size * next_period; ssc_writel(chip->ssc->regs, PDC_TNPR, (long)runtime->dma_addr + offset); ssc_writel(chip->ssc->regs, PDC_TNCR, runtime->period_size * runtime->channels); retval = IRQ_HANDLED; } ssc_readl(chip->ssc->regs, IMR); spin_unlock(&chip->lock); if (status & SSC_BIT(IMR_ENDTX)) snd_pcm_period_elapsed(chip->substream); return retval; } /* * Mixer functions. */ static int snd_at73c213_mono_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; int invert = (kcontrol->private_value >> 24) & 0xff; mutex_lock(&chip->mixer_lock); ucontrol->value.integer.value[0] = (chip->reg_image[reg] >> shift) & mask; if (invert) ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; mutex_unlock(&chip->mixer_lock); return 0; } static int snd_at73c213_mono_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; int invert = (kcontrol->private_value >> 24) & 0xff; int change, retval; unsigned short val; val = (ucontrol->value.integer.value[0] & mask); if (invert) val = mask - val; val <<= shift; mutex_lock(&chip->mixer_lock); val = (chip->reg_image[reg] & ~(mask << shift)) | val; change = val != chip->reg_image[reg]; retval = snd_at73c213_write_reg(chip, reg, val); mutex_unlock(&chip->mixer_lock); if (retval) return retval; return change; } static int snd_at73c213_stereo_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; if (mask == 1) uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; else uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; uinfo->value.integer.max = mask; return 0; } static int snd_at73c213_stereo_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; int shift_right = (kcontrol->private_value >> 19) & 0x07; int mask = (kcontrol->private_value >> 24) & 0xff; int invert = (kcontrol->private_value >> 22) & 1; mutex_lock(&chip->mixer_lock); ucontrol->value.integer.value[0] = (chip->reg_image[left_reg] >> shift_left) & mask; ucontrol->value.integer.value[1] = (chip->reg_image[right_reg] >> shift_right) & mask; if (invert) { ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1]; } mutex_unlock(&chip->mixer_lock); return 0; } static int snd_at73c213_stereo_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; int shift_right = (kcontrol->private_value >> 19) & 0x07; int mask = (kcontrol->private_value >> 24) & 0xff; int invert = (kcontrol->private_value >> 22) & 1; int change, retval; unsigned short val1, val2; val1 = ucontrol->value.integer.value[0] & mask; val2 = ucontrol->value.integer.value[1] & mask; if (invert) { val1 = mask - val1; val2 = mask - val2; } val1 <<= shift_left; val2 <<= shift_right; mutex_lock(&chip->mixer_lock); val1 = (chip->reg_image[left_reg] & ~(mask << shift_left)) | val1; val2 = (chip->reg_image[right_reg] & ~(mask << shift_right)) | val2; change = val1 != chip->reg_image[left_reg] || val2 != chip->reg_image[right_reg]; retval = snd_at73c213_write_reg(chip, left_reg, val1); if (retval) { mutex_unlock(&chip->mixer_lock); goto out; } retval = snd_at73c213_write_reg(chip, right_reg, val2); if (retval) { mutex_unlock(&chip->mixer_lock); goto out; } mutex_unlock(&chip->mixer_lock); return change; out: return retval; } #define snd_at73c213_mono_switch_info snd_ctl_boolean_mono_info static int snd_at73c213_mono_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int invert = (kcontrol->private_value >> 24) & 0xff; mutex_lock(&chip->mixer_lock); ucontrol->value.integer.value[0] = (chip->reg_image[reg] >> shift) & 0x01; if (invert) ucontrol->value.integer.value[0] = 0x01 - ucontrol->value.integer.value[0]; mutex_unlock(&chip->mixer_lock); return 0; } static int snd_at73c213_mono_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_at73c213 *chip = snd_kcontrol_chip(kcontrol); int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; int invert = (kcontrol->private_value >> 24) & 0xff; int change, retval; unsigned short val; if (ucontrol->value.integer.value[0]) val = mask; else val = 0; if (invert) val = mask - val; val <<= shift; mutex_lock(&chip->mixer_lock); val |= (chip->reg_image[reg] & ~(mask << shift)); change = val != chip->reg_image[reg]; retval = snd_at73c213_write_reg(chip, reg, val); mutex_unlock(&chip->mixer_lock); if (retval) return retval; return change; } static int snd_at73c213_pa_volume_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = ((kcontrol->private_value >> 16) & 0xff) - 1; return 0; } static int snd_at73c213_line_capture_volume_info( struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; /* When inverted will give values 0x10001 => 0. */ uinfo->value.integer.min = 14; uinfo->value.integer.max = 31; return 0; } static int snd_at73c213_aux_capture_volume_info( struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; /* When inverted will give values 0x10001 => 0. */ uinfo->value.integer.min = 14; uinfo->value.integer.max = 31; return 0; } #define AT73C213_MONO_SWITCH(xname, xindex, reg, shift, mask, invert) \ { \ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ .name = xname, \ .index = xindex, \ .info = snd_at73c213_mono_switch_info, \ .get = snd_at73c213_mono_switch_get, \ .put = snd_at73c213_mono_switch_put, \ .private_value = (reg | (shift << 8) | (mask << 16) | (invert << 24)) \ } #define AT73C213_STEREO(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \ { \ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ .name = xname, \ .index = xindex, \ .info = snd_at73c213_stereo_info, \ .get = snd_at73c213_stereo_get, \ .put = snd_at73c213_stereo_put, \ .private_value = (left_reg | (right_reg << 8) \ | (shift_left << 16) | (shift_right << 19) \ | (mask << 24) | (invert << 22)) \ } static const struct snd_kcontrol_new snd_at73c213_controls[] = { AT73C213_STEREO("Master Playback Volume", 0, DAC_LMPG, DAC_RMPG, 0, 0, 0x1f, 1), AT73C213_STEREO("Master Playback Switch", 0, DAC_LMPG, DAC_RMPG, 5, 5, 1, 1), AT73C213_STEREO("PCM Playback Volume", 0, DAC_LLOG, DAC_RLOG, 0, 0, 0x1f, 1), AT73C213_STEREO("PCM Playback Switch", 0, DAC_LLOG, DAC_RLOG, 5, 5, 1, 1), AT73C213_MONO_SWITCH("Mono PA Playback Switch", 0, DAC_CTRL, DAC_CTRL_ONPADRV, 0x01, 0), { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PA Playback Volume", .index = 0, .info = snd_at73c213_pa_volume_info, .get = snd_at73c213_mono_get, .put = snd_at73c213_mono_put, .private_value = PA_CTRL | (PA_CTRL_APAGAIN << 8) | \ (0x0f << 16) | (1 << 24), }, AT73C213_MONO_SWITCH("PA High Gain Playback Switch", 0, PA_CTRL, PA_CTRL_APALP, 0x01, 1), AT73C213_MONO_SWITCH("PA Playback Switch", 0, PA_CTRL, PA_CTRL_APAON, 0x01, 0), { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Aux Capture Volume", .index = 0, .info = snd_at73c213_aux_capture_volume_info, .get = snd_at73c213_mono_get, .put = snd_at73c213_mono_put, .private_value = DAC_AUXG | (0 << 8) | (0x1f << 16) | (1 << 24), }, AT73C213_MONO_SWITCH("Aux Capture Switch", 0, DAC_CTRL, DAC_CTRL_ONAUXIN, 0x01, 0), { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line Capture Volume", .index = 0, .info = snd_at73c213_line_capture_volume_info, .get = snd_at73c213_stereo_get, .put = snd_at73c213_stereo_put, .private_value = DAC_LLIG | (DAC_RLIG << 8) | (0 << 16) | (0 << 19) | (0x1f << 24) | (1 << 22), }, AT73C213_MONO_SWITCH("Line Capture Switch", 0, DAC_CTRL, 0, 0x03, 0), }; static int snd_at73c213_mixer(struct snd_at73c213 *chip) { struct snd_card *card; int errval, idx; if (chip == NULL || chip->pcm == NULL) return -EINVAL; card = chip->card; strcpy(card->mixername, chip->pcm->name); for (idx = 0; idx < ARRAY_SIZE(snd_at73c213_controls); idx++) { errval = snd_ctl_add(card, snd_ctl_new1(&snd_at73c213_controls[idx], chip)); if (errval < 0) goto cleanup; } return 0; cleanup: for (idx = 1; idx < ARRAY_SIZE(snd_at73c213_controls) + 1; idx++) { struct snd_kcontrol *kctl; kctl = snd_ctl_find_numid(card, idx); if (kctl) snd_ctl_remove(card, kctl); } return errval; } /* * Device functions */ static int snd_at73c213_ssc_init(struct snd_at73c213 *chip) { /* * Continuous clock output. * Starts on falling TF. * Delay 1 cycle (1 bit). * Periode is 16 bit (16 - 1). */ ssc_writel(chip->ssc->regs, TCMR, SSC_BF(TCMR_CKO, 1) | SSC_BF(TCMR_START, 4) | SSC_BF(TCMR_STTDLY, 1) | SSC_BF(TCMR_PERIOD, 16 - 1)); /* * Data length is 16 bit (16 - 1). * Transmit MSB first. * Transmit 2 words each transfer. * Frame sync length is 16 bit (16 - 1). * Frame starts on negative pulse. */ ssc_writel(chip->ssc->regs, TFMR, SSC_BF(TFMR_DATLEN, 16 - 1) | SSC_BIT(TFMR_MSBF) | SSC_BF(TFMR_DATNB, 1) | SSC_BF(TFMR_FSLEN, 16 - 1) | SSC_BF(TFMR_FSOS, 1)); return 0; } static int snd_at73c213_chip_init(struct snd_at73c213 *chip) { int retval; unsigned char dac_ctrl = 0; retval = snd_at73c213_set_bitrate(chip); if (retval) goto out; /* Enable DAC master clock. */ retval = clk_enable(chip->board->dac_clk); if (retval) goto out; /* Initialize at73c213 on SPI bus. */ retval = snd_at73c213_write_reg(chip, DAC_RST, 0x04); if (retval) goto out_clk; msleep(1); retval = snd_at73c213_write_reg(chip, DAC_RST, 0x03); if (retval) goto out_clk; /* Precharge everything. */ retval = snd_at73c213_write_reg(chip, DAC_PRECH, 0xff); if (retval) goto out_clk; retval = snd_at73c213_write_reg(chip, PA_CTRL, (1<<PA_CTRL_APAPRECH)); if (retval) goto out_clk; retval = snd_at73c213_write_reg(chip, DAC_CTRL, (1<<DAC_CTRL_ONLNOL) | (1<<DAC_CTRL_ONLNOR)); if (retval) goto out_clk; msleep(50); /* Stop precharging PA. */ retval = snd_at73c213_write_reg(chip, PA_CTRL, (1<<PA_CTRL_APALP) | 0x0f); if (retval) goto out_clk; msleep(450); /* Stop precharging DAC, turn on master power. */ retval = snd_at73c213_write_reg(chip, DAC_PRECH, (1<<DAC_PRECH_ONMSTR)); if (retval) goto out_clk; msleep(1); /* Turn on DAC. */ dac_ctrl = (1<<DAC_CTRL_ONDACL) | (1<<DAC_CTRL_ONDACR) | (1<<DAC_CTRL_ONLNOL) | (1<<DAC_CTRL_ONLNOR); retval = snd_at73c213_write_reg(chip, DAC_CTRL, dac_ctrl); if (retval) goto out_clk; /* Mute sound. */ retval = snd_at73c213_write_reg(chip, DAC_LMPG, 0x3f); if (retval) goto out_clk; retval = snd_at73c213_write_reg(chip, DAC_RMPG, 0x3f); if (retval) goto out_clk; retval = snd_at73c213_write_reg(chip, DAC_LLOG, 0x3f); if (retval) goto out_clk; retval = snd_at73c213_write_reg(chip, DAC_RLOG, 0x3f); if (retval) goto out_clk; retval = snd_at73c213_write_reg(chip, DAC_LLIG, 0x11); if (retval) goto out_clk; retval = snd_at73c213_write_reg(chip, DAC_RLIG, 0x11); if (retval) goto out_clk; retval = snd_at73c213_write_reg(chip, DAC_AUXG, 0x11); if (retval) goto out_clk; /* Enable I2S device, i.e. clock output. */ ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXEN)); goto out; out_clk: clk_disable(chip->board->dac_clk); out: return retval; } static int snd_at73c213_dev_free(struct snd_device *device) { struct snd_at73c213 *chip = device->device_data; ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXDIS)); if (chip->irq >= 0) { free_irq(chip->irq, chip); chip->irq = -1; } return 0; } static int snd_at73c213_dev_init(struct snd_card *card, struct spi_device *spi) { static const struct snd_device_ops ops = { .dev_free = snd_at73c213_dev_free, }; struct snd_at73c213 *chip = get_chip(card); int irq, retval; irq = chip->ssc->irq; if (irq < 0) return irq; spin_lock_init(&chip->lock); mutex_init(&chip->mixer_lock); chip->card = card; chip->irq = -1; retval = clk_enable(chip->ssc->clk); if (retval) return retval; retval = request_irq(irq, snd_at73c213_interrupt, 0, "at73c213", chip); if (retval) { dev_dbg(&chip->spi->dev, "unable to request irq %d\n", irq); goto out; } chip->irq = irq; memcpy(&chip->reg_image, &snd_at73c213_original_image, sizeof(snd_at73c213_original_image)); retval = snd_at73c213_ssc_init(chip); if (retval) goto out_irq; retval = snd_at73c213_chip_init(chip); if (retval) goto out_irq; retval = snd_at73c213_pcm_new(chip, 0); if (retval) goto out_irq; retval = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops); if (retval) goto out_irq; retval = snd_at73c213_mixer(chip); if (retval) goto out_snd_dev; goto out; out_snd_dev: snd_device_free(card, chip); out_irq: free_irq(chip->irq, chip); chip->irq = -1; out: clk_disable(chip->ssc->clk); return retval; } static int snd_at73c213_probe(struct spi_device *spi) { struct snd_card *card; struct snd_at73c213 *chip; struct at73c213_board_info *board; int retval; char id[16]; board = spi->dev.platform_data; if (!board) { dev_dbg(&spi->dev, "no platform_data\n"); return -ENXIO; } if (!board->dac_clk) { dev_dbg(&spi->dev, "no DAC clk\n"); return -ENXIO; } if (IS_ERR(board->dac_clk)) { dev_dbg(&spi->dev, "no DAC clk\n"); return PTR_ERR(board->dac_clk); } /* Allocate "card" using some unused identifiers. */ snprintf(id, sizeof id, "at73c213_%d", board->ssc_id); retval = snd_card_new(&spi->dev, -1, id, THIS_MODULE, sizeof(struct snd_at73c213), &card); if (retval < 0) goto out; chip = card->private_data; chip->spi = spi; chip->board = board; chip->ssc = ssc_request(board->ssc_id); if (IS_ERR(chip->ssc)) { dev_dbg(&spi->dev, "could not get ssc%d device\n", board->ssc_id); retval = PTR_ERR(chip->ssc); goto out_card; } retval = snd_at73c213_dev_init(card, spi); if (retval) goto out_ssc; strcpy(card->driver, "at73c213"); strcpy(card->shortname, board->shortname); sprintf(card->longname, "%s on irq %d", card->shortname, chip->irq); retval = snd_card_register(card); if (retval) goto out_ssc; dev_set_drvdata(&spi->dev, card); goto out; out_ssc: ssc_free(chip->ssc); out_card: snd_card_free(card); out: return retval; } static void snd_at73c213_remove(struct spi_device *spi) { struct snd_card *card = dev_get_drvdata(&spi->dev); struct snd_at73c213 *chip = card->private_data; int retval; /* Stop playback. */ retval = clk_enable(chip->ssc->clk); if (retval) goto out; ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXDIS)); clk_disable(chip->ssc->clk); /* Mute sound. */ retval = snd_at73c213_write_reg(chip, DAC_LMPG, 0x3f); if (retval) goto out; retval = snd_at73c213_write_reg(chip, DAC_RMPG, 0x3f); if (retval) goto out; retval = snd_at73c213_write_reg(chip, DAC_LLOG, 0x3f); if (retval) goto out; retval = snd_at73c213_write_reg(chip, DAC_RLOG, 0x3f); if (retval) goto out; retval = snd_at73c213_write_reg(chip, DAC_LLIG, 0x11); if (retval) goto out; retval = snd_at73c213_write_reg(chip, DAC_RLIG, 0x11); if (retval) goto out; retval = snd_at73c213_write_reg(chip, DAC_AUXG, 0x11); if (retval) goto out; /* Turn off PA. */ retval = snd_at73c213_write_reg(chip, PA_CTRL, chip->reg_image[PA_CTRL] | 0x0f); if (retval) goto out; msleep(10); retval = snd_at73c213_write_reg(chip, PA_CTRL, (1 << PA_CTRL_APALP) | 0x0f); if (retval) goto out; /* Turn off external DAC. */ retval = snd_at73c213_write_reg(chip, DAC_CTRL, 0x0c); if (retval) goto out; msleep(2); retval = snd_at73c213_write_reg(chip, DAC_CTRL, 0x00); if (retval) goto out; /* Turn off master power. */ retval = snd_at73c213_write_reg(chip, DAC_PRECH, 0x00); if (retval) goto out; out: /* Stop DAC master clock. */ clk_disable(chip->board->dac_clk); ssc_free(chip->ssc); snd_card_free(card); } #ifdef CONFIG_PM_SLEEP static int snd_at73c213_suspend(struct device *dev) { struct snd_card *card = dev_get_drvdata(dev); struct snd_at73c213 *chip = card->private_data; ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXDIS)); clk_disable(chip->ssc->clk); clk_disable(chip->board->dac_clk); return 0; } static int snd_at73c213_resume(struct device *dev) { struct snd_card *card = dev_get_drvdata(dev); struct snd_at73c213 *chip = card->private_data; int retval; retval = clk_enable(chip->board->dac_clk); if (retval) return retval; retval = clk_enable(chip->ssc->clk); if (retval) { clk_disable(chip->board->dac_clk); return retval; } ssc_writel(chip->ssc->regs, CR, SSC_BIT(CR_TXEN)); return 0; } static SIMPLE_DEV_PM_OPS(at73c213_pm_ops, snd_at73c213_suspend, snd_at73c213_resume); #define AT73C213_PM_OPS (&at73c213_pm_ops) #else #define AT73C213_PM_OPS NULL #endif static struct spi_driver at73c213_driver = { .driver = { .name = "at73c213", .pm = AT73C213_PM_OPS, }, .probe = snd_at73c213_probe, .remove = snd_at73c213_remove, }; module_spi_driver(at73c213_driver); MODULE_AUTHOR("Hans-Christian Egtvedt <[email protected]>"); MODULE_DESCRIPTION("Sound driver for AT73C213 with Atmel SSC"); MODULE_LICENSE("GPL");
linux-master
sound/spi/at73c213.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (C) 2000 Takashi Iwai <[email protected]> * * Generic memory management routines for soundcard memory allocation */ #include <linux/mutex.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/module.h> #include <sound/core.h> #include <sound/util_mem.h> MODULE_AUTHOR("Takashi Iwai"); MODULE_DESCRIPTION("Generic memory management routines for soundcard memory allocation"); MODULE_LICENSE("GPL"); #define get_memblk(p) list_entry(p, struct snd_util_memblk, list) /* * create a new memory manager */ struct snd_util_memhdr * snd_util_memhdr_new(int memsize) { struct snd_util_memhdr *hdr; hdr = kzalloc(sizeof(*hdr), GFP_KERNEL); if (hdr == NULL) return NULL; hdr->size = memsize; mutex_init(&hdr->block_mutex); INIT_LIST_HEAD(&hdr->block); return hdr; } /* * free a memory manager */ void snd_util_memhdr_free(struct snd_util_memhdr *hdr) { struct list_head *p; if (!hdr) return; /* release all blocks */ while ((p = hdr->block.next) != &hdr->block) { list_del(p); kfree(get_memblk(p)); } kfree(hdr); } /* * allocate a memory block (without mutex) */ struct snd_util_memblk * __snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size) { struct snd_util_memblk *blk; unsigned int units, prev_offset; struct list_head *p; if (snd_BUG_ON(!hdr || size <= 0)) return NULL; /* word alignment */ units = size; if (units & 1) units++; if (units > hdr->size) return NULL; /* look for empty block */ prev_offset = 0; list_for_each(p, &hdr->block) { blk = get_memblk(p); if (blk->offset - prev_offset >= units) goto __found; prev_offset = blk->offset + blk->size; } if (hdr->size - prev_offset < units) return NULL; __found: return __snd_util_memblk_new(hdr, units, p->prev); } /* * create a new memory block with the given size * the block is linked next to prev */ struct snd_util_memblk * __snd_util_memblk_new(struct snd_util_memhdr *hdr, unsigned int units, struct list_head *prev) { struct snd_util_memblk *blk; blk = kmalloc(sizeof(struct snd_util_memblk) + hdr->block_extra_size, GFP_KERNEL); if (blk == NULL) return NULL; if (prev == &hdr->block) blk->offset = 0; else { struct snd_util_memblk *p = get_memblk(prev); blk->offset = p->offset + p->size; } blk->size = units; list_add(&blk->list, prev); hdr->nblocks++; hdr->used += units; return blk; } /* * allocate a memory block (with mutex) */ struct snd_util_memblk * snd_util_mem_alloc(struct snd_util_memhdr *hdr, int size) { struct snd_util_memblk *blk; mutex_lock(&hdr->block_mutex); blk = __snd_util_mem_alloc(hdr, size); mutex_unlock(&hdr->block_mutex); return blk; } /* * remove the block from linked-list and free resource * (without mutex) */ void __snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk) { list_del(&blk->list); hdr->nblocks--; hdr->used -= blk->size; kfree(blk); } /* * free a memory block (with mutex) */ int snd_util_mem_free(struct snd_util_memhdr *hdr, struct snd_util_memblk *blk) { if (snd_BUG_ON(!hdr || !blk)) return -EINVAL; mutex_lock(&hdr->block_mutex); __snd_util_mem_free(hdr, blk); mutex_unlock(&hdr->block_mutex); return 0; } /* * return available memory size */ int snd_util_mem_avail(struct snd_util_memhdr *hdr) { unsigned int size; mutex_lock(&hdr->block_mutex); size = hdr->size - hdr->used; mutex_unlock(&hdr->block_mutex); return size; } EXPORT_SYMBOL(snd_util_memhdr_new); EXPORT_SYMBOL(snd_util_memhdr_free); EXPORT_SYMBOL(snd_util_mem_alloc); EXPORT_SYMBOL(snd_util_mem_free); EXPORT_SYMBOL(snd_util_mem_avail); EXPORT_SYMBOL(__snd_util_mem_alloc); EXPORT_SYMBOL(__snd_util_mem_free); EXPORT_SYMBOL(__snd_util_memblk_new);
linux-master
sound/synth/util_mem.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Midi synth routines for the Emu8k/Emu10k1 * * Copyright (C) 1999 Steve Ratcliffe * Copyright (c) 1999-2000 Takashi Iwai <[email protected]> * * Contains code based on awe_wave.c by Takashi Iwai */ #include "emux_voice.h" #include <linux/slab.h> #ifdef SNDRV_EMUX_USE_RAW_EFFECT /* * effects table */ #define xoffsetof(type,tag) ((long)(&((type)NULL)->tag) - (long)(NULL)) #define parm_offset(tag) xoffsetof(struct soundfont_voice_parm *, tag) #define PARM_IS_BYTE (1 << 0) #define PARM_IS_WORD (1 << 1) #define PARM_IS_ALIGNED (3 << 2) #define PARM_IS_ALIGN_HI (1 << 2) #define PARM_IS_ALIGN_LO (2 << 2) #define PARM_IS_SIGNED (1 << 4) #define PARM_WORD (PARM_IS_WORD) #define PARM_BYTE_LO (PARM_IS_BYTE|PARM_IS_ALIGN_LO) #define PARM_BYTE_HI (PARM_IS_BYTE|PARM_IS_ALIGN_HI) #define PARM_BYTE (PARM_IS_BYTE) #define PARM_SIGN_LO (PARM_IS_BYTE|PARM_IS_ALIGN_LO|PARM_IS_SIGNED) #define PARM_SIGN_HI (PARM_IS_BYTE|PARM_IS_ALIGN_HI|PARM_IS_SIGNED) static struct emux_parm_defs { int type; /* byte or word */ int low, high; /* value range */ long offset; /* offset in parameter record (-1 = not written) */ int update; /* flgas for real-time update */ } parm_defs[EMUX_NUM_EFFECTS] = { {PARM_WORD, 0, 0x8000, parm_offset(moddelay), 0}, /* env1 delay */ {PARM_BYTE_LO, 1, 0x80, parm_offset(modatkhld), 0}, /* env1 attack */ {PARM_BYTE_HI, 0, 0x7e, parm_offset(modatkhld), 0}, /* env1 hold */ {PARM_BYTE_LO, 1, 0x7f, parm_offset(moddcysus), 0}, /* env1 decay */ {PARM_BYTE_LO, 1, 0x7f, parm_offset(modrelease), 0}, /* env1 release */ {PARM_BYTE_HI, 0, 0x7f, parm_offset(moddcysus), 0}, /* env1 sustain */ {PARM_BYTE_HI, 0, 0xff, parm_offset(pefe), 0}, /* env1 pitch */ {PARM_BYTE_LO, 0, 0xff, parm_offset(pefe), 0}, /* env1 fc */ {PARM_WORD, 0, 0x8000, parm_offset(voldelay), 0}, /* env2 delay */ {PARM_BYTE_LO, 1, 0x80, parm_offset(volatkhld), 0}, /* env2 attack */ {PARM_BYTE_HI, 0, 0x7e, parm_offset(volatkhld), 0}, /* env2 hold */ {PARM_BYTE_LO, 1, 0x7f, parm_offset(voldcysus), 0}, /* env2 decay */ {PARM_BYTE_LO, 1, 0x7f, parm_offset(volrelease), 0}, /* env2 release */ {PARM_BYTE_HI, 0, 0x7f, parm_offset(voldcysus), 0}, /* env2 sustain */ {PARM_WORD, 0, 0x8000, parm_offset(lfo1delay), 0}, /* lfo1 delay */ {PARM_BYTE_LO, 0, 0xff, parm_offset(tremfrq), SNDRV_EMUX_UPDATE_TREMFREQ}, /* lfo1 freq */ {PARM_SIGN_HI, -128, 127, parm_offset(tremfrq), SNDRV_EMUX_UPDATE_TREMFREQ}, /* lfo1 vol */ {PARM_SIGN_HI, -128, 127, parm_offset(fmmod), SNDRV_EMUX_UPDATE_FMMOD}, /* lfo1 pitch */ {PARM_BYTE_LO, 0, 0xff, parm_offset(fmmod), SNDRV_EMUX_UPDATE_FMMOD}, /* lfo1 cutoff */ {PARM_WORD, 0, 0x8000, parm_offset(lfo2delay), 0}, /* lfo2 delay */ {PARM_BYTE_LO, 0, 0xff, parm_offset(fm2frq2), SNDRV_EMUX_UPDATE_FM2FRQ2}, /* lfo2 freq */ {PARM_SIGN_HI, -128, 127, parm_offset(fm2frq2), SNDRV_EMUX_UPDATE_FM2FRQ2}, /* lfo2 pitch */ {PARM_WORD, 0, 0xffff, -1, SNDRV_EMUX_UPDATE_PITCH}, /* initial pitch */ {PARM_BYTE, 0, 0xff, parm_offset(chorus), 0}, /* chorus */ {PARM_BYTE, 0, 0xff, parm_offset(reverb), 0}, /* reverb */ {PARM_BYTE, 0, 0xff, parm_offset(cutoff), SNDRV_EMUX_UPDATE_VOLUME}, /* cutoff */ {PARM_BYTE, 0, 15, parm_offset(filterQ), SNDRV_EMUX_UPDATE_Q}, /* resonance */ {PARM_WORD, 0, 0xffff, -1, 0}, /* sample start */ {PARM_WORD, 0, 0xffff, -1, 0}, /* loop start */ {PARM_WORD, 0, 0xffff, -1, 0}, /* loop end */ {PARM_WORD, 0, 0xffff, -1, 0}, /* coarse sample start */ {PARM_WORD, 0, 0xffff, -1, 0}, /* coarse loop start */ {PARM_WORD, 0, 0xffff, -1, 0}, /* coarse loop end */ {PARM_BYTE, 0, 0xff, -1, SNDRV_EMUX_UPDATE_VOLUME}, /* initial attenuation */ }; /* set byte effect value */ static void effect_set_byte(unsigned char *valp, struct snd_midi_channel *chan, int type) { short effect; struct snd_emux_effect_table *fx = chan->private; effect = fx->val[type]; if (fx->flag[type] == EMUX_FX_FLAG_ADD) { if (parm_defs[type].type & PARM_IS_SIGNED) effect += *(char*)valp; else effect += *valp; } if (effect < parm_defs[type].low) effect = parm_defs[type].low; else if (effect > parm_defs[type].high) effect = parm_defs[type].high; *valp = (unsigned char)effect; } /* set word effect value */ static void effect_set_word(unsigned short *valp, struct snd_midi_channel *chan, int type) { int effect; struct snd_emux_effect_table *fx = chan->private; effect = *(unsigned short*)&fx->val[type]; if (fx->flag[type] == EMUX_FX_FLAG_ADD) effect += *valp; if (effect < parm_defs[type].low) effect = parm_defs[type].low; else if (effect > parm_defs[type].high) effect = parm_defs[type].high; *valp = (unsigned short)effect; } /* address offset */ static int effect_get_offset(struct snd_midi_channel *chan, int lo, int hi, int mode) { int addr = 0; struct snd_emux_effect_table *fx = chan->private; if (fx->flag[hi]) addr = (short)fx->val[hi]; addr = addr << 15; if (fx->flag[lo]) addr += (short)fx->val[lo]; if (!(mode & SNDRV_SFNT_SAMPLE_8BITS)) addr /= 2; return addr; } #if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS) /* change effects - for OSS sequencer compatibility */ void snd_emux_send_effect_oss(struct snd_emux_port *port, struct snd_midi_channel *chan, int type, int val) { int mode; if (type & 0x40) mode = EMUX_FX_FLAG_OFF; else if (type & 0x80) mode = EMUX_FX_FLAG_ADD; else mode = EMUX_FX_FLAG_SET; type &= 0x3f; snd_emux_send_effect(port, chan, type, val, mode); } #endif /* Modify the effect value. * if update is necessary, call emu8000_control */ void snd_emux_send_effect(struct snd_emux_port *port, struct snd_midi_channel *chan, int type, int val, int mode) { int i; int offset; unsigned char *srcp, *origp; struct snd_emux *emu; struct snd_emux_effect_table *fx; unsigned long flags; emu = port->emu; fx = chan->private; if (emu == NULL || fx == NULL) return; if (type < 0 || type >= EMUX_NUM_EFFECTS) return; fx->val[type] = val; fx->flag[type] = mode; /* do we need to modify the register in realtime ? */ if (!parm_defs[type].update) return; offset = parm_defs[type].offset; if (offset < 0) return; #ifdef SNDRV_LITTLE_ENDIAN if (parm_defs[type].type & PARM_IS_ALIGN_HI) offset++; #else if (parm_defs[type].type & PARM_IS_ALIGN_LO) offset++; #endif /* modify the register values */ spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { struct snd_emux_voice *vp = &emu->voices[i]; if (!STATE_IS_PLAYING(vp->state) || vp->chan != chan) continue; srcp = (unsigned char*)&vp->reg.parm + offset; origp = (unsigned char*)&vp->zone->v.parm + offset; if (parm_defs[i].type & PARM_IS_BYTE) { *srcp = *origp; effect_set_byte(srcp, chan, type); } else { *(unsigned short*)srcp = *(unsigned short*)origp; effect_set_word((unsigned short*)srcp, chan, type); } } spin_unlock_irqrestore(&emu->voice_lock, flags); /* activate them */ snd_emux_update_channel(port, chan, parm_defs[type].update); } /* copy wavetable registers to voice table */ void snd_emux_setup_effect(struct snd_emux_voice *vp) { struct snd_midi_channel *chan = vp->chan; struct snd_emux_effect_table *fx; unsigned char *srcp; int i; fx = chan->private; if (!fx) return; /* modify the register values via effect table */ for (i = 0; i < EMUX_FX_END; i++) { int offset; if (!fx->flag[i]) continue; offset = parm_defs[i].offset; if (offset < 0) continue; #ifdef SNDRV_LITTLE_ENDIAN if (parm_defs[i].type & PARM_IS_ALIGN_HI) offset++; #else if (parm_defs[i].type & PARM_IS_ALIGN_LO) offset++; #endif srcp = (unsigned char*)&vp->reg.parm + offset; if (parm_defs[i].type & PARM_IS_BYTE) effect_set_byte(srcp, chan, i); else effect_set_word((unsigned short*)srcp, chan, i); } /* correct sample and loop points */ vp->reg.start += effect_get_offset(chan, EMUX_FX_SAMPLE_START, EMUX_FX_COARSE_SAMPLE_START, vp->reg.sample_mode); vp->reg.loopstart += effect_get_offset(chan, EMUX_FX_LOOP_START, EMUX_FX_COARSE_LOOP_START, vp->reg.sample_mode); vp->reg.loopend += effect_get_offset(chan, EMUX_FX_LOOP_END, EMUX_FX_COARSE_LOOP_END, vp->reg.sample_mode); } /* * effect table */ void snd_emux_create_effect(struct snd_emux_port *p) { int i; p->effect = kcalloc(p->chset.max_channels, sizeof(struct snd_emux_effect_table), GFP_KERNEL); if (p->effect) { for (i = 0; i < p->chset.max_channels; i++) p->chset.channels[i].private = p->effect + i; } else { for (i = 0; i < p->chset.max_channels; i++) p->chset.channels[i].private = NULL; } } void snd_emux_delete_effect(struct snd_emux_port *p) { kfree(p->effect); p->effect = NULL; } void snd_emux_clear_effect(struct snd_emux_port *p) { if (p->effect) { memset(p->effect, 0, sizeof(struct snd_emux_effect_table) * p->chset.max_channels); } } #endif /* SNDRV_EMUX_USE_RAW_EFFECT */
linux-master
sound/synth/emux/emux_effect.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Interface for hwdep device * * Copyright (C) 2004 Takashi Iwai <[email protected]> */ #include <sound/core.h> #include <sound/hwdep.h> #include <linux/uaccess.h> #include <linux/nospec.h> #include "emux_voice.h" #define TMP_CLIENT_ID 0x1001 /* * load patch */ static int snd_emux_hwdep_load_patch(struct snd_emux *emu, void __user *arg) { int err; struct soundfont_patch_info patch; if (copy_from_user(&patch, arg, sizeof(patch))) return -EFAULT; if (patch.key == GUS_PATCH) return snd_soundfont_load_guspatch(emu->sflist, arg, patch.len + sizeof(patch), TMP_CLIENT_ID); if (patch.type >= SNDRV_SFNT_LOAD_INFO && patch.type <= SNDRV_SFNT_PROBE_DATA) { err = snd_soundfont_load(emu->sflist, arg, patch.len + sizeof(patch), TMP_CLIENT_ID); if (err < 0) return err; } else { if (emu->ops.load_fx) return emu->ops.load_fx(emu, patch.type, patch.optarg, arg, patch.len + sizeof(patch)); else return -EINVAL; } return 0; } /* * set misc mode */ static int snd_emux_hwdep_misc_mode(struct snd_emux *emu, void __user *arg) { struct snd_emux_misc_mode info; int i; if (copy_from_user(&info, arg, sizeof(info))) return -EFAULT; if (info.mode < 0 || info.mode >= EMUX_MD_END) return -EINVAL; info.mode = array_index_nospec(info.mode, EMUX_MD_END); if (info.port < 0) { for (i = 0; i < emu->num_ports; i++) emu->portptrs[i]->ctrls[info.mode] = info.value; } else { if (info.port < emu->num_ports) { info.port = array_index_nospec(info.port, emu->num_ports); emu->portptrs[info.port]->ctrls[info.mode] = info.value; } } return 0; } /* * ioctl */ static int snd_emux_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, unsigned int cmd, unsigned long arg) { struct snd_emux *emu = hw->private_data; switch (cmd) { case SNDRV_EMUX_IOCTL_VERSION: return put_user(SNDRV_EMUX_VERSION, (unsigned int __user *)arg); case SNDRV_EMUX_IOCTL_LOAD_PATCH: return snd_emux_hwdep_load_patch(emu, (void __user *)arg); case SNDRV_EMUX_IOCTL_RESET_SAMPLES: snd_soundfont_remove_samples(emu->sflist); break; case SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES: snd_soundfont_remove_unlocked(emu->sflist); break; case SNDRV_EMUX_IOCTL_MEM_AVAIL: if (emu->memhdr) { int size = snd_util_mem_avail(emu->memhdr); return put_user(size, (unsigned int __user *)arg); } break; case SNDRV_EMUX_IOCTL_MISC_MODE: return snd_emux_hwdep_misc_mode(emu, (void __user *)arg); } return 0; } /* * register hwdep device */ int snd_emux_init_hwdep(struct snd_emux *emu) { struct snd_hwdep *hw; int err; err = snd_hwdep_new(emu->card, SNDRV_EMUX_HWDEP_NAME, emu->hwdep_idx, &hw); if (err < 0) return err; emu->hwdep = hw; strcpy(hw->name, SNDRV_EMUX_HWDEP_NAME); hw->iface = SNDRV_HWDEP_IFACE_EMUX_WAVETABLE; hw->ops.ioctl = snd_emux_hwdep_ioctl; /* The ioctl parameter types are compatible between 32- and * 64-bit architectures, so use the same function. */ hw->ops.ioctl_compat = snd_emux_hwdep_ioctl; hw->exclusive = 1; hw->private_data = emu; err = snd_card_register(emu->card); if (err < 0) return err; return 0; } /* * unregister */ void snd_emux_delete_hwdep(struct snd_emux *emu) { if (emu->hwdep) { snd_device_free(emu->card, emu->hwdep); emu->hwdep = NULL; } }
linux-master
sound/synth/emux/emux_hwdep.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (C) 2000 Takashi Iwai <[email protected]> * * Proc interface for Emu8k/Emu10k1 WaveTable synth */ #include <linux/wait.h> #include <sound/core.h> #include <sound/emux_synth.h> #include <sound/info.h> #include "emux_voice.h" static void snd_emux_proc_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buf) { struct snd_emux *emu; int i; emu = entry->private_data; mutex_lock(&emu->register_mutex); if (emu->name) snd_iprintf(buf, "Device: %s\n", emu->name); snd_iprintf(buf, "Ports: %d\n", emu->num_ports); snd_iprintf(buf, "Addresses:"); for (i = 0; i < emu->num_ports; i++) snd_iprintf(buf, " %d:%d", emu->client, emu->ports[i]); snd_iprintf(buf, "\n"); snd_iprintf(buf, "Use Counter: %d\n", emu->used); snd_iprintf(buf, "Max Voices: %d\n", emu->max_voices); snd_iprintf(buf, "Allocated Voices: %d\n", emu->num_voices); if (emu->memhdr) { snd_iprintf(buf, "Memory Size: %d\n", emu->memhdr->size); snd_iprintf(buf, "Memory Available: %d\n", snd_util_mem_avail(emu->memhdr)); snd_iprintf(buf, "Allocated Blocks: %d\n", emu->memhdr->nblocks); } else { snd_iprintf(buf, "Memory Size: 0\n"); } if (emu->sflist) { mutex_lock(&emu->sflist->presets_mutex); snd_iprintf(buf, "SoundFonts: %d\n", emu->sflist->fonts_size); snd_iprintf(buf, "Instruments: %d\n", emu->sflist->zone_counter); snd_iprintf(buf, "Samples: %d\n", emu->sflist->sample_counter); snd_iprintf(buf, "Locked Instruments: %d\n", emu->sflist->zone_locked); snd_iprintf(buf, "Locked Samples: %d\n", emu->sflist->sample_locked); mutex_unlock(&emu->sflist->presets_mutex); } #if 0 /* debug */ if (emu->voices[0].state != SNDRV_EMUX_ST_OFF && emu->voices[0].ch >= 0) { struct snd_emux_voice *vp = &emu->voices[0]; snd_iprintf(buf, "voice 0: on\n"); snd_iprintf(buf, "mod delay=%x, atkhld=%x, dcysus=%x, rel=%x\n", vp->reg.parm.moddelay, vp->reg.parm.modatkhld, vp->reg.parm.moddcysus, vp->reg.parm.modrelease); snd_iprintf(buf, "vol delay=%x, atkhld=%x, dcysus=%x, rel=%x\n", vp->reg.parm.voldelay, vp->reg.parm.volatkhld, vp->reg.parm.voldcysus, vp->reg.parm.volrelease); snd_iprintf(buf, "lfo1 delay=%x, lfo2 delay=%x, pefe=%x\n", vp->reg.parm.lfo1delay, vp->reg.parm.lfo2delay, vp->reg.parm.pefe); snd_iprintf(buf, "fmmod=%x, tremfrq=%x, fm2frq2=%x\n", vp->reg.parm.fmmod, vp->reg.parm.tremfrq, vp->reg.parm.fm2frq2); snd_iprintf(buf, "cutoff=%x, filterQ=%x, chorus=%x, reverb=%x\n", vp->reg.parm.cutoff, vp->reg.parm.filterQ, vp->reg.parm.chorus, vp->reg.parm.reverb); snd_iprintf(buf, "avol=%x, acutoff=%x, apitch=%x\n", vp->avol, vp->acutoff, vp->apitch); snd_iprintf(buf, "apan=%x, aaux=%x, ptarget=%x, vtarget=%x, ftarget=%x\n", vp->apan, vp->aaux, vp->ptarget, vp->vtarget, vp->ftarget); snd_iprintf(buf, "start=%x, end=%x, loopstart=%x, loopend=%x\n", vp->reg.start, vp->reg.end, vp->reg.loopstart, vp->reg.loopend); snd_iprintf(buf, "sample_mode=%x, rate=%x\n", vp->reg.sample_mode, vp->reg.rate_offset); } #endif mutex_unlock(&emu->register_mutex); } void snd_emux_proc_init(struct snd_emux *emu, struct snd_card *card, int device) { struct snd_info_entry *entry; char name[64]; sprintf(name, "wavetableD%d", device); entry = snd_info_create_card_entry(card, name, card->proc_root); if (entry == NULL) return; entry->content = SNDRV_INFO_CONTENT_TEXT; entry->private_data = emu; entry->c.text.read = snd_emux_proc_info_read; } void snd_emux_proc_free(struct snd_emux *emu) { snd_info_free_entry(emu->proc); emu->proc = NULL; }
linux-master
sound/synth/emux/emux_proc.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * NRPN / SYSEX callbacks for Emu8k/Emu10k1 * * Copyright (c) 1999-2000 Takashi Iwai <[email protected]> */ #include "emux_voice.h" #include <sound/asoundef.h> /* * conversion from NRPN/control parameters to Emu8000 raw parameters */ /* NRPN / CC -> Emu8000 parameter converter */ struct nrpn_conv_table { int control; int effect; int (*convert)(int val); }; /* effect sensitivity */ #define FX_CUTOFF 0 #define FX_RESONANCE 1 #define FX_ATTACK 2 #define FX_RELEASE 3 #define FX_VIBRATE 4 #define FX_VIBDEPTH 5 #define FX_VIBDELAY 6 #define FX_NUMS 7 /* * convert NRPN/control values */ static int send_converted_effect(const struct nrpn_conv_table *table, int num_tables, struct snd_emux_port *port, struct snd_midi_channel *chan, int type, int val, int mode) { int i, cval; for (i = 0; i < num_tables; i++) { if (table[i].control == type) { cval = table[i].convert(val); snd_emux_send_effect(port, chan, table[i].effect, cval, mode); return 1; } } return 0; } #define DEF_FX_CUTOFF 170 #define DEF_FX_RESONANCE 6 #define DEF_FX_ATTACK 50 #define DEF_FX_RELEASE 50 #define DEF_FX_VIBRATE 30 #define DEF_FX_VIBDEPTH 4 #define DEF_FX_VIBDELAY 1500 /* effect sensitivities for GS NRPN: * adjusted for chaos 8MB soundfonts */ static const int gs_sense[] = { DEF_FX_CUTOFF, DEF_FX_RESONANCE, DEF_FX_ATTACK, DEF_FX_RELEASE, DEF_FX_VIBRATE, DEF_FX_VIBDEPTH, DEF_FX_VIBDELAY }; /* effect sensitivities for XG controls: * adjusted for chaos 8MB soundfonts */ static const int xg_sense[] = { DEF_FX_CUTOFF, DEF_FX_RESONANCE, DEF_FX_ATTACK, DEF_FX_RELEASE, DEF_FX_VIBRATE, DEF_FX_VIBDEPTH, DEF_FX_VIBDELAY }; /* * AWE32 NRPN effects */ static int fx_delay(int val); static int fx_attack(int val); static int fx_hold(int val); static int fx_decay(int val); static int fx_the_value(int val); static int fx_twice_value(int val); static int fx_conv_pitch(int val); static int fx_conv_Q(int val); /* function for each NRPN */ /* [range] units */ #define fx_env1_delay fx_delay /* [0,5900] 4msec */ #define fx_env1_attack fx_attack /* [0,5940] 1msec */ #define fx_env1_hold fx_hold /* [0,8191] 1msec */ #define fx_env1_decay fx_decay /* [0,5940] 4msec */ #define fx_env1_release fx_decay /* [0,5940] 4msec */ #define fx_env1_sustain fx_the_value /* [0,127] 0.75dB */ #define fx_env1_pitch fx_the_value /* [-127,127] 9.375cents */ #define fx_env1_cutoff fx_the_value /* [-127,127] 56.25cents */ #define fx_env2_delay fx_delay /* [0,5900] 4msec */ #define fx_env2_attack fx_attack /* [0,5940] 1msec */ #define fx_env2_hold fx_hold /* [0,8191] 1msec */ #define fx_env2_decay fx_decay /* [0,5940] 4msec */ #define fx_env2_release fx_decay /* [0,5940] 4msec */ #define fx_env2_sustain fx_the_value /* [0,127] 0.75dB */ #define fx_lfo1_delay fx_delay /* [0,5900] 4msec */ #define fx_lfo1_freq fx_twice_value /* [0,127] 84mHz */ #define fx_lfo1_volume fx_twice_value /* [0,127] 0.1875dB */ #define fx_lfo1_pitch fx_the_value /* [-127,127] 9.375cents */ #define fx_lfo1_cutoff fx_twice_value /* [-64,63] 56.25cents */ #define fx_lfo2_delay fx_delay /* [0,5900] 4msec */ #define fx_lfo2_freq fx_twice_value /* [0,127] 84mHz */ #define fx_lfo2_pitch fx_the_value /* [-127,127] 9.375cents */ #define fx_init_pitch fx_conv_pitch /* [-8192,8192] cents */ #define fx_chorus fx_the_value /* [0,255] -- */ #define fx_reverb fx_the_value /* [0,255] -- */ #define fx_cutoff fx_twice_value /* [0,127] 62Hz */ #define fx_filterQ fx_conv_Q /* [0,127] -- */ static int fx_delay(int val) { return (unsigned short)snd_sf_calc_parm_delay(val); } static int fx_attack(int val) { return (unsigned short)snd_sf_calc_parm_attack(val); } static int fx_hold(int val) { return (unsigned short)snd_sf_calc_parm_hold(val); } static int fx_decay(int val) { return (unsigned short)snd_sf_calc_parm_decay(val); } static int fx_the_value(int val) { return (unsigned short)(val & 0xff); } static int fx_twice_value(int val) { return (unsigned short)((val * 2) & 0xff); } static int fx_conv_pitch(int val) { return (short)(val * 4096 / 1200); } static int fx_conv_Q(int val) { return (unsigned short)((val / 8) & 0xff); } static const struct nrpn_conv_table awe_effects[] = { { 0, EMUX_FX_LFO1_DELAY, fx_lfo1_delay}, { 1, EMUX_FX_LFO1_FREQ, fx_lfo1_freq}, { 2, EMUX_FX_LFO2_DELAY, fx_lfo2_delay}, { 3, EMUX_FX_LFO2_FREQ, fx_lfo2_freq}, { 4, EMUX_FX_ENV1_DELAY, fx_env1_delay}, { 5, EMUX_FX_ENV1_ATTACK,fx_env1_attack}, { 6, EMUX_FX_ENV1_HOLD, fx_env1_hold}, { 7, EMUX_FX_ENV1_DECAY, fx_env1_decay}, { 8, EMUX_FX_ENV1_SUSTAIN, fx_env1_sustain}, { 9, EMUX_FX_ENV1_RELEASE, fx_env1_release}, {10, EMUX_FX_ENV2_DELAY, fx_env2_delay}, {11, EMUX_FX_ENV2_ATTACK, fx_env2_attack}, {12, EMUX_FX_ENV2_HOLD, fx_env2_hold}, {13, EMUX_FX_ENV2_DECAY, fx_env2_decay}, {14, EMUX_FX_ENV2_SUSTAIN, fx_env2_sustain}, {15, EMUX_FX_ENV2_RELEASE, fx_env2_release}, {16, EMUX_FX_INIT_PITCH, fx_init_pitch}, {17, EMUX_FX_LFO1_PITCH, fx_lfo1_pitch}, {18, EMUX_FX_LFO2_PITCH, fx_lfo2_pitch}, {19, EMUX_FX_ENV1_PITCH, fx_env1_pitch}, {20, EMUX_FX_LFO1_VOLUME, fx_lfo1_volume}, {21, EMUX_FX_CUTOFF, fx_cutoff}, {22, EMUX_FX_FILTERQ, fx_filterQ}, {23, EMUX_FX_LFO1_CUTOFF, fx_lfo1_cutoff}, {24, EMUX_FX_ENV1_CUTOFF, fx_env1_cutoff}, {25, EMUX_FX_CHORUS, fx_chorus}, {26, EMUX_FX_REVERB, fx_reverb}, }; /* * GS(SC88) NRPN effects; still experimental */ /* cutoff: quarter semitone step, max=255 */ static int gs_cutoff(int val) { return (val - 64) * gs_sense[FX_CUTOFF] / 50; } /* resonance: 0 to 15(max) */ static int gs_filterQ(int val) { return (val - 64) * gs_sense[FX_RESONANCE] / 50; } /* attack: */ static int gs_attack(int val) { return -(val - 64) * gs_sense[FX_ATTACK] / 50; } /* decay: */ static int gs_decay(int val) { return -(val - 64) * gs_sense[FX_RELEASE] / 50; } /* release: */ static int gs_release(int val) { return -(val - 64) * gs_sense[FX_RELEASE] / 50; } /* vibrato freq: 0.042Hz step, max=255 */ static int gs_vib_rate(int val) { return (val - 64) * gs_sense[FX_VIBRATE] / 50; } /* vibrato depth: max=127, 1 octave */ static int gs_vib_depth(int val) { return (val - 64) * gs_sense[FX_VIBDEPTH] / 50; } /* vibrato delay: -0.725msec step */ static int gs_vib_delay(int val) { return -(val - 64) * gs_sense[FX_VIBDELAY] / 50; } static const struct nrpn_conv_table gs_effects[] = { {32, EMUX_FX_CUTOFF, gs_cutoff}, {33, EMUX_FX_FILTERQ, gs_filterQ}, {99, EMUX_FX_ENV2_ATTACK, gs_attack}, {100, EMUX_FX_ENV2_DECAY, gs_decay}, {102, EMUX_FX_ENV2_RELEASE, gs_release}, {8, EMUX_FX_LFO1_FREQ, gs_vib_rate}, {9, EMUX_FX_LFO1_VOLUME, gs_vib_depth}, {10, EMUX_FX_LFO1_DELAY, gs_vib_delay}, }; /* * NRPN events */ void snd_emux_nrpn(void *p, struct snd_midi_channel *chan, struct snd_midi_channel_set *chset) { struct snd_emux_port *port; port = p; if (snd_BUG_ON(!port || !chan)) return; if (chan->control[MIDI_CTL_NONREG_PARM_NUM_MSB] == 127 && chan->control[MIDI_CTL_NONREG_PARM_NUM_LSB] <= 26) { int val; /* Win/DOS AWE32 specific NRPNs */ /* both MSB/LSB necessary */ val = (chan->control[MIDI_CTL_MSB_DATA_ENTRY] << 7) | chan->control[MIDI_CTL_LSB_DATA_ENTRY]; val -= 8192; send_converted_effect (awe_effects, ARRAY_SIZE(awe_effects), port, chan, chan->control[MIDI_CTL_NONREG_PARM_NUM_LSB], val, EMUX_FX_FLAG_SET); return; } if (port->chset.midi_mode == SNDRV_MIDI_MODE_GS && chan->control[MIDI_CTL_NONREG_PARM_NUM_MSB] == 1) { int val; /* GS specific NRPNs */ /* only MSB is valid */ val = chan->control[MIDI_CTL_MSB_DATA_ENTRY]; send_converted_effect (gs_effects, ARRAY_SIZE(gs_effects), port, chan, chan->control[MIDI_CTL_NONREG_PARM_NUM_LSB], val, EMUX_FX_FLAG_ADD); return; } } /* * XG control effects; still experimental */ /* cutoff: quarter semitone step, max=255 */ static int xg_cutoff(int val) { return (val - 64) * xg_sense[FX_CUTOFF] / 64; } /* resonance: 0(open) to 15(most nasal) */ static int xg_filterQ(int val) { return (val - 64) * xg_sense[FX_RESONANCE] / 64; } /* attack: */ static int xg_attack(int val) { return -(val - 64) * xg_sense[FX_ATTACK] / 64; } /* release: */ static int xg_release(int val) { return -(val - 64) * xg_sense[FX_RELEASE] / 64; } static const struct nrpn_conv_table xg_effects[] = { {71, EMUX_FX_CUTOFF, xg_cutoff}, {74, EMUX_FX_FILTERQ, xg_filterQ}, {72, EMUX_FX_ENV2_RELEASE, xg_release}, {73, EMUX_FX_ENV2_ATTACK, xg_attack}, }; int snd_emux_xg_control(struct snd_emux_port *port, struct snd_midi_channel *chan, int param) { if (param >= ARRAY_SIZE(chan->control)) return -EINVAL; return send_converted_effect(xg_effects, ARRAY_SIZE(xg_effects), port, chan, param, chan->control[param], EMUX_FX_FLAG_ADD); } /* * receive sysex */ void snd_emux_sysex(void *p, unsigned char *buf, int len, int parsed, struct snd_midi_channel_set *chset) { struct snd_emux_port *port; struct snd_emux *emu; port = p; if (snd_BUG_ON(!port || !chset)) return; emu = port->emu; switch (parsed) { case SNDRV_MIDI_SYSEX_GS_MASTER_VOLUME: snd_emux_update_port(port, SNDRV_EMUX_UPDATE_VOLUME); break; default: if (emu->ops.sysex) emu->ops.sysex(emu, buf, len, parsed, chset); break; } }
linux-master
sound/synth/emux/emux_nrpn.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Midi synth routines for the Emu8k/Emu10k1 * * Copyright (C) 1999 Steve Ratcliffe * Copyright (c) 1999-2000 Takashi Iwai <[email protected]> * * Contains code based on awe_wave.c by Takashi Iwai */ #include <linux/export.h> #include "emux_voice.h" #include <sound/asoundef.h> /* * Prototypes */ /* * Ensure a value is between two points * macro evaluates its args more than once, so changed to upper-case. */ #define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0) #define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0) static int get_zone(struct snd_emux *emu, struct snd_emux_port *port, int *notep, int vel, struct snd_midi_channel *chan, struct snd_sf_zone **table); static int get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan); static void terminate_note1(struct snd_emux *emu, int note, struct snd_midi_channel *chan, int free); static void exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, int exclass); static void terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free); static void update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update); static void setup_voice(struct snd_emux_voice *vp); static int calc_pan(struct snd_emux_voice *vp); static int calc_volume(struct snd_emux_voice *vp); static int calc_pitch(struct snd_emux_voice *vp); /* * Start a note. */ void snd_emux_note_on(void *p, int note, int vel, struct snd_midi_channel *chan) { struct snd_emux *emu; int i, key, nvoices; struct snd_emux_voice *vp; struct snd_sf_zone *table[SNDRV_EMUX_MAX_MULTI_VOICES]; unsigned long flags; struct snd_emux_port *port; port = p; if (snd_BUG_ON(!port || !chan)) return; emu = port->emu; if (snd_BUG_ON(!emu || !emu->ops.get_voice || !emu->ops.trigger)) return; key = note; /* remember the original note */ nvoices = get_zone(emu, port, &note, vel, chan, table); if (! nvoices) return; /* exclusive note off */ for (i = 0; i < nvoices; i++) { struct snd_sf_zone *zp = table[i]; if (zp && zp->v.exclusiveClass) exclusive_note_off(emu, port, zp->v.exclusiveClass); } #if 0 // seems not necessary /* Turn off the same note on the same channel. */ terminate_note1(emu, key, chan, 0); #endif spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < nvoices; i++) { /* set up each voice parameter */ /* at this stage, we don't trigger the voice yet. */ if (table[i] == NULL) continue; vp = emu->ops.get_voice(emu, port); if (vp == NULL || vp->ch < 0) continue; if (STATE_IS_PLAYING(vp->state)) emu->ops.terminate(vp); vp->time = emu->use_time++; vp->chan = chan; vp->port = port; vp->key = key; vp->note = note; vp->velocity = vel; vp->zone = table[i]; if (vp->zone->sample) vp->block = vp->zone->sample->block; else vp->block = NULL; setup_voice(vp); vp->state = SNDRV_EMUX_ST_STANDBY; if (emu->ops.prepare) { vp->state = SNDRV_EMUX_ST_OFF; if (emu->ops.prepare(vp) >= 0) vp->state = SNDRV_EMUX_ST_STANDBY; } } /* start envelope now */ for (i = 0; i < emu->max_voices; i++) { vp = &emu->voices[i]; if (vp->state == SNDRV_EMUX_ST_STANDBY && vp->chan == chan) { emu->ops.trigger(vp); vp->state = SNDRV_EMUX_ST_ON; vp->ontime = jiffies; /* remember the trigger timing */ } } spin_unlock_irqrestore(&emu->voice_lock, flags); #ifdef SNDRV_EMUX_USE_RAW_EFFECT if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) { /* clear voice position for the next note on this channel */ struct snd_emux_effect_table *fx = chan->private; if (fx) { fx->flag[EMUX_FX_SAMPLE_START] = 0; fx->flag[EMUX_FX_COARSE_SAMPLE_START] = 0; } } #endif } /* * Release a note in response to a midi note off. */ void snd_emux_note_off(void *p, int note, int vel, struct snd_midi_channel *chan) { int ch; struct snd_emux *emu; struct snd_emux_voice *vp; unsigned long flags; struct snd_emux_port *port; port = p; if (snd_BUG_ON(!port || !chan)) return; emu = port->emu; if (snd_BUG_ON(!emu || !emu->ops.release)) return; spin_lock_irqsave(&emu->voice_lock, flags); for (ch = 0; ch < emu->max_voices; ch++) { vp = &emu->voices[ch]; if (STATE_IS_PLAYING(vp->state) && vp->chan == chan && vp->key == note) { vp->state = SNDRV_EMUX_ST_RELEASED; if (vp->ontime == jiffies) { /* if note-off is sent too shortly after * note-on, emuX engine cannot produce the sound * correctly. so we'll release this note * a bit later via timer callback. */ vp->state = SNDRV_EMUX_ST_PENDING; if (! emu->timer_active) { mod_timer(&emu->tlist, jiffies + 1); emu->timer_active = 1; } } else /* ok now release the note */ emu->ops.release(vp); } } spin_unlock_irqrestore(&emu->voice_lock, flags); } /* * timer callback * * release the pending note-offs */ void snd_emux_timer_callback(struct timer_list *t) { struct snd_emux *emu = from_timer(emu, t, tlist); struct snd_emux_voice *vp; unsigned long flags; int ch, do_again = 0; spin_lock_irqsave(&emu->voice_lock, flags); for (ch = 0; ch < emu->max_voices; ch++) { vp = &emu->voices[ch]; if (vp->state == SNDRV_EMUX_ST_PENDING) { if (vp->ontime == jiffies) do_again++; /* release this at the next interrupt */ else { emu->ops.release(vp); vp->state = SNDRV_EMUX_ST_RELEASED; } } } if (do_again) { mod_timer(&emu->tlist, jiffies + 1); emu->timer_active = 1; } else emu->timer_active = 0; spin_unlock_irqrestore(&emu->voice_lock, flags); } /* * key pressure change */ void snd_emux_key_press(void *p, int note, int vel, struct snd_midi_channel *chan) { int ch; struct snd_emux *emu; struct snd_emux_voice *vp; unsigned long flags; struct snd_emux_port *port; port = p; if (snd_BUG_ON(!port || !chan)) return; emu = port->emu; if (snd_BUG_ON(!emu || !emu->ops.update)) return; spin_lock_irqsave(&emu->voice_lock, flags); for (ch = 0; ch < emu->max_voices; ch++) { vp = &emu->voices[ch]; if (vp->state == SNDRV_EMUX_ST_ON && vp->chan == chan && vp->key == note) { vp->velocity = vel; update_voice(emu, vp, SNDRV_EMUX_UPDATE_VOLUME); } } spin_unlock_irqrestore(&emu->voice_lock, flags); } /* * Modulate the voices which belong to the channel */ void snd_emux_update_channel(struct snd_emux_port *port, struct snd_midi_channel *chan, int update) { struct snd_emux *emu; struct snd_emux_voice *vp; int i; unsigned long flags; if (! update) return; emu = port->emu; if (snd_BUG_ON(!emu || !emu->ops.update)) return; spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { vp = &emu->voices[i]; if (vp->chan == chan) update_voice(emu, vp, update); } spin_unlock_irqrestore(&emu->voice_lock, flags); } /* * Modulate all the voices which belong to the port. */ void snd_emux_update_port(struct snd_emux_port *port, int update) { struct snd_emux *emu; struct snd_emux_voice *vp; int i; unsigned long flags; if (! update) return; emu = port->emu; if (snd_BUG_ON(!emu || !emu->ops.update)) return; spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { vp = &emu->voices[i]; if (vp->port == port) update_voice(emu, vp, update); } spin_unlock_irqrestore(&emu->voice_lock, flags); } /* * Deal with a controller type event. This includes all types of * control events, not just the midi controllers */ void snd_emux_control(void *p, int type, struct snd_midi_channel *chan) { struct snd_emux_port *port; port = p; if (snd_BUG_ON(!port || !chan)) return; switch (type) { case MIDI_CTL_MSB_MAIN_VOLUME: case MIDI_CTL_MSB_EXPRESSION: snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_VOLUME); break; case MIDI_CTL_MSB_PAN: snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN); break; case MIDI_CTL_SOFT_PEDAL: #ifdef SNDRV_EMUX_USE_RAW_EFFECT /* FIXME: this is an emulation */ if (chan->control[type] >= 64) snd_emux_send_effect(port, chan, EMUX_FX_CUTOFF, -160, EMUX_FX_FLAG_ADD); else snd_emux_send_effect(port, chan, EMUX_FX_CUTOFF, 0, EMUX_FX_FLAG_OFF); #endif break; case MIDI_CTL_PITCHBEND: snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PITCH); break; case MIDI_CTL_MSB_MODWHEEL: case MIDI_CTL_CHAN_PRESSURE: snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_FMMOD | SNDRV_EMUX_UPDATE_FM2FRQ2); break; } if (port->chset.midi_mode == SNDRV_MIDI_MODE_XG) { snd_emux_xg_control(port, chan, type); } } /* * terminate note - if free flag is true, free the terminated voice */ static void terminate_note1(struct snd_emux *emu, int note, struct snd_midi_channel *chan, int free) { int i; struct snd_emux_voice *vp; unsigned long flags; spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { vp = &emu->voices[i]; if (STATE_IS_PLAYING(vp->state) && vp->chan == chan && vp->key == note) terminate_voice(emu, vp, free); } spin_unlock_irqrestore(&emu->voice_lock, flags); } /* * terminate note - exported for midi emulation */ void snd_emux_terminate_note(void *p, int note, struct snd_midi_channel *chan) { struct snd_emux *emu; struct snd_emux_port *port; port = p; if (snd_BUG_ON(!port || !chan)) return; emu = port->emu; if (snd_BUG_ON(!emu || !emu->ops.terminate)) return; terminate_note1(emu, note, chan, 1); } /* * Terminate all the notes */ void snd_emux_terminate_all(struct snd_emux *emu) { int i; struct snd_emux_voice *vp; unsigned long flags; spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { vp = &emu->voices[i]; if (STATE_IS_PLAYING(vp->state)) terminate_voice(emu, vp, 0); if (vp->state == SNDRV_EMUX_ST_OFF) { if (emu->ops.free_voice) emu->ops.free_voice(vp); if (emu->ops.reset) emu->ops.reset(emu, i); } vp->time = 0; } /* initialize allocation time */ emu->use_time = 0; spin_unlock_irqrestore(&emu->voice_lock, flags); } EXPORT_SYMBOL(snd_emux_terminate_all); /* * Terminate all voices associated with the given port */ void snd_emux_sounds_off_all(struct snd_emux_port *port) { int i; struct snd_emux *emu; struct snd_emux_voice *vp; unsigned long flags; if (snd_BUG_ON(!port)) return; emu = port->emu; if (snd_BUG_ON(!emu || !emu->ops.terminate)) return; spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { vp = &emu->voices[i]; if (STATE_IS_PLAYING(vp->state) && vp->port == port) terminate_voice(emu, vp, 0); if (vp->state == SNDRV_EMUX_ST_OFF) { if (emu->ops.free_voice) emu->ops.free_voice(vp); if (emu->ops.reset) emu->ops.reset(emu, i); } } spin_unlock_irqrestore(&emu->voice_lock, flags); } /* * Terminate all voices that have the same exclusive class. This * is mainly for drums. */ static void exclusive_note_off(struct snd_emux *emu, struct snd_emux_port *port, int exclass) { struct snd_emux_voice *vp; int i; unsigned long flags; spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { vp = &emu->voices[i]; if (STATE_IS_PLAYING(vp->state) && vp->port == port && vp->reg.exclusiveClass == exclass) { terminate_voice(emu, vp, 0); } } spin_unlock_irqrestore(&emu->voice_lock, flags); } /* * terminate a voice * if free flag is true, call free_voice after termination */ static void terminate_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int free) { emu->ops.terminate(vp); vp->time = emu->use_time++; vp->chan = NULL; vp->port = NULL; vp->zone = NULL; vp->block = NULL; vp->state = SNDRV_EMUX_ST_OFF; if (free && emu->ops.free_voice) emu->ops.free_voice(vp); } /* * Modulate the voice */ static void update_voice(struct snd_emux *emu, struct snd_emux_voice *vp, int update) { if (!STATE_IS_PLAYING(vp->state)) return; if (vp->chan == NULL || vp->port == NULL) return; if (update & SNDRV_EMUX_UPDATE_VOLUME) calc_volume(vp); if (update & SNDRV_EMUX_UPDATE_PITCH) calc_pitch(vp); if (update & SNDRV_EMUX_UPDATE_PAN) { if (! calc_pan(vp) && (update == SNDRV_EMUX_UPDATE_PAN)) return; } emu->ops.update(vp, update); } #if 0 // not used /* table for volume target calculation */ static const unsigned short voltarget[16] = { 0xEAC0, 0xE0C8, 0xD740, 0xCE20, 0xC560, 0xBD08, 0xB500, 0xAD58, 0xA5F8, 0x9EF0, 0x9830, 0x91C0, 0x8B90, 0x85A8, 0x8000, 0x7A90 }; #endif #define LO_BYTE(v) ((v) & 0xff) #define HI_BYTE(v) (((v) >> 8) & 0xff) /* * Sets up the voice structure by calculating some values that * will be needed later. */ static void setup_voice(struct snd_emux_voice *vp) { struct soundfont_voice_parm *parm; int pitch; /* copy the original register values */ vp->reg = vp->zone->v; #ifdef SNDRV_EMUX_USE_RAW_EFFECT snd_emux_setup_effect(vp); #endif /* reset status */ vp->apan = -1; vp->avol = -1; vp->apitch = -1; calc_volume(vp); calc_pitch(vp); calc_pan(vp); parm = &vp->reg.parm; /* compute filter target and correct modulation parameters */ if (LO_BYTE(parm->modatkhld) >= 0x80 && parm->moddelay >= 0x8000) { parm->moddelay = 0xbfff; pitch = (HI_BYTE(parm->pefe) << 4) + vp->apitch; if (pitch > 0xffff) pitch = 0xffff; /* calculate filter target */ vp->ftarget = parm->cutoff + LO_BYTE(parm->pefe); LIMITVALUE(vp->ftarget, 0, 255); vp->ftarget <<= 8; } else { vp->ftarget = parm->cutoff; vp->ftarget <<= 8; pitch = vp->apitch; } /* compute pitch target */ if (pitch != 0xffff) { vp->ptarget = 1 << (pitch >> 12); if (pitch & 0x800) vp->ptarget += (vp->ptarget*0x102e)/0x2710; if (pitch & 0x400) vp->ptarget += (vp->ptarget*0x764)/0x2710; if (pitch & 0x200) vp->ptarget += (vp->ptarget*0x389)/0x2710; vp->ptarget += (vp->ptarget >> 1); if (vp->ptarget > 0xffff) vp->ptarget = 0xffff; } else vp->ptarget = 0xffff; if (LO_BYTE(parm->modatkhld) >= 0x80) { parm->modatkhld &= ~0xff; parm->modatkhld |= 0x7f; } /* compute volume target and correct volume parameters */ vp->vtarget = 0; #if 0 /* FIXME: this leads to some clicks.. */ if (LO_BYTE(parm->volatkhld) >= 0x80 && parm->voldelay >= 0x8000) { parm->voldelay = 0xbfff; vp->vtarget = voltarget[vp->avol % 0x10] >> (vp->avol >> 4); } #endif if (LO_BYTE(parm->volatkhld) >= 0x80) { parm->volatkhld &= ~0xff; parm->volatkhld |= 0x7f; } } /* * calculate pitch parameter */ static const unsigned char pan_volumes[256] = { 0x00,0x03,0x06,0x09,0x0c,0x0f,0x12,0x14,0x17,0x1a,0x1d,0x20,0x22,0x25,0x28,0x2a, 0x2d,0x30,0x32,0x35,0x37,0x3a,0x3c,0x3f,0x41,0x44,0x46,0x49,0x4b,0x4d,0x50,0x52, 0x54,0x57,0x59,0x5b,0x5d,0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6f,0x71,0x73,0x75, 0x77,0x79,0x7b,0x7c,0x7e,0x80,0x82,0x84,0x86,0x88,0x89,0x8b,0x8d,0x8f,0x90,0x92, 0x94,0x96,0x97,0x99,0x9a,0x9c,0x9e,0x9f,0xa1,0xa2,0xa4,0xa5,0xa7,0xa8,0xaa,0xab, 0xad,0xae,0xaf,0xb1,0xb2,0xb3,0xb5,0xb6,0xb7,0xb9,0xba,0xbb,0xbc,0xbe,0xbf,0xc0, 0xc1,0xc2,0xc3,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1, 0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd7,0xd8,0xd9,0xda,0xdb,0xdc,0xdc,0xdd,0xde,0xdf, 0xdf,0xe0,0xe1,0xe2,0xe2,0xe3,0xe4,0xe4,0xe5,0xe6,0xe6,0xe7,0xe8,0xe8,0xe9,0xe9, 0xea,0xeb,0xeb,0xec,0xec,0xed,0xed,0xee,0xee,0xef,0xef,0xf0,0xf0,0xf1,0xf1,0xf1, 0xf2,0xf2,0xf3,0xf3,0xf3,0xf4,0xf4,0xf5,0xf5,0xf5,0xf6,0xf6,0xf6,0xf7,0xf7,0xf7, 0xf7,0xf8,0xf8,0xf8,0xf9,0xf9,0xf9,0xf9,0xf9,0xfa,0xfa,0xfa,0xfa,0xfb,0xfb,0xfb, 0xfb,0xfb,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfc,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd,0xfd, 0xfd,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe,0xfe, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, }; static int calc_pan(struct snd_emux_voice *vp) { struct snd_midi_channel *chan = vp->chan; int pan; /* pan & loop start (pan 8bit, MSB, 0:right, 0xff:left) */ if (vp->reg.fixpan > 0) /* 0-127 */ pan = 255 - (int)vp->reg.fixpan * 2; else { pan = chan->control[MIDI_CTL_MSB_PAN] - 64; if (vp->reg.pan >= 0) /* 0-127 */ pan += vp->reg.pan - 64; pan = 127 - (int)pan * 2; } LIMITVALUE(pan, 0, 255); if (vp->emu->linear_panning) { /* assuming linear volume */ if (pan != vp->apan) { vp->apan = pan; if (pan == 0) vp->aaux = 0xff; else vp->aaux = (-pan) & 0xff; return 1; } else return 0; } else { /* using volume table */ if (vp->apan != (int)pan_volumes[pan]) { vp->apan = pan_volumes[pan]; vp->aaux = pan_volumes[255 - pan]; return 1; } return 0; } } /* * calculate volume attenuation * * Voice volume is controlled by volume attenuation parameter. * So volume becomes maximum when avol is 0 (no attenuation), and * minimum when 255 (-96dB or silence). */ /* tables for volume->attenuation calculation */ static const unsigned char voltab1[128] = { 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x2b, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; static const unsigned char voltab2[128] = { 0x32, 0x31, 0x30, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }; static const unsigned char expressiontab[128] = { 0x7f, 0x6c, 0x62, 0x5a, 0x54, 0x50, 0x4b, 0x48, 0x45, 0x42, 0x40, 0x3d, 0x3b, 0x39, 0x38, 0x36, 0x34, 0x33, 0x31, 0x30, 0x2f, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1d, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; /* * Magic to calculate the volume (actually attenuation) from all the * voice and channels parameters. */ static int calc_volume(struct snd_emux_voice *vp) { int vol; int main_vol, expression_vol, master_vol; struct snd_midi_channel *chan = vp->chan; struct snd_emux_port *port = vp->port; expression_vol = chan->control[MIDI_CTL_MSB_EXPRESSION]; LIMITMAX(vp->velocity, 127); LIMITVALUE(expression_vol, 0, 127); if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) { /* 0 - 127 */ main_vol = chan->control[MIDI_CTL_MSB_MAIN_VOLUME]; vol = (vp->velocity * main_vol * expression_vol) / (127*127); vol = vol * vp->reg.amplitude / 127; LIMITVALUE(vol, 0, 127); /* calc to attenuation */ vol = snd_sf_vol_table[vol]; } else { main_vol = chan->control[MIDI_CTL_MSB_MAIN_VOLUME] * vp->reg.amplitude / 127; LIMITVALUE(main_vol, 0, 127); vol = voltab1[main_vol] + voltab2[vp->velocity]; vol = (vol * 8) / 3; vol += vp->reg.attenuation; vol += ((0x100 - vol) * expressiontab[expression_vol])/128; } master_vol = port->chset.gs_master_volume; LIMITVALUE(master_vol, 0, 127); vol += snd_sf_vol_table[master_vol]; vol += port->volume_atten; #ifdef SNDRV_EMUX_USE_RAW_EFFECT if (chan->private) { struct snd_emux_effect_table *fx = chan->private; vol += fx->val[EMUX_FX_ATTEN]; } #endif LIMITVALUE(vol, 0, 255); if (vp->avol == vol) return 0; /* value unchanged */ vp->avol = vol; if (!SF_IS_DRUM_BANK(get_bank(port, chan)) && LO_BYTE(vp->reg.parm.volatkhld) < 0x7d) { int atten; if (vp->velocity < 70) atten = 70; else atten = vp->velocity; vp->acutoff = (atten * vp->reg.parm.cutoff + 0xa0) >> 7; } else { vp->acutoff = vp->reg.parm.cutoff; } return 1; /* value changed */ } /* * calculate pitch offset * * 0xE000 is no pitch offset at 44100Hz sample. * Every 4096 is one octave. */ static int calc_pitch(struct snd_emux_voice *vp) { struct snd_midi_channel *chan = vp->chan; int offset; /* calculate offset */ if (vp->reg.fixkey >= 0) { offset = (vp->reg.fixkey - vp->reg.root) * 4096 / 12; } else { offset = (vp->note - vp->reg.root) * 4096 / 12; } offset = (offset * vp->reg.scaleTuning) / 100; offset += vp->reg.tune * 4096 / 1200; if (chan->midi_pitchbend != 0) { /* (128 * 8192: 1 semitone) ==> (4096: 12 semitones) */ offset += chan->midi_pitchbend * chan->gm_rpn_pitch_bend_range / 3072; } /* tuning via RPN: * coarse = -8192 to 8192 (100 cent per 128) * fine = -8192 to 8192 (max=100cent) */ /* 4096 = 1200 cents in emu8000 parameter */ offset += chan->gm_rpn_coarse_tuning * 4096 / (12 * 128); offset += chan->gm_rpn_fine_tuning / 24; #ifdef SNDRV_EMUX_USE_RAW_EFFECT /* add initial pitch correction */ if (chan->private) { struct snd_emux_effect_table *fx = chan->private; if (fx->flag[EMUX_FX_INIT_PITCH]) offset += fx->val[EMUX_FX_INIT_PITCH]; } #endif /* 0xe000: root pitch */ offset += 0xe000 + vp->reg.rate_offset; if (vp->emu->ops.get_pitch_shift) offset += vp->emu->ops.get_pitch_shift(vp->emu); LIMITVALUE(offset, 0, 0xffff); if (offset == vp->apitch) return 0; /* unchanged */ vp->apitch = offset; return 1; /* value changed */ } /* * Get the bank number assigned to the channel */ static int get_bank(struct snd_emux_port *port, struct snd_midi_channel *chan) { int val; switch (port->chset.midi_mode) { case SNDRV_MIDI_MODE_XG: val = chan->control[MIDI_CTL_MSB_BANK]; if (val == 127) return 128; /* return drum bank */ return chan->control[MIDI_CTL_LSB_BANK]; case SNDRV_MIDI_MODE_GS: if (chan->drum_channel) return 128; /* ignore LSB (bank map) */ return chan->control[MIDI_CTL_MSB_BANK]; default: if (chan->drum_channel) return 128; return chan->control[MIDI_CTL_MSB_BANK]; } } /* Look for the zones matching with the given note and velocity. * The resultant zones are stored on table. */ static int get_zone(struct snd_emux *emu, struct snd_emux_port *port, int *notep, int vel, struct snd_midi_channel *chan, struct snd_sf_zone **table) { int preset, bank, def_preset, def_bank; bank = get_bank(port, chan); preset = chan->midi_program; if (SF_IS_DRUM_BANK(bank)) { def_preset = port->ctrls[EMUX_MD_DEF_DRUM]; def_bank = bank; } else { def_preset = preset; def_bank = port->ctrls[EMUX_MD_DEF_BANK]; } return snd_soundfont_search_zone(emu->sflist, notep, vel, preset, bank, def_preset, def_bank, table, SNDRV_EMUX_MAX_MULTI_VOICES); } /* */ void snd_emux_init_voices(struct snd_emux *emu) { struct snd_emux_voice *vp; int i; unsigned long flags; spin_lock_irqsave(&emu->voice_lock, flags); for (i = 0; i < emu->max_voices; i++) { vp = &emu->voices[i]; vp->ch = -1; /* not used */ vp->state = SNDRV_EMUX_ST_OFF; vp->chan = NULL; vp->port = NULL; vp->time = 0; vp->emu = emu; vp->hw = emu->hw; } spin_unlock_irqrestore(&emu->voice_lock, flags); } /* */ void snd_emux_lock_voice(struct snd_emux *emu, int voice) { unsigned long flags; spin_lock_irqsave(&emu->voice_lock, flags); if (emu->voices[voice].state == SNDRV_EMUX_ST_OFF) emu->voices[voice].state = SNDRV_EMUX_ST_LOCKED; else snd_printk(KERN_WARNING "invalid voice for lock %d (state = %x)\n", voice, emu->voices[voice].state); spin_unlock_irqrestore(&emu->voice_lock, flags); } EXPORT_SYMBOL(snd_emux_lock_voice); /* */ void snd_emux_unlock_voice(struct snd_emux *emu, int voice) { unsigned long flags; spin_lock_irqsave(&emu->voice_lock, flags); if (emu->voices[voice].state == SNDRV_EMUX_ST_LOCKED) emu->voices[voice].state = SNDRV_EMUX_ST_OFF; else snd_printk(KERN_WARNING "invalid voice for unlock %d (state = %x)\n", voice, emu->voices[voice].state); spin_unlock_irqrestore(&emu->voice_lock, flags); } EXPORT_SYMBOL(snd_emux_unlock_voice);
linux-master
sound/synth/emux/emux_synth.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (C) 2000 Takashi Iwai <[email protected]> * * Routines for control of EMU WaveTable chip */ #include <linux/wait.h> #include <linux/slab.h> #include <linux/string.h> #include <sound/core.h> #include <sound/emux_synth.h> #include <linux/init.h> #include <linux/module.h> #include "emux_voice.h" MODULE_AUTHOR("Takashi Iwai"); MODULE_DESCRIPTION("Routines for control of EMU WaveTable chip"); MODULE_LICENSE("GPL"); /* * create a new hardware dependent device for Emu8000/Emu10k1 */ int snd_emux_new(struct snd_emux **remu) { struct snd_emux *emu; *remu = NULL; emu = kzalloc(sizeof(*emu), GFP_KERNEL); if (emu == NULL) return -ENOMEM; spin_lock_init(&emu->voice_lock); mutex_init(&emu->register_mutex); emu->client = -1; #if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS) emu->oss_synth = NULL; #endif emu->max_voices = 0; emu->use_time = 0; timer_setup(&emu->tlist, snd_emux_timer_callback, 0); emu->timer_active = 0; *remu = emu; return 0; } EXPORT_SYMBOL(snd_emux_new); /* */ static int sf_sample_new(void *private_data, struct snd_sf_sample *sp, struct snd_util_memhdr *hdr, const void __user *buf, long count) { struct snd_emux *emu = private_data; return emu->ops.sample_new(emu, sp, hdr, buf, count); } static int sf_sample_free(void *private_data, struct snd_sf_sample *sp, struct snd_util_memhdr *hdr) { struct snd_emux *emu = private_data; return emu->ops.sample_free(emu, sp, hdr); } static void sf_sample_reset(void *private_data) { struct snd_emux *emu = private_data; emu->ops.sample_reset(emu); } int snd_emux_register(struct snd_emux *emu, struct snd_card *card, int index, char *name) { int err; struct snd_sf_callback sf_cb; if (snd_BUG_ON(!emu->hw || emu->max_voices <= 0)) return -EINVAL; if (snd_BUG_ON(!card || !name)) return -EINVAL; emu->card = card; emu->name = kstrdup(name, GFP_KERNEL); emu->voices = kcalloc(emu->max_voices, sizeof(struct snd_emux_voice), GFP_KERNEL); if (emu->name == NULL || emu->voices == NULL) return -ENOMEM; /* create soundfont list */ memset(&sf_cb, 0, sizeof(sf_cb)); sf_cb.private_data = emu; if (emu->ops.sample_new) sf_cb.sample_new = sf_sample_new; if (emu->ops.sample_free) sf_cb.sample_free = sf_sample_free; if (emu->ops.sample_reset) sf_cb.sample_reset = sf_sample_reset; emu->sflist = snd_sf_new(&sf_cb, emu->memhdr); if (emu->sflist == NULL) return -ENOMEM; err = snd_emux_init_hwdep(emu); if (err < 0) return err; snd_emux_init_voices(emu); snd_emux_init_seq(emu, card, index); #if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS) snd_emux_init_seq_oss(emu); #endif snd_emux_init_virmidi(emu, card); snd_emux_proc_init(emu, card, index); return 0; } EXPORT_SYMBOL(snd_emux_register); /* */ int snd_emux_free(struct snd_emux *emu) { if (! emu) return -EINVAL; timer_shutdown_sync(&emu->tlist); snd_emux_proc_free(emu); snd_emux_delete_virmidi(emu); #if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS) snd_emux_detach_seq_oss(emu); #endif snd_emux_detach_seq(emu); snd_emux_delete_hwdep(emu); snd_sf_free(emu->sflist); kfree(emu->voices); kfree(emu->name); kfree(emu); return 0; } EXPORT_SYMBOL(snd_emux_free);
linux-master
sound/synth/emux/emux.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Interface for OSS sequencer emulation * * Copyright (C) 1999 Takashi Iwai <[email protected]> * * Changes * 19990227 Steve Ratcliffe Made separate file and merged in latest * midi emulation. */ #include <linux/export.h> #include <linux/uaccess.h> #include <sound/core.h> #include "emux_voice.h" #include <sound/asoundef.h> static int snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure); static int snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg); static int snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned long ioarg); static int snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, const char __user *buf, int offs, int count); static int snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg); static int snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop); static void reset_port_mode(struct snd_emux_port *port, int midi_mode); static void emuspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd, unsigned char *event, int atomic, int hop); static void gusspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd, unsigned char *event, int atomic, int hop); static void fake_event(struct snd_emux *emu, struct snd_emux_port *port, int ch, int param, int val, int atomic, int hop); /* operators */ static const struct snd_seq_oss_callback oss_callback = { .owner = THIS_MODULE, .open = snd_emux_open_seq_oss, .close = snd_emux_close_seq_oss, .ioctl = snd_emux_ioctl_seq_oss, .load_patch = snd_emux_load_patch_seq_oss, .reset = snd_emux_reset_seq_oss, }; /* * register OSS synth */ void snd_emux_init_seq_oss(struct snd_emux *emu) { struct snd_seq_oss_reg *arg; struct snd_seq_device *dev; /* using device#1 here for avoiding conflicts with OPL3 */ if (snd_seq_device_new(emu->card, 1, SNDRV_SEQ_DEV_ID_OSS, sizeof(struct snd_seq_oss_reg), &dev) < 0) return; emu->oss_synth = dev; strcpy(dev->name, emu->name); arg = SNDRV_SEQ_DEVICE_ARGPTR(dev); arg->type = SYNTH_TYPE_SAMPLE; arg->subtype = SAMPLE_TYPE_AWE32; arg->nvoices = emu->max_voices; arg->oper = oss_callback; arg->private_data = emu; /* register to OSS synth table */ snd_device_register(emu->card, dev); } /* * unregister */ void snd_emux_detach_seq_oss(struct snd_emux *emu) { if (emu->oss_synth) { snd_device_free(emu->card, emu->oss_synth); emu->oss_synth = NULL; } } /* use port number as a unique soundfont client number */ #define SF_CLIENT_NO(p) ((p) + 0x1000) /* * open port for OSS sequencer */ static int snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure) { struct snd_emux *emu; struct snd_emux_port *p; struct snd_seq_port_callback callback; char tmpname[64]; emu = closure; if (snd_BUG_ON(!arg || !emu)) return -ENXIO; if (!snd_emux_inc_count(emu)) return -EFAULT; memset(&callback, 0, sizeof(callback)); callback.owner = THIS_MODULE; callback.event_input = snd_emux_event_oss_input; sprintf(tmpname, "%s OSS Port", emu->name); p = snd_emux_create_port(emu, tmpname, 32, 1, &callback); if (p == NULL) { snd_printk(KERN_ERR "can't create port\n"); snd_emux_dec_count(emu); return -ENOMEM; } /* fill the argument data */ arg->private_data = p; arg->addr.client = p->chset.client; arg->addr.port = p->chset.port; p->oss_arg = arg; reset_port_mode(p, arg->seq_mode); snd_emux_reset_port(p); return 0; } #define DEFAULT_DRUM_FLAGS ((1<<9) | (1<<25)) /* * reset port mode */ static void reset_port_mode(struct snd_emux_port *port, int midi_mode) { if (midi_mode) { port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_MIDI; port->drum_flags = DEFAULT_DRUM_FLAGS; port->volume_atten = 0; port->oss_arg->event_passing = SNDRV_SEQ_OSS_PROCESS_KEYPRESS; } else { port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_SYNTH; port->drum_flags = 0; port->volume_atten = 32; port->oss_arg->event_passing = SNDRV_SEQ_OSS_PROCESS_EVENTS; } } /* * close port */ static int snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg) { struct snd_emux *emu; struct snd_emux_port *p; if (snd_BUG_ON(!arg)) return -ENXIO; p = arg->private_data; if (snd_BUG_ON(!p)) return -ENXIO; emu = p->emu; if (snd_BUG_ON(!emu)) return -ENXIO; snd_emux_sounds_off_all(p); snd_soundfont_close_check(emu->sflist, SF_CLIENT_NO(p->chset.port)); snd_seq_event_port_detach(p->chset.client, p->chset.port); snd_emux_dec_count(emu); return 0; } /* * load patch */ static int snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format, const char __user *buf, int offs, int count) { struct snd_emux *emu; struct snd_emux_port *p; int rc; if (snd_BUG_ON(!arg)) return -ENXIO; p = arg->private_data; if (snd_BUG_ON(!p)) return -ENXIO; emu = p->emu; if (snd_BUG_ON(!emu)) return -ENXIO; if (format == GUS_PATCH) rc = snd_soundfont_load_guspatch(emu->sflist, buf, count, SF_CLIENT_NO(p->chset.port)); else if (format == SNDRV_OSS_SOUNDFONT_PATCH) { struct soundfont_patch_info patch; if (count < (int)sizeof(patch)) return -EINVAL; if (copy_from_user(&patch, buf, sizeof(patch))) return -EFAULT; if (patch.type >= SNDRV_SFNT_LOAD_INFO && patch.type <= SNDRV_SFNT_PROBE_DATA) rc = snd_soundfont_load(emu->sflist, buf, count, SF_CLIENT_NO(p->chset.port)); else { if (emu->ops.load_fx) rc = emu->ops.load_fx(emu, patch.type, patch.optarg, buf, count); else rc = -EINVAL; } } else rc = 0; return rc; } /* * ioctl */ static int snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned long ioarg) { struct snd_emux_port *p; struct snd_emux *emu; if (snd_BUG_ON(!arg)) return -ENXIO; p = arg->private_data; if (snd_BUG_ON(!p)) return -ENXIO; emu = p->emu; if (snd_BUG_ON(!emu)) return -ENXIO; switch (cmd) { case SNDCTL_SEQ_RESETSAMPLES: snd_soundfont_remove_samples(emu->sflist); return 0; case SNDCTL_SYNTH_MEMAVL: if (emu->memhdr) return snd_util_mem_avail(emu->memhdr); return 0; } return 0; } /* * reset device */ static int snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg) { struct snd_emux_port *p; if (snd_BUG_ON(!arg)) return -ENXIO; p = arg->private_data; if (snd_BUG_ON(!p)) return -ENXIO; snd_emux_reset_port(p); return 0; } /* * receive raw events: only SEQ_PRIVATE is accepted. */ static int snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop) { struct snd_emux *emu; struct snd_emux_port *p; unsigned char cmd, *data; p = private_data; if (snd_BUG_ON(!p)) return -EINVAL; emu = p->emu; if (snd_BUG_ON(!emu)) return -EINVAL; if (ev->type != SNDRV_SEQ_EVENT_OSS) return snd_emux_event_input(ev, direct, private_data, atomic, hop); data = ev->data.raw8.d; /* only SEQ_PRIVATE is accepted */ if (data[0] != 0xfe) return 0; cmd = data[2] & _EMUX_OSS_MODE_VALUE_MASK; if (data[2] & _EMUX_OSS_MODE_FLAG) emuspec_control(emu, p, cmd, data, atomic, hop); else gusspec_control(emu, p, cmd, data, atomic, hop); return 0; } /* * OSS/AWE driver specific h/w controls */ static void emuspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd, unsigned char *event, int atomic, int hop) { int voice; unsigned short p1; short p2; int i; struct snd_midi_channel *chan; voice = event[3]; if (voice < 0 || voice >= port->chset.max_channels) chan = NULL; else chan = &port->chset.channels[voice]; p1 = *(unsigned short *) &event[4]; p2 = *(short *) &event[6]; switch (cmd) { #if 0 /* don't do this atomically */ case _EMUX_OSS_REMOVE_LAST_SAMPLES: snd_soundfont_remove_unlocked(emu->sflist); break; #endif case _EMUX_OSS_SEND_EFFECT: if (chan) snd_emux_send_effect_oss(port, chan, p1, p2); break; case _EMUX_OSS_TERMINATE_ALL: snd_emux_terminate_all(emu); break; case _EMUX_OSS_TERMINATE_CHANNEL: /*snd_emux_mute_channel(emu, chan);*/ break; case _EMUX_OSS_RESET_CHANNEL: /*snd_emux_channel_init(chset, chan);*/ break; case _EMUX_OSS_RELEASE_ALL: fake_event(emu, port, voice, MIDI_CTL_ALL_NOTES_OFF, 0, atomic, hop); break; case _EMUX_OSS_NOTEOFF_ALL: fake_event(emu, port, voice, MIDI_CTL_ALL_SOUNDS_OFF, 0, atomic, hop); break; case _EMUX_OSS_INITIAL_VOLUME: if (p2) { port->volume_atten = (short)p1; snd_emux_update_port(port, SNDRV_EMUX_UPDATE_VOLUME); } break; case _EMUX_OSS_CHN_PRESSURE: if (chan) { chan->midi_pressure = p1; snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_FMMOD|SNDRV_EMUX_UPDATE_FM2FRQ2); } break; case _EMUX_OSS_CHANNEL_MODE: reset_port_mode(port, p1); snd_emux_reset_port(port); break; case _EMUX_OSS_DRUM_CHANNELS: port->drum_flags = *(unsigned int*)&event[4]; for (i = 0; i < port->chset.max_channels; i++) { chan = &port->chset.channels[i]; chan->drum_channel = ((port->drum_flags >> i) & 1) ? 1 : 0; } break; case _EMUX_OSS_MISC_MODE: if (p1 < EMUX_MD_END) port->ctrls[p1] = p2; break; case _EMUX_OSS_DEBUG_MODE: break; default: if (emu->ops.oss_ioctl) emu->ops.oss_ioctl(emu, cmd, p1, p2); break; } } /* * GUS specific h/w controls */ #include <linux/ultrasound.h> static void gusspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd, unsigned char *event, int atomic, int hop) { int voice; unsigned short p1; int plong; struct snd_midi_channel *chan; if (port->port_mode != SNDRV_EMUX_PORT_MODE_OSS_SYNTH) return; if (cmd == _GUS_NUMVOICES) return; voice = event[3]; if (voice < 0 || voice >= port->chset.max_channels) return; chan = &port->chset.channels[voice]; p1 = *(unsigned short *) &event[4]; plong = *(int*) &event[4]; switch (cmd) { case _GUS_VOICESAMPLE: chan->midi_program = p1; return; case _GUS_VOICEBALA: /* 0 to 15 --> 0 to 127 */ chan->control[MIDI_CTL_MSB_PAN] = (int)p1 << 3; snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN); return; case _GUS_VOICEVOL: case _GUS_VOICEVOL2: /* not supported yet */ return; case _GUS_RAMPRANGE: case _GUS_RAMPRATE: case _GUS_RAMPMODE: case _GUS_RAMPON: case _GUS_RAMPOFF: /* volume ramping not supported */ return; case _GUS_VOLUME_SCALE: return; case _GUS_VOICE_POS: #ifdef SNDRV_EMUX_USE_RAW_EFFECT snd_emux_send_effect(port, chan, EMUX_FX_SAMPLE_START, (short)(plong & 0x7fff), EMUX_FX_FLAG_SET); snd_emux_send_effect(port, chan, EMUX_FX_COARSE_SAMPLE_START, (plong >> 15) & 0xffff, EMUX_FX_FLAG_SET); #endif return; } } /* * send an event to midi emulation */ static void fake_event(struct snd_emux *emu, struct snd_emux_port *port, int ch, int param, int val, int atomic, int hop) { struct snd_seq_event ev; memset(&ev, 0, sizeof(ev)); ev.type = SNDRV_SEQ_EVENT_CONTROLLER; ev.data.control.channel = ch; ev.data.control.param = param; ev.data.control.value = val; snd_emux_event_input(&ev, 0, port, atomic, hop); }
linux-master
sound/synth/emux/emux_oss.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Midi Sequencer interface routines. * * Copyright (C) 1999 Steve Ratcliffe * Copyright (c) 1999-2000 Takashi Iwai <[email protected]> */ #include "emux_voice.h" #include <linux/slab.h> #include <linux/module.h> /* Prototypes for static functions */ static void free_port(void *private); static void snd_emux_init_port(struct snd_emux_port *p); static int snd_emux_use(void *private_data, struct snd_seq_port_subscribe *info); static int snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info); /* * MIDI emulation operators */ static const struct snd_midi_op emux_ops = { .note_on = snd_emux_note_on, .note_off = snd_emux_note_off, .key_press = snd_emux_key_press, .note_terminate = snd_emux_terminate_note, .control = snd_emux_control, .nrpn = snd_emux_nrpn, .sysex = snd_emux_sysex, }; /* * number of MIDI channels */ #define MIDI_CHANNELS 16 /* * type flags for MIDI sequencer port */ #define DEFAULT_MIDI_TYPE (SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |\ SNDRV_SEQ_PORT_TYPE_MIDI_GM |\ SNDRV_SEQ_PORT_TYPE_MIDI_GS |\ SNDRV_SEQ_PORT_TYPE_MIDI_XG |\ SNDRV_SEQ_PORT_TYPE_HARDWARE |\ SNDRV_SEQ_PORT_TYPE_SYNTHESIZER) /* * Initialise the EMUX Synth by creating a client and registering * a series of ports. * Each of the ports will contain the 16 midi channels. Applications * can connect to these ports to play midi data. */ int snd_emux_init_seq(struct snd_emux *emu, struct snd_card *card, int index) { int i; struct snd_seq_port_callback pinfo; char tmpname[64]; emu->client = snd_seq_create_kernel_client(card, index, "%s WaveTable", emu->name); if (emu->client < 0) { snd_printk(KERN_ERR "can't create client\n"); return -ENODEV; } if (emu->num_ports < 0) { snd_printk(KERN_WARNING "seqports must be greater than zero\n"); emu->num_ports = 1; } else if (emu->num_ports >= SNDRV_EMUX_MAX_PORTS) { snd_printk(KERN_WARNING "too many ports." "limited max. ports %d\n", SNDRV_EMUX_MAX_PORTS); emu->num_ports = SNDRV_EMUX_MAX_PORTS; } memset(&pinfo, 0, sizeof(pinfo)); pinfo.owner = THIS_MODULE; pinfo.use = snd_emux_use; pinfo.unuse = snd_emux_unuse; pinfo.event_input = snd_emux_event_input; for (i = 0; i < emu->num_ports; i++) { struct snd_emux_port *p; sprintf(tmpname, "%s Port %d", emu->name, i); p = snd_emux_create_port(emu, tmpname, MIDI_CHANNELS, 0, &pinfo); if (!p) { snd_printk(KERN_ERR "can't create port\n"); return -ENOMEM; } p->port_mode = SNDRV_EMUX_PORT_MODE_MIDI; snd_emux_init_port(p); emu->ports[i] = p->chset.port; emu->portptrs[i] = p; } return 0; } /* * Detach from the ports that were set up for this synthesizer and * destroy the kernel client. */ void snd_emux_detach_seq(struct snd_emux *emu) { if (emu->voices) snd_emux_terminate_all(emu); if (emu->client >= 0) { snd_seq_delete_kernel_client(emu->client); emu->client = -1; } } /* * create a sequencer port and channel_set */ struct snd_emux_port * snd_emux_create_port(struct snd_emux *emu, char *name, int max_channels, int oss_port, struct snd_seq_port_callback *callback) { struct snd_emux_port *p; int i, type, cap; /* Allocate structures for this channel */ p = kzalloc(sizeof(*p), GFP_KERNEL); if (!p) return NULL; p->chset.channels = kcalloc(max_channels, sizeof(*p->chset.channels), GFP_KERNEL); if (!p->chset.channels) { kfree(p); return NULL; } for (i = 0; i < max_channels; i++) p->chset.channels[i].number = i; p->chset.private_data = p; p->chset.max_channels = max_channels; p->emu = emu; p->chset.client = emu->client; #ifdef SNDRV_EMUX_USE_RAW_EFFECT snd_emux_create_effect(p); #endif callback->private_free = free_port; callback->private_data = p; cap = SNDRV_SEQ_PORT_CAP_WRITE; if (oss_port) { type = SNDRV_SEQ_PORT_TYPE_SPECIFIC; } else { type = DEFAULT_MIDI_TYPE; cap |= SNDRV_SEQ_PORT_CAP_SUBS_WRITE; } p->chset.port = snd_seq_event_port_attach(emu->client, callback, cap, type, max_channels, emu->max_voices, name); return p; } /* * release memory block for port */ static void free_port(void *private_data) { struct snd_emux_port *p; p = private_data; if (p) { #ifdef SNDRV_EMUX_USE_RAW_EFFECT snd_emux_delete_effect(p); #endif kfree(p->chset.channels); kfree(p); } } #define DEFAULT_DRUM_FLAGS (1<<9) /* * initialize the port specific parameters */ static void snd_emux_init_port(struct snd_emux_port *p) { p->drum_flags = DEFAULT_DRUM_FLAGS; p->volume_atten = 0; snd_emux_reset_port(p); } /* * reset port */ void snd_emux_reset_port(struct snd_emux_port *port) { int i; /* stop all sounds */ snd_emux_sounds_off_all(port); snd_midi_channel_set_clear(&port->chset); #ifdef SNDRV_EMUX_USE_RAW_EFFECT snd_emux_clear_effect(port); #endif /* set port specific control parameters */ port->ctrls[EMUX_MD_DEF_BANK] = 0; port->ctrls[EMUX_MD_DEF_DRUM] = 0; port->ctrls[EMUX_MD_REALTIME_PAN] = 1; for (i = 0; i < port->chset.max_channels; i++) { struct snd_midi_channel *chan = port->chset.channels + i; chan->drum_channel = ((port->drum_flags >> i) & 1) ? 1 : 0; } } /* * input sequencer event */ int snd_emux_event_input(struct snd_seq_event *ev, int direct, void *private_data, int atomic, int hop) { struct snd_emux_port *port; port = private_data; if (snd_BUG_ON(!port || !ev)) return -EINVAL; snd_midi_process_event(&emux_ops, ev, &port->chset); return 0; } /* * increment usage count */ static int __snd_emux_inc_count(struct snd_emux *emu) { emu->used++; if (!try_module_get(emu->ops.owner)) goto __error; if (!try_module_get(emu->card->module)) { module_put(emu->ops.owner); __error: emu->used--; return 0; } return 1; } int snd_emux_inc_count(struct snd_emux *emu) { int ret; mutex_lock(&emu->register_mutex); ret = __snd_emux_inc_count(emu); mutex_unlock(&emu->register_mutex); return ret; } /* * decrease usage count */ static void __snd_emux_dec_count(struct snd_emux *emu) { module_put(emu->card->module); emu->used--; if (emu->used <= 0) snd_emux_terminate_all(emu); module_put(emu->ops.owner); } void snd_emux_dec_count(struct snd_emux *emu) { mutex_lock(&emu->register_mutex); __snd_emux_dec_count(emu); mutex_unlock(&emu->register_mutex); } /* * Routine that is called upon a first use of a particular port */ static int snd_emux_use(void *private_data, struct snd_seq_port_subscribe *info) { struct snd_emux_port *p; struct snd_emux *emu; p = private_data; if (snd_BUG_ON(!p)) return -EINVAL; emu = p->emu; if (snd_BUG_ON(!emu)) return -EINVAL; mutex_lock(&emu->register_mutex); snd_emux_init_port(p); __snd_emux_inc_count(emu); mutex_unlock(&emu->register_mutex); return 0; } /* * Routine that is called upon the last unuse() of a particular port. */ static int snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info) { struct snd_emux_port *p; struct snd_emux *emu; p = private_data; if (snd_BUG_ON(!p)) return -EINVAL; emu = p->emu; if (snd_BUG_ON(!emu)) return -EINVAL; mutex_lock(&emu->register_mutex); snd_emux_sounds_off_all(p); __snd_emux_dec_count(emu); mutex_unlock(&emu->register_mutex); return 0; } /* * attach virtual rawmidi devices */ int snd_emux_init_virmidi(struct snd_emux *emu, struct snd_card *card) { int i; emu->vmidi = NULL; if (emu->midi_ports <= 0) return 0; emu->vmidi = kcalloc(emu->midi_ports, sizeof(*emu->vmidi), GFP_KERNEL); if (!emu->vmidi) return -ENOMEM; for (i = 0; i < emu->midi_ports; i++) { struct snd_rawmidi *rmidi; struct snd_virmidi_dev *rdev; if (snd_virmidi_new(card, emu->midi_devidx + i, &rmidi) < 0) goto __error; rdev = rmidi->private_data; sprintf(rmidi->name, "%s Synth MIDI", emu->name); rdev->seq_mode = SNDRV_VIRMIDI_SEQ_ATTACH; rdev->client = emu->client; rdev->port = emu->ports[i]; if (snd_device_register(card, rmidi) < 0) { snd_device_free(card, rmidi); goto __error; } emu->vmidi[i] = rmidi; /* snd_printk(KERN_DEBUG "virmidi %d ok\n", i); */ } return 0; __error: /* snd_printk(KERN_DEBUG "error init..\n"); */ snd_emux_delete_virmidi(emu); return -ENOMEM; } int snd_emux_delete_virmidi(struct snd_emux *emu) { int i; if (!emu->vmidi) return 0; for (i = 0; i < emu->midi_ports; i++) { if (emu->vmidi[i]) snd_device_free(emu->card, emu->vmidi[i]); } kfree(emu->vmidi); emu->vmidi = NULL; return 0; }
linux-master
sound/synth/emux/emux_seq.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Soundfont generic routines. * It is intended that these should be used by any driver that is willing * to accept soundfont patches. * * Copyright (C) 1999 Steve Ratcliffe * Copyright (c) 1999-2000 Takashi Iwai <[email protected]> */ /* * Deal with reading in of a soundfont. Code follows the OSS way * of doing things so that the old sfxload utility can be used. * Everything may change when there is an alsa way of doing things. */ #include <linux/uaccess.h> #include <linux/slab.h> #include <linux/export.h> #include <sound/core.h> #include <sound/soundfont.h> #include <sound/seq_oss_legacy.h> /* Prototypes for static functions */ static int open_patch(struct snd_sf_list *sflist, const char __user *data, int count, int client); static struct snd_soundfont *newsf(struct snd_sf_list *sflist, int type, char *name); static int is_identical_font(struct snd_soundfont *sf, int type, unsigned char *name); static int close_patch(struct snd_sf_list *sflist); static int probe_data(struct snd_sf_list *sflist, int sample_id); static void set_zone_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf, struct snd_sf_zone *zp); static struct snd_sf_zone *sf_zone_new(struct snd_sf_list *sflist, struct snd_soundfont *sf); static void set_sample_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf, struct snd_sf_sample *sp); static struct snd_sf_sample *sf_sample_new(struct snd_sf_list *sflist, struct snd_soundfont *sf); static void sf_sample_delete(struct snd_sf_list *sflist, struct snd_soundfont *sf, struct snd_sf_sample *sp); static int load_map(struct snd_sf_list *sflist, const void __user *data, int count); static int load_info(struct snd_sf_list *sflist, const void __user *data, long count); static int remove_info(struct snd_sf_list *sflist, struct snd_soundfont *sf, int bank, int instr); static void init_voice_info(struct soundfont_voice_info *avp); static void init_voice_parm(struct soundfont_voice_parm *pp); static struct snd_sf_sample *set_sample(struct snd_soundfont *sf, struct soundfont_voice_info *avp); static struct snd_sf_sample *find_sample(struct snd_soundfont *sf, int sample_id); static int load_data(struct snd_sf_list *sflist, const void __user *data, long count); static void rebuild_presets(struct snd_sf_list *sflist); static void add_preset(struct snd_sf_list *sflist, struct snd_sf_zone *cur); static void delete_preset(struct snd_sf_list *sflist, struct snd_sf_zone *zp); static struct snd_sf_zone *search_first_zone(struct snd_sf_list *sflist, int bank, int preset, int key); static int search_zones(struct snd_sf_list *sflist, int *notep, int vel, int preset, int bank, struct snd_sf_zone **table, int max_layers, int level); static int get_index(int bank, int instr, int key); static void snd_sf_init(struct snd_sf_list *sflist); static void snd_sf_clear(struct snd_sf_list *sflist); /* * lock access to sflist */ static void lock_preset(struct snd_sf_list *sflist) { unsigned long flags; mutex_lock(&sflist->presets_mutex); spin_lock_irqsave(&sflist->lock, flags); sflist->presets_locked = 1; spin_unlock_irqrestore(&sflist->lock, flags); } /* * remove lock */ static void unlock_preset(struct snd_sf_list *sflist) { unsigned long flags; spin_lock_irqsave(&sflist->lock, flags); sflist->presets_locked = 0; spin_unlock_irqrestore(&sflist->lock, flags); mutex_unlock(&sflist->presets_mutex); } /* * close the patch if the patch was opened by this client. */ int snd_soundfont_close_check(struct snd_sf_list *sflist, int client) { unsigned long flags; spin_lock_irqsave(&sflist->lock, flags); if (sflist->open_client == client) { spin_unlock_irqrestore(&sflist->lock, flags); return close_patch(sflist); } spin_unlock_irqrestore(&sflist->lock, flags); return 0; } /* * Deal with a soundfont patch. Any driver could use these routines * although it was designed for the AWE64. * * The sample_write and callargs parameters allow a callback into * the actual driver to write sample data to the board or whatever * it wants to do with it. */ int snd_soundfont_load(struct snd_sf_list *sflist, const void __user *data, long count, int client) { struct soundfont_patch_info patch; unsigned long flags; int rc; if (count < (long)sizeof(patch)) { snd_printk(KERN_ERR "patch record too small %ld\n", count); return -EINVAL; } if (copy_from_user(&patch, data, sizeof(patch))) return -EFAULT; count -= sizeof(patch); data += sizeof(patch); if (patch.key != SNDRV_OSS_SOUNDFONT_PATCH) { snd_printk(KERN_ERR "The wrong kind of patch %x\n", patch.key); return -EINVAL; } if (count < patch.len) { snd_printk(KERN_ERR "Patch too short %ld, need %d\n", count, patch.len); return -EINVAL; } if (patch.len < 0) { snd_printk(KERN_ERR "poor length %d\n", patch.len); return -EINVAL; } if (patch.type == SNDRV_SFNT_OPEN_PATCH) { /* grab sflist to open */ lock_preset(sflist); rc = open_patch(sflist, data, count, client); unlock_preset(sflist); return rc; } /* check if other client already opened patch */ spin_lock_irqsave(&sflist->lock, flags); if (sflist->open_client != client) { spin_unlock_irqrestore(&sflist->lock, flags); return -EBUSY; } spin_unlock_irqrestore(&sflist->lock, flags); lock_preset(sflist); rc = -EINVAL; switch (patch.type) { case SNDRV_SFNT_LOAD_INFO: rc = load_info(sflist, data, count); break; case SNDRV_SFNT_LOAD_DATA: rc = load_data(sflist, data, count); break; case SNDRV_SFNT_CLOSE_PATCH: rc = close_patch(sflist); break; case SNDRV_SFNT_REPLACE_DATA: /*rc = replace_data(&patch, data, count);*/ break; case SNDRV_SFNT_MAP_PRESET: rc = load_map(sflist, data, count); break; case SNDRV_SFNT_PROBE_DATA: rc = probe_data(sflist, patch.optarg); break; case SNDRV_SFNT_REMOVE_INFO: /* patch must be opened */ if (!sflist->currsf) { snd_printk(KERN_ERR "soundfont: remove_info: " "patch not opened\n"); rc = -EINVAL; } else { int bank, instr; bank = ((unsigned short)patch.optarg >> 8) & 0xff; instr = (unsigned short)patch.optarg & 0xff; if (! remove_info(sflist, sflist->currsf, bank, instr)) rc = -EINVAL; else rc = 0; } break; } unlock_preset(sflist); return rc; } /* check if specified type is special font (GUS or preset-alias) */ static inline int is_special_type(int type) { type &= 0x0f; return (type == SNDRV_SFNT_PAT_TYPE_GUS || type == SNDRV_SFNT_PAT_TYPE_MAP); } /* open patch; create sf list */ static int open_patch(struct snd_sf_list *sflist, const char __user *data, int count, int client) { struct soundfont_open_parm parm; struct snd_soundfont *sf; unsigned long flags; spin_lock_irqsave(&sflist->lock, flags); if (sflist->open_client >= 0 || sflist->currsf) { spin_unlock_irqrestore(&sflist->lock, flags); return -EBUSY; } spin_unlock_irqrestore(&sflist->lock, flags); if (copy_from_user(&parm, data, sizeof(parm))) return -EFAULT; if (is_special_type(parm.type)) { parm.type |= SNDRV_SFNT_PAT_SHARED; sf = newsf(sflist, parm.type, NULL); } else sf = newsf(sflist, parm.type, parm.name); if (sf == NULL) { return -ENOMEM; } spin_lock_irqsave(&sflist->lock, flags); sflist->open_client = client; sflist->currsf = sf; spin_unlock_irqrestore(&sflist->lock, flags); return 0; } /* * Allocate a new soundfont structure. */ static struct snd_soundfont * newsf(struct snd_sf_list *sflist, int type, char *name) { struct snd_soundfont *sf; /* check the shared fonts */ if (type & SNDRV_SFNT_PAT_SHARED) { for (sf = sflist->fonts; sf; sf = sf->next) { if (is_identical_font(sf, type, name)) { return sf; } } } /* not found -- create a new one */ sf = kzalloc(sizeof(*sf), GFP_KERNEL); if (sf == NULL) return NULL; sf->id = sflist->fonts_size; sflist->fonts_size++; /* prepend this record */ sf->next = sflist->fonts; sflist->fonts = sf; sf->type = type; sf->zones = NULL; sf->samples = NULL; if (name) memcpy(sf->name, name, SNDRV_SFNT_PATCH_NAME_LEN); return sf; } /* check if the given name matches to the existing list */ static int is_identical_font(struct snd_soundfont *sf, int type, unsigned char *name) { return ((sf->type & SNDRV_SFNT_PAT_SHARED) && (sf->type & 0x0f) == (type & 0x0f) && (name == NULL || memcmp(sf->name, name, SNDRV_SFNT_PATCH_NAME_LEN) == 0)); } /* * Close the current patch. */ static int close_patch(struct snd_sf_list *sflist) { unsigned long flags; spin_lock_irqsave(&sflist->lock, flags); sflist->currsf = NULL; sflist->open_client = -1; spin_unlock_irqrestore(&sflist->lock, flags); rebuild_presets(sflist); return 0; } /* probe sample in the current list -- nothing to be loaded */ static int probe_data(struct snd_sf_list *sflist, int sample_id) { /* patch must be opened */ if (sflist->currsf) { /* search the specified sample by optarg */ if (find_sample(sflist->currsf, sample_id)) return 0; } return -EINVAL; } /* * increment zone counter */ static void set_zone_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf, struct snd_sf_zone *zp) { zp->counter = sflist->zone_counter++; if (sf->type & SNDRV_SFNT_PAT_LOCKED) sflist->zone_locked = sflist->zone_counter; } /* * allocate a new zone record */ static struct snd_sf_zone * sf_zone_new(struct snd_sf_list *sflist, struct snd_soundfont *sf) { struct snd_sf_zone *zp; zp = kzalloc(sizeof(*zp), GFP_KERNEL); if (!zp) return NULL; zp->next = sf->zones; sf->zones = zp; init_voice_info(&zp->v); set_zone_counter(sflist, sf, zp); return zp; } /* * increment sample counter */ static void set_sample_counter(struct snd_sf_list *sflist, struct snd_soundfont *sf, struct snd_sf_sample *sp) { sp->counter = sflist->sample_counter++; if (sf->type & SNDRV_SFNT_PAT_LOCKED) sflist->sample_locked = sflist->sample_counter; } /* * allocate a new sample list record */ static struct snd_sf_sample * sf_sample_new(struct snd_sf_list *sflist, struct snd_soundfont *sf) { struct snd_sf_sample *sp; sp = kzalloc(sizeof(*sp), GFP_KERNEL); if (!sp) return NULL; sp->next = sf->samples; sf->samples = sp; set_sample_counter(sflist, sf, sp); return sp; } /* * delete sample list -- this is an exceptional job. * only the last allocated sample can be deleted. */ static void sf_sample_delete(struct snd_sf_list *sflist, struct snd_soundfont *sf, struct snd_sf_sample *sp) { /* only last sample is accepted */ if (sp == sf->samples) { sf->samples = sp->next; kfree(sp); } } /* load voice map */ static int load_map(struct snd_sf_list *sflist, const void __user *data, int count) { struct snd_sf_zone *zp, *prevp; struct snd_soundfont *sf; struct soundfont_voice_map map; /* get the link info */ if (count < (int)sizeof(map)) return -EINVAL; if (copy_from_user(&map, data, sizeof(map))) return -EFAULT; if (map.map_instr < 0 || map.map_instr >= SF_MAX_INSTRUMENTS) return -EINVAL; sf = newsf(sflist, SNDRV_SFNT_PAT_TYPE_MAP|SNDRV_SFNT_PAT_SHARED, NULL); if (sf == NULL) return -ENOMEM; prevp = NULL; for (zp = sf->zones; zp; prevp = zp, zp = zp->next) { if (zp->mapped && zp->instr == map.map_instr && zp->bank == map.map_bank && zp->v.low == map.map_key && zp->v.start == map.src_instr && zp->v.end == map.src_bank && zp->v.fixkey == map.src_key) { /* the same mapping is already present */ /* relink this record to the link head */ if (prevp) { prevp->next = zp->next; zp->next = sf->zones; sf->zones = zp; } /* update the counter */ set_zone_counter(sflist, sf, zp); return 0; } } /* create a new zone */ zp = sf_zone_new(sflist, sf); if (!zp) return -ENOMEM; zp->bank = map.map_bank; zp->instr = map.map_instr; zp->mapped = 1; if (map.map_key >= 0) { zp->v.low = map.map_key; zp->v.high = map.map_key; } zp->v.start = map.src_instr; zp->v.end = map.src_bank; zp->v.fixkey = map.src_key; zp->v.sf_id = sf->id; add_preset(sflist, zp); return 0; } /* remove the present instrument layers */ static int remove_info(struct snd_sf_list *sflist, struct snd_soundfont *sf, int bank, int instr) { struct snd_sf_zone *prev, *next, *p; int removed = 0; prev = NULL; for (p = sf->zones; p; p = next) { next = p->next; if (! p->mapped && p->bank == bank && p->instr == instr) { /* remove this layer */ if (prev) prev->next = next; else sf->zones = next; removed++; kfree(p); } else prev = p; } if (removed) rebuild_presets(sflist); return removed; } /* * Read an info record from the user buffer and save it on the current * open soundfont. */ static int load_info(struct snd_sf_list *sflist, const void __user *data, long count) { struct snd_soundfont *sf; struct snd_sf_zone *zone; struct soundfont_voice_rec_hdr hdr; int i; /* patch must be opened */ sf = sflist->currsf; if (!sf) return -EINVAL; if (is_special_type(sf->type)) return -EINVAL; if (count < (long)sizeof(hdr)) { printk(KERN_ERR "Soundfont error: invalid patch zone length\n"); return -EINVAL; } if (copy_from_user((char*)&hdr, data, sizeof(hdr))) return -EFAULT; data += sizeof(hdr); count -= sizeof(hdr); if (hdr.nvoices <= 0 || hdr.nvoices >= 100) { printk(KERN_ERR "Soundfont error: Illegal voice number %d\n", hdr.nvoices); return -EINVAL; } if (count < (long)sizeof(struct soundfont_voice_info) * hdr.nvoices) { printk(KERN_ERR "Soundfont Error: " "patch length(%ld) is smaller than nvoices(%d)\n", count, hdr.nvoices); return -EINVAL; } switch (hdr.write_mode) { case SNDRV_SFNT_WR_EXCLUSIVE: /* exclusive mode - if the instrument already exists, return error */ for (zone = sf->zones; zone; zone = zone->next) { if (!zone->mapped && zone->bank == hdr.bank && zone->instr == hdr.instr) return -EINVAL; } break; case SNDRV_SFNT_WR_REPLACE: /* replace mode - remove the instrument if it already exists */ remove_info(sflist, sf, hdr.bank, hdr.instr); break; } for (i = 0; i < hdr.nvoices; i++) { struct snd_sf_zone tmpzone; /* copy awe_voice_info parameters */ if (copy_from_user(&tmpzone.v, data, sizeof(tmpzone.v))) { return -EFAULT; } data += sizeof(tmpzone.v); count -= sizeof(tmpzone.v); tmpzone.bank = hdr.bank; tmpzone.instr = hdr.instr; tmpzone.mapped = 0; tmpzone.v.sf_id = sf->id; if (tmpzone.v.mode & SNDRV_SFNT_MODE_INIT_PARM) init_voice_parm(&tmpzone.v.parm); /* create a new zone */ zone = sf_zone_new(sflist, sf); if (!zone) return -ENOMEM; /* copy the temporary data */ zone->bank = tmpzone.bank; zone->instr = tmpzone.instr; zone->v = tmpzone.v; /* look up the sample */ zone->sample = set_sample(sf, &zone->v); } return 0; } /* initialize voice_info record */ static void init_voice_info(struct soundfont_voice_info *avp) { memset(avp, 0, sizeof(*avp)); avp->root = 60; avp->high = 127; avp->velhigh = 127; avp->fixkey = -1; avp->fixvel = -1; avp->fixpan = -1; avp->pan = -1; avp->amplitude = 127; avp->scaleTuning = 100; init_voice_parm(&avp->parm); } /* initialize voice_parm record: * Env1/2: delay=0, attack=0, hold=0, sustain=0, decay=0, release=0. * Vibrato and Tremolo effects are zero. * Cutoff is maximum. * Chorus and Reverb effects are zero. */ static void init_voice_parm(struct soundfont_voice_parm *pp) { memset(pp, 0, sizeof(*pp)); pp->moddelay = 0x8000; pp->modatkhld = 0x7f7f; pp->moddcysus = 0x7f7f; pp->modrelease = 0x807f; pp->voldelay = 0x8000; pp->volatkhld = 0x7f7f; pp->voldcysus = 0x7f7f; pp->volrelease = 0x807f; pp->lfo1delay = 0x8000; pp->lfo2delay = 0x8000; pp->cutoff = 0xff; } /* search the specified sample */ static struct snd_sf_sample * set_sample(struct snd_soundfont *sf, struct soundfont_voice_info *avp) { struct snd_sf_sample *sample; sample = find_sample(sf, avp->sample); if (sample == NULL) return NULL; /* add in the actual sample offsets: * The voice_info addresses define only the relative offset * from sample pointers. Here we calculate the actual DRAM * offset from sample pointers. */ avp->start += sample->v.start; avp->end += sample->v.end; avp->loopstart += sample->v.loopstart; avp->loopend += sample->v.loopend; /* copy mode flags */ avp->sample_mode = sample->v.mode_flags; return sample; } /* find the sample pointer with the given id in the soundfont */ static struct snd_sf_sample * find_sample(struct snd_soundfont *sf, int sample_id) { struct snd_sf_sample *p; if (sf == NULL) return NULL; for (p = sf->samples; p; p = p->next) { if (p->v.sample == sample_id) return p; } return NULL; } /* * Load sample information, this can include data to be loaded onto * the soundcard. It can also just be a pointer into soundcard ROM. * If there is data it will be written to the soundcard via the callback * routine. */ static int load_data(struct snd_sf_list *sflist, const void __user *data, long count) { struct snd_soundfont *sf; struct soundfont_sample_info sample_info; struct snd_sf_sample *sp; long off; /* patch must be opened */ sf = sflist->currsf; if (!sf) return -EINVAL; if (is_special_type(sf->type)) return -EINVAL; if (copy_from_user(&sample_info, data, sizeof(sample_info))) return -EFAULT; off = sizeof(sample_info); if (sample_info.size != (count-off)/2) return -EINVAL; /* Check for dup */ if (find_sample(sf, sample_info.sample)) { /* if shared sample, skip this data */ if (sf->type & SNDRV_SFNT_PAT_SHARED) return 0; return -EINVAL; } /* Allocate a new sample structure */ sp = sf_sample_new(sflist, sf); if (!sp) return -ENOMEM; sp->v = sample_info; sp->v.sf_id = sf->id; sp->v.dummy = 0; sp->v.truesize = sp->v.size; /* * If there is wave data then load it. */ if (sp->v.size > 0) { int rc; rc = sflist->callback.sample_new (sflist->callback.private_data, sp, sflist->memhdr, data + off, count - off); if (rc < 0) { sf_sample_delete(sflist, sf, sp); return rc; } sflist->mem_used += sp->v.truesize; } return count; } /* log2_tbl[i] = log2(i+128) * 0x10000 */ static const int log_tbl[129] = { 0x70000, 0x702df, 0x705b9, 0x7088e, 0x70b5d, 0x70e26, 0x710eb, 0x713aa, 0x71663, 0x71918, 0x71bc8, 0x71e72, 0x72118, 0x723b9, 0x72655, 0x728ed, 0x72b80, 0x72e0e, 0x73098, 0x7331d, 0x7359e, 0x7381b, 0x73a93, 0x73d08, 0x73f78, 0x741e4, 0x7444c, 0x746b0, 0x74910, 0x74b6c, 0x74dc4, 0x75019, 0x75269, 0x754b6, 0x75700, 0x75946, 0x75b88, 0x75dc7, 0x76002, 0x7623a, 0x7646e, 0x766a0, 0x768cd, 0x76af8, 0x76d1f, 0x76f43, 0x77164, 0x77382, 0x7759d, 0x777b4, 0x779c9, 0x77bdb, 0x77dea, 0x77ff5, 0x781fe, 0x78404, 0x78608, 0x78808, 0x78a06, 0x78c01, 0x78df9, 0x78fef, 0x791e2, 0x793d2, 0x795c0, 0x797ab, 0x79993, 0x79b79, 0x79d5d, 0x79f3e, 0x7a11d, 0x7a2f9, 0x7a4d3, 0x7a6ab, 0x7a880, 0x7aa53, 0x7ac24, 0x7adf2, 0x7afbe, 0x7b188, 0x7b350, 0x7b515, 0x7b6d8, 0x7b899, 0x7ba58, 0x7bc15, 0x7bdd0, 0x7bf89, 0x7c140, 0x7c2f5, 0x7c4a7, 0x7c658, 0x7c807, 0x7c9b3, 0x7cb5e, 0x7cd07, 0x7ceae, 0x7d053, 0x7d1f7, 0x7d398, 0x7d538, 0x7d6d6, 0x7d872, 0x7da0c, 0x7dba4, 0x7dd3b, 0x7ded0, 0x7e063, 0x7e1f4, 0x7e384, 0x7e512, 0x7e69f, 0x7e829, 0x7e9b3, 0x7eb3a, 0x7ecc0, 0x7ee44, 0x7efc7, 0x7f148, 0x7f2c8, 0x7f446, 0x7f5c2, 0x7f73d, 0x7f8b7, 0x7fa2f, 0x7fba5, 0x7fd1a, 0x7fe8d, 0x80000, }; /* convert from linear to log value * * conversion: value = log2(amount / base) * ratio * * argument: * amount = linear value (unsigned, 32bit max) * offset = base offset (:= log2(base) * 0x10000) * ratio = division ratio * */ int snd_sf_linear_to_log(unsigned int amount, int offset, int ratio) { int v; int s, low, bit; if (amount < 2) return 0; for (bit = 0; ! (amount & 0x80000000L); bit++) amount <<= 1; s = (amount >> 24) & 0x7f; low = (amount >> 16) & 0xff; /* linear approximation by lower 8 bit */ v = (log_tbl[s + 1] * low + log_tbl[s] * (0x100 - low)) >> 8; v -= offset; v = (v * ratio) >> 16; v += (24 - bit) * ratio; return v; } EXPORT_SYMBOL(snd_sf_linear_to_log); #define OFFSET_MSEC 653117 /* base = 1000 */ #define OFFSET_ABSCENT 851781 /* base = 8176 */ #define OFFSET_SAMPLERATE 1011119 /* base = 44100 */ #define ABSCENT_RATIO 1200 #define TIMECENT_RATIO 1200 #define SAMPLERATE_RATIO 4096 /* * mHz to abscent * conversion: abscent = log2(MHz / 8176) * 1200 */ static int freq_to_note(int mhz) { return snd_sf_linear_to_log(mhz, OFFSET_ABSCENT, ABSCENT_RATIO); } /* convert Hz to AWE32 rate offset: * sample pitch offset for the specified sample rate * rate=44100 is no offset, each 4096 is 1 octave (twice). * eg, when rate is 22050, this offset becomes -4096. * * conversion: offset = log2(Hz / 44100) * 4096 */ static int calc_rate_offset(int hz) { return snd_sf_linear_to_log(hz, OFFSET_SAMPLERATE, SAMPLERATE_RATIO); } /* calculate GUS envelope time */ static int calc_gus_envelope_time(int rate, int start, int end) { int r, p, t; r = (3 - ((rate >> 6) & 3)) * 3; p = rate & 0x3f; if (!p) p = 1; t = end - start; if (t < 0) t = -t; if (13 > r) t = t << (13 - r); else t = t >> (r - 13); return (t * 10) / (p * 441); } /* convert envelope time parameter to soundfont parameters */ /* attack & decay/release time table (msec) */ static const short attack_time_tbl[128] = { 32767, 32767, 5989, 4235, 2994, 2518, 2117, 1780, 1497, 1373, 1259, 1154, 1058, 970, 890, 816, 707, 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, 361, 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, 180, 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, 90, 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, 45, 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, 22, 21, 20, 19, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12, 11, 11, 10, 10, 10, 9, 9, 8, 8, 8, 8, 7, 7, 7, 6, 0, }; static const short decay_time_tbl[128] = { 32767, 32767, 22614, 15990, 11307, 9508, 7995, 6723, 5653, 5184, 4754, 4359, 3997, 3665, 3361, 3082, 2828, 2765, 2648, 2535, 2428, 2325, 2226, 2132, 2042, 1955, 1872, 1793, 1717, 1644, 1574, 1507, 1443, 1382, 1324, 1267, 1214, 1162, 1113, 1066, 978, 936, 897, 859, 822, 787, 754, 722, 691, 662, 634, 607, 581, 557, 533, 510, 489, 468, 448, 429, 411, 393, 377, 361, 345, 331, 317, 303, 290, 278, 266, 255, 244, 234, 224, 214, 205, 196, 188, 180, 172, 165, 158, 151, 145, 139, 133, 127, 122, 117, 112, 107, 102, 98, 94, 90, 86, 82, 79, 75, 72, 69, 66, 63, 61, 58, 56, 53, 51, 49, 47, 45, 43, 41, 39, 37, 36, 34, 33, 31, 30, 29, 28, 26, 25, 24, 23, 22, }; /* delay time = 0x8000 - msec/92 */ int snd_sf_calc_parm_hold(int msec) { int val = (0x7f * 92 - msec) / 92; if (val < 1) val = 1; if (val >= 126) val = 126; return val; } /* search an index for specified time from given time table */ static int calc_parm_search(int msec, const short *table) { int left = 1, right = 127, mid; while (left < right) { mid = (left + right) / 2; if (msec < (int)table[mid]) left = mid + 1; else right = mid; } return left; } /* attack time: search from time table */ int snd_sf_calc_parm_attack(int msec) { return calc_parm_search(msec, attack_time_tbl); } /* decay/release time: search from time table */ int snd_sf_calc_parm_decay(int msec) { return calc_parm_search(msec, decay_time_tbl); } int snd_sf_vol_table[128] = { 255,111,95,86,79,74,70,66,63,61,58,56,54,52,50,49, 47,46,45,43,42,41,40,39,38,37,36,35,34,34,33,32, 31,31,30,29,29,28,27,27,26,26,25,24,24,23,23,22, 22,21,21,21,20,20,19,19,18,18,18,17,17,16,16,16, 15,15,15,14,14,14,13,13,13,12,12,12,11,11,11,10, 10,10,10,9,9,9,8,8,8,8,7,7,7,7,6,6, 6,6,5,5,5,5,5,4,4,4,4,3,3,3,3,3, 2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,0, }; #define calc_gus_sustain(val) (0x7f - snd_sf_vol_table[(val)/2]) #define calc_gus_attenuation(val) snd_sf_vol_table[(val)/2] /* load GUS patch */ static int load_guspatch(struct snd_sf_list *sflist, const char __user *data, long count, int client) { struct patch_info patch; struct snd_soundfont *sf; struct snd_sf_zone *zone; struct snd_sf_sample *smp; int note, sample_id; int rc; if (count < (long)sizeof(patch)) { snd_printk(KERN_ERR "patch record too small %ld\n", count); return -EINVAL; } if (copy_from_user(&patch, data, sizeof(patch))) return -EFAULT; count -= sizeof(patch); data += sizeof(patch); sf = newsf(sflist, SNDRV_SFNT_PAT_TYPE_GUS|SNDRV_SFNT_PAT_SHARED, NULL); if (sf == NULL) return -ENOMEM; smp = sf_sample_new(sflist, sf); if (!smp) return -ENOMEM; sample_id = sflist->sample_counter; smp->v.sample = sample_id; smp->v.start = 0; smp->v.end = patch.len; smp->v.loopstart = patch.loop_start; smp->v.loopend = patch.loop_end; smp->v.size = patch.len; /* set up mode flags */ smp->v.mode_flags = 0; if (!(patch.mode & WAVE_16_BITS)) smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_8BITS; if (patch.mode & WAVE_UNSIGNED) smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_UNSIGNED; smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_NO_BLANK; if (!(patch.mode & (WAVE_LOOPING|WAVE_BIDIR_LOOP|WAVE_LOOP_BACK))) smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_SINGLESHOT; if (patch.mode & WAVE_BIDIR_LOOP) smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_BIDIR_LOOP; if (patch.mode & WAVE_LOOP_BACK) smp->v.mode_flags |= SNDRV_SFNT_SAMPLE_REVERSE_LOOP; if (patch.mode & WAVE_16_BITS) { /* convert to word offsets */ smp->v.size /= 2; smp->v.end /= 2; smp->v.loopstart /= 2; smp->v.loopend /= 2; } /*smp->v.loopend++;*/ smp->v.dummy = 0; smp->v.truesize = 0; smp->v.sf_id = sf->id; /* set up voice info */ zone = sf_zone_new(sflist, sf); if (!zone) { sf_sample_delete(sflist, sf, smp); return -ENOMEM; } /* * load wave data */ if (sflist->callback.sample_new) { rc = sflist->callback.sample_new (sflist->callback.private_data, smp, sflist->memhdr, data, count); if (rc < 0) { sf_sample_delete(sflist, sf, smp); kfree(zone); return rc; } /* memory offset is updated after */ } /* update the memory offset here */ sflist->mem_used += smp->v.truesize; zone->v.sample = sample_id; /* the last sample */ zone->v.rate_offset = calc_rate_offset(patch.base_freq); note = freq_to_note(patch.base_note); zone->v.root = note / 100; zone->v.tune = -(note % 100); zone->v.low = (freq_to_note(patch.low_note) + 99) / 100; zone->v.high = freq_to_note(patch.high_note) / 100; /* panning position; -128 - 127 => 0-127 */ zone->v.pan = (patch.panning + 128) / 2; #if 0 snd_printk(KERN_DEBUG "gus: basefrq=%d (ofs=%d) root=%d,tune=%d, range:%d-%d\n", (int)patch.base_freq, zone->v.rate_offset, zone->v.root, zone->v.tune, zone->v.low, zone->v.high); #endif /* detuning is ignored */ /* 6points volume envelope */ if (patch.mode & WAVE_ENVELOPES) { int attack, hold, decay, release; attack = calc_gus_envelope_time (patch.env_rate[0], 0, patch.env_offset[0]); hold = calc_gus_envelope_time (patch.env_rate[1], patch.env_offset[0], patch.env_offset[1]); decay = calc_gus_envelope_time (patch.env_rate[2], patch.env_offset[1], patch.env_offset[2]); release = calc_gus_envelope_time (patch.env_rate[3], patch.env_offset[1], patch.env_offset[4]); release += calc_gus_envelope_time (patch.env_rate[4], patch.env_offset[3], patch.env_offset[4]); release += calc_gus_envelope_time (patch.env_rate[5], patch.env_offset[4], patch.env_offset[5]); zone->v.parm.volatkhld = (snd_sf_calc_parm_hold(hold) << 8) | snd_sf_calc_parm_attack(attack); zone->v.parm.voldcysus = (calc_gus_sustain(patch.env_offset[2]) << 8) | snd_sf_calc_parm_decay(decay); zone->v.parm.volrelease = 0x8000 | snd_sf_calc_parm_decay(release); zone->v.attenuation = calc_gus_attenuation(patch.env_offset[0]); #if 0 snd_printk(KERN_DEBUG "gus: atkhld=%x, dcysus=%x, volrel=%x, att=%d\n", zone->v.parm.volatkhld, zone->v.parm.voldcysus, zone->v.parm.volrelease, zone->v.attenuation); #endif } /* fast release */ if (patch.mode & WAVE_FAST_RELEASE) { zone->v.parm.volrelease = 0x807f; } /* tremolo effect */ if (patch.mode & WAVE_TREMOLO) { int rate = (patch.tremolo_rate * 1000 / 38) / 42; zone->v.parm.tremfrq = ((patch.tremolo_depth / 2) << 8) | rate; } /* vibrato effect */ if (patch.mode & WAVE_VIBRATO) { int rate = (patch.vibrato_rate * 1000 / 38) / 42; zone->v.parm.fm2frq2 = ((patch.vibrato_depth / 6) << 8) | rate; } /* scale_freq, scale_factor, volume, and fractions not implemented */ if (!(smp->v.mode_flags & SNDRV_SFNT_SAMPLE_SINGLESHOT)) zone->v.mode = SNDRV_SFNT_MODE_LOOPING; else zone->v.mode = 0; /* append to the tail of the list */ /*zone->bank = ctrls[AWE_MD_GUS_BANK];*/ zone->bank = 0; zone->instr = patch.instr_no; zone->mapped = 0; zone->v.sf_id = sf->id; zone->sample = set_sample(sf, &zone->v); /* rebuild preset now */ add_preset(sflist, zone); return 0; } /* load GUS patch */ int snd_soundfont_load_guspatch(struct snd_sf_list *sflist, const char __user *data, long count, int client) { int rc; lock_preset(sflist); rc = load_guspatch(sflist, data, count, client); unlock_preset(sflist); return rc; } /* * Rebuild the preset table. This is like a hash table in that it allows * quick access to the zone information. For each preset there are zone * structures linked by next_instr and by next_zone. Former is the whole * link for this preset, and latter is the link for zone (i.e. instrument/ * bank/key combination). */ static void rebuild_presets(struct snd_sf_list *sflist) { struct snd_soundfont *sf; struct snd_sf_zone *cur; /* clear preset table */ memset(sflist->presets, 0, sizeof(sflist->presets)); /* search all fonts and insert each font */ for (sf = sflist->fonts; sf; sf = sf->next) { for (cur = sf->zones; cur; cur = cur->next) { if (! cur->mapped && cur->sample == NULL) { /* try again to search the corresponding sample */ cur->sample = set_sample(sf, &cur->v); if (cur->sample == NULL) continue; } add_preset(sflist, cur); } } } /* * add the given zone to preset table */ static void add_preset(struct snd_sf_list *sflist, struct snd_sf_zone *cur) { struct snd_sf_zone *zone; int index; zone = search_first_zone(sflist, cur->bank, cur->instr, cur->v.low); if (zone && zone->v.sf_id != cur->v.sf_id) { /* different instrument was already defined */ struct snd_sf_zone *p; /* compare the allocated time */ for (p = zone; p; p = p->next_zone) { if (p->counter > cur->counter) /* the current is older.. skipped */ return; } /* remove old zones */ delete_preset(sflist, zone); zone = NULL; /* do not forget to clear this! */ } /* prepend this zone */ index = get_index(cur->bank, cur->instr, cur->v.low); if (index < 0) return; cur->next_zone = zone; /* zone link */ cur->next_instr = sflist->presets[index]; /* preset table link */ sflist->presets[index] = cur; } /* * delete the given zones from preset_table */ static void delete_preset(struct snd_sf_list *sflist, struct snd_sf_zone *zp) { int index; struct snd_sf_zone *p; index = get_index(zp->bank, zp->instr, zp->v.low); if (index < 0) return; for (p = sflist->presets[index]; p; p = p->next_instr) { while (p->next_instr == zp) { p->next_instr = zp->next_instr; zp = zp->next_zone; if (zp == NULL) return; } } } /* * Search matching zones from preset table. * The note can be rewritten by preset mapping (alias). * The found zones are stored on 'table' array. max_layers defines * the maximum number of elements in this array. * This function returns the number of found zones. 0 if not found. */ int snd_soundfont_search_zone(struct snd_sf_list *sflist, int *notep, int vel, int preset, int bank, int def_preset, int def_bank, struct snd_sf_zone **table, int max_layers) { int nvoices; unsigned long flags; /* this function is supposed to be called atomically, * so we check the lock. if it's busy, just returns 0 to * tell the caller the busy state */ spin_lock_irqsave(&sflist->lock, flags); if (sflist->presets_locked) { spin_unlock_irqrestore(&sflist->lock, flags); return 0; } nvoices = search_zones(sflist, notep, vel, preset, bank, table, max_layers, 0); if (! nvoices) { if (preset != def_preset || bank != def_bank) nvoices = search_zones(sflist, notep, vel, def_preset, def_bank, table, max_layers, 0); } spin_unlock_irqrestore(&sflist->lock, flags); return nvoices; } /* * search the first matching zone */ static struct snd_sf_zone * search_first_zone(struct snd_sf_list *sflist, int bank, int preset, int key) { int index; struct snd_sf_zone *zp; index = get_index(bank, preset, key); if (index < 0) return NULL; for (zp = sflist->presets[index]; zp; zp = zp->next_instr) { if (zp->instr == preset && zp->bank == bank) return zp; } return NULL; } /* * search matching zones from sflist. can be called recursively. */ static int search_zones(struct snd_sf_list *sflist, int *notep, int vel, int preset, int bank, struct snd_sf_zone **table, int max_layers, int level) { struct snd_sf_zone *zp; int nvoices; zp = search_first_zone(sflist, bank, preset, *notep); nvoices = 0; for (; zp; zp = zp->next_zone) { if (*notep >= zp->v.low && *notep <= zp->v.high && vel >= zp->v.vellow && vel <= zp->v.velhigh) { if (zp->mapped) { /* search preset mapping (aliasing) */ int key = zp->v.fixkey; preset = zp->v.start; bank = zp->v.end; if (level > 5) /* too deep alias level */ return 0; if (key < 0) key = *notep; nvoices = search_zones(sflist, &key, vel, preset, bank, table, max_layers, level + 1); if (nvoices > 0) *notep = key; break; } table[nvoices++] = zp; if (nvoices >= max_layers) break; } } return nvoices; } /* calculate the index of preset table: * drums are mapped from 128 to 255 according to its note key. * other instruments are mapped from 0 to 127. * if the index is out of range, return -1. */ static int get_index(int bank, int instr, int key) { int index; if (SF_IS_DRUM_BANK(bank)) index = key + SF_MAX_INSTRUMENTS; else index = instr; index = index % SF_MAX_PRESETS; if (index < 0) return -1; return index; } /* * Initialise the sflist structure. */ static void snd_sf_init(struct snd_sf_list *sflist) { memset(sflist->presets, 0, sizeof(sflist->presets)); sflist->mem_used = 0; sflist->currsf = NULL; sflist->open_client = -1; sflist->fonts = NULL; sflist->fonts_size = 0; sflist->zone_counter = 0; sflist->sample_counter = 0; sflist->zone_locked = 0; sflist->sample_locked = 0; } /* * Release all list records */ static void snd_sf_clear(struct snd_sf_list *sflist) { struct snd_soundfont *sf, *nextsf; struct snd_sf_zone *zp, *nextzp; struct snd_sf_sample *sp, *nextsp; for (sf = sflist->fonts; sf; sf = nextsf) { nextsf = sf->next; for (zp = sf->zones; zp; zp = nextzp) { nextzp = zp->next; kfree(zp); } for (sp = sf->samples; sp; sp = nextsp) { nextsp = sp->next; if (sflist->callback.sample_free) sflist->callback.sample_free(sflist->callback.private_data, sp, sflist->memhdr); kfree(sp); } kfree(sf); } snd_sf_init(sflist); } /* * Create a new sflist structure */ struct snd_sf_list * snd_sf_new(struct snd_sf_callback *callback, struct snd_util_memhdr *hdr) { struct snd_sf_list *sflist; sflist = kzalloc(sizeof(*sflist), GFP_KERNEL); if (!sflist) return NULL; mutex_init(&sflist->presets_mutex); spin_lock_init(&sflist->lock); sflist->memhdr = hdr; if (callback) sflist->callback = *callback; snd_sf_init(sflist); return sflist; } /* * Free everything allocated off the sflist structure. */ void snd_sf_free(struct snd_sf_list *sflist) { if (sflist == NULL) return; lock_preset(sflist); if (sflist->callback.sample_reset) sflist->callback.sample_reset(sflist->callback.private_data); snd_sf_clear(sflist); unlock_preset(sflist); kfree(sflist); } /* * Remove all samples * The soundcard should be silent before calling this function. */ int snd_soundfont_remove_samples(struct snd_sf_list *sflist) { lock_preset(sflist); if (sflist->callback.sample_reset) sflist->callback.sample_reset(sflist->callback.private_data); snd_sf_clear(sflist); unlock_preset(sflist); return 0; } /* * Remove unlocked samples. * The soundcard should be silent before calling this function. */ int snd_soundfont_remove_unlocked(struct snd_sf_list *sflist) { struct snd_soundfont *sf; struct snd_sf_zone *zp, *nextzp; struct snd_sf_sample *sp, *nextsp; lock_preset(sflist); if (sflist->callback.sample_reset) sflist->callback.sample_reset(sflist->callback.private_data); /* to be sure */ memset(sflist->presets, 0, sizeof(sflist->presets)); for (sf = sflist->fonts; sf; sf = sf->next) { for (zp = sf->zones; zp; zp = nextzp) { if (zp->counter < sflist->zone_locked) break; nextzp = zp->next; sf->zones = nextzp; kfree(zp); } for (sp = sf->samples; sp; sp = nextsp) { if (sp->counter < sflist->sample_locked) break; nextsp = sp->next; sf->samples = nextsp; sflist->mem_used -= sp->v.truesize; if (sflist->callback.sample_free) sflist->callback.sample_free(sflist->callback.private_data, sp, sflist->memhdr); kfree(sp); } } sflist->zone_counter = sflist->zone_locked; sflist->sample_counter = sflist->sample_locked; rebuild_presets(sflist); unlock_preset(sflist); return 0; }
linux-master
sound/synth/emux/soundfont.c
// SPDX-License-Identifier: GPL-2.0-only /* * intel_hdmi_audio.c - Intel HDMI audio driver * * Copyright (C) 2016 Intel Corp * Authors: Sailaja Bandarupalli <[email protected]> * Ramesh Babu K V <[email protected]> * Vaibhav Agarwal <[email protected]> * Jerome Anand <[email protected]> * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * ALSA driver for Intel HDMI audio */ #include <linux/types.h> #include <linux/platform_device.h> #include <linux/io.h> #include <linux/slab.h> #include <linux/module.h> #include <linux/interrupt.h> #include <linux/pm_runtime.h> #include <linux/dma-mapping.h> #include <linux/delay.h> #include <sound/core.h> #include <sound/asoundef.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include <sound/initval.h> #include <sound/control.h> #include <sound/jack.h> #include <drm/drm_edid.h> #include <drm/intel_lpe_audio.h> #include "intel_hdmi_audio.h" #define INTEL_HDMI_AUDIO_SUSPEND_DELAY_MS 5000 #define for_each_pipe(card_ctx, pipe) \ for ((pipe) = 0; (pipe) < (card_ctx)->num_pipes; (pipe)++) #define for_each_port(card_ctx, port) \ for ((port) = 0; (port) < (card_ctx)->num_ports; (port)++) /*standard module options for ALSA. This module supports only one card*/ static int hdmi_card_index = SNDRV_DEFAULT_IDX1; static char *hdmi_card_id = SNDRV_DEFAULT_STR1; static bool single_port; module_param_named(index, hdmi_card_index, int, 0444); MODULE_PARM_DESC(index, "Index value for INTEL Intel HDMI Audio controller."); module_param_named(id, hdmi_card_id, charp, 0444); MODULE_PARM_DESC(id, "ID string for INTEL Intel HDMI Audio controller."); module_param(single_port, bool, 0444); MODULE_PARM_DESC(single_port, "Single-port mode (for compatibility)"); /* * ELD SA bits in the CEA Speaker Allocation data block */ static const int eld_speaker_allocation_bits[] = { [0] = FL | FR, [1] = LFE, [2] = FC, [3] = RL | RR, [4] = RC, [5] = FLC | FRC, [6] = RLC | RRC, /* the following are not defined in ELD yet */ [7] = 0, }; /* * This is an ordered list! * * The preceding ones have better chances to be selected by * hdmi_channel_allocation(). */ static struct cea_channel_speaker_allocation channel_allocations[] = { /* channel: 7 6 5 4 3 2 1 0 */ { .ca_index = 0x00, .speakers = { 0, 0, 0, 0, 0, 0, FR, FL } }, /* 2.1 */ { .ca_index = 0x01, .speakers = { 0, 0, 0, 0, 0, LFE, FR, FL } }, /* Dolby Surround */ { .ca_index = 0x02, .speakers = { 0, 0, 0, 0, FC, 0, FR, FL } }, /* surround40 */ { .ca_index = 0x08, .speakers = { 0, 0, RR, RL, 0, 0, FR, FL } }, /* surround41 */ { .ca_index = 0x09, .speakers = { 0, 0, RR, RL, 0, LFE, FR, FL } }, /* surround50 */ { .ca_index = 0x0a, .speakers = { 0, 0, RR, RL, FC, 0, FR, FL } }, /* surround51 */ { .ca_index = 0x0b, .speakers = { 0, 0, RR, RL, FC, LFE, FR, FL } }, /* 6.1 */ { .ca_index = 0x0f, .speakers = { 0, RC, RR, RL, FC, LFE, FR, FL } }, /* surround71 */ { .ca_index = 0x13, .speakers = { RRC, RLC, RR, RL, FC, LFE, FR, FL } }, { .ca_index = 0x03, .speakers = { 0, 0, 0, 0, FC, LFE, FR, FL } }, { .ca_index = 0x04, .speakers = { 0, 0, 0, RC, 0, 0, FR, FL } }, { .ca_index = 0x05, .speakers = { 0, 0, 0, RC, 0, LFE, FR, FL } }, { .ca_index = 0x06, .speakers = { 0, 0, 0, RC, FC, 0, FR, FL } }, { .ca_index = 0x07, .speakers = { 0, 0, 0, RC, FC, LFE, FR, FL } }, { .ca_index = 0x0c, .speakers = { 0, RC, RR, RL, 0, 0, FR, FL } }, { .ca_index = 0x0d, .speakers = { 0, RC, RR, RL, 0, LFE, FR, FL } }, { .ca_index = 0x0e, .speakers = { 0, RC, RR, RL, FC, 0, FR, FL } }, { .ca_index = 0x10, .speakers = { RRC, RLC, RR, RL, 0, 0, FR, FL } }, { .ca_index = 0x11, .speakers = { RRC, RLC, RR, RL, 0, LFE, FR, FL } }, { .ca_index = 0x12, .speakers = { RRC, RLC, RR, RL, FC, 0, FR, FL } }, { .ca_index = 0x14, .speakers = { FRC, FLC, 0, 0, 0, 0, FR, FL } }, { .ca_index = 0x15, .speakers = { FRC, FLC, 0, 0, 0, LFE, FR, FL } }, { .ca_index = 0x16, .speakers = { FRC, FLC, 0, 0, FC, 0, FR, FL } }, { .ca_index = 0x17, .speakers = { FRC, FLC, 0, 0, FC, LFE, FR, FL } }, { .ca_index = 0x18, .speakers = { FRC, FLC, 0, RC, 0, 0, FR, FL } }, { .ca_index = 0x19, .speakers = { FRC, FLC, 0, RC, 0, LFE, FR, FL } }, { .ca_index = 0x1a, .speakers = { FRC, FLC, 0, RC, FC, 0, FR, FL } }, { .ca_index = 0x1b, .speakers = { FRC, FLC, 0, RC, FC, LFE, FR, FL } }, { .ca_index = 0x1c, .speakers = { FRC, FLC, RR, RL, 0, 0, FR, FL } }, { .ca_index = 0x1d, .speakers = { FRC, FLC, RR, RL, 0, LFE, FR, FL } }, { .ca_index = 0x1e, .speakers = { FRC, FLC, RR, RL, FC, 0, FR, FL } }, { .ca_index = 0x1f, .speakers = { FRC, FLC, RR, RL, FC, LFE, FR, FL } }, }; static const struct channel_map_table map_tables[] = { { SNDRV_CHMAP_FL, 0x00, FL }, { SNDRV_CHMAP_FR, 0x01, FR }, { SNDRV_CHMAP_RL, 0x04, RL }, { SNDRV_CHMAP_RR, 0x05, RR }, { SNDRV_CHMAP_LFE, 0x02, LFE }, { SNDRV_CHMAP_FC, 0x03, FC }, { SNDRV_CHMAP_RLC, 0x06, RLC }, { SNDRV_CHMAP_RRC, 0x07, RRC }, {} /* terminator */ }; /* hardware capability structure */ static const struct snd_pcm_hardware had_pcm_hardware = { .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_NO_PERIOD_WAKEUP), .formats = (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE), .rates = SNDRV_PCM_RATE_32000 | 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 = HAD_MIN_RATE, .rate_max = HAD_MAX_RATE, .channels_min = HAD_MIN_CHANNEL, .channels_max = HAD_MAX_CHANNEL, .buffer_bytes_max = HAD_MAX_BUFFER, .period_bytes_min = HAD_MIN_PERIOD_BYTES, .period_bytes_max = HAD_MAX_PERIOD_BYTES, .periods_min = HAD_MIN_PERIODS, .periods_max = HAD_MAX_PERIODS, .fifo_size = HAD_FIFO_SIZE, }; /* Get the active PCM substream; * Call had_substream_put() for unreferecing. * Don't call this inside had_spinlock, as it takes by itself */ static struct snd_pcm_substream * had_substream_get(struct snd_intelhad *intelhaddata) { struct snd_pcm_substream *substream; unsigned long flags; spin_lock_irqsave(&intelhaddata->had_spinlock, flags); substream = intelhaddata->stream_info.substream; if (substream) intelhaddata->stream_info.substream_refcount++; spin_unlock_irqrestore(&intelhaddata->had_spinlock, flags); return substream; } /* Unref the active PCM substream; * Don't call this inside had_spinlock, as it takes by itself */ static void had_substream_put(struct snd_intelhad *intelhaddata) { unsigned long flags; spin_lock_irqsave(&intelhaddata->had_spinlock, flags); intelhaddata->stream_info.substream_refcount--; spin_unlock_irqrestore(&intelhaddata->had_spinlock, flags); } static u32 had_config_offset(int pipe) { switch (pipe) { default: case 0: return AUDIO_HDMI_CONFIG_A; case 1: return AUDIO_HDMI_CONFIG_B; case 2: return AUDIO_HDMI_CONFIG_C; } } /* Register access functions */ static u32 had_read_register_raw(struct snd_intelhad_card *card_ctx, int pipe, u32 reg) { return ioread32(card_ctx->mmio_start + had_config_offset(pipe) + reg); } static void had_write_register_raw(struct snd_intelhad_card *card_ctx, int pipe, u32 reg, u32 val) { iowrite32(val, card_ctx->mmio_start + had_config_offset(pipe) + reg); } static void had_read_register(struct snd_intelhad *ctx, u32 reg, u32 *val) { if (!ctx->connected) *val = 0; else *val = had_read_register_raw(ctx->card_ctx, ctx->pipe, reg); } static void had_write_register(struct snd_intelhad *ctx, u32 reg, u32 val) { if (ctx->connected) had_write_register_raw(ctx->card_ctx, ctx->pipe, reg, val); } /* * enable / disable audio configuration * * The normal read/modify should not directly be used on VLV2 for * updating AUD_CONFIG register. * This is because: * Bit6 of AUD_CONFIG register is writeonly due to a silicon bug on VLV2 * HDMI IP. As a result a read-modify of AUD_CONFIG register will always * clear bit6. AUD_CONFIG[6:4] represents the "channels" field of the * register. This field should be 1xy binary for configuration with 6 or * more channels. Read-modify of AUD_CONFIG (Eg. for enabling audio) * causes the "channels" field to be updated as 0xy binary resulting in * bad audio. The fix is to always write the AUD_CONFIG[6:4] with * appropriate value when doing read-modify of AUD_CONFIG register. */ static void had_enable_audio(struct snd_intelhad *intelhaddata, bool enable) { /* update the cached value */ intelhaddata->aud_config.regx.aud_en = enable; had_write_register(intelhaddata, AUD_CONFIG, intelhaddata->aud_config.regval); } /* forcibly ACKs to both BUFFER_DONE and BUFFER_UNDERRUN interrupts */ static void had_ack_irqs(struct snd_intelhad *ctx) { u32 status_reg; if (!ctx->connected) return; had_read_register(ctx, AUD_HDMI_STATUS, &status_reg); status_reg |= HDMI_AUDIO_BUFFER_DONE | HDMI_AUDIO_UNDERRUN; had_write_register(ctx, AUD_HDMI_STATUS, status_reg); had_read_register(ctx, AUD_HDMI_STATUS, &status_reg); } /* Reset buffer pointers */ static void had_reset_audio(struct snd_intelhad *intelhaddata) { had_write_register(intelhaddata, AUD_HDMI_STATUS, AUD_HDMI_STATUSG_MASK_FUNCRST); had_write_register(intelhaddata, AUD_HDMI_STATUS, 0); } /* * initialize audio channel status registers * This function is called in the prepare callback */ static int had_prog_status_reg(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata) { union aud_ch_status_0 ch_stat0 = {.regval = 0}; union aud_ch_status_1 ch_stat1 = {.regval = 0}; ch_stat0.regx.lpcm_id = (intelhaddata->aes_bits & IEC958_AES0_NONAUDIO) >> 1; ch_stat0.regx.clk_acc = (intelhaddata->aes_bits & IEC958_AES3_CON_CLOCK) >> 4; switch (substream->runtime->rate) { case AUD_SAMPLE_RATE_32: ch_stat0.regx.samp_freq = CH_STATUS_MAP_32KHZ; break; case AUD_SAMPLE_RATE_44_1: ch_stat0.regx.samp_freq = CH_STATUS_MAP_44KHZ; break; case AUD_SAMPLE_RATE_48: ch_stat0.regx.samp_freq = CH_STATUS_MAP_48KHZ; break; case AUD_SAMPLE_RATE_88_2: ch_stat0.regx.samp_freq = CH_STATUS_MAP_88KHZ; break; case AUD_SAMPLE_RATE_96: ch_stat0.regx.samp_freq = CH_STATUS_MAP_96KHZ; break; case AUD_SAMPLE_RATE_176_4: ch_stat0.regx.samp_freq = CH_STATUS_MAP_176KHZ; break; case AUD_SAMPLE_RATE_192: ch_stat0.regx.samp_freq = CH_STATUS_MAP_192KHZ; break; default: /* control should never come here */ return -EINVAL; } had_write_register(intelhaddata, AUD_CH_STATUS_0, ch_stat0.regval); switch (substream->runtime->format) { case SNDRV_PCM_FORMAT_S16_LE: ch_stat1.regx.max_wrd_len = MAX_SMPL_WIDTH_20; ch_stat1.regx.wrd_len = SMPL_WIDTH_16BITS; break; case SNDRV_PCM_FORMAT_S24_LE: case SNDRV_PCM_FORMAT_S32_LE: ch_stat1.regx.max_wrd_len = MAX_SMPL_WIDTH_24; ch_stat1.regx.wrd_len = SMPL_WIDTH_24BITS; break; default: return -EINVAL; } had_write_register(intelhaddata, AUD_CH_STATUS_1, ch_stat1.regval); return 0; } /* * function to initialize audio * registers and buffer configuration registers * This function is called in the prepare callback */ static int had_init_audio_ctrl(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata) { union aud_cfg cfg_val = {.regval = 0}; union aud_buf_config buf_cfg = {.regval = 0}; u8 channels; had_prog_status_reg(substream, intelhaddata); buf_cfg.regx.audio_fifo_watermark = FIFO_THRESHOLD; buf_cfg.regx.dma_fifo_watermark = DMA_FIFO_THRESHOLD; buf_cfg.regx.aud_delay = 0; had_write_register(intelhaddata, AUD_BUF_CONFIG, buf_cfg.regval); channels = substream->runtime->channels; cfg_val.regx.num_ch = channels - 2; if (channels <= 2) cfg_val.regx.layout = LAYOUT0; else cfg_val.regx.layout = LAYOUT1; if (substream->runtime->format == SNDRV_PCM_FORMAT_S16_LE) cfg_val.regx.packet_mode = 1; if (substream->runtime->format == SNDRV_PCM_FORMAT_S32_LE) cfg_val.regx.left_align = 1; cfg_val.regx.val_bit = 1; /* fix up the DP bits */ if (intelhaddata->dp_output) { cfg_val.regx.dp_modei = 1; cfg_val.regx.set = 1; } had_write_register(intelhaddata, AUD_CONFIG, cfg_val.regval); intelhaddata->aud_config = cfg_val; return 0; } /* * Compute derived values in channel_allocations[]. */ static void init_channel_allocations(void) { int i, j; struct cea_channel_speaker_allocation *p; for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) { p = channel_allocations + i; p->channels = 0; p->spk_mask = 0; for (j = 0; j < ARRAY_SIZE(p->speakers); j++) if (p->speakers[j]) { p->channels++; p->spk_mask |= p->speakers[j]; } } } /* * The transformation takes two steps: * * eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask * spk_mask => (channel_allocations[]) => ai->CA * * TODO: it could select the wrong CA from multiple candidates. */ static int had_channel_allocation(struct snd_intelhad *intelhaddata, int channels) { int i; int ca = 0; int spk_mask = 0; /* * CA defaults to 0 for basic stereo audio */ if (channels <= 2) return 0; /* * expand ELD's speaker allocation mask * * ELD tells the speaker mask in a compact(paired) form, * expand ELD's notions to match the ones used by Audio InfoFrame. */ for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) { if (intelhaddata->eld[DRM_ELD_SPEAKER] & (1 << i)) spk_mask |= eld_speaker_allocation_bits[i]; } /* search for the first working match in the CA table */ for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) { if (channels == channel_allocations[i].channels && (spk_mask & channel_allocations[i].spk_mask) == channel_allocations[i].spk_mask) { ca = channel_allocations[i].ca_index; break; } } dev_dbg(intelhaddata->dev, "select CA 0x%x for %d\n", ca, channels); return ca; } /* from speaker bit mask to ALSA API channel position */ static int spk_to_chmap(int spk) { const struct channel_map_table *t = map_tables; for (; t->map; t++) { if (t->spk_mask == spk) return t->map; } return 0; } static void had_build_channel_allocation_map(struct snd_intelhad *intelhaddata) { int i, c; int spk_mask = 0; struct snd_pcm_chmap_elem *chmap; u8 eld_high, eld_high_mask = 0xF0; u8 high_msb; kfree(intelhaddata->chmap->chmap); intelhaddata->chmap->chmap = NULL; chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); if (!chmap) return; dev_dbg(intelhaddata->dev, "eld speaker = %x\n", intelhaddata->eld[DRM_ELD_SPEAKER]); /* WA: Fix the max channel supported to 8 */ /* * Sink may support more than 8 channels, if eld_high has more than * one bit set. SOC supports max 8 channels. * Refer eld_speaker_allocation_bits, for sink speaker allocation */ /* if 0x2F < eld < 0x4F fall back to 0x2f, else fall back to 0x4F */ eld_high = intelhaddata->eld[DRM_ELD_SPEAKER] & eld_high_mask; if ((eld_high & (eld_high-1)) && (eld_high > 0x1F)) { /* eld_high & (eld_high-1): if more than 1 bit set */ /* 0x1F: 7 channels */ for (i = 1; i < 4; i++) { high_msb = eld_high & (0x80 >> i); if (high_msb) { intelhaddata->eld[DRM_ELD_SPEAKER] &= high_msb | 0xF; break; } } } for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) { if (intelhaddata->eld[DRM_ELD_SPEAKER] & (1 << i)) spk_mask |= eld_speaker_allocation_bits[i]; } for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) { if (spk_mask == channel_allocations[i].spk_mask) { for (c = 0; c < channel_allocations[i].channels; c++) { chmap->map[c] = spk_to_chmap( channel_allocations[i].speakers[ (MAX_SPEAKERS - 1) - c]); } chmap->channels = channel_allocations[i].channels; intelhaddata->chmap->chmap = chmap; break; } } if (i >= ARRAY_SIZE(channel_allocations)) kfree(chmap); } /* * ALSA API channel-map control callbacks */ static int had_chmap_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = HAD_MAX_CHANNEL; uinfo->value.integer.min = 0; uinfo->value.integer.max = SNDRV_CHMAP_LAST; return 0; } static int had_chmap_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); struct snd_intelhad *intelhaddata = info->private_data; int i; const struct snd_pcm_chmap_elem *chmap; memset(ucontrol->value.integer.value, 0, sizeof(long) * HAD_MAX_CHANNEL); mutex_lock(&intelhaddata->mutex); if (!intelhaddata->chmap->chmap) { mutex_unlock(&intelhaddata->mutex); return 0; } chmap = intelhaddata->chmap->chmap; for (i = 0; i < chmap->channels; i++) ucontrol->value.integer.value[i] = chmap->map[i]; mutex_unlock(&intelhaddata->mutex); return 0; } static int had_register_chmap_ctls(struct snd_intelhad *intelhaddata, struct snd_pcm *pcm) { int err; err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, NULL, 0, (unsigned long)intelhaddata, &intelhaddata->chmap); if (err < 0) return err; intelhaddata->chmap->private_data = intelhaddata; intelhaddata->chmap->kctl->info = had_chmap_ctl_info; intelhaddata->chmap->kctl->get = had_chmap_ctl_get; intelhaddata->chmap->chmap = NULL; return 0; } /* * Initialize Data Island Packets registers * This function is called in the prepare callback */ static void had_prog_dip(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata) { int i; union aud_ctrl_st ctrl_state = {.regval = 0}; union aud_info_frame2 frame2 = {.regval = 0}; union aud_info_frame3 frame3 = {.regval = 0}; u8 checksum = 0; u32 info_frame; int channels; int ca; channels = substream->runtime->channels; had_write_register(intelhaddata, AUD_CNTL_ST, ctrl_state.regval); ca = had_channel_allocation(intelhaddata, channels); if (intelhaddata->dp_output) { info_frame = DP_INFO_FRAME_WORD1; frame2.regval = (substream->runtime->channels - 1) | (ca << 24); } else { info_frame = HDMI_INFO_FRAME_WORD1; frame2.regx.chnl_cnt = substream->runtime->channels - 1; frame3.regx.chnl_alloc = ca; /* Calculte the byte wide checksum for all valid DIP words */ for (i = 0; i < BYTES_PER_WORD; i++) checksum += (info_frame >> (i * 8)) & 0xff; for (i = 0; i < BYTES_PER_WORD; i++) checksum += (frame2.regval >> (i * 8)) & 0xff; for (i = 0; i < BYTES_PER_WORD; i++) checksum += (frame3.regval >> (i * 8)) & 0xff; frame2.regx.chksum = -(checksum); } had_write_register(intelhaddata, AUD_HDMIW_INFOFR, info_frame); had_write_register(intelhaddata, AUD_HDMIW_INFOFR, frame2.regval); had_write_register(intelhaddata, AUD_HDMIW_INFOFR, frame3.regval); /* program remaining DIP words with zero */ for (i = 0; i < HAD_MAX_DIP_WORDS-VALID_DIP_WORDS; i++) had_write_register(intelhaddata, AUD_HDMIW_INFOFR, 0x0); ctrl_state.regx.dip_freq = 1; ctrl_state.regx.dip_en_sta = 1; had_write_register(intelhaddata, AUD_CNTL_ST, ctrl_state.regval); } static int had_calculate_maud_value(u32 aud_samp_freq, u32 link_rate) { u32 maud_val; /* Select maud according to DP 1.2 spec */ if (link_rate == DP_2_7_GHZ) { switch (aud_samp_freq) { case AUD_SAMPLE_RATE_32: maud_val = AUD_SAMPLE_RATE_32_DP_2_7_MAUD_VAL; break; case AUD_SAMPLE_RATE_44_1: maud_val = AUD_SAMPLE_RATE_44_1_DP_2_7_MAUD_VAL; break; case AUD_SAMPLE_RATE_48: maud_val = AUD_SAMPLE_RATE_48_DP_2_7_MAUD_VAL; break; case AUD_SAMPLE_RATE_88_2: maud_val = AUD_SAMPLE_RATE_88_2_DP_2_7_MAUD_VAL; break; case AUD_SAMPLE_RATE_96: maud_val = AUD_SAMPLE_RATE_96_DP_2_7_MAUD_VAL; break; case AUD_SAMPLE_RATE_176_4: maud_val = AUD_SAMPLE_RATE_176_4_DP_2_7_MAUD_VAL; break; case HAD_MAX_RATE: maud_val = HAD_MAX_RATE_DP_2_7_MAUD_VAL; break; default: maud_val = -EINVAL; break; } } else if (link_rate == DP_1_62_GHZ) { switch (aud_samp_freq) { case AUD_SAMPLE_RATE_32: maud_val = AUD_SAMPLE_RATE_32_DP_1_62_MAUD_VAL; break; case AUD_SAMPLE_RATE_44_1: maud_val = AUD_SAMPLE_RATE_44_1_DP_1_62_MAUD_VAL; break; case AUD_SAMPLE_RATE_48: maud_val = AUD_SAMPLE_RATE_48_DP_1_62_MAUD_VAL; break; case AUD_SAMPLE_RATE_88_2: maud_val = AUD_SAMPLE_RATE_88_2_DP_1_62_MAUD_VAL; break; case AUD_SAMPLE_RATE_96: maud_val = AUD_SAMPLE_RATE_96_DP_1_62_MAUD_VAL; break; case AUD_SAMPLE_RATE_176_4: maud_val = AUD_SAMPLE_RATE_176_4_DP_1_62_MAUD_VAL; break; case HAD_MAX_RATE: maud_val = HAD_MAX_RATE_DP_1_62_MAUD_VAL; break; default: maud_val = -EINVAL; break; } } else maud_val = -EINVAL; return maud_val; } /* * Program HDMI audio CTS value * * @aud_samp_freq: sampling frequency of audio data * @tmds: sampling frequency of the display data * @link_rate: DP link rate * @n_param: N value, depends on aud_samp_freq * @intelhaddata: substream private data * * Program CTS register based on the audio and display sampling frequency */ static void had_prog_cts(u32 aud_samp_freq, u32 tmds, u32 link_rate, u32 n_param, struct snd_intelhad *intelhaddata) { u32 cts_val; u64 dividend, divisor; if (intelhaddata->dp_output) { /* Substitute cts_val with Maud according to DP 1.2 spec*/ cts_val = had_calculate_maud_value(aud_samp_freq, link_rate); } else { /* Calculate CTS according to HDMI 1.3a spec*/ dividend = (u64)tmds * n_param*1000; divisor = 128 * aud_samp_freq; cts_val = div64_u64(dividend, divisor); } dev_dbg(intelhaddata->dev, "TMDS value=%d, N value=%d, CTS Value=%d\n", tmds, n_param, cts_val); had_write_register(intelhaddata, AUD_HDMI_CTS, (BIT(24) | cts_val)); } static int had_calculate_n_value(u32 aud_samp_freq) { int n_val; /* Select N according to HDMI 1.3a spec*/ switch (aud_samp_freq) { case AUD_SAMPLE_RATE_32: n_val = 4096; break; case AUD_SAMPLE_RATE_44_1: n_val = 6272; break; case AUD_SAMPLE_RATE_48: n_val = 6144; break; case AUD_SAMPLE_RATE_88_2: n_val = 12544; break; case AUD_SAMPLE_RATE_96: n_val = 12288; break; case AUD_SAMPLE_RATE_176_4: n_val = 25088; break; case HAD_MAX_RATE: n_val = 24576; break; default: n_val = -EINVAL; break; } return n_val; } /* * Program HDMI audio N value * * @aud_samp_freq: sampling frequency of audio data * @n_param: N value, depends on aud_samp_freq * @intelhaddata: substream private data * * This function is called in the prepare callback. * It programs based on the audio and display sampling frequency */ static int had_prog_n(u32 aud_samp_freq, u32 *n_param, struct snd_intelhad *intelhaddata) { int n_val; if (intelhaddata->dp_output) { /* * According to DP specs, Maud and Naud values hold * a relationship, which is stated as: * Maud/Naud = 512 * fs / f_LS_Clk * where, fs is the sampling frequency of the audio stream * and Naud is 32768 for Async clock. */ n_val = DP_NAUD_VAL; } else n_val = had_calculate_n_value(aud_samp_freq); if (n_val < 0) return n_val; had_write_register(intelhaddata, AUD_N_ENABLE, (BIT(24) | n_val)); *n_param = n_val; return 0; } /* * PCM ring buffer handling * * The hardware provides a ring buffer with the fixed 4 buffer descriptors * (BDs). The driver maps these 4 BDs onto the PCM ring buffer. The mapping * moves at each period elapsed. The below illustrates how it works: * * At time=0 * PCM | 0 | 1 | 2 | 3 | 4 | 5 | .... |n-1| * BD | 0 | 1 | 2 | 3 | * * At time=1 (period elapsed) * PCM | 0 | 1 | 2 | 3 | 4 | 5 | .... |n-1| * BD | 1 | 2 | 3 | 0 | * * At time=2 (second period elapsed) * PCM | 0 | 1 | 2 | 3 | 4 | 5 | .... |n-1| * BD | 2 | 3 | 0 | 1 | * * The bd_head field points to the index of the BD to be read. It's also the * position to be filled at next. The pcm_head and the pcm_filled fields * point to the indices of the current position and of the next position to * be filled, respectively. For PCM buffer there are both _head and _filled * because they may be difference when nperiods > 4. For example, in the * example above at t=1, bd_head=1 and pcm_head=1 while pcm_filled=5: * * pcm_head (=1) --v v-- pcm_filled (=5) * PCM | 0 | 1 | 2 | 3 | 4 | 5 | .... |n-1| * BD | 1 | 2 | 3 | 0 | * bd_head (=1) --^ ^-- next to fill (= bd_head) * * For nperiods < 4, the remaining BDs out of 4 are marked as invalid, so that * the hardware skips those BDs in the loop. * * An exceptional setup is the case with nperiods=1. Since we have to update * BDs after finishing one BD processing, we'd need at least two BDs, where * both BDs point to the same content, the same address, the same size of the * whole PCM buffer. */ #define AUD_BUF_ADDR(x) (AUD_BUF_A_ADDR + (x) * HAD_REG_WIDTH) #define AUD_BUF_LEN(x) (AUD_BUF_A_LENGTH + (x) * HAD_REG_WIDTH) /* Set up a buffer descriptor at the "filled" position */ static void had_prog_bd(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata) { int idx = intelhaddata->bd_head; int ofs = intelhaddata->pcmbuf_filled * intelhaddata->period_bytes; u32 addr = substream->runtime->dma_addr + ofs; addr |= AUD_BUF_VALID; if (!substream->runtime->no_period_wakeup) addr |= AUD_BUF_INTR_EN; had_write_register(intelhaddata, AUD_BUF_ADDR(idx), addr); had_write_register(intelhaddata, AUD_BUF_LEN(idx), intelhaddata->period_bytes); /* advance the indices to the next */ intelhaddata->bd_head++; intelhaddata->bd_head %= intelhaddata->num_bds; intelhaddata->pcmbuf_filled++; intelhaddata->pcmbuf_filled %= substream->runtime->periods; } /* invalidate a buffer descriptor with the given index */ static void had_invalidate_bd(struct snd_intelhad *intelhaddata, int idx) { had_write_register(intelhaddata, AUD_BUF_ADDR(idx), 0); had_write_register(intelhaddata, AUD_BUF_LEN(idx), 0); } /* Initial programming of ring buffer */ static void had_init_ringbuf(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata) { struct snd_pcm_runtime *runtime = substream->runtime; int i, num_periods; num_periods = runtime->periods; intelhaddata->num_bds = min(num_periods, HAD_NUM_OF_RING_BUFS); /* set the minimum 2 BDs for num_periods=1 */ intelhaddata->num_bds = max(intelhaddata->num_bds, 2U); intelhaddata->period_bytes = frames_to_bytes(runtime, runtime->period_size); WARN_ON(intelhaddata->period_bytes & 0x3f); intelhaddata->bd_head = 0; intelhaddata->pcmbuf_head = 0; intelhaddata->pcmbuf_filled = 0; for (i = 0; i < HAD_NUM_OF_RING_BUFS; i++) { if (i < intelhaddata->num_bds) had_prog_bd(substream, intelhaddata); else /* invalidate the rest */ had_invalidate_bd(intelhaddata, i); } intelhaddata->bd_head = 0; /* reset at head again before starting */ } /* process a bd, advance to the next */ static void had_advance_ringbuf(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata) { int num_periods = substream->runtime->periods; /* reprogram the next buffer */ had_prog_bd(substream, intelhaddata); /* proceed to next */ intelhaddata->pcmbuf_head++; intelhaddata->pcmbuf_head %= num_periods; } /* process the current BD(s); * returns the current PCM buffer byte position, or -EPIPE for underrun. */ static int had_process_ringbuf(struct snd_pcm_substream *substream, struct snd_intelhad *intelhaddata) { int len, processed; unsigned long flags; processed = 0; spin_lock_irqsave(&intelhaddata->had_spinlock, flags); for (;;) { /* get the remaining bytes on the buffer */ had_read_register(intelhaddata, AUD_BUF_LEN(intelhaddata->bd_head), &len); if (len < 0 || len > intelhaddata->period_bytes) { dev_dbg(intelhaddata->dev, "Invalid buf length %d\n", len); len = -EPIPE; goto out; } if (len > 0) /* OK, this is the current buffer */ break; /* len=0 => already empty, check the next buffer */ if (++processed >= intelhaddata->num_bds) { len = -EPIPE; /* all empty? - report underrun */ goto out; } had_advance_ringbuf(substream, intelhaddata); } len = intelhaddata->period_bytes - len; len += intelhaddata->period_bytes * intelhaddata->pcmbuf_head; out: spin_unlock_irqrestore(&intelhaddata->had_spinlock, flags); return len; } /* called from irq handler */ static void had_process_buffer_done(struct snd_intelhad *intelhaddata) { struct snd_pcm_substream *substream; substream = had_substream_get(intelhaddata); if (!substream) return; /* no stream? - bail out */ if (!intelhaddata->connected) { snd_pcm_stop_xrun(substream); goto out; /* disconnected? - bail out */ } /* process or stop the stream */ if (had_process_ringbuf(substream, intelhaddata) < 0) snd_pcm_stop_xrun(substream); else snd_pcm_period_elapsed(substream); out: had_substream_put(intelhaddata); } /* * The interrupt status 'sticky' bits might not be cleared by * setting '1' to that bit once... */ static void wait_clear_underrun_bit(struct snd_intelhad *intelhaddata) { int i; u32 val; for (i = 0; i < 100; i++) { /* clear bit30, 31 AUD_HDMI_STATUS */ had_read_register(intelhaddata, AUD_HDMI_STATUS, &val); if (!(val & AUD_HDMI_STATUS_MASK_UNDERRUN)) return; udelay(100); cond_resched(); had_write_register(intelhaddata, AUD_HDMI_STATUS, val); } dev_err(intelhaddata->dev, "Unable to clear UNDERRUN bits\n"); } /* Perform some reset procedure after stopping the stream; * this is called from prepare or hw_free callbacks once after trigger STOP * or underrun has been processed in order to settle down the h/w state. */ static int had_pcm_sync_stop(struct snd_pcm_substream *substream) { struct snd_intelhad *intelhaddata = snd_pcm_substream_chip(substream); if (!intelhaddata->connected) return 0; /* Reset buffer pointers */ had_reset_audio(intelhaddata); wait_clear_underrun_bit(intelhaddata); return 0; } /* called from irq handler */ static void had_process_buffer_underrun(struct snd_intelhad *intelhaddata) { struct snd_pcm_substream *substream; /* Report UNDERRUN error to above layers */ substream = had_substream_get(intelhaddata); if (substream) { snd_pcm_stop_xrun(substream); had_substream_put(intelhaddata); } } /* * ALSA PCM open callback */ static int had_pcm_open(struct snd_pcm_substream *substream) { struct snd_intelhad *intelhaddata; struct snd_pcm_runtime *runtime; int retval; intelhaddata = snd_pcm_substream_chip(substream); runtime = substream->runtime; retval = pm_runtime_resume_and_get(intelhaddata->dev); if (retval < 0) return retval; /* set the runtime hw parameter with local snd_pcm_hardware struct */ runtime->hw = had_pcm_hardware; retval = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); if (retval < 0) goto error; /* Make sure, that the period size is always aligned * 64byte boundary */ retval = snd_pcm_hw_constraint_step(substream->runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64); if (retval < 0) goto error; retval = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24); if (retval < 0) goto error; /* expose PCM substream */ spin_lock_irq(&intelhaddata->had_spinlock); intelhaddata->stream_info.substream = substream; intelhaddata->stream_info.substream_refcount++; spin_unlock_irq(&intelhaddata->had_spinlock); return retval; error: pm_runtime_mark_last_busy(intelhaddata->dev); pm_runtime_put_autosuspend(intelhaddata->dev); return retval; } /* * ALSA PCM close callback */ static int had_pcm_close(struct snd_pcm_substream *substream) { struct snd_intelhad *intelhaddata; intelhaddata = snd_pcm_substream_chip(substream); /* unreference and sync with the pending PCM accesses */ spin_lock_irq(&intelhaddata->had_spinlock); intelhaddata->stream_info.substream = NULL; intelhaddata->stream_info.substream_refcount--; while (intelhaddata->stream_info.substream_refcount > 0) { spin_unlock_irq(&intelhaddata->had_spinlock); cpu_relax(); spin_lock_irq(&intelhaddata->had_spinlock); } spin_unlock_irq(&intelhaddata->had_spinlock); pm_runtime_mark_last_busy(intelhaddata->dev); pm_runtime_put_autosuspend(intelhaddata->dev); return 0; } /* * ALSA PCM hw_params callback */ static int had_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { struct snd_intelhad *intelhaddata; int buf_size; intelhaddata = snd_pcm_substream_chip(substream); buf_size = params_buffer_bytes(hw_params); dev_dbg(intelhaddata->dev, "%s:allocated memory = %d\n", __func__, buf_size); return 0; } /* * ALSA PCM trigger callback */ static int had_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { int retval = 0; struct snd_intelhad *intelhaddata; intelhaddata = snd_pcm_substream_chip(substream); spin_lock(&intelhaddata->had_spinlock); switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_RESUME: /* Enable Audio */ had_ack_irqs(intelhaddata); /* FIXME: do we need this? */ had_enable_audio(intelhaddata, true); break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* Disable Audio */ had_enable_audio(intelhaddata, false); break; default: retval = -EINVAL; } spin_unlock(&intelhaddata->had_spinlock); return retval; } /* * ALSA PCM prepare callback */ static int had_pcm_prepare(struct snd_pcm_substream *substream) { int retval; u32 disp_samp_freq, n_param; u32 link_rate = 0; struct snd_intelhad *intelhaddata; struct snd_pcm_runtime *runtime; intelhaddata = snd_pcm_substream_chip(substream); runtime = substream->runtime; dev_dbg(intelhaddata->dev, "period_size=%d\n", (int)frames_to_bytes(runtime, runtime->period_size)); dev_dbg(intelhaddata->dev, "periods=%d\n", runtime->periods); dev_dbg(intelhaddata->dev, "buffer_size=%d\n", (int)snd_pcm_lib_buffer_bytes(substream)); dev_dbg(intelhaddata->dev, "rate=%d\n", runtime->rate); dev_dbg(intelhaddata->dev, "channels=%d\n", runtime->channels); /* Get N value in KHz */ disp_samp_freq = intelhaddata->tmds_clock_speed; retval = had_prog_n(substream->runtime->rate, &n_param, intelhaddata); if (retval) { dev_err(intelhaddata->dev, "programming N value failed %#x\n", retval); goto prep_end; } if (intelhaddata->dp_output) link_rate = intelhaddata->link_rate; had_prog_cts(substream->runtime->rate, disp_samp_freq, link_rate, n_param, intelhaddata); had_prog_dip(substream, intelhaddata); retval = had_init_audio_ctrl(substream, intelhaddata); /* Prog buffer address */ had_init_ringbuf(substream, intelhaddata); /* * Program channel mapping in following order: * FL, FR, C, LFE, RL, RR */ had_write_register(intelhaddata, AUD_BUF_CH_SWAP, SWAP_LFE_CENTER); prep_end: return retval; } /* * ALSA PCM pointer callback */ static snd_pcm_uframes_t had_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_intelhad *intelhaddata; int len; intelhaddata = snd_pcm_substream_chip(substream); if (!intelhaddata->connected) return SNDRV_PCM_POS_XRUN; len = had_process_ringbuf(substream, intelhaddata); if (len < 0) return SNDRV_PCM_POS_XRUN; len = bytes_to_frames(substream->runtime, len); /* wrapping may happen when periods=1 */ len %= substream->runtime->buffer_size; return len; } /* * ALSA PCM ops */ static const struct snd_pcm_ops had_pcm_ops = { .open = had_pcm_open, .close = had_pcm_close, .hw_params = had_pcm_hw_params, .prepare = had_pcm_prepare, .trigger = had_pcm_trigger, .sync_stop = had_pcm_sync_stop, .pointer = had_pcm_pointer, }; /* process mode change of the running stream; called in mutex */ static int had_process_mode_change(struct snd_intelhad *intelhaddata) { struct snd_pcm_substream *substream; int retval = 0; u32 disp_samp_freq, n_param; u32 link_rate = 0; substream = had_substream_get(intelhaddata); if (!substream) return 0; /* Disable Audio */ had_enable_audio(intelhaddata, false); /* Update CTS value */ disp_samp_freq = intelhaddata->tmds_clock_speed; retval = had_prog_n(substream->runtime->rate, &n_param, intelhaddata); if (retval) { dev_err(intelhaddata->dev, "programming N value failed %#x\n", retval); goto out; } if (intelhaddata->dp_output) link_rate = intelhaddata->link_rate; had_prog_cts(substream->runtime->rate, disp_samp_freq, link_rate, n_param, intelhaddata); /* Enable Audio */ had_enable_audio(intelhaddata, true); out: had_substream_put(intelhaddata); return retval; } /* process hot plug, called from wq with mutex locked */ static void had_process_hot_plug(struct snd_intelhad *intelhaddata) { struct snd_pcm_substream *substream; spin_lock_irq(&intelhaddata->had_spinlock); if (intelhaddata->connected) { dev_dbg(intelhaddata->dev, "Device already connected\n"); spin_unlock_irq(&intelhaddata->had_spinlock); return; } /* Disable Audio */ had_enable_audio(intelhaddata, false); intelhaddata->connected = true; dev_dbg(intelhaddata->dev, "%s @ %d:DEBUG PLUG/UNPLUG : HAD_DRV_CONNECTED\n", __func__, __LINE__); spin_unlock_irq(&intelhaddata->had_spinlock); had_build_channel_allocation_map(intelhaddata); /* Report to above ALSA layer */ substream = had_substream_get(intelhaddata); if (substream) { snd_pcm_stop_xrun(substream); had_substream_put(intelhaddata); } snd_jack_report(intelhaddata->jack, SND_JACK_AVOUT); } /* process hot unplug, called from wq with mutex locked */ static void had_process_hot_unplug(struct snd_intelhad *intelhaddata) { struct snd_pcm_substream *substream; spin_lock_irq(&intelhaddata->had_spinlock); if (!intelhaddata->connected) { dev_dbg(intelhaddata->dev, "Device already disconnected\n"); spin_unlock_irq(&intelhaddata->had_spinlock); return; } /* Disable Audio */ had_enable_audio(intelhaddata, false); intelhaddata->connected = false; dev_dbg(intelhaddata->dev, "%s @ %d:DEBUG PLUG/UNPLUG : HAD_DRV_DISCONNECTED\n", __func__, __LINE__); spin_unlock_irq(&intelhaddata->had_spinlock); kfree(intelhaddata->chmap->chmap); intelhaddata->chmap->chmap = NULL; /* Report to above ALSA layer */ substream = had_substream_get(intelhaddata); if (substream) { snd_pcm_stop_xrun(substream); had_substream_put(intelhaddata); } snd_jack_report(intelhaddata->jack, 0); } /* * ALSA iec958 and ELD controls */ static int had_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } static int had_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_intelhad *intelhaddata = snd_kcontrol_chip(kcontrol); mutex_lock(&intelhaddata->mutex); ucontrol->value.iec958.status[0] = (intelhaddata->aes_bits >> 0) & 0xff; ucontrol->value.iec958.status[1] = (intelhaddata->aes_bits >> 8) & 0xff; ucontrol->value.iec958.status[2] = (intelhaddata->aes_bits >> 16) & 0xff; ucontrol->value.iec958.status[3] = (intelhaddata->aes_bits >> 24) & 0xff; mutex_unlock(&intelhaddata->mutex); return 0; } static int had_iec958_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { ucontrol->value.iec958.status[0] = 0xff; ucontrol->value.iec958.status[1] = 0xff; ucontrol->value.iec958.status[2] = 0xff; ucontrol->value.iec958.status[3] = 0xff; return 0; } static int had_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { unsigned int val; struct snd_intelhad *intelhaddata = snd_kcontrol_chip(kcontrol); int changed = 0; val = (ucontrol->value.iec958.status[0] << 0) | (ucontrol->value.iec958.status[1] << 8) | (ucontrol->value.iec958.status[2] << 16) | (ucontrol->value.iec958.status[3] << 24); mutex_lock(&intelhaddata->mutex); if (intelhaddata->aes_bits != val) { intelhaddata->aes_bits = val; changed = 1; } mutex_unlock(&intelhaddata->mutex); return changed; } static int had_ctl_eld_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; uinfo->count = HDMI_MAX_ELD_BYTES; return 0; } static int had_ctl_eld_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_intelhad *intelhaddata = snd_kcontrol_chip(kcontrol); mutex_lock(&intelhaddata->mutex); memcpy(ucontrol->value.bytes.data, intelhaddata->eld, HDMI_MAX_ELD_BYTES); mutex_unlock(&intelhaddata->mutex); return 0; } static const struct snd_kcontrol_new had_controls[] = { { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK), .info = had_iec958_info, /* shared */ .get = had_iec958_mask_get, }, { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), .info = had_iec958_info, .get = had_iec958_get, .put = had_iec958_put, }, { .access = (SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE), .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = "ELD", .info = had_ctl_eld_info, .get = had_ctl_eld_get, }, }; /* * audio interrupt handler */ static irqreturn_t display_pipe_interrupt_handler(int irq, void *dev_id) { struct snd_intelhad_card *card_ctx = dev_id; u32 audio_stat[3] = {}; int pipe, port; for_each_pipe(card_ctx, pipe) { /* use raw register access to ack IRQs even while disconnected */ audio_stat[pipe] = had_read_register_raw(card_ctx, pipe, AUD_HDMI_STATUS) & (HDMI_AUDIO_UNDERRUN | HDMI_AUDIO_BUFFER_DONE); if (audio_stat[pipe]) had_write_register_raw(card_ctx, pipe, AUD_HDMI_STATUS, audio_stat[pipe]); } for_each_port(card_ctx, port) { struct snd_intelhad *ctx = &card_ctx->pcm_ctx[port]; int pipe = ctx->pipe; if (pipe < 0) continue; if (audio_stat[pipe] & HDMI_AUDIO_BUFFER_DONE) had_process_buffer_done(ctx); if (audio_stat[pipe] & HDMI_AUDIO_UNDERRUN) had_process_buffer_underrun(ctx); } return IRQ_HANDLED; } /* * monitor plug/unplug notification from i915; just kick off the work */ static void notify_audio_lpe(struct platform_device *pdev, int port) { struct snd_intelhad_card *card_ctx = platform_get_drvdata(pdev); struct snd_intelhad *ctx; ctx = &card_ctx->pcm_ctx[single_port ? 0 : port]; if (single_port) ctx->port = port; schedule_work(&ctx->hdmi_audio_wq); } /* the work to handle monitor hot plug/unplug */ static void had_audio_wq(struct work_struct *work) { struct snd_intelhad *ctx = container_of(work, struct snd_intelhad, hdmi_audio_wq); struct intel_hdmi_lpe_audio_pdata *pdata = ctx->dev->platform_data; struct intel_hdmi_lpe_audio_port_pdata *ppdata = &pdata->port[ctx->port]; int ret; ret = pm_runtime_resume_and_get(ctx->dev); if (ret < 0) return; mutex_lock(&ctx->mutex); if (ppdata->pipe < 0) { dev_dbg(ctx->dev, "%s: Event: HAD_NOTIFY_HOT_UNPLUG : port = %d\n", __func__, ctx->port); memset(ctx->eld, 0, sizeof(ctx->eld)); /* clear the old ELD */ ctx->dp_output = false; ctx->tmds_clock_speed = 0; ctx->link_rate = 0; /* Shut down the stream */ had_process_hot_unplug(ctx); ctx->pipe = -1; } else { dev_dbg(ctx->dev, "%s: HAD_NOTIFY_ELD : port = %d, tmds = %d\n", __func__, ctx->port, ppdata->ls_clock); memcpy(ctx->eld, ppdata->eld, sizeof(ctx->eld)); ctx->dp_output = ppdata->dp_output; if (ctx->dp_output) { ctx->tmds_clock_speed = 0; ctx->link_rate = ppdata->ls_clock; } else { ctx->tmds_clock_speed = ppdata->ls_clock; ctx->link_rate = 0; } /* * Shut down the stream before we change * the pipe assignment for this pcm device */ had_process_hot_plug(ctx); ctx->pipe = ppdata->pipe; /* Restart the stream if necessary */ had_process_mode_change(ctx); } mutex_unlock(&ctx->mutex); pm_runtime_mark_last_busy(ctx->dev); pm_runtime_put_autosuspend(ctx->dev); } /* * Jack interface */ static int had_create_jack(struct snd_intelhad *ctx, struct snd_pcm *pcm) { char hdmi_str[32]; int err; snprintf(hdmi_str, sizeof(hdmi_str), "HDMI/DP,pcm=%d", pcm->device); err = snd_jack_new(ctx->card_ctx->card, hdmi_str, SND_JACK_AVOUT, &ctx->jack, true, false); if (err < 0) return err; ctx->jack->private_data = ctx; return 0; } /* * PM callbacks */ static int __maybe_unused hdmi_lpe_audio_suspend(struct device *dev) { struct snd_intelhad_card *card_ctx = dev_get_drvdata(dev); snd_power_change_state(card_ctx->card, SNDRV_CTL_POWER_D3hot); return 0; } static int __maybe_unused hdmi_lpe_audio_resume(struct device *dev) { struct snd_intelhad_card *card_ctx = dev_get_drvdata(dev); pm_runtime_mark_last_busy(dev); snd_power_change_state(card_ctx->card, SNDRV_CTL_POWER_D0); return 0; } /* release resources */ static void hdmi_lpe_audio_free(struct snd_card *card) { struct snd_intelhad_card *card_ctx = card->private_data; struct intel_hdmi_lpe_audio_pdata *pdata = card_ctx->dev->platform_data; int port; spin_lock_irq(&pdata->lpe_audio_slock); pdata->notify_audio_lpe = NULL; spin_unlock_irq(&pdata->lpe_audio_slock); for_each_port(card_ctx, port) { struct snd_intelhad *ctx = &card_ctx->pcm_ctx[port]; cancel_work_sync(&ctx->hdmi_audio_wq); } } /* * hdmi_lpe_audio_probe - start bridge with i915 * * This function is called when the i915 driver creates the * hdmi-lpe-audio platform device. */ static int __hdmi_lpe_audio_probe(struct platform_device *pdev) { struct snd_card *card; struct snd_intelhad_card *card_ctx; struct snd_intelhad *ctx; struct snd_pcm *pcm; struct intel_hdmi_lpe_audio_pdata *pdata; int irq; struct resource *res_mmio; int port, ret; pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "%s: quit: pdata not allocated by i915!!\n", __func__); return -EINVAL; } /* get resources */ irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; res_mmio = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res_mmio) { dev_err(&pdev->dev, "Could not get IO_MEM resources\n"); return -ENXIO; } /* create a card instance with ALSA framework */ ret = snd_devm_card_new(&pdev->dev, hdmi_card_index, hdmi_card_id, THIS_MODULE, sizeof(*card_ctx), &card); if (ret) return ret; card_ctx = card->private_data; card_ctx->dev = &pdev->dev; card_ctx->card = card; strcpy(card->driver, INTEL_HAD); strcpy(card->shortname, "Intel HDMI/DP LPE Audio"); strcpy(card->longname, "Intel HDMI/DP LPE Audio"); card_ctx->irq = -1; card->private_free = hdmi_lpe_audio_free; platform_set_drvdata(pdev, card_ctx); card_ctx->num_pipes = pdata->num_pipes; card_ctx->num_ports = single_port ? 1 : pdata->num_ports; for_each_port(card_ctx, port) { ctx = &card_ctx->pcm_ctx[port]; ctx->card_ctx = card_ctx; ctx->dev = card_ctx->dev; ctx->port = single_port ? -1 : port; ctx->pipe = -1; spin_lock_init(&ctx->had_spinlock); mutex_init(&ctx->mutex); INIT_WORK(&ctx->hdmi_audio_wq, had_audio_wq); } dev_dbg(&pdev->dev, "%s: mmio_start = 0x%x, mmio_end = 0x%x\n", __func__, (unsigned int)res_mmio->start, (unsigned int)res_mmio->end); card_ctx->mmio_start = devm_ioremap(&pdev->dev, res_mmio->start, (size_t)(resource_size(res_mmio))); if (!card_ctx->mmio_start) { dev_err(&pdev->dev, "Could not get ioremap\n"); return -EACCES; } /* setup interrupt handler */ ret = devm_request_irq(&pdev->dev, irq, display_pipe_interrupt_handler, 0, pdev->name, card_ctx); if (ret < 0) { dev_err(&pdev->dev, "request_irq failed\n"); return ret; } card_ctx->irq = irq; /* only 32bit addressable */ ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); if (ret) return ret; init_channel_allocations(); card_ctx->num_pipes = pdata->num_pipes; card_ctx->num_ports = single_port ? 1 : pdata->num_ports; for_each_port(card_ctx, port) { int i; ctx = &card_ctx->pcm_ctx[port]; ret = snd_pcm_new(card, INTEL_HAD, port, MAX_PB_STREAMS, MAX_CAP_STREAMS, &pcm); if (ret) return ret; /* setup private data which can be retrieved when required */ pcm->private_data = ctx; pcm->info_flags = 0; strscpy(pcm->name, card->shortname, strlen(card->shortname)); /* setup the ops for playback */ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &had_pcm_ops); /* allocate dma pages; * try to allocate 600k buffer as default which is large enough */ snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV_WC, card->dev, HAD_DEFAULT_BUFFER, HAD_MAX_BUFFER); /* create controls */ for (i = 0; i < ARRAY_SIZE(had_controls); i++) { struct snd_kcontrol *kctl; kctl = snd_ctl_new1(&had_controls[i], ctx); if (!kctl) return -ENOMEM; kctl->id.device = pcm->device; ret = snd_ctl_add(card, kctl); if (ret < 0) return ret; } /* Register channel map controls */ ret = had_register_chmap_ctls(ctx, pcm); if (ret < 0) return ret; ret = had_create_jack(ctx, pcm); if (ret < 0) return ret; } ret = snd_card_register(card); if (ret) return ret; spin_lock_irq(&pdata->lpe_audio_slock); pdata->notify_audio_lpe = notify_audio_lpe; spin_unlock_irq(&pdata->lpe_audio_slock); pm_runtime_set_autosuspend_delay(&pdev->dev, INTEL_HDMI_AUDIO_SUSPEND_DELAY_MS); pm_runtime_use_autosuspend(&pdev->dev); pm_runtime_enable(&pdev->dev); pm_runtime_mark_last_busy(&pdev->dev); pm_runtime_idle(&pdev->dev); dev_dbg(&pdev->dev, "%s: handle pending notification\n", __func__); for_each_port(card_ctx, port) { struct snd_intelhad *ctx = &card_ctx->pcm_ctx[port]; schedule_work(&ctx->hdmi_audio_wq); } return 0; } static int hdmi_lpe_audio_probe(struct platform_device *pdev) { return snd_card_free_on_error(&pdev->dev, __hdmi_lpe_audio_probe(pdev)); } static const struct dev_pm_ops hdmi_lpe_audio_pm = { SET_SYSTEM_SLEEP_PM_OPS(hdmi_lpe_audio_suspend, hdmi_lpe_audio_resume) }; static struct platform_driver hdmi_lpe_audio_driver = { .driver = { .name = "hdmi-lpe-audio", .pm = &hdmi_lpe_audio_pm, }, .probe = hdmi_lpe_audio_probe, }; module_platform_driver(hdmi_lpe_audio_driver); MODULE_ALIAS("platform:hdmi_lpe_audio"); MODULE_AUTHOR("Sailaja Bandarupalli <[email protected]>"); MODULE_AUTHOR("Ramesh Babu K V <[email protected]>"); MODULE_AUTHOR("Vaibhav Agarwal <[email protected]>"); MODULE_AUTHOR("Jerome Anand <[email protected]>"); MODULE_DESCRIPTION("Intel HDMI Audio driver"); MODULE_LICENSE("GPL v2");
linux-master
sound/x86/intel_hdmi_audio.c
/* * linux/sound/oss/dmasound/dmasound_core.c * * * OSS/Free compatible Atari TT/Falcon and Amiga DMA sound driver for * Linux/m68k * Extended to support Power Macintosh for Linux/ppc by Paul Mackerras * * (c) 1995 by Michael Schlueter & Michael Marte * * Michael Schlueter ([email protected]) did the basic structure of the VFS * interface and the u-law to signed byte conversion. * * Michael Marte ([email protected]) did the sound queue, * /dev/mixer, /dev/sndstat and complemented the VFS interface. He would like * to thank: * - Michael Schlueter for initial ideas and documentation on the MFP and * the DMA sound hardware. * - Therapy? for their CD 'Troublegum' which really made me rock. * * /dev/sndstat is based on code by Hannu Savolainen, the author of the * VoxWare family of drivers. * * This file is subject to the terms and conditions of the GNU General Public * License. See the file COPYING in the main directory of this archive * for more details. * * History: * * 1995/8/25 First release * * 1995/9/02 Roman Hodek: * - Fixed atari_stram_alloc() call, the timer * programming and several race conditions * 1995/9/14 Roman Hodek: * - After some discussion with Michael Schlueter, * revised the interrupt disabling * - Slightly speeded up U8->S8 translation by using * long operations where possible * - Added 4:3 interpolation for /dev/audio * * 1995/9/20 Torsten Scherer: * - Fixed a bug in sq_write and changed /dev/audio * converting to play at 12517Hz instead of 6258Hz. * * 1995/9/23 Torsten Scherer: * - Changed sq_interrupt() and sq_play() to pre-program * the DMA for another frame while there's still one * running. This allows the IRQ response to be * arbitrarily delayed and playing will still continue. * * 1995/10/14 Guenther Kelleter, Torsten Scherer: * - Better support for Falcon audio (the Falcon doesn't * raise an IRQ at the end of a frame, but at the * beginning instead!). uses 'if (codec_dma)' in lots * of places to simply switch between Falcon and TT * code. * * 1995/11/06 Torsten Scherer: * - Started introducing a hardware abstraction scheme * (may perhaps also serve for Amigas?) * - Can now play samples at almost all frequencies by * means of a more generalized expand routine * - Takes a good deal of care to cut data only at * sample sizes * - Buffer size is now a kernel runtime option * - Implemented fsync() & several minor improvements * Guenther Kelleter: * - Useful hints and bug fixes * - Cross-checked it for Falcons * * 1996/3/9 Geert Uytterhoeven: * - Support added for Amiga, A-law, 16-bit little * endian. * - Unification to drivers/sound/dmasound.c. * * 1996/4/6 Martin Mitchell: * - Updated to 1.3 kernel. * * 1996/6/13 Topi Kanerva: * - Fixed things that were broken (mainly the amiga * 14-bit routines) * - /dev/sndstat shows now the real hardware frequency * - The lowpass filter is disabled by default now * * 1996/9/25 Geert Uytterhoeven: * - Modularization * * 1998/6/10 Andreas Schwab: * - Converted to use sound_core * * 1999/12/28 Richard Zidlicky: * - Added support for Q40 * * 2000/2/27 Geert Uytterhoeven: * - Clean up and split the code into 4 parts: * o dmasound_core: machine-independent code * o dmasound_atari: Atari TT and Falcon support * o dmasound_awacs: Apple PowerMac support * o dmasound_paula: Amiga support * * 2000/3/25 Geert Uytterhoeven: * - Integration of dmasound_q40 * - Small clean ups * * 2001/01/26 [1.0] Iain Sandoe * - make /dev/sndstat show revision & edition info. * - since dmasound.mach.sq_setup() can fail on pmac * its type has been changed to int and the returns * are checked. * [1.1] - stop missing translations from being called. * 2001/02/08 [1.2] - remove unused translation tables & move machine- * specific tables to low-level. * - return correct info. for SNDCTL_DSP_GETFMTS. * [1.3] - implement SNDCTL_DSP_GETCAPS fully. * [1.4] - make /dev/sndstat text length usage deterministic. * - make /dev/sndstat call to low-level * dmasound.mach.state_info() pass max space to ll driver. * - tidy startup banners and output info. * [1.5] - tidy up a little (removed some unused #defines in * dmasound.h) * - fix up HAS_RECORD conditionalisation. * - add record code in places it is missing... * - change buf-sizes to bytes to allow < 1kb for pmac * if user param entry is < 256 the value is taken to * be in kb > 256 is taken to be in bytes. * - make default buff/frag params conditional on * machine to allow smaller values for pmac. * - made the ioctls, read & write comply with the OSS * rules on setting params. * - added parsing of _setup() params for record. * 2001/04/04 [1.6] - fix bug where sample rates higher than maximum were * being reported as OK. * - fix open() to return -EBUSY as per OSS doc. when * audio is in use - this is independent of O_NOBLOCK. * - fix bug where SNDCTL_DSP_POST was blocking. */ /* Record capability notes 30/01/2001: * At present these observations apply only to pmac LL driver (the only one * that can do record, at present). However, if other LL drivers for machines * with record are added they may apply. * * The fragment parameters for the record and play channels are separate. * However, if the driver is opened O_RDWR there is no way (in the current OSS * API) to specify their values independently for the record and playback * channels. Since the only common factor between the input & output is the * sample rate (on pmac) it should be possible to open /dev/dspX O_WRONLY and * /dev/dspY O_RDONLY. The input & output channels could then have different * characteristics (other than the first that sets sample rate claiming the * right to set it for ever). As it stands, the format, channels, number of * bits & sample rate are assumed to be common. In the future perhaps these * should be the responsibility of the LL driver - and then if a card really * does not share items between record & playback they can be specified * separately. */ /* Thread-safeness of shared_resources notes: 31/01/2001 * If the user opens O_RDWR and then splits record & play between two threads * both of which inherit the fd - and then starts changing things from both * - we will have difficulty telling. * * It's bad application coding - but ... * TODO: think about how to sort this out... without bogging everything down in * semaphores. * * Similarly, the OSS spec says "all changes to parameters must be between * open() and the first read() or write(). - and a bit later on (by * implication) "between SNDCTL_DSP_RESET and the first read() or write() after * it". If the app is multi-threaded and this rule is broken between threads * we will have trouble spotting it - and the fault will be rather obscure :-( * * We will try and put out at least a kmsg if we see it happen... but I think * it will be quite hard to trap it with an -EXXX return... because we can't * see the fault until after the damage is done. */ #include <linux/module.h> #include <linux/slab.h> #include <linux/sound.h> #include <linux/init.h> #include <linux/soundcard.h> #include <linux/poll.h> #include <linux/mutex.h> #include <linux/sched/signal.h> #include <linux/uaccess.h> #include "dmasound.h" #define DMASOUND_CORE_REVISION 1 #define DMASOUND_CORE_EDITION 6 /* * Declarations */ static DEFINE_MUTEX(dmasound_core_mutex); int dmasound_catchRadius = 0; module_param(dmasound_catchRadius, int, 0); static unsigned int numWriteBufs = DEFAULT_N_BUFFERS; module_param(numWriteBufs, int, 0); static unsigned int writeBufSize = DEFAULT_BUFF_SIZE ; /* in bytes */ module_param(writeBufSize, int, 0); MODULE_LICENSE("GPL"); static int sq_unit = -1; static int mixer_unit = -1; static int state_unit = -1; static int irq_installed; /* control over who can modify resources shared between play/record */ static fmode_t shared_resource_owner; static int shared_resources_initialised; /* * Mid level stuff */ struct sound_settings dmasound = { .lock = __SPIN_LOCK_UNLOCKED(dmasound.lock) }; static inline void sound_silence(void) { dmasound.mach.silence(); /* _MUST_ stop DMA */ } static inline int sound_set_format(int format) { return dmasound.mach.setFormat(format); } static int sound_set_speed(int speed) { if (speed < 0) return dmasound.soft.speed; /* trap out-of-range speed settings. at present we allow (arbitrarily) low rates - using soft up-conversion - but we can't allow > max because there is no soft down-conversion. */ if (dmasound.mach.max_dsp_speed && (speed > dmasound.mach.max_dsp_speed)) speed = dmasound.mach.max_dsp_speed ; dmasound.soft.speed = speed; if (dmasound.minDev == SND_DEV_DSP) dmasound.dsp.speed = dmasound.soft.speed; return dmasound.soft.speed; } static int sound_set_stereo(int stereo) { if (stereo < 0) return dmasound.soft.stereo; stereo = !!stereo; /* should be 0 or 1 now */ dmasound.soft.stereo = stereo; if (dmasound.minDev == SND_DEV_DSP) dmasound.dsp.stereo = stereo; return stereo; } static ssize_t sound_copy_translate(TRANS *trans, const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t (*ct_func)(const u_char __user *, size_t, u_char *, ssize_t *, ssize_t); switch (dmasound.soft.format) { case AFMT_MU_LAW: ct_func = trans->ct_ulaw; break; case AFMT_A_LAW: ct_func = trans->ct_alaw; break; case AFMT_S8: ct_func = trans->ct_s8; break; case AFMT_U8: ct_func = trans->ct_u8; break; case AFMT_S16_BE: ct_func = trans->ct_s16be; break; case AFMT_U16_BE: ct_func = trans->ct_u16be; break; case AFMT_S16_LE: ct_func = trans->ct_s16le; break; case AFMT_U16_LE: ct_func = trans->ct_u16le; break; default: return 0; } /* if the user has requested a non-existent translation don't try to call it but just return 0 bytes moved */ if (ct_func) return ct_func(userPtr, userCount, frame, frameUsed, frameLeft); return 0; } /* * /dev/mixer abstraction */ static struct { int busy; int modify_counter; } mixer; static int mixer_open(struct inode *inode, struct file *file) { mutex_lock(&dmasound_core_mutex); if (!try_module_get(dmasound.mach.owner)) { mutex_unlock(&dmasound_core_mutex); return -ENODEV; } mixer.busy = 1; mutex_unlock(&dmasound_core_mutex); return 0; } static int mixer_release(struct inode *inode, struct file *file) { mutex_lock(&dmasound_core_mutex); mixer.busy = 0; module_put(dmasound.mach.owner); mutex_unlock(&dmasound_core_mutex); return 0; } static int mixer_ioctl(struct file *file, u_int cmd, u_long arg) { if (_SIOC_DIR(cmd) & _SIOC_WRITE) mixer.modify_counter++; switch (cmd) { case OSS_GETVERSION: return IOCTL_OUT(arg, SOUND_VERSION); case SOUND_MIXER_INFO: { mixer_info info; memset(&info, 0, sizeof(info)); strscpy(info.id, dmasound.mach.name2, sizeof(info.id)); strscpy(info.name, dmasound.mach.name2, sizeof(info.name)); info.modify_counter = mixer.modify_counter; if (copy_to_user((void __user *)arg, &info, sizeof(info))) return -EFAULT; return 0; } } if (dmasound.mach.mixer_ioctl) return dmasound.mach.mixer_ioctl(cmd, arg); return -EINVAL; } static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) { int ret; mutex_lock(&dmasound_core_mutex); ret = mixer_ioctl(file, cmd, arg); mutex_unlock(&dmasound_core_mutex); return ret; } static const struct file_operations mixer_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .unlocked_ioctl = mixer_unlocked_ioctl, .compat_ioctl = compat_ptr_ioctl, .open = mixer_open, .release = mixer_release, }; static void mixer_init(void) { mixer_unit = register_sound_mixer(&mixer_fops, -1); if (mixer_unit < 0) return; mixer.busy = 0; dmasound.treble = 0; dmasound.bass = 0; if (dmasound.mach.mixer_init) dmasound.mach.mixer_init(); } /* * Sound queue stuff, the heart of the driver */ struct sound_queue dmasound_write_sq; static void sq_reset_output(void) ; static int sq_allocate_buffers(struct sound_queue *sq, int num, int size) { int i; if (sq->buffers) return 0; sq->numBufs = num; sq->bufSize = size; sq->buffers = kmalloc_array (num, sizeof(char *), GFP_KERNEL); if (!sq->buffers) return -ENOMEM; for (i = 0; i < num; i++) { sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL); if (!sq->buffers[i]) { while (i--) dmasound.mach.dma_free(sq->buffers[i], size); kfree(sq->buffers); sq->buffers = NULL; return -ENOMEM; } } return 0; } static void sq_release_buffers(struct sound_queue *sq) { int i; if (sq->buffers) { for (i = 0; i < sq->numBufs; i++) dmasound.mach.dma_free(sq->buffers[i], sq->bufSize); kfree(sq->buffers); sq->buffers = NULL; } } static int sq_setup(struct sound_queue *sq) { int (*setup_func)(void) = NULL; int hard_frame ; if (sq->locked) { /* are we already set? - and not changeable */ #ifdef DEBUG_DMASOUND printk("dmasound_core: tried to sq_setup a locked queue\n") ; #endif return -EINVAL ; } sq->locked = 1 ; /* don't think we have a race prob. here _check_ */ /* make sure that the parameters are set up This should have been done already... */ dmasound.mach.init(); /* OK. If the user has set fragment parameters explicitly, then we should leave them alone... as long as they are valid. Invalid user fragment params can occur if we allow the whole buffer to be used when the user requests the fragments sizes (with no soft x-lation) and then the user subsequently sets a soft x-lation that requires increased internal buffering. Othwerwise (if the user did not set them) OSS says that we should select frag params on the basis of 0.5 s output & 0.1 s input latency. (TODO. For now we will copy in the defaults.) */ if (sq->user_frags <= 0) { sq->max_count = sq->numBufs ; sq->max_active = sq->numBufs ; sq->block_size = sq->bufSize; /* set up the user info */ sq->user_frags = sq->numBufs ; sq->user_frag_size = sq->bufSize ; sq->user_frag_size *= (dmasound.soft.size * (dmasound.soft.stereo+1) ) ; sq->user_frag_size /= (dmasound.hard.size * (dmasound.hard.stereo+1) ) ; } else { /* work out requested block size */ sq->block_size = sq->user_frag_size ; sq->block_size *= (dmasound.hard.size * (dmasound.hard.stereo+1) ) ; sq->block_size /= (dmasound.soft.size * (dmasound.soft.stereo+1) ) ; /* the user wants to write frag-size chunks */ sq->block_size *= dmasound.hard.speed ; sq->block_size /= dmasound.soft.speed ; /* this only works for size values which are powers of 2 */ hard_frame = (dmasound.hard.size * (dmasound.hard.stereo+1))/8 ; sq->block_size += (hard_frame - 1) ; sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */ /* let's just check for obvious mistakes */ if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) { #ifdef DEBUG_DMASOUND printk("dmasound_core: invalid frag size (user set %d)\n", sq->user_frag_size) ; #endif sq->block_size = sq->bufSize ; } if ( sq->user_frags <= sq->numBufs ) { sq->max_count = sq->user_frags ; /* if user has set max_active - then use it */ sq->max_active = (sq->max_active <= sq->max_count) ? sq->max_active : sq->max_count ; } else { #ifdef DEBUG_DMASOUND printk("dmasound_core: invalid frag count (user set %d)\n", sq->user_frags) ; #endif sq->max_count = sq->max_active = sq->numBufs ; } } sq->front = sq->count = sq->rear_size = 0; sq->syncing = 0; sq->active = 0; if (sq == &write_sq) { sq->rear = -1; setup_func = dmasound.mach.write_sq_setup; } if (setup_func) return setup_func(); return 0 ; } static inline void sq_play(void) { dmasound.mach.play(); } static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft, loff_t *ppos) { ssize_t uWritten = 0; u_char *dest; ssize_t uUsed = 0, bUsed, bLeft; unsigned long flags ; /* ++TeSche: Is something like this necessary? * Hey, that's an honest question! Or does any other part of the * filesystem already checks this situation? I really don't know. */ if (uLeft == 0) return 0; /* implement any changes we have made to the soft/hard params. this is not satisfactory really, all we have done up to now is to say what we would like - there hasn't been any real checking of capability */ if (shared_resources_initialised == 0) { dmasound.mach.init() ; shared_resources_initialised = 1 ; } /* set up the sq if it is not already done. This may seem a dumb place to do it - but it is what OSS requires. It means that write() can return memory allocation errors. To avoid this possibility use the GETBLKSIZE or GETOSPACE ioctls (after you've fiddled with all the params you want to change) - these ioctls also force the setup. */ if (write_sq.locked == 0) { if ((uWritten = sq_setup(&write_sq)) < 0) return uWritten ; uWritten = 0 ; } /* FIXME: I think that this may be the wrong behaviour when we get strapped for time and the cpu is close to being (or actually) behind in sending data. - because we've lost the time that the N samples, already in the buffer, would have given us to get here with the next lot from the user. */ /* The interrupt doesn't start to play the last, incomplete frame. * Thus we can append to it without disabling the interrupts! (Note * also that write_sq.rear isn't affected by the interrupt.) */ /* as of 1.6 this behaviour changes if SNDCTL_DSP_POST has been issued: this will mimic the behaviour of syncing and allow the sq_play() to queue a partial fragment. Since sq_play() may/will be called from the IRQ handler - at least on Pmac we have to deal with it. The strategy - possibly not optimum - is to kill _POST status if we get here. This seems, at least, reasonable - in the sense that POST is supposed to indicate that we might not write before the queue is drained - and if we get here in time then it does not apply. */ spin_lock_irqsave(&dmasound.lock, flags); write_sq.syncing &= ~2 ; /* take out POST status */ spin_unlock_irqrestore(&dmasound.lock, flags); if (write_sq.count > 0 && (bLeft = write_sq.block_size-write_sq.rear_size) > 0) { dest = write_sq.buffers[write_sq.rear]; bUsed = write_sq.rear_size; uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft, dest, &bUsed, bLeft); if (uUsed <= 0) return uUsed; src += uUsed; uWritten += uUsed; uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */ write_sq.rear_size = bUsed; } while (uLeft) { DEFINE_WAIT(wait); while (write_sq.count >= write_sq.max_active) { prepare_to_wait(&write_sq.action_queue, &wait, TASK_INTERRUPTIBLE); sq_play(); if (write_sq.non_blocking) { finish_wait(&write_sq.action_queue, &wait); return uWritten > 0 ? uWritten : -EAGAIN; } if (write_sq.count < write_sq.max_active) break; schedule_timeout(HZ); if (signal_pending(current)) { finish_wait(&write_sq.action_queue, &wait); return uWritten > 0 ? uWritten : -EINTR; } } finish_wait(&write_sq.action_queue, &wait); /* Here, we can avoid disabling the interrupt by first * copying and translating the data, and then updating * the write_sq variables. Until this is done, the interrupt * won't see the new frame and we can work on it * undisturbed. */ dest = write_sq.buffers[(write_sq.rear+1) % write_sq.max_count]; bUsed = 0; bLeft = write_sq.block_size; uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft, dest, &bUsed, bLeft); if (uUsed <= 0) break; src += uUsed; uWritten += uUsed; uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */ if (bUsed) { write_sq.rear = (write_sq.rear+1) % write_sq.max_count; write_sq.rear_size = bUsed; write_sq.count++; } } /* uUsed may have been 0 */ sq_play(); return uUsed < 0? uUsed: uWritten; } static __poll_t sq_poll(struct file *file, struct poll_table_struct *wait) { __poll_t mask = 0; int retVal; if (write_sq.locked == 0) { if ((retVal = sq_setup(&write_sq)) < 0) return retVal; return 0; } if (file->f_mode & FMODE_WRITE ) poll_wait(file, &write_sq.action_queue, wait); if (file->f_mode & FMODE_WRITE) if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0) mask |= EPOLLOUT | EPOLLWRNORM; return mask; } static inline void sq_init_waitqueue(struct sound_queue *sq) { init_waitqueue_head(&sq->action_queue); init_waitqueue_head(&sq->open_queue); init_waitqueue_head(&sq->sync_queue); sq->busy = 0; } #if 0 /* blocking open() */ static inline void sq_wake_up(struct sound_queue *sq, struct file *file, fmode_t mode) { if (file->f_mode & mode) { sq->busy = 0; /* CHECK: IS THIS OK??? */ WAKE_UP(sq->open_queue); } } #endif static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode, int numbufs, int bufsize) { int rc = 0; if (file->f_mode & mode) { if (sq->busy) { #if 0 /* blocking open() */ rc = -EBUSY; if (file->f_flags & O_NONBLOCK) return rc; rc = -EINTR; if (wait_event_interruptible(sq->open_queue, !sq->busy)) return rc; rc = 0; #else /* OSS manual says we will return EBUSY regardless of O_NOBLOCK. */ return -EBUSY ; #endif } sq->busy = 1; /* Let's play spot-the-race-condition */ /* allocate the default number & size of buffers. (i.e. specified in _setup() or as module params) can't be changed at the moment - but _could_ be perhaps in the setfragments ioctl. */ if (( rc = sq_allocate_buffers(sq, numbufs, bufsize))) { #if 0 /* blocking open() */ sq_wake_up(sq, file, mode); #else sq->busy = 0 ; #endif return rc; } sq->non_blocking = file->f_flags & O_NONBLOCK; } return rc; } #define write_sq_init_waitqueue() sq_init_waitqueue(&write_sq) #if 0 /* blocking open() */ #define write_sq_wake_up(file) sq_wake_up(&write_sq, file, FMODE_WRITE) #endif #define write_sq_release_buffers() sq_release_buffers(&write_sq) #define write_sq_open(file) \ sq_open2(&write_sq, file, FMODE_WRITE, numWriteBufs, writeBufSize ) static int sq_open(struct inode *inode, struct file *file) { int rc; mutex_lock(&dmasound_core_mutex); if (!try_module_get(dmasound.mach.owner)) { mutex_unlock(&dmasound_core_mutex); return -ENODEV; } rc = write_sq_open(file); /* checks the f_mode */ if (rc) goto out; if (file->f_mode & FMODE_READ) { /* TODO: if O_RDWR, release any resources grabbed by write part */ rc = -ENXIO ; /* I think this is what is required by open(2) */ goto out; } if (dmasound.mach.sq_open) dmasound.mach.sq_open(file->f_mode); /* CHECK whether this is sensible - in the case that dsp0 could be opened O_RDONLY and dsp1 could be opened O_WRONLY */ dmasound.minDev = iminor(inode) & 0x0f; /* OK. - we should make some attempt at consistency. At least the H'ware options should be set with a valid mode. We will make it that the LL driver must supply defaults for hard & soft params. */ if (shared_resource_owner == 0) { /* you can make this AFMT_U8/mono/8K if you want to mimic old OSS behaviour - while we still have soft translations ;-) */ dmasound.soft = dmasound.mach.default_soft ; dmasound.dsp = dmasound.mach.default_soft ; dmasound.hard = dmasound.mach.default_hard ; } #ifndef DMASOUND_STRICT_OSS_COMPLIANCE /* none of the current LL drivers can actually do this "native" at the moment OSS does not really require us to supply /dev/audio if we can't do it. */ if (dmasound.minDev == SND_DEV_AUDIO) { sound_set_speed(8000); sound_set_stereo(0); sound_set_format(AFMT_MU_LAW); } #endif mutex_unlock(&dmasound_core_mutex); return 0; out: module_put(dmasound.mach.owner); mutex_unlock(&dmasound_core_mutex); return rc; } static void sq_reset_output(void) { sound_silence(); /* this _must_ stop DMA, we might be about to lose the buffers */ write_sq.active = 0; write_sq.count = 0; write_sq.rear_size = 0; /* write_sq.front = (write_sq.rear+1) % write_sq.max_count;*/ write_sq.front = 0 ; write_sq.rear = -1 ; /* same as for set-up */ /* OK - we can unlock the parameters and fragment settings */ write_sq.locked = 0 ; write_sq.user_frags = 0 ; write_sq.user_frag_size = 0 ; } static void sq_reset(void) { sq_reset_output() ; /* we could consider resetting the shared_resources_owner here... but I think it is probably still rather non-obvious to application writer */ /* we release everything else though */ shared_resources_initialised = 0 ; } static int sq_fsync(void) { int rc = 0; int timeout = 5; write_sq.syncing |= 1; sq_play(); /* there may be an incomplete frame waiting */ while (write_sq.active) { wait_event_interruptible_timeout(write_sq.sync_queue, !write_sq.active, HZ); if (signal_pending(current)) { /* While waiting for audio output to drain, an * interrupt occurred. Stop audio output immediately * and clear the queue. */ sq_reset_output(); rc = -EINTR; break; } if (!--timeout) { printk(KERN_WARNING "dmasound: Timeout draining output\n"); sq_reset_output(); rc = -EIO; break; } } /* flag no sync regardless of whether we had a DSP_POST or not */ write_sq.syncing = 0 ; return rc; } static int sq_release(struct inode *inode, struct file *file) { int rc = 0; mutex_lock(&dmasound_core_mutex); if (file->f_mode & FMODE_WRITE) { if (write_sq.busy) rc = sq_fsync(); sq_reset_output() ; /* make sure dma is stopped and all is quiet */ write_sq_release_buffers(); write_sq.busy = 0; } if (file->f_mode & shared_resource_owner) { /* it's us that has them */ shared_resource_owner = 0 ; shared_resources_initialised = 0 ; dmasound.hard = dmasound.mach.default_hard ; } module_put(dmasound.mach.owner); #if 0 /* blocking open() */ /* Wake up a process waiting for the queue being released. * Note: There may be several processes waiting for a call * to open() returning. */ /* Iain: hmm I don't understand this next comment ... */ /* There is probably a DOS atack here. They change the mode flag. */ /* XXX add check here,*/ read_sq_wake_up(file); /* checks f_mode */ write_sq_wake_up(file); /* checks f_mode */ #endif /* blocking open() */ mutex_unlock(&dmasound_core_mutex); return rc; } /* here we see if we have a right to modify format, channels, size and so on if no-one else has claimed it already then we do... TODO: We might change this to mask O_RDWR such that only one or the other channel is the owner - if we have problems. */ static int shared_resources_are_mine(fmode_t md) { if (shared_resource_owner) return (shared_resource_owner & md) != 0; else { shared_resource_owner = md ; return 1 ; } } /* if either queue is locked we must deny the right to change shared params */ static int queues_are_quiescent(void) { if (write_sq.locked) return 0 ; return 1 ; } /* check and set a queue's fragments per user's wishes... we will check against the pre-defined literals and the actual sizes. This is a bit fraught - because soft translations can mess with our buffer requirements *after* this call - OSS says "call setfrags first" */ /* It is possible to replace all the -EINVAL returns with an override that just puts the allowable value in. This may be what many OSS apps require */ static int set_queue_frags(struct sound_queue *sq, int bufs, int size) { if (sq->locked) { #ifdef DEBUG_DMASOUND printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ; #endif return -EINVAL ; } if ((size < MIN_FRAG_SIZE) || (size > MAX_FRAG_SIZE)) return -EINVAL ; size = (1<<size) ; /* now in bytes */ if (size > sq->bufSize) return -EINVAL ; /* this might still not work */ if (bufs <= 0) return -EINVAL ; if (bufs > sq->numBufs) /* the user is allowed say "don't care" with 0x7fff */ bufs = sq->numBufs ; /* there is, currently, no way to specify max_active separately from max_count. This could be a LL driver issue - I guess if there is a requirement for these values to be different then we will have to pass that info. up to this level. */ sq->user_frags = sq->max_active = bufs ; sq->user_frag_size = size ; return 0 ; } static int sq_ioctl(struct file *file, u_int cmd, u_long arg) { int val, result; u_long fmt; int data; int size, nbufs; audio_buf_info info; switch (cmd) { case SNDCTL_DSP_RESET: sq_reset(); return 0; case SNDCTL_DSP_GETFMTS: fmt = dmasound.mach.hardware_afmts ; /* this is what OSS says.. */ return IOCTL_OUT(arg, fmt); case SNDCTL_DSP_GETBLKSIZE: /* this should tell the caller about bytes that the app can read/write - the app doesn't care about our internal buffers. We force sq_setup() here as per OSS 1.1 (which should compute the values necessary). Since there is no mechanism to specify read/write separately, for fds opened O_RDWR, the write_sq values will, arbitrarily, overwrite the read_sq ones. */ size = 0 ; if (file->f_mode & FMODE_WRITE) { if ( !write_sq.locked ) sq_setup(&write_sq) ; size = write_sq.user_frag_size ; } return IOCTL_OUT(arg, size); case SNDCTL_DSP_POST: /* all we are going to do is to tell the LL that any partial frags can be queued for output. The LL will have to clear this flag when last output is queued. */ write_sq.syncing |= 0x2 ; sq_play() ; return 0 ; case SNDCTL_DSP_SYNC: /* This call, effectively, has the same behaviour as SNDCTL_DSP_RESET except that it waits for output to finish before resetting everything - read, however, is killed immediately. */ result = 0 ; if (file->f_mode & FMODE_WRITE) { result = sq_fsync(); sq_reset_output() ; } /* if we are the shared resource owner then release them */ if (file->f_mode & shared_resource_owner) shared_resources_initialised = 0 ; return result ; case SOUND_PCM_READ_RATE: return IOCTL_OUT(arg, dmasound.soft.speed); case SNDCTL_DSP_SPEED: /* changing this on the fly will have weird effects on the sound. Where there are rate conversions implemented in soft form - it will cause the _ctx_xxx() functions to be substituted. However, there doesn't appear to be any reason to dis-allow it from a driver pov. */ if (shared_resources_are_mine(file->f_mode)) { IOCTL_IN(arg, data); data = sound_set_speed(data) ; shared_resources_initialised = 0 ; return IOCTL_OUT(arg, data); } else return -EINVAL ; break ; /* OSS says these next 4 actions are undefined when the device is busy/active - we will just return -EINVAL. To be allowed to change one - (a) you have to own the right (b) the queue(s) must be quiescent */ case SNDCTL_DSP_STEREO: if (shared_resources_are_mine(file->f_mode) && queues_are_quiescent()) { IOCTL_IN(arg, data); shared_resources_initialised = 0 ; return IOCTL_OUT(arg, sound_set_stereo(data)); } else return -EINVAL ; break ; case SOUND_PCM_WRITE_CHANNELS: if (shared_resources_are_mine(file->f_mode) && queues_are_quiescent()) { IOCTL_IN(arg, data); /* the user might ask for 20 channels, we will return 1 or 2 */ shared_resources_initialised = 0 ; return IOCTL_OUT(arg, sound_set_stereo(data-1)+1); } else return -EINVAL ; break ; case SNDCTL_DSP_SETFMT: if (shared_resources_are_mine(file->f_mode) && queues_are_quiescent()) { int format; IOCTL_IN(arg, data); shared_resources_initialised = 0 ; format = sound_set_format(data); result = IOCTL_OUT(arg, format); if (result < 0) return result; if (format != data && data != AFMT_QUERY) return -EINVAL; return 0; } else return -EINVAL ; case SNDCTL_DSP_SUBDIVIDE: return -EINVAL ; case SNDCTL_DSP_SETFRAGMENT: /* we can do this independently for the two queues - with the proviso that for fds opened O_RDWR we cannot separate the actions and both queues will be set per the last call. NOTE: this does *NOT* actually set the queue up - merely registers our intentions. */ IOCTL_IN(arg, data); result = 0 ; nbufs = (data >> 16) & 0x7fff ; /* 0x7fff is 'use maximum' */ size = data & 0xffff; if (file->f_mode & FMODE_WRITE) { result = set_queue_frags(&write_sq, nbufs, size) ; if (result) return result ; } /* NOTE: this return value is irrelevant - OSS specifically says that the value is 'random' and that the user _must_ check the actual frags values using SNDCTL_DSP_GETBLKSIZE or similar */ return IOCTL_OUT(arg, data); case SNDCTL_DSP_GETOSPACE: /* */ if (file->f_mode & FMODE_WRITE) { if ( !write_sq.locked ) sq_setup(&write_sq) ; info.fragments = write_sq.max_active - write_sq.count; info.fragstotal = write_sq.max_active; info.fragsize = write_sq.user_frag_size; info.bytes = info.fragments * info.fragsize; if (copy_to_user((void __user *)arg, &info, sizeof(info))) return -EFAULT; return 0; } else return -EINVAL ; break ; case SNDCTL_DSP_GETCAPS: val = dmasound.mach.capabilities & 0xffffff00; return IOCTL_OUT(arg,val); default: return mixer_ioctl(file, cmd, arg); } return -EINVAL; } static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) { int ret; mutex_lock(&dmasound_core_mutex); ret = sq_ioctl(file, cmd, arg); mutex_unlock(&dmasound_core_mutex); return ret; } static const struct file_operations sq_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .write = sq_write, .poll = sq_poll, .unlocked_ioctl = sq_unlocked_ioctl, .compat_ioctl = compat_ptr_ioctl, .open = sq_open, .release = sq_release, }; static int sq_init(void) { const struct file_operations *fops = &sq_fops; sq_unit = register_sound_dsp(fops, -1); if (sq_unit < 0) { printk(KERN_ERR "dmasound_core: couldn't register fops\n") ; return sq_unit ; } write_sq_init_waitqueue(); /* These parameters will be restored for every clean open() * in the case of multiple open()s (e.g. dsp0 & dsp1) they * will be set so long as the shared resources have no owner. */ if (shared_resource_owner == 0) { dmasound.soft = dmasound.mach.default_soft ; dmasound.hard = dmasound.mach.default_hard ; dmasound.dsp = dmasound.mach.default_soft ; shared_resources_initialised = 0 ; } return 0 ; } /* * /dev/sndstat */ /* we allow more space for record-enabled because there are extra output lines. the number here must include the amount we are prepared to give to the low-level driver. */ #define STAT_BUFF_LEN 768 /* this is how much space we will allow the low-level driver to use in the stat buffer. Currently, 2 * (80 character line + <NL>). We do not police this (it is up to the ll driver to be honest). */ #define LOW_LEVEL_STAT_ALLOC 162 static struct { int busy; char buf[STAT_BUFF_LEN]; /* state.buf should not overflow! */ int len, ptr; } state; /* publish this function for use by low-level code, if required */ static char *get_afmt_string(int afmt) { switch(afmt) { case AFMT_MU_LAW: return "mu-law"; case AFMT_A_LAW: return "A-law"; case AFMT_U8: return "unsigned 8 bit"; case AFMT_S8: return "signed 8 bit"; case AFMT_S16_BE: return "signed 16 bit BE"; case AFMT_U16_BE: return "unsigned 16 bit BE"; case AFMT_S16_LE: return "signed 16 bit LE"; case AFMT_U16_LE: return "unsigned 16 bit LE"; case 0: return "format not set" ; default: break ; } return "ERROR: Unsupported AFMT_XXXX code" ; } static int state_open(struct inode *inode, struct file *file) { char *buffer = state.buf; int len = 0; int ret; mutex_lock(&dmasound_core_mutex); ret = -EBUSY; if (state.busy) goto out; ret = -ENODEV; if (!try_module_get(dmasound.mach.owner)) goto out; state.ptr = 0; state.busy = 1; len += sprintf(buffer+len, "%sDMA sound driver rev %03d :\n", dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) + ((dmasound.mach.version>>8) & 0x0f)); len += sprintf(buffer+len, "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n", DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2, (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ; /* call the low-level module to fill in any stat info. that it has if present. Maximum buffer usage is specified. */ if (dmasound.mach.state_info) len += dmasound.mach.state_info(buffer+len, (size_t) LOW_LEVEL_STAT_ALLOC) ; /* make usage of the state buffer as deterministic as poss. exceptional conditions could cause overrun - and this is flagged as a kernel error. */ /* formats and settings */ len += sprintf(buffer+len,"\t\t === Formats & settings ===\n") ; len += sprintf(buffer+len,"Parameter %20s%20s\n","soft","hard") ; len += sprintf(buffer+len,"Format :%20s%20s\n", get_afmt_string(dmasound.soft.format), get_afmt_string(dmasound.hard.format)); len += sprintf(buffer+len,"Samp Rate:%14d s/sec%14d s/sec\n", dmasound.soft.speed, dmasound.hard.speed); len += sprintf(buffer+len,"Channels :%20s%20s\n", dmasound.soft.stereo ? "stereo" : "mono", dmasound.hard.stereo ? "stereo" : "mono" ); /* sound queue status */ len += sprintf(buffer+len,"\t\t === Sound Queue status ===\n"); len += sprintf(buffer+len,"Allocated:%8s%6s\n","Buffers","Size") ; len += sprintf(buffer+len,"%9s:%8d%6d\n", "write", write_sq.numBufs, write_sq.bufSize) ; len += sprintf(buffer+len, "Current : MaxFrg FragSiz MaxAct Frnt Rear " "Cnt RrSize A B S L xruns\n") ; len += sprintf(buffer+len,"%9s:%7d%8d%7d%5d%5d%4d%7d%2d%2d%2d%2d%7d\n", "write", write_sq.max_count, write_sq.block_size, write_sq.max_active, write_sq.front, write_sq.rear, write_sq.count, write_sq.rear_size, write_sq.active, write_sq.busy, write_sq.syncing, write_sq.locked, write_sq.xruns) ; #ifdef DEBUG_DMASOUND printk("dmasound: stat buffer used %d bytes\n", len) ; #endif if (len >= STAT_BUFF_LEN) printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n"); state.len = len; ret = 0; out: mutex_unlock(&dmasound_core_mutex); return ret; } static int state_release(struct inode *inode, struct file *file) { mutex_lock(&dmasound_core_mutex); state.busy = 0; module_put(dmasound.mach.owner); mutex_unlock(&dmasound_core_mutex); return 0; } static ssize_t state_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { int n = state.len - state.ptr; if (n > count) n = count; if (n <= 0) return 0; if (copy_to_user(buf, &state.buf[state.ptr], n)) return -EFAULT; state.ptr += n; return n; } static const struct file_operations state_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .read = state_read, .open = state_open, .release = state_release, }; static int state_init(void) { state_unit = register_sound_special(&state_fops, SND_DEV_STATUS); if (state_unit < 0) return state_unit ; state.busy = 0; return 0 ; } /* * Config & Setup * * This function is called by _one_ chipset-specific driver */ int dmasound_init(void) { int res ; if (irq_installed) return -EBUSY; /* Set up sound queue, /dev/audio and /dev/dsp. */ /* Set default settings. */ if ((res = sq_init()) < 0) return res ; /* Set up /dev/sndstat. */ if ((res = state_init()) < 0) return res ; /* Set up /dev/mixer. */ mixer_init(); if (!dmasound.mach.irqinit()) { printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n"); return -ENODEV; } irq_installed = 1; printk(KERN_INFO "%s DMA sound driver rev %03d installed\n", dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) + ((dmasound.mach.version>>8) & 0x0f)); printk(KERN_INFO "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n", DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2, (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ; printk(KERN_INFO "Write will use %4d fragments of %7d bytes as default\n", numWriteBufs, writeBufSize) ; return 0; } void dmasound_deinit(void) { if (irq_installed) { sound_silence(); dmasound.mach.irqcleanup(); irq_installed = 0; } write_sq_release_buffers(); if (mixer_unit >= 0) unregister_sound_mixer(mixer_unit); if (state_unit >= 0) unregister_sound_special(state_unit); if (sq_unit >= 0) unregister_sound_dsp(sq_unit); } static int __maybe_unused dmasound_setup(char *str) { int ints[6], size; str = get_options(str, ARRAY_SIZE(ints), ints); /* check the bootstrap parameter for "dmasound=" */ /* FIXME: other than in the most naive of cases there is no sense in these * buffers being other than powers of two. This is not checked yet. */ switch (ints[0]) { case 3: if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS)) printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius); else catchRadius = ints[3]; fallthrough; case 2: if (ints[1] < MIN_BUFFERS) printk("dmasound_setup: invalid number of buffers, using default = %d\n", numWriteBufs); else numWriteBufs = ints[1]; fallthrough; case 1: if ((size = ints[2]) < 256) /* check for small buffer specs */ size <<= 10 ; if (size < MIN_BUFSIZE || size > MAX_BUFSIZE) printk("dmasound_setup: invalid write buffer size, using default = %d\n", writeBufSize); else writeBufSize = size; case 0: break; default: printk("dmasound_setup: invalid number of arguments\n"); return 0; } return 1; } __setup("dmasound=", dmasound_setup); /* * Conversion tables */ #ifdef HAS_8BIT_TABLES /* 8 bit mu-law */ char dmasound_ulaw2dma8[] = { -126, -122, -118, -114, -110, -106, -102, -98, -94, -90, -86, -82, -78, -74, -70, -66, -63, -61, -59, -57, -55, -53, -51, -49, -47, -45, -43, -41, -39, -37, -35, -33, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21, -20, -19, -18, -17, -16, -16, -15, -15, -14, -14, -13, -13, -12, -12, -11, -11, -10, -10, -9, -9, -8, -8, -8, -7, -7, -7, -7, -6, -6, -6, -6, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 125, 121, 117, 113, 109, 105, 101, 97, 93, 89, 85, 81, 77, 73, 69, 65, 62, 60, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 15, 14, 14, 13, 13, 12, 12, 11, 11, 10, 10, 9, 9, 8, 8, 7, 7, 7, 6, 6, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; /* 8 bit A-law */ char dmasound_alaw2dma8[] = { -22, -21, -24, -23, -18, -17, -20, -19, -30, -29, -32, -31, -26, -25, -28, -27, -11, -11, -12, -12, -9, -9, -10, -10, -15, -15, -16, -16, -13, -13, -14, -14, -86, -82, -94, -90, -70, -66, -78, -74, -118, -114, -126, -122, -102, -98, -110, -106, -43, -41, -47, -45, -35, -33, -39, -37, -59, -57, -63, -61, -51, -49, -55, -53, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -6, -6, -6, -6, -5, -5, -5, -5, -8, -8, -8, -8, -7, -7, -7, -7, -3, -3, -3, -3, -3, -3, -3, -3, -4, -4, -4, -4, -4, -4, -4, -4, 21, 20, 23, 22, 17, 16, 19, 18, 29, 28, 31, 30, 25, 24, 27, 26, 10, 10, 11, 11, 8, 8, 9, 9, 14, 14, 15, 15, 12, 12, 13, 13, 86, 82, 94, 90, 70, 66, 78, 74, 118, 114, 126, 122, 102, 98, 110, 106, 43, 41, 47, 45, 35, 33, 39, 37, 59, 57, 63, 61, 51, 49, 55, 53, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 4, 4, 4, 4, 7, 7, 7, 7, 6, 6, 6, 6, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 }; #endif /* HAS_8BIT_TABLES */ /* * Visible symbols for modules */ EXPORT_SYMBOL(dmasound); EXPORT_SYMBOL(dmasound_init); EXPORT_SYMBOL(dmasound_deinit); EXPORT_SYMBOL(dmasound_write_sq); EXPORT_SYMBOL(dmasound_catchRadius); #ifdef HAS_8BIT_TABLES EXPORT_SYMBOL(dmasound_ulaw2dma8); EXPORT_SYMBOL(dmasound_alaw2dma8); #endif
linux-master
sound/oss/dmasound/dmasound_core.c
// SPDX-License-Identifier: GPL-2.0-only /* * linux/sound/oss/dmasound/dmasound_paula.c * * Amiga `Paula' DMA Sound Driver * * See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits * prior to 28/01/2001 * * 28/01/2001 [0.1] Iain Sandoe * - added versioning * - put in and populated the hardware_afmts field. * [0.2] - put in SNDCTL_DSP_GETCAPS value. * [0.3] - put in constraint on state buffer usage. * [0.4] - put in default hard/soft settings */ #include <linux/module.h> #include <linux/mm.h> #include <linux/init.h> #include <linux/ioport.h> #include <linux/soundcard.h> #include <linux/interrupt.h> #include <linux/platform_device.h> #include <linux/uaccess.h> #include <asm/setup.h> #include <asm/amigahw.h> #include <asm/amigaints.h> #include <asm/machdep.h> #include "dmasound.h" #define DMASOUND_PAULA_REVISION 0 #define DMASOUND_PAULA_EDITION 4 #define custom amiga_custom /* * The minimum period for audio depends on htotal (for OCS/ECS/AGA) * (Imported from arch/m68k/amiga/amisound.c) */ extern volatile u_short amiga_audio_min_period; /* * amiga_mksound() should be able to restore the period after beeping * (Imported from arch/m68k/amiga/amisound.c) */ extern u_short amiga_audio_period; /* * Audio DMA masks */ #define AMI_AUDIO_OFF (DMAF_AUD0 | DMAF_AUD1 | DMAF_AUD2 | DMAF_AUD3) #define AMI_AUDIO_8 (DMAF_SETCLR | DMAF_MASTER | DMAF_AUD0 | DMAF_AUD1) #define AMI_AUDIO_14 (AMI_AUDIO_8 | DMAF_AUD2 | DMAF_AUD3) /* * Helper pointers for 16(14)-bit sound */ static int write_sq_block_size_half, write_sq_block_size_quarter; /*** Low level stuff *********************************************************/ static void *AmiAlloc(unsigned int size, gfp_t flags); static void AmiFree(void *obj, unsigned int size); static int AmiIrqInit(void); #ifdef MODULE static void AmiIrqCleanUp(void); #endif static void AmiSilence(void); static void AmiInit(void); static int AmiSetFormat(int format); static int AmiSetVolume(int volume); static int AmiSetTreble(int treble); static void AmiPlayNextFrame(int index); static void AmiPlay(void); static irqreturn_t AmiInterrupt(int irq, void *dummy); #ifdef CONFIG_HEARTBEAT /* * Heartbeat interferes with sound since the 7 kHz low-pass filter and the * power LED are controlled by the same line. */ static void (*saved_heartbeat)(int) = NULL; static inline void disable_heartbeat(void) { if (mach_heartbeat) { saved_heartbeat = mach_heartbeat; mach_heartbeat = NULL; } AmiSetTreble(dmasound.treble); } static inline void enable_heartbeat(void) { if (saved_heartbeat) mach_heartbeat = saved_heartbeat; } #else /* !CONFIG_HEARTBEAT */ #define disable_heartbeat() do { } while (0) #define enable_heartbeat() do { } while (0) #endif /* !CONFIG_HEARTBEAT */ /*** Mid level stuff *********************************************************/ static void AmiMixerInit(void); static int AmiMixerIoctl(u_int cmd, u_long arg); static int AmiWriteSqSetup(void); static int AmiStateInfo(char *buffer, size_t space); /*** Translations ************************************************************/ /* ++TeSche: radically changed for new expanding purposes... * * These two routines now deal with copying/expanding/translating the samples * from user space into our buffer at the right frequency. They take care about * how much data there's actually to read, how much buffer space there is and * to convert samples into the right frequency/encoding. They will only work on * complete samples so it may happen they leave some bytes in the input stream * if the user didn't write a multiple of the current sample size. They both * return the number of bytes they've used from both streams so you may detect * such a situation. Luckily all programs should be able to cope with that. * * I think I've optimized anything as far as one can do in plain C, all * variables should fit in registers and the loops are really short. There's * one loop for every possible situation. Writing a more generalized and thus * parameterized loop would only produce slower code. Feel free to optimize * this in assembler if you like. :) * * I think these routines belong here because they're not yet really hardware * independent, especially the fact that the Falcon can play 16bit samples * only in stereo is hardcoded in both of them! * * ++geert: split in even more functions (one per format) */ /* * Native format */ static ssize_t ami_ct_s8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; if (!dmasound.soft.stereo) { void *p = &frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft) & ~1; used = count; if (copy_from_user(p, userPtr, count)) return -EFAULT; } else { u_char *left = &frame[*frameUsed>>1]; u_char *right = left+write_sq_block_size_half; count = min_t(unsigned long, userCount, frameLeft)>>1 & ~1; used = count*2; while (count > 0) { if (get_user(*left++, userPtr++) || get_user(*right++, userPtr++)) return -EFAULT; count--; } } *frameUsed += used; return used; } /* * Copy and convert 8 bit data */ #define GENERATE_AMI_CT8(funcname, convsample) \ static ssize_t funcname(const u_char __user *userPtr, size_t userCount, \ u_char frame[], ssize_t *frameUsed, \ ssize_t frameLeft) \ { \ ssize_t count, used; \ \ if (!dmasound.soft.stereo) { \ u_char *p = &frame[*frameUsed]; \ count = min_t(size_t, userCount, frameLeft) & ~1; \ used = count; \ while (count > 0) { \ u_char data; \ if (get_user(data, userPtr++)) \ return -EFAULT; \ *p++ = convsample(data); \ count--; \ } \ } else { \ u_char *left = &frame[*frameUsed>>1]; \ u_char *right = left+write_sq_block_size_half; \ count = min_t(size_t, userCount, frameLeft)>>1 & ~1; \ used = count*2; \ while (count > 0) { \ u_char data; \ if (get_user(data, userPtr++)) \ return -EFAULT; \ *left++ = convsample(data); \ if (get_user(data, userPtr++)) \ return -EFAULT; \ *right++ = convsample(data); \ count--; \ } \ } \ *frameUsed += used; \ return used; \ } #define AMI_CT_ULAW(x) (dmasound_ulaw2dma8[(x)]) #define AMI_CT_ALAW(x) (dmasound_alaw2dma8[(x)]) #define AMI_CT_U8(x) ((x) ^ 0x80) GENERATE_AMI_CT8(ami_ct_ulaw, AMI_CT_ULAW) GENERATE_AMI_CT8(ami_ct_alaw, AMI_CT_ALAW) GENERATE_AMI_CT8(ami_ct_u8, AMI_CT_U8) /* * Copy and convert 16 bit data */ #define GENERATE_AMI_CT_16(funcname, convsample) \ static ssize_t funcname(const u_char __user *userPtr, size_t userCount, \ u_char frame[], ssize_t *frameUsed, \ ssize_t frameLeft) \ { \ const u_short __user *ptr = (const u_short __user *)userPtr; \ ssize_t count, used; \ u_short data; \ \ if (!dmasound.soft.stereo) { \ u_char *high = &frame[*frameUsed>>1]; \ u_char *low = high+write_sq_block_size_half; \ count = min_t(size_t, userCount, frameLeft)>>1 & ~1; \ used = count*2; \ while (count > 0) { \ if (get_user(data, ptr++)) \ return -EFAULT; \ data = convsample(data); \ *high++ = data>>8; \ *low++ = (data>>2) & 0x3f; \ count--; \ } \ } else { \ u_char *lefth = &frame[*frameUsed>>2]; \ u_char *leftl = lefth+write_sq_block_size_quarter; \ u_char *righth = lefth+write_sq_block_size_half; \ u_char *rightl = righth+write_sq_block_size_quarter; \ count = min_t(size_t, userCount, frameLeft)>>2 & ~1; \ used = count*4; \ while (count > 0) { \ if (get_user(data, ptr++)) \ return -EFAULT; \ data = convsample(data); \ *lefth++ = data>>8; \ *leftl++ = (data>>2) & 0x3f; \ if (get_user(data, ptr++)) \ return -EFAULT; \ data = convsample(data); \ *righth++ = data>>8; \ *rightl++ = (data>>2) & 0x3f; \ count--; \ } \ } \ *frameUsed += used; \ return used; \ } #define AMI_CT_S16BE(x) (x) #define AMI_CT_U16BE(x) ((x) ^ 0x8000) #define AMI_CT_S16LE(x) (le2be16((x))) #define AMI_CT_U16LE(x) (le2be16((x)) ^ 0x8000) GENERATE_AMI_CT_16(ami_ct_s16be, AMI_CT_S16BE) GENERATE_AMI_CT_16(ami_ct_u16be, AMI_CT_U16BE) GENERATE_AMI_CT_16(ami_ct_s16le, AMI_CT_S16LE) GENERATE_AMI_CT_16(ami_ct_u16le, AMI_CT_U16LE) static TRANS transAmiga = { .ct_ulaw = ami_ct_ulaw, .ct_alaw = ami_ct_alaw, .ct_s8 = ami_ct_s8, .ct_u8 = ami_ct_u8, .ct_s16be = ami_ct_s16be, .ct_u16be = ami_ct_u16be, .ct_s16le = ami_ct_s16le, .ct_u16le = ami_ct_u16le, }; /*** Low level stuff *********************************************************/ static inline void StopDMA(void) { custom.aud[0].audvol = custom.aud[1].audvol = 0; custom.aud[2].audvol = custom.aud[3].audvol = 0; custom.dmacon = AMI_AUDIO_OFF; enable_heartbeat(); } static void *AmiAlloc(unsigned int size, gfp_t flags) { return amiga_chip_alloc((long)size, "dmasound [Paula]"); } static void AmiFree(void *obj, unsigned int size) { amiga_chip_free (obj); } static int __init AmiIrqInit(void) { /* turn off DMA for audio channels */ StopDMA(); /* Register interrupt handler. */ if (request_irq(IRQ_AMIGA_AUD0, AmiInterrupt, 0, "DMA sound", AmiInterrupt)) return 0; return 1; } #ifdef MODULE static void AmiIrqCleanUp(void) { /* turn off DMA for audio channels */ StopDMA(); /* release the interrupt */ free_irq(IRQ_AMIGA_AUD0, AmiInterrupt); } #endif /* MODULE */ static void AmiSilence(void) { /* turn off DMA for audio channels */ StopDMA(); } static void AmiInit(void) { int period, i; AmiSilence(); if (dmasound.soft.speed) period = amiga_colorclock/dmasound.soft.speed-1; else period = amiga_audio_min_period; dmasound.hard = dmasound.soft; dmasound.trans_write = &transAmiga; if (period < amiga_audio_min_period) { /* we would need to squeeze the sound, but we won't do that */ period = amiga_audio_min_period; } else if (period > 65535) { period = 65535; } dmasound.hard.speed = amiga_colorclock/(period+1); for (i = 0; i < 4; i++) custom.aud[i].audper = period; amiga_audio_period = period; } static int AmiSetFormat(int format) { int size; /* Amiga sound DMA supports 8bit and 16bit (pseudo 14 bit) modes */ switch (format) { case AFMT_QUERY: return dmasound.soft.format; case AFMT_MU_LAW: case AFMT_A_LAW: case AFMT_U8: case AFMT_S8: size = 8; break; case AFMT_S16_BE: case AFMT_U16_BE: case AFMT_S16_LE: case AFMT_U16_LE: size = 16; break; default: /* :-) */ size = 8; format = AFMT_S8; } dmasound.soft.format = format; dmasound.soft.size = size; if (dmasound.minDev == SND_DEV_DSP) { dmasound.dsp.format = format; dmasound.dsp.size = dmasound.soft.size; } AmiInit(); return format; } #define VOLUME_VOXWARE_TO_AMI(v) \ (((v) < 0) ? 0 : ((v) > 100) ? 64 : ((v) * 64)/100) #define VOLUME_AMI_TO_VOXWARE(v) ((v)*100/64) static int AmiSetVolume(int volume) { dmasound.volume_left = VOLUME_VOXWARE_TO_AMI(volume & 0xff); custom.aud[0].audvol = dmasound.volume_left; dmasound.volume_right = VOLUME_VOXWARE_TO_AMI((volume & 0xff00) >> 8); custom.aud[1].audvol = dmasound.volume_right; if (dmasound.hard.size == 16) { if (dmasound.volume_left == 64 && dmasound.volume_right == 64) { custom.aud[2].audvol = 1; custom.aud[3].audvol = 1; } else { custom.aud[2].audvol = 0; custom.aud[3].audvol = 0; } } return VOLUME_AMI_TO_VOXWARE(dmasound.volume_left) | (VOLUME_AMI_TO_VOXWARE(dmasound.volume_right) << 8); } static int AmiSetTreble(int treble) { dmasound.treble = treble; if (treble < 50) ciaa.pra &= ~0x02; else ciaa.pra |= 0x02; return treble; } #define AMI_PLAY_LOADED 1 #define AMI_PLAY_PLAYING 2 #define AMI_PLAY_MASK 3 static void AmiPlayNextFrame(int index) { u_char *start, *ch0, *ch1, *ch2, *ch3; u_long size; /* used by AmiPlay() if all doubts whether there really is something * to be played are already wiped out. */ start = write_sq.buffers[write_sq.front]; size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size)>>1; if (dmasound.hard.stereo) { ch0 = start; ch1 = start+write_sq_block_size_half; size >>= 1; } else { ch0 = start; ch1 = start; } disable_heartbeat(); custom.aud[0].audvol = dmasound.volume_left; custom.aud[1].audvol = dmasound.volume_right; if (dmasound.hard.size == 8) { custom.aud[0].audlc = (u_short *)ZTWO_PADDR(ch0); custom.aud[0].audlen = size; custom.aud[1].audlc = (u_short *)ZTWO_PADDR(ch1); custom.aud[1].audlen = size; custom.dmacon = AMI_AUDIO_8; } else { size >>= 1; custom.aud[0].audlc = (u_short *)ZTWO_PADDR(ch0); custom.aud[0].audlen = size; custom.aud[1].audlc = (u_short *)ZTWO_PADDR(ch1); custom.aud[1].audlen = size; if (dmasound.volume_left == 64 && dmasound.volume_right == 64) { /* We can play pseudo 14-bit only with the maximum volume */ ch3 = ch0+write_sq_block_size_quarter; ch2 = ch1+write_sq_block_size_quarter; custom.aud[2].audvol = 1; /* we are being affected by the beeps */ custom.aud[3].audvol = 1; /* restoring volume here helps a bit */ custom.aud[2].audlc = (u_short *)ZTWO_PADDR(ch2); custom.aud[2].audlen = size; custom.aud[3].audlc = (u_short *)ZTWO_PADDR(ch3); custom.aud[3].audlen = size; custom.dmacon = AMI_AUDIO_14; } else { custom.aud[2].audvol = 0; custom.aud[3].audvol = 0; custom.dmacon = AMI_AUDIO_8; } } write_sq.front = (write_sq.front+1) % write_sq.max_count; write_sq.active |= AMI_PLAY_LOADED; } static void AmiPlay(void) { int minframes = 1; custom.intena = IF_AUD0; if (write_sq.active & AMI_PLAY_LOADED) { /* There's already a frame loaded */ custom.intena = IF_SETCLR | IF_AUD0; return; } if (write_sq.active & AMI_PLAY_PLAYING) /* Increase threshold: frame 1 is already being played */ minframes = 2; if (write_sq.count < minframes) { /* Nothing to do */ custom.intena = IF_SETCLR | IF_AUD0; return; } if (write_sq.count <= minframes && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { /* hmmm, the only existing frame is not * yet filled and we're not syncing? */ custom.intena = IF_SETCLR | IF_AUD0; return; } AmiPlayNextFrame(minframes); custom.intena = IF_SETCLR | IF_AUD0; } static irqreturn_t AmiInterrupt(int irq, void *dummy) { int minframes = 1; custom.intena = IF_AUD0; if (!write_sq.active) { /* Playing was interrupted and sq_reset() has already cleared * the sq variables, so better don't do anything here. */ WAKE_UP(write_sq.sync_queue); return IRQ_HANDLED; } if (write_sq.active & AMI_PLAY_PLAYING) { /* We've just finished a frame */ write_sq.count--; WAKE_UP(write_sq.action_queue); } if (write_sq.active & AMI_PLAY_LOADED) /* Increase threshold: frame 1 is already being played */ minframes = 2; /* Shift the flags */ write_sq.active = (write_sq.active<<1) & AMI_PLAY_MASK; if (!write_sq.active) /* No frame is playing, disable audio DMA */ StopDMA(); custom.intena = IF_SETCLR | IF_AUD0; if (write_sq.count >= minframes) /* Try to play the next frame */ AmiPlay(); if (!write_sq.active) /* Nothing to play anymore. Wake up a process waiting for audio output to drain. */ WAKE_UP(write_sq.sync_queue); return IRQ_HANDLED; } /*** Mid level stuff *********************************************************/ /* * /dev/mixer abstraction */ static void __init AmiMixerInit(void) { dmasound.volume_left = 64; dmasound.volume_right = 64; custom.aud[0].audvol = dmasound.volume_left; custom.aud[3].audvol = 1; /* For pseudo 14bit */ custom.aud[1].audvol = dmasound.volume_right; custom.aud[2].audvol = 1; /* For pseudo 14bit */ dmasound.treble = 50; } static int AmiMixerIoctl(u_int cmd, u_long arg) { int data; switch (cmd) { case SOUND_MIXER_READ_DEVMASK: return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_TREBLE); case SOUND_MIXER_READ_RECMASK: return IOCTL_OUT(arg, 0); case SOUND_MIXER_READ_STEREODEVS: return IOCTL_OUT(arg, SOUND_MASK_VOLUME); case SOUND_MIXER_READ_VOLUME: return IOCTL_OUT(arg, VOLUME_AMI_TO_VOXWARE(dmasound.volume_left) | VOLUME_AMI_TO_VOXWARE(dmasound.volume_right) << 8); case SOUND_MIXER_WRITE_VOLUME: IOCTL_IN(arg, data); return IOCTL_OUT(arg, dmasound_set_volume(data)); case SOUND_MIXER_READ_TREBLE: return IOCTL_OUT(arg, dmasound.treble); case SOUND_MIXER_WRITE_TREBLE: IOCTL_IN(arg, data); return IOCTL_OUT(arg, dmasound_set_treble(data)); } return -EINVAL; } static int AmiWriteSqSetup(void) { write_sq_block_size_half = write_sq.block_size>>1; write_sq_block_size_quarter = write_sq_block_size_half>>1; return 0; } static int AmiStateInfo(char *buffer, size_t space) { int len = 0; len += sprintf(buffer+len, "\tsound.volume_left = %d [0...64]\n", dmasound.volume_left); len += sprintf(buffer+len, "\tsound.volume_right = %d [0...64]\n", dmasound.volume_right); if (len >= space) { printk(KERN_ERR "dmasound_paula: overflowed state buffer alloc.\n") ; len = space ; } return len; } /*** Machine definitions *****************************************************/ static SETTINGS def_hard = { .format = AFMT_S8, .stereo = 0, .size = 8, .speed = 8000 } ; static SETTINGS def_soft = { .format = AFMT_U8, .stereo = 0, .size = 8, .speed = 8000 } ; static MACHINE machAmiga = { .name = "Amiga", .name2 = "AMIGA", .owner = THIS_MODULE, .dma_alloc = AmiAlloc, .dma_free = AmiFree, .irqinit = AmiIrqInit, #ifdef MODULE .irqcleanup = AmiIrqCleanUp, #endif /* MODULE */ .init = AmiInit, .silence = AmiSilence, .setFormat = AmiSetFormat, .setVolume = AmiSetVolume, .setTreble = AmiSetTreble, .play = AmiPlay, .mixer_init = AmiMixerInit, .mixer_ioctl = AmiMixerIoctl, .write_sq_setup = AmiWriteSqSetup, .state_info = AmiStateInfo, .min_dsp_speed = 8000, .version = ((DMASOUND_PAULA_REVISION<<8) | DMASOUND_PAULA_EDITION), .hardware_afmts = (AFMT_S8 | AFMT_S16_BE), /* h'ware-supported formats *only* here */ .capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */ }; /*** Config & Setup **********************************************************/ static int __init amiga_audio_probe(struct platform_device *pdev) { dmasound.mach = machAmiga; dmasound.mach.default_hard = def_hard ; dmasound.mach.default_soft = def_soft ; return dmasound_init(); } static int __exit amiga_audio_remove(struct platform_device *pdev) { dmasound_deinit(); return 0; } static struct platform_driver amiga_audio_driver = { .remove = __exit_p(amiga_audio_remove), .driver = { .name = "amiga-audio", }, }; module_platform_driver_probe(amiga_audio_driver, amiga_audio_probe); MODULE_LICENSE("GPL"); MODULE_ALIAS("platform:amiga-audio");
linux-master
sound/oss/dmasound/dmasound_paula.c
// SPDX-License-Identifier: GPL-2.0-only /* * linux/sound/oss/dmasound/dmasound_atari.c * * Atari TT and Falcon DMA Sound Driver * * See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits * prior to 28/01/2001 * * 28/01/2001 [0.1] Iain Sandoe * - added versioning * - put in and populated the hardware_afmts field. * [0.2] - put in SNDCTL_DSP_GETCAPS value. * 01/02/2001 [0.3] - put in default hard/soft settings. */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/soundcard.h> #include <linux/mm.h> #include <linux/spinlock.h> #include <linux/interrupt.h> #include <linux/uaccess.h> #include <asm/atariints.h> #include <asm/atari_stram.h> #include "dmasound.h" #define DMASOUND_ATARI_REVISION 0 #define DMASOUND_ATARI_EDITION 3 extern void atari_microwire_cmd(int cmd); static int is_falcon; static int write_sq_ignore_int; /* ++TeSche: used for Falcon */ static int expand_bal; /* Balance factor for expanding (not volume!) */ static int expand_data; /* Data for expanding */ /*** Translations ************************************************************/ /* ++TeSche: radically changed for new expanding purposes... * * These two routines now deal with copying/expanding/translating the samples * from user space into our buffer at the right frequency. They take care about * how much data there's actually to read, how much buffer space there is and * to convert samples into the right frequency/encoding. They will only work on * complete samples so it may happen they leave some bytes in the input stream * if the user didn't write a multiple of the current sample size. They both * return the number of bytes they've used from both streams so you may detect * such a situation. Luckily all programs should be able to cope with that. * * I think I've optimized anything as far as one can do in plain C, all * variables should fit in registers and the loops are really short. There's * one loop for every possible situation. Writing a more generalized and thus * parameterized loop would only produce slower code. Feel free to optimize * this in assembler if you like. :) * * I think these routines belong here because they're not yet really hardware * independent, especially the fact that the Falcon can play 16bit samples * only in stereo is hardcoded in both of them! * * ++geert: split in even more functions (one per format) */ static ssize_t ata_ct_law(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ct_s8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ct_u8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ct_s16be(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ct_u16be(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ct_s16le(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ct_u16le(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ctx_law(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ctx_s8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ctx_u8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ctx_s16be(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ctx_u16be(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ctx_s16le(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); static ssize_t ata_ctx_u16le(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft); /*** Low level stuff *********************************************************/ static void *AtaAlloc(unsigned int size, gfp_t flags); static void AtaFree(void *, unsigned int size); static int AtaIrqInit(void); #ifdef MODULE static void AtaIrqCleanUp(void); #endif /* MODULE */ static int AtaSetBass(int bass); static int AtaSetTreble(int treble); static void TTSilence(void); static void TTInit(void); static int TTSetFormat(int format); static int TTSetVolume(int volume); static int TTSetGain(int gain); static void FalconSilence(void); static void FalconInit(void); static int FalconSetFormat(int format); static int FalconSetVolume(int volume); static void AtaPlayNextFrame(int index); static void AtaPlay(void); static irqreturn_t AtaInterrupt(int irq, void *dummy); /*** Mid level stuff *********************************************************/ static void TTMixerInit(void); static void FalconMixerInit(void); static int AtaMixerIoctl(u_int cmd, u_long arg); static int TTMixerIoctl(u_int cmd, u_long arg); static int FalconMixerIoctl(u_int cmd, u_long arg); static int AtaWriteSqSetup(void); static int AtaSqOpen(fmode_t mode); static int TTStateInfo(char *buffer, size_t space); static int FalconStateInfo(char *buffer, size_t space); /*** Translations ************************************************************/ static ssize_t ata_ct_law(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8 : dmasound_alaw2dma8; ssize_t count, used; u_char *p = &frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft); if (dmasound.soft.stereo) count &= ~1; used = count; while (count > 0) { u_char data; if (get_user(data, userPtr++)) return -EFAULT; *p++ = table[data]; count--; } *frameUsed += used; return used; } static ssize_t ata_ct_s8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; void *p = &frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft); if (dmasound.soft.stereo) count &= ~1; used = count; if (copy_from_user(p, userPtr, count)) return -EFAULT; *frameUsed += used; return used; } static ssize_t ata_ct_u8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; if (!dmasound.soft.stereo) { u_char *p = &frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft); used = count; while (count > 0) { u_char data; if (get_user(data, userPtr++)) return -EFAULT; *p++ = data ^ 0x80; count--; } } else { u_short *p = (u_short *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft)>>1; used = count*2; while (count > 0) { u_short data; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; *p++ = data ^ 0x8080; count--; } } *frameUsed += used; return used; } static ssize_t ata_ct_s16be(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; if (!dmasound.soft.stereo) { u_short *p = (u_short *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft)>>1; used = count*2; while (count > 0) { u_short data; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; *p++ = data; *p++ = data; count--; } *frameUsed += used*2; } else { void *p = (u_short *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft) & ~3; used = count; if (copy_from_user(p, userPtr, count)) return -EFAULT; *frameUsed += used; } return used; } static ssize_t ata_ct_u16be(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; if (!dmasound.soft.stereo) { u_short *p = (u_short *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft)>>1; used = count*2; while (count > 0) { u_short data; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; data ^= 0x8000; *p++ = data; *p++ = data; count--; } *frameUsed += used*2; } else { u_long *p = (u_long *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft)>>2; used = count*4; while (count > 0) { u_int data; if (get_user(data, (u_int __user *)userPtr)) return -EFAULT; userPtr += 4; *p++ = data ^ 0x80008000; count--; } *frameUsed += used; } return used; } static ssize_t ata_ct_s16le(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; count = frameLeft; if (!dmasound.soft.stereo) { u_short *p = (u_short *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft)>>1; used = count*2; while (count > 0) { u_short data; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; data = le2be16(data); *p++ = data; *p++ = data; count--; } *frameUsed += used*2; } else { u_long *p = (u_long *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft)>>2; used = count*4; while (count > 0) { u_long data; if (get_user(data, (u_int __user *)userPtr)) return -EFAULT; userPtr += 4; data = le2be16dbl(data); *p++ = data; count--; } *frameUsed += used; } return used; } static ssize_t ata_ct_u16le(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; count = frameLeft; if (!dmasound.soft.stereo) { u_short *p = (u_short *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft)>>1; used = count*2; while (count > 0) { u_short data; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; data = le2be16(data) ^ 0x8000; *p++ = data; *p++ = data; } *frameUsed += used*2; } else { u_long *p = (u_long *)&frame[*frameUsed]; count = min_t(unsigned long, userCount, frameLeft)>>2; used = count; while (count > 0) { u_long data; if (get_user(data, (u_int __user *)userPtr)) return -EFAULT; userPtr += 4; data = le2be16dbl(data) ^ 0x80008000; *p++ = data; count--; } *frameUsed += used; } return used; } static ssize_t ata_ctx_law(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8 : dmasound_alaw2dma8; /* this should help gcc to stuff everything into registers */ long bal = expand_bal; long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; ssize_t used, usedf; used = userCount; usedf = frameLeft; if (!dmasound.soft.stereo) { u_char *p = &frame[*frameUsed]; u_char data = expand_data; while (frameLeft) { u_char c; if (bal < 0) { if (!userCount) break; if (get_user(c, userPtr++)) return -EFAULT; data = table[c]; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } expand_data = data; } else { u_short *p = (u_short *)&frame[*frameUsed]; u_short data = expand_data; while (frameLeft >= 2) { u_char c; if (bal < 0) { if (userCount < 2) break; if (get_user(c, userPtr++)) return -EFAULT; data = table[c] << 8; if (get_user(c, userPtr++)) return -EFAULT; data |= table[c]; userCount -= 2; bal += hSpeed; } *p++ = data; frameLeft -= 2; bal -= sSpeed; } expand_data = data; } expand_bal = bal; used -= userCount; *frameUsed += usedf-frameLeft; return used; } static ssize_t ata_ctx_s8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { /* this should help gcc to stuff everything into registers */ long bal = expand_bal; long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; ssize_t used, usedf; used = userCount; usedf = frameLeft; if (!dmasound.soft.stereo) { u_char *p = &frame[*frameUsed]; u_char data = expand_data; while (frameLeft) { if (bal < 0) { if (!userCount) break; if (get_user(data, userPtr++)) return -EFAULT; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } expand_data = data; } else { u_short *p = (u_short *)&frame[*frameUsed]; u_short data = expand_data; while (frameLeft >= 2) { if (bal < 0) { if (userCount < 2) break; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; userCount -= 2; bal += hSpeed; } *p++ = data; frameLeft -= 2; bal -= sSpeed; } expand_data = data; } expand_bal = bal; used -= userCount; *frameUsed += usedf-frameLeft; return used; } static ssize_t ata_ctx_u8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { /* this should help gcc to stuff everything into registers */ long bal = expand_bal; long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; ssize_t used, usedf; used = userCount; usedf = frameLeft; if (!dmasound.soft.stereo) { u_char *p = &frame[*frameUsed]; u_char data = expand_data; while (frameLeft) { if (bal < 0) { if (!userCount) break; if (get_user(data, userPtr++)) return -EFAULT; data ^= 0x80; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } expand_data = data; } else { u_short *p = (u_short *)&frame[*frameUsed]; u_short data = expand_data; while (frameLeft >= 2) { if (bal < 0) { if (userCount < 2) break; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; data ^= 0x8080; userCount -= 2; bal += hSpeed; } *p++ = data; frameLeft -= 2; bal -= sSpeed; } expand_data = data; } expand_bal = bal; used -= userCount; *frameUsed += usedf-frameLeft; return used; } static ssize_t ata_ctx_s16be(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { /* this should help gcc to stuff everything into registers */ long bal = expand_bal; long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; ssize_t used, usedf; used = userCount; usedf = frameLeft; if (!dmasound.soft.stereo) { u_short *p = (u_short *)&frame[*frameUsed]; u_short data = expand_data; while (frameLeft >= 4) { if (bal < 0) { if (userCount < 2) break; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; userCount -= 2; bal += hSpeed; } *p++ = data; *p++ = data; frameLeft -= 4; bal -= sSpeed; } expand_data = data; } else { u_long *p = (u_long *)&frame[*frameUsed]; u_long data = expand_data; while (frameLeft >= 4) { if (bal < 0) { if (userCount < 4) break; if (get_user(data, (u_int __user *)userPtr)) return -EFAULT; userPtr += 4; userCount -= 4; bal += hSpeed; } *p++ = data; frameLeft -= 4; bal -= sSpeed; } expand_data = data; } expand_bal = bal; used -= userCount; *frameUsed += usedf-frameLeft; return used; } static ssize_t ata_ctx_u16be(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { /* this should help gcc to stuff everything into registers */ long bal = expand_bal; long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; ssize_t used, usedf; used = userCount; usedf = frameLeft; if (!dmasound.soft.stereo) { u_short *p = (u_short *)&frame[*frameUsed]; u_short data = expand_data; while (frameLeft >= 4) { if (bal < 0) { if (userCount < 2) break; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; data ^= 0x8000; userCount -= 2; bal += hSpeed; } *p++ = data; *p++ = data; frameLeft -= 4; bal -= sSpeed; } expand_data = data; } else { u_long *p = (u_long *)&frame[*frameUsed]; u_long data = expand_data; while (frameLeft >= 4) { if (bal < 0) { if (userCount < 4) break; if (get_user(data, (u_int __user *)userPtr)) return -EFAULT; userPtr += 4; data ^= 0x80008000; userCount -= 4; bal += hSpeed; } *p++ = data; frameLeft -= 4; bal -= sSpeed; } expand_data = data; } expand_bal = bal; used -= userCount; *frameUsed += usedf-frameLeft; return used; } static ssize_t ata_ctx_s16le(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { /* this should help gcc to stuff everything into registers */ long bal = expand_bal; long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; ssize_t used, usedf; used = userCount; usedf = frameLeft; if (!dmasound.soft.stereo) { u_short *p = (u_short *)&frame[*frameUsed]; u_short data = expand_data; while (frameLeft >= 4) { if (bal < 0) { if (userCount < 2) break; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; data = le2be16(data); userCount -= 2; bal += hSpeed; } *p++ = data; *p++ = data; frameLeft -= 4; bal -= sSpeed; } expand_data = data; } else { u_long *p = (u_long *)&frame[*frameUsed]; u_long data = expand_data; while (frameLeft >= 4) { if (bal < 0) { if (userCount < 4) break; if (get_user(data, (u_int __user *)userPtr)) return -EFAULT; userPtr += 4; data = le2be16dbl(data); userCount -= 4; bal += hSpeed; } *p++ = data; frameLeft -= 4; bal -= sSpeed; } expand_data = data; } expand_bal = bal; used -= userCount; *frameUsed += usedf-frameLeft; return used; } static ssize_t ata_ctx_u16le(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { /* this should help gcc to stuff everything into registers */ long bal = expand_bal; long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; ssize_t used, usedf; used = userCount; usedf = frameLeft; if (!dmasound.soft.stereo) { u_short *p = (u_short *)&frame[*frameUsed]; u_short data = expand_data; while (frameLeft >= 4) { if (bal < 0) { if (userCount < 2) break; if (get_user(data, (u_short __user *)userPtr)) return -EFAULT; userPtr += 2; data = le2be16(data) ^ 0x8000; userCount -= 2; bal += hSpeed; } *p++ = data; *p++ = data; frameLeft -= 4; bal -= sSpeed; } expand_data = data; } else { u_long *p = (u_long *)&frame[*frameUsed]; u_long data = expand_data; while (frameLeft >= 4) { if (bal < 0) { if (userCount < 4) break; if (get_user(data, (u_int __user *)userPtr)) return -EFAULT; userPtr += 4; data = le2be16dbl(data) ^ 0x80008000; userCount -= 4; bal += hSpeed; } *p++ = data; frameLeft -= 4; bal -= sSpeed; } expand_data = data; } expand_bal = bal; used -= userCount; *frameUsed += usedf-frameLeft; return used; } static TRANS transTTNormal = { .ct_ulaw = ata_ct_law, .ct_alaw = ata_ct_law, .ct_s8 = ata_ct_s8, .ct_u8 = ata_ct_u8, }; static TRANS transTTExpanding = { .ct_ulaw = ata_ctx_law, .ct_alaw = ata_ctx_law, .ct_s8 = ata_ctx_s8, .ct_u8 = ata_ctx_u8, }; static TRANS transFalconNormal = { .ct_ulaw = ata_ct_law, .ct_alaw = ata_ct_law, .ct_s8 = ata_ct_s8, .ct_u8 = ata_ct_u8, .ct_s16be = ata_ct_s16be, .ct_u16be = ata_ct_u16be, .ct_s16le = ata_ct_s16le, .ct_u16le = ata_ct_u16le }; static TRANS transFalconExpanding = { .ct_ulaw = ata_ctx_law, .ct_alaw = ata_ctx_law, .ct_s8 = ata_ctx_s8, .ct_u8 = ata_ctx_u8, .ct_s16be = ata_ctx_s16be, .ct_u16be = ata_ctx_u16be, .ct_s16le = ata_ctx_s16le, .ct_u16le = ata_ctx_u16le, }; /*** Low level stuff *********************************************************/ /* * Atari (TT/Falcon) */ static void *AtaAlloc(unsigned int size, gfp_t flags) { return atari_stram_alloc(size, "dmasound"); } static void AtaFree(void *obj, unsigned int size) { atari_stram_free( obj ); } static int __init AtaIrqInit(void) { /* Set up timer A. Timer A will receive a signal upon end of playing from the sound hardware. Furthermore Timer A is able to count events and will cause an interrupt after a programmed number of events. So all we need to keep the music playing is to provide the sound hardware with new data upon an interrupt from timer A. */ st_mfp.tim_ct_a = 0; /* ++roman: Stop timer before programming! */ st_mfp.tim_dt_a = 1; /* Cause interrupt after first event. */ st_mfp.tim_ct_a = 8; /* Turn on event counting. */ /* Register interrupt handler. */ if (request_irq(IRQ_MFP_TIMA, AtaInterrupt, 0, "DMA sound", AtaInterrupt)) return 0; st_mfp.int_en_a |= 0x20; /* Turn interrupt on. */ st_mfp.int_mk_a |= 0x20; return 1; } #ifdef MODULE static void AtaIrqCleanUp(void) { st_mfp.tim_ct_a = 0; /* stop timer */ st_mfp.int_en_a &= ~0x20; /* turn interrupt off */ free_irq(IRQ_MFP_TIMA, AtaInterrupt); } #endif /* MODULE */ #define TONE_VOXWARE_TO_DB(v) \ (((v) < 0) ? -12 : ((v) > 100) ? 12 : ((v) - 50) * 6 / 25) #define TONE_DB_TO_VOXWARE(v) (((v) * 25 + ((v) > 0 ? 5 : -5)) / 6 + 50) static int AtaSetBass(int bass) { dmasound.bass = TONE_VOXWARE_TO_DB(bass); atari_microwire_cmd(MW_LM1992_BASS(dmasound.bass)); return TONE_DB_TO_VOXWARE(dmasound.bass); } static int AtaSetTreble(int treble) { dmasound.treble = TONE_VOXWARE_TO_DB(treble); atari_microwire_cmd(MW_LM1992_TREBLE(dmasound.treble)); return TONE_DB_TO_VOXWARE(dmasound.treble); } /* * TT */ static void TTSilence(void) { tt_dmasnd.ctrl = DMASND_CTRL_OFF; atari_microwire_cmd(MW_LM1992_PSG_HIGH); /* mix in PSG signal 1:1 */ } static void TTInit(void) { int mode, i, idx; const int freq[4] = {50066, 25033, 12517, 6258}; /* search a frequency that fits into the allowed error range */ idx = -1; for (i = 0; i < ARRAY_SIZE(freq); i++) /* this isn't as much useful for a TT than for a Falcon, but * then it doesn't hurt very much to implement it for a TT too. */ if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) < catchRadius) idx = i; if (idx > -1) { dmasound.soft.speed = freq[idx]; dmasound.trans_write = &transTTNormal; } else dmasound.trans_write = &transTTExpanding; TTSilence(); dmasound.hard = dmasound.soft; if (dmasound.hard.speed > 50066) { /* we would need to squeeze the sound, but we won't do that */ dmasound.hard.speed = 50066; mode = DMASND_MODE_50KHZ; dmasound.trans_write = &transTTNormal; } else if (dmasound.hard.speed > 25033) { dmasound.hard.speed = 50066; mode = DMASND_MODE_50KHZ; } else if (dmasound.hard.speed > 12517) { dmasound.hard.speed = 25033; mode = DMASND_MODE_25KHZ; } else if (dmasound.hard.speed > 6258) { dmasound.hard.speed = 12517; mode = DMASND_MODE_12KHZ; } else { dmasound.hard.speed = 6258; mode = DMASND_MODE_6KHZ; } tt_dmasnd.mode = (dmasound.hard.stereo ? DMASND_MODE_STEREO : DMASND_MODE_MONO) | DMASND_MODE_8BIT | mode; expand_bal = -dmasound.soft.speed; } static int TTSetFormat(int format) { /* TT sound DMA supports only 8bit modes */ switch (format) { case AFMT_QUERY: return dmasound.soft.format; case AFMT_MU_LAW: case AFMT_A_LAW: case AFMT_S8: case AFMT_U8: break; default: format = AFMT_S8; } dmasound.soft.format = format; dmasound.soft.size = 8; if (dmasound.minDev == SND_DEV_DSP) { dmasound.dsp.format = format; dmasound.dsp.size = 8; } TTInit(); return format; } #define VOLUME_VOXWARE_TO_DB(v) \ (((v) < 0) ? -40 : ((v) > 100) ? 0 : ((v) * 2) / 5 - 40) #define VOLUME_DB_TO_VOXWARE(v) ((((v) + 40) * 5 + 1) / 2) static int TTSetVolume(int volume) { dmasound.volume_left = VOLUME_VOXWARE_TO_DB(volume & 0xff); atari_microwire_cmd(MW_LM1992_BALLEFT(dmasound.volume_left)); dmasound.volume_right = VOLUME_VOXWARE_TO_DB((volume & 0xff00) >> 8); atari_microwire_cmd(MW_LM1992_BALRIGHT(dmasound.volume_right)); return VOLUME_DB_TO_VOXWARE(dmasound.volume_left) | (VOLUME_DB_TO_VOXWARE(dmasound.volume_right) << 8); } #define GAIN_VOXWARE_TO_DB(v) \ (((v) < 0) ? -80 : ((v) > 100) ? 0 : ((v) * 4) / 5 - 80) #define GAIN_DB_TO_VOXWARE(v) ((((v) + 80) * 5 + 1) / 4) static int TTSetGain(int gain) { dmasound.gain = GAIN_VOXWARE_TO_DB(gain); atari_microwire_cmd(MW_LM1992_VOLUME(dmasound.gain)); return GAIN_DB_TO_VOXWARE(dmasound.gain); } /* * Falcon */ static void FalconSilence(void) { /* stop playback, set sample rate 50kHz for PSG sound */ tt_dmasnd.ctrl = DMASND_CTRL_OFF; tt_dmasnd.mode = DMASND_MODE_50KHZ | DMASND_MODE_STEREO | DMASND_MODE_8BIT; tt_dmasnd.int_div = 0; /* STE compatible divider */ tt_dmasnd.int_ctrl = 0x0; tt_dmasnd.cbar_src = 0x0000; /* no matrix inputs */ tt_dmasnd.cbar_dst = 0x0000; /* no matrix outputs */ tt_dmasnd.dac_src = 1; /* connect ADC to DAC, disconnect matrix */ tt_dmasnd.adc_src = 3; /* ADC Input = PSG */ } static void FalconInit(void) { int divider, i, idx; const int freq[8] = {49170, 32780, 24585, 19668, 16390, 12292, 9834, 8195}; /* search a frequency that fits into the allowed error range */ idx = -1; for (i = 0; i < ARRAY_SIZE(freq); i++) /* if we will tolerate 3% error 8000Hz->8195Hz (2.38%) would * be playable without expanding, but that now a kernel runtime * option */ if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) < catchRadius) idx = i; if (idx > -1) { dmasound.soft.speed = freq[idx]; dmasound.trans_write = &transFalconNormal; } else dmasound.trans_write = &transFalconExpanding; FalconSilence(); dmasound.hard = dmasound.soft; if (dmasound.hard.size == 16) { /* the Falcon can play 16bit samples only in stereo */ dmasound.hard.stereo = 1; } if (dmasound.hard.speed > 49170) { /* we would need to squeeze the sound, but we won't do that */ dmasound.hard.speed = 49170; divider = 1; dmasound.trans_write = &transFalconNormal; } else if (dmasound.hard.speed > 32780) { dmasound.hard.speed = 49170; divider = 1; } else if (dmasound.hard.speed > 24585) { dmasound.hard.speed = 32780; divider = 2; } else if (dmasound.hard.speed > 19668) { dmasound.hard.speed = 24585; divider = 3; } else if (dmasound.hard.speed > 16390) { dmasound.hard.speed = 19668; divider = 4; } else if (dmasound.hard.speed > 12292) { dmasound.hard.speed = 16390; divider = 5; } else if (dmasound.hard.speed > 9834) { dmasound.hard.speed = 12292; divider = 7; } else if (dmasound.hard.speed > 8195) { dmasound.hard.speed = 9834; divider = 9; } else { dmasound.hard.speed = 8195; divider = 11; } tt_dmasnd.int_div = divider; /* Setup Falcon sound DMA for playback */ tt_dmasnd.int_ctrl = 0x4; /* Timer A int at play end */ tt_dmasnd.track_select = 0x0; /* play 1 track, track 1 */ tt_dmasnd.cbar_src = 0x0001; /* DMA(25MHz) --> DAC */ tt_dmasnd.cbar_dst = 0x0000; tt_dmasnd.rec_track_select = 0; tt_dmasnd.dac_src = 2; /* connect matrix to DAC */ tt_dmasnd.adc_src = 0; /* ADC Input = Mic */ tt_dmasnd.mode = (dmasound.hard.stereo ? DMASND_MODE_STEREO : DMASND_MODE_MONO) | ((dmasound.hard.size == 8) ? DMASND_MODE_8BIT : DMASND_MODE_16BIT) | DMASND_MODE_6KHZ; expand_bal = -dmasound.soft.speed; } static int FalconSetFormat(int format) { int size; /* Falcon sound DMA supports 8bit and 16bit modes */ switch (format) { case AFMT_QUERY: return dmasound.soft.format; case AFMT_MU_LAW: case AFMT_A_LAW: case AFMT_U8: case AFMT_S8: size = 8; break; case AFMT_S16_BE: case AFMT_U16_BE: case AFMT_S16_LE: case AFMT_U16_LE: size = 16; break; default: /* :-) */ size = 8; format = AFMT_S8; } dmasound.soft.format = format; dmasound.soft.size = size; if (dmasound.minDev == SND_DEV_DSP) { dmasound.dsp.format = format; dmasound.dsp.size = dmasound.soft.size; } FalconInit(); return format; } /* This is for the Falcon output *attenuation* in 1.5dB steps, * i.e. output level from 0 to -22.5dB in -1.5dB steps. */ #define VOLUME_VOXWARE_TO_ATT(v) \ ((v) < 0 ? 15 : (v) > 100 ? 0 : 15 - (v) * 3 / 20) #define VOLUME_ATT_TO_VOXWARE(v) (100 - (v) * 20 / 3) static int FalconSetVolume(int volume) { dmasound.volume_left = VOLUME_VOXWARE_TO_ATT(volume & 0xff); dmasound.volume_right = VOLUME_VOXWARE_TO_ATT((volume & 0xff00) >> 8); tt_dmasnd.output_atten = dmasound.volume_left << 8 | dmasound.volume_right << 4; return VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) | VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8; } static void AtaPlayNextFrame(int index) { char *start, *end; /* used by AtaPlay() if all doubts whether there really is something * to be played are already wiped out. */ start = write_sq.buffers[write_sq.front]; end = start+((write_sq.count == index) ? write_sq.rear_size : write_sq.block_size); /* end might not be a legal virtual address. */ DMASNDSetEnd(virt_to_phys(end - 1) + 1); DMASNDSetBase(virt_to_phys(start)); /* Since only an even number of samples per frame can be played, we might lose one byte here. (TO DO) */ write_sq.front = (write_sq.front+1) % write_sq.max_count; write_sq.active++; tt_dmasnd.ctrl = DMASND_CTRL_ON | DMASND_CTRL_REPEAT; } static void AtaPlay(void) { /* ++TeSche: Note that write_sq.active is no longer just a flag but * holds the number of frames the DMA is currently programmed for * instead, may be 0, 1 (currently being played) or 2 (pre-programmed). * * Changes done to write_sq.count and write_sq.active are a bit more * subtle again so now I must admit I also prefer disabling the irq * here rather than considering all possible situations. But the point * is that disabling the irq doesn't have any bad influence on this * version of the driver as we benefit from having pre-programmed the * DMA wherever possible: There's no need to reload the DMA at the * exact time of an interrupt but only at some time while the * pre-programmed frame is playing! */ atari_disable_irq(IRQ_MFP_TIMA); if (write_sq.active == 2 || /* DMA is 'full' */ write_sq.count <= 0) { /* nothing to do */ atari_enable_irq(IRQ_MFP_TIMA); return; } if (write_sq.active == 0) { /* looks like there's nothing 'in' the DMA yet, so try * to put two frames into it (at least one is available). */ if (write_sq.count == 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { /* hmmm, the only existing frame is not * yet filled and we're not syncing? */ atari_enable_irq(IRQ_MFP_TIMA); return; } AtaPlayNextFrame(1); if (write_sq.count == 1) { /* no more frames */ atari_enable_irq(IRQ_MFP_TIMA); return; } if (write_sq.count == 2 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { /* hmmm, there were two frames, but the second * one is not yet filled and we're not syncing? */ atari_enable_irq(IRQ_MFP_TIMA); return; } AtaPlayNextFrame(2); } else { /* there's already a frame being played so we may only stuff * one new into the DMA, but even if this may be the last * frame existing the previous one is still on write_sq.count. */ if (write_sq.count == 2 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { /* hmmm, the only existing frame is not * yet filled and we're not syncing? */ atari_enable_irq(IRQ_MFP_TIMA); return; } AtaPlayNextFrame(2); } atari_enable_irq(IRQ_MFP_TIMA); } static irqreturn_t AtaInterrupt(int irq, void *dummy) { #if 0 /* ++TeSche: if you should want to test this... */ static int cnt; if (write_sq.active == 2) if (++cnt == 10) { /* simulate losing an interrupt */ cnt = 0; return IRQ_HANDLED; } #endif spin_lock(&dmasound.lock); if (write_sq_ignore_int && is_falcon) { /* ++TeSche: Falcon only: ignore first irq because it comes * immediately after starting a frame. after that, irqs come * (almost) like on the TT. */ write_sq_ignore_int = 0; goto out; } if (!write_sq.active) { /* playing was interrupted and sq_reset() has already cleared * the sq variables, so better don't do anything here. */ WAKE_UP(write_sq.sync_queue); goto out; } /* Probably ;) one frame is finished. Well, in fact it may be that a * pre-programmed one is also finished because there has been a long * delay in interrupt delivery and we've completely lost one, but * there's no way to detect such a situation. In such a case the last * frame will be played more than once and the situation will recover * as soon as the irq gets through. */ write_sq.count--; write_sq.active--; if (!write_sq.active) { tt_dmasnd.ctrl = DMASND_CTRL_OFF; write_sq_ignore_int = 1; } WAKE_UP(write_sq.action_queue); /* At least one block of the queue is free now so wake up a writing process blocked because of a full queue. */ if ((write_sq.active != 1) || (write_sq.count != 1)) /* We must be a bit carefully here: write_sq.count indicates the * number of buffers used and not the number of frames to be * played. If write_sq.count==1 and write_sq.active==1 that * means the only remaining frame was already programmed * earlier (and is currently running) so we mustn't call * AtaPlay() here, otherwise we'll play one frame too much. */ AtaPlay(); if (!write_sq.active) WAKE_UP(write_sq.sync_queue); /* We are not playing after AtaPlay(), so there is nothing to play any more. Wake up a process waiting for audio output to drain. */ out: spin_unlock(&dmasound.lock); return IRQ_HANDLED; } /*** Mid level stuff *********************************************************/ /* * /dev/mixer abstraction */ #define RECLEVEL_VOXWARE_TO_GAIN(v) \ ((v) < 0 ? 0 : (v) > 100 ? 15 : (v) * 3 / 20) #define RECLEVEL_GAIN_TO_VOXWARE(v) (((v) * 20 + 2) / 3) static void __init TTMixerInit(void) { atari_microwire_cmd(MW_LM1992_VOLUME(0)); dmasound.volume_left = 0; atari_microwire_cmd(MW_LM1992_BALLEFT(0)); dmasound.volume_right = 0; atari_microwire_cmd(MW_LM1992_BALRIGHT(0)); atari_microwire_cmd(MW_LM1992_TREBLE(0)); atari_microwire_cmd(MW_LM1992_BASS(0)); } static void __init FalconMixerInit(void) { dmasound.volume_left = (tt_dmasnd.output_atten & 0xf00) >> 8; dmasound.volume_right = (tt_dmasnd.output_atten & 0xf0) >> 4; } static int AtaMixerIoctl(u_int cmd, u_long arg) { int data; unsigned long flags; switch (cmd) { case SOUND_MIXER_READ_SPEAKER: if (is_falcon || MACH_IS_TT) { int porta; spin_lock_irqsave(&dmasound.lock, flags); sound_ym.rd_data_reg_sel = 14; porta = sound_ym.rd_data_reg_sel; spin_unlock_irqrestore(&dmasound.lock, flags); return IOCTL_OUT(arg, porta & 0x40 ? 0 : 100); } break; case SOUND_MIXER_WRITE_VOLUME: IOCTL_IN(arg, data); return IOCTL_OUT(arg, dmasound_set_volume(data)); case SOUND_MIXER_WRITE_SPEAKER: if (is_falcon || MACH_IS_TT) { int porta; IOCTL_IN(arg, data); spin_lock_irqsave(&dmasound.lock, flags); sound_ym.rd_data_reg_sel = 14; porta = (sound_ym.rd_data_reg_sel & ~0x40) | (data < 50 ? 0x40 : 0); sound_ym.wd_data = porta; spin_unlock_irqrestore(&dmasound.lock, flags); return IOCTL_OUT(arg, porta & 0x40 ? 0 : 100); } } return -EINVAL; } static int TTMixerIoctl(u_int cmd, u_long arg) { int data; switch (cmd) { case SOUND_MIXER_READ_RECMASK: return IOCTL_OUT(arg, 0); case SOUND_MIXER_READ_DEVMASK: return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_TREBLE | SOUND_MASK_BASS | (MACH_IS_TT ? SOUND_MASK_SPEAKER : 0)); case SOUND_MIXER_READ_STEREODEVS: return IOCTL_OUT(arg, SOUND_MASK_VOLUME); case SOUND_MIXER_READ_VOLUME: return IOCTL_OUT(arg, VOLUME_DB_TO_VOXWARE(dmasound.volume_left) | (VOLUME_DB_TO_VOXWARE(dmasound.volume_right) << 8)); case SOUND_MIXER_READ_BASS: return IOCTL_OUT(arg, TONE_DB_TO_VOXWARE(dmasound.bass)); case SOUND_MIXER_READ_TREBLE: return IOCTL_OUT(arg, TONE_DB_TO_VOXWARE(dmasound.treble)); case SOUND_MIXER_READ_OGAIN: return IOCTL_OUT(arg, GAIN_DB_TO_VOXWARE(dmasound.gain)); case SOUND_MIXER_WRITE_BASS: IOCTL_IN(arg, data); return IOCTL_OUT(arg, dmasound_set_bass(data)); case SOUND_MIXER_WRITE_TREBLE: IOCTL_IN(arg, data); return IOCTL_OUT(arg, dmasound_set_treble(data)); case SOUND_MIXER_WRITE_OGAIN: IOCTL_IN(arg, data); return IOCTL_OUT(arg, dmasound_set_gain(data)); } return AtaMixerIoctl(cmd, arg); } static int FalconMixerIoctl(u_int cmd, u_long arg) { int data; switch (cmd) { case SOUND_MIXER_READ_RECMASK: return IOCTL_OUT(arg, SOUND_MASK_MIC); case SOUND_MIXER_READ_DEVMASK: return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC | SOUND_MASK_SPEAKER); case SOUND_MIXER_READ_STEREODEVS: return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC); case SOUND_MIXER_READ_VOLUME: return IOCTL_OUT(arg, VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) | VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8); case SOUND_MIXER_READ_CAPS: return IOCTL_OUT(arg, SOUND_CAP_EXCL_INPUT); case SOUND_MIXER_WRITE_MIC: IOCTL_IN(arg, data); tt_dmasnd.input_gain = RECLEVEL_VOXWARE_TO_GAIN(data & 0xff) << 4 | RECLEVEL_VOXWARE_TO_GAIN(data >> 8 & 0xff); fallthrough; /* return set value */ case SOUND_MIXER_READ_MIC: return IOCTL_OUT(arg, RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain >> 4 & 0xf) | RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain & 0xf) << 8); } return AtaMixerIoctl(cmd, arg); } static int AtaWriteSqSetup(void) { write_sq_ignore_int = 0; return 0 ; } static int AtaSqOpen(fmode_t mode) { write_sq_ignore_int = 1; return 0 ; } static int TTStateInfo(char *buffer, size_t space) { int len = 0; len += sprintf(buffer+len, "\tvol left %ddB [-40... 0]\n", dmasound.volume_left); len += sprintf(buffer+len, "\tvol right %ddB [-40... 0]\n", dmasound.volume_right); len += sprintf(buffer+len, "\tbass %ddB [-12...+12]\n", dmasound.bass); len += sprintf(buffer+len, "\ttreble %ddB [-12...+12]\n", dmasound.treble); if (len >= space) { printk(KERN_ERR "dmasound_atari: overflowed state buffer alloc.\n") ; len = space ; } return len; } static int FalconStateInfo(char *buffer, size_t space) { int len = 0; len += sprintf(buffer+len, "\tvol left %ddB [-22.5 ... 0]\n", dmasound.volume_left); len += sprintf(buffer+len, "\tvol right %ddB [-22.5 ... 0]\n", dmasound.volume_right); if (len >= space) { printk(KERN_ERR "dmasound_atari: overflowed state buffer alloc.\n") ; len = space ; } return len; } /*** Machine definitions *****************************************************/ static SETTINGS def_hard_falcon = { .format = AFMT_S8, .stereo = 0, .size = 8, .speed = 8195 } ; static SETTINGS def_hard_tt = { .format = AFMT_S8, .stereo = 0, .size = 8, .speed = 12517 } ; static SETTINGS def_soft = { .format = AFMT_U8, .stereo = 0, .size = 8, .speed = 8000 } ; static __initdata MACHINE machTT = { .name = "Atari", .name2 = "TT", .owner = THIS_MODULE, .dma_alloc = AtaAlloc, .dma_free = AtaFree, .irqinit = AtaIrqInit, #ifdef MODULE .irqcleanup = AtaIrqCleanUp, #endif /* MODULE */ .init = TTInit, .silence = TTSilence, .setFormat = TTSetFormat, .setVolume = TTSetVolume, .setBass = AtaSetBass, .setTreble = AtaSetTreble, .setGain = TTSetGain, .play = AtaPlay, .mixer_init = TTMixerInit, .mixer_ioctl = TTMixerIoctl, .write_sq_setup = AtaWriteSqSetup, .sq_open = AtaSqOpen, .state_info = TTStateInfo, .min_dsp_speed = 6258, .version = ((DMASOUND_ATARI_REVISION<<8) | DMASOUND_ATARI_EDITION), .hardware_afmts = AFMT_S8, /* h'ware-supported formats *only* here */ .capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */ }; static __initdata MACHINE machFalcon = { .name = "Atari", .name2 = "FALCON", .dma_alloc = AtaAlloc, .dma_free = AtaFree, .irqinit = AtaIrqInit, #ifdef MODULE .irqcleanup = AtaIrqCleanUp, #endif /* MODULE */ .init = FalconInit, .silence = FalconSilence, .setFormat = FalconSetFormat, .setVolume = FalconSetVolume, .setBass = AtaSetBass, .setTreble = AtaSetTreble, .play = AtaPlay, .mixer_init = FalconMixerInit, .mixer_ioctl = FalconMixerIoctl, .write_sq_setup = AtaWriteSqSetup, .sq_open = AtaSqOpen, .state_info = FalconStateInfo, .min_dsp_speed = 8195, .version = ((DMASOUND_ATARI_REVISION<<8) | DMASOUND_ATARI_EDITION), .hardware_afmts = (AFMT_S8 | AFMT_S16_BE), /* h'ware-supported formats *only* here */ .capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */ }; /*** Config & Setup **********************************************************/ static int __init dmasound_atari_init(void) { if (MACH_IS_ATARI && ATARIHW_PRESENT(PCM_8BIT)) { if (ATARIHW_PRESENT(CODEC)) { dmasound.mach = machFalcon; dmasound.mach.default_soft = def_soft ; dmasound.mach.default_hard = def_hard_falcon ; is_falcon = 1; } else if (ATARIHW_PRESENT(MICROWIRE)) { dmasound.mach = machTT; dmasound.mach.default_soft = def_soft ; dmasound.mach.default_hard = def_hard_tt ; is_falcon = 0; } else return -ENODEV; if ((st_mfp.int_en_a & st_mfp.int_mk_a & 0x20) == 0) return dmasound_init(); else { printk("DMA sound driver: Timer A interrupt already in use\n"); return -EBUSY; } } return -ENODEV; } static void __exit dmasound_atari_cleanup(void) { dmasound_deinit(); } module_init(dmasound_atari_init); module_exit(dmasound_atari_cleanup); MODULE_LICENSE("GPL");
linux-master
sound/oss/dmasound/dmasound_atari.c
// SPDX-License-Identifier: GPL-2.0-only /* * linux/sound/oss/dmasound/dmasound_q40.c * * Q40 DMA Sound Driver * * See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits * prior to 28/01/2001 * * 28/01/2001 [0.1] Iain Sandoe * - added versioning * - put in and populated the hardware_afmts field. * [0.2] - put in SNDCTL_DSP_GETCAPS value. * [0.3] - put in default hard/soft settings. */ #include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/soundcard.h> #include <linux/interrupt.h> #include <linux/uaccess.h> #include <asm/q40ints.h> #include <asm/q40_master.h> #include "dmasound.h" #define DMASOUND_Q40_REVISION 0 #define DMASOUND_Q40_EDITION 3 static int expand_bal; /* Balance factor for expanding (not volume!) */ static int expand_data; /* Data for expanding */ /*** Low level stuff *********************************************************/ static void *Q40Alloc(unsigned int size, gfp_t flags); static void Q40Free(void *, unsigned int); static int Q40IrqInit(void); #ifdef MODULE static void Q40IrqCleanUp(void); #endif static void Q40Silence(void); static void Q40Init(void); static int Q40SetFormat(int format); static int Q40SetVolume(int volume); static void Q40PlayNextFrame(int index); static void Q40Play(void); static irqreturn_t Q40StereoInterrupt(int irq, void *dummy); static irqreturn_t Q40MonoInterrupt(int irq, void *dummy); static void Q40Interrupt(void); /*** Mid level stuff *********************************************************/ /* userCount, frameUsed, frameLeft == byte counts */ static ssize_t q40_ct_law(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8; ssize_t count, used; u_char *p = (u_char *) &frame[*frameUsed]; used = count = min_t(size_t, userCount, frameLeft); if (copy_from_user(p,userPtr,count)) return -EFAULT; while (count > 0) { *p = table[*p]+128; p++; count--; } *frameUsed += used ; return used; } static ssize_t q40_ct_s8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; u_char *p = (u_char *) &frame[*frameUsed]; used = count = min_t(size_t, userCount, frameLeft); if (copy_from_user(p,userPtr,count)) return -EFAULT; while (count > 0) { *p = *p + 128; p++; count--; } *frameUsed += used; return used; } static ssize_t q40_ct_u8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { ssize_t count, used; u_char *p = (u_char *) &frame[*frameUsed]; used = count = min_t(size_t, userCount, frameLeft); if (copy_from_user(p,userPtr,count)) return -EFAULT; *frameUsed += used; return used; } /* a bit too complicated to optimise right now ..*/ static ssize_t q40_ctx_law(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { unsigned char *table = (unsigned char *) (dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8); unsigned int data = expand_data; u_char *p = (u_char *) &frame[*frameUsed]; int bal = expand_bal; int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; int utotal, ftotal; ftotal = frameLeft; utotal = userCount; while (frameLeft) { u_char c; if (bal < 0) { if (userCount == 0) break; if (get_user(c, userPtr++)) return -EFAULT; data = table[c]; data += 0x80; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } expand_bal = bal; expand_data = data; *frameUsed += (ftotal - frameLeft); utotal -= userCount; return utotal; } static ssize_t q40_ctx_s8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { u_char *p = (u_char *) &frame[*frameUsed]; unsigned int data = expand_data; int bal = expand_bal; int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; int utotal, ftotal; ftotal = frameLeft; utotal = userCount; while (frameLeft) { u_char c; if (bal < 0) { if (userCount == 0) break; if (get_user(c, userPtr++)) return -EFAULT; data = c ; data += 0x80; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } expand_bal = bal; expand_data = data; *frameUsed += (ftotal - frameLeft); utotal -= userCount; return utotal; } static ssize_t q40_ctx_u8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { u_char *p = (u_char *) &frame[*frameUsed]; unsigned int data = expand_data; int bal = expand_bal; int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; int utotal, ftotal; ftotal = frameLeft; utotal = userCount; while (frameLeft) { u_char c; if (bal < 0) { if (userCount == 0) break; if (get_user(c, userPtr++)) return -EFAULT; data = c ; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } expand_bal = bal; expand_data = data; *frameUsed += (ftotal - frameLeft) ; utotal -= userCount; return utotal; } /* compressing versions */ static ssize_t q40_ctc_law(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { unsigned char *table = (unsigned char *) (dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8); unsigned int data = expand_data; u_char *p = (u_char *) &frame[*frameUsed]; int bal = expand_bal; int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; int utotal, ftotal; ftotal = frameLeft; utotal = userCount; while (frameLeft) { u_char c; while(bal<0) { if (userCount == 0) goto lout; if (!(bal<(-hSpeed))) { if (get_user(c, userPtr)) return -EFAULT; data = 0x80 + table[c]; } userPtr++; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } lout: expand_bal = bal; expand_data = data; *frameUsed += (ftotal - frameLeft); utotal -= userCount; return utotal; } static ssize_t q40_ctc_s8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { u_char *p = (u_char *) &frame[*frameUsed]; unsigned int data = expand_data; int bal = expand_bal; int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; int utotal, ftotal; ftotal = frameLeft; utotal = userCount; while (frameLeft) { u_char c; while (bal < 0) { if (userCount == 0) goto lout; if (!(bal<(-hSpeed))) { if (get_user(c, userPtr)) return -EFAULT; data = c + 0x80; } userPtr++; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } lout: expand_bal = bal; expand_data = data; *frameUsed += (ftotal - frameLeft); utotal -= userCount; return utotal; } static ssize_t q40_ctc_u8(const u_char __user *userPtr, size_t userCount, u_char frame[], ssize_t *frameUsed, ssize_t frameLeft) { u_char *p = (u_char *) &frame[*frameUsed]; unsigned int data = expand_data; int bal = expand_bal; int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; int utotal, ftotal; ftotal = frameLeft; utotal = userCount; while (frameLeft) { u_char c; while (bal < 0) { if (userCount == 0) goto lout; if (!(bal<(-hSpeed))) { if (get_user(c, userPtr)) return -EFAULT; data = c ; } userPtr++; userCount--; bal += hSpeed; } *p++ = data; frameLeft--; bal -= sSpeed; } lout: expand_bal = bal; expand_data = data; *frameUsed += (ftotal - frameLeft) ; utotal -= userCount; return utotal; } static TRANS transQ40Normal = { q40_ct_law, q40_ct_law, q40_ct_s8, q40_ct_u8, NULL, NULL, NULL, NULL }; static TRANS transQ40Expanding = { q40_ctx_law, q40_ctx_law, q40_ctx_s8, q40_ctx_u8, NULL, NULL, NULL, NULL }; static TRANS transQ40Compressing = { q40_ctc_law, q40_ctc_law, q40_ctc_s8, q40_ctc_u8, NULL, NULL, NULL, NULL }; /*** Low level stuff *********************************************************/ static void *Q40Alloc(unsigned int size, gfp_t flags) { return kmalloc(size, flags); /* change to vmalloc */ } static void Q40Free(void *ptr, unsigned int size) { kfree(ptr); } static int __init Q40IrqInit(void) { /* Register interrupt handler. */ if (request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0, "DMA sound", Q40Interrupt)) return 0; return(1); } #ifdef MODULE static void Q40IrqCleanUp(void) { master_outb(0,SAMPLE_ENABLE_REG); free_irq(Q40_IRQ_SAMPLE, Q40Interrupt); } #endif /* MODULE */ static void Q40Silence(void) { master_outb(0,SAMPLE_ENABLE_REG); *DAC_LEFT=*DAC_RIGHT=127; } static char *q40_pp; static unsigned int q40_sc; static void Q40PlayNextFrame(int index) { u_char *start; u_long size; u_char speed; int error; /* used by Q40Play() if all doubts whether there really is something * to be played are already wiped out. */ start = write_sq.buffers[write_sq.front]; size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size); q40_pp=start; q40_sc=size; write_sq.front = (write_sq.front+1) % write_sq.max_count; write_sq.active++; speed=(dmasound.hard.speed==10000 ? 0 : 1); master_outb( 0,SAMPLE_ENABLE_REG); free_irq(Q40_IRQ_SAMPLE, Q40Interrupt); if (dmasound.soft.stereo) error = request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0, "Q40 sound", Q40Interrupt); else error = request_irq(Q40_IRQ_SAMPLE, Q40MonoInterrupt, 0, "Q40 sound", Q40Interrupt); if (error && printk_ratelimit()) pr_err("Couldn't register sound interrupt\n"); master_outb( speed, SAMPLE_RATE_REG); master_outb( 1,SAMPLE_CLEAR_REG); master_outb( 1,SAMPLE_ENABLE_REG); } static void Q40Play(void) { unsigned long flags; if (write_sq.active || write_sq.count<=0 ) { /* There's already a frame loaded */ return; } /* nothing in the queue */ if (write_sq.count <= 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) { /* hmmm, the only existing frame is not * yet filled and we're not syncing? */ return; } spin_lock_irqsave(&dmasound.lock, flags); Q40PlayNextFrame(1); spin_unlock_irqrestore(&dmasound.lock, flags); } static irqreturn_t Q40StereoInterrupt(int irq, void *dummy) { spin_lock(&dmasound.lock); if (q40_sc>1){ *DAC_LEFT=*q40_pp++; *DAC_RIGHT=*q40_pp++; q40_sc -=2; master_outb(1,SAMPLE_CLEAR_REG); }else Q40Interrupt(); spin_unlock(&dmasound.lock); return IRQ_HANDLED; } static irqreturn_t Q40MonoInterrupt(int irq, void *dummy) { spin_lock(&dmasound.lock); if (q40_sc>0){ *DAC_LEFT=*q40_pp; *DAC_RIGHT=*q40_pp++; q40_sc --; master_outb(1,SAMPLE_CLEAR_REG); }else Q40Interrupt(); spin_unlock(&dmasound.lock); return IRQ_HANDLED; } static void Q40Interrupt(void) { if (!write_sq.active) { /* playing was interrupted and sq_reset() has already cleared * the sq variables, so better don't do anything here. */ WAKE_UP(write_sq.sync_queue); master_outb(0,SAMPLE_ENABLE_REG); /* better safe */ goto exit; } else write_sq.active=0; write_sq.count--; Q40Play(); if (q40_sc<2) { /* there was nothing to play, disable irq */ master_outb(0,SAMPLE_ENABLE_REG); *DAC_LEFT=*DAC_RIGHT=127; } WAKE_UP(write_sq.action_queue); exit: master_outb(1,SAMPLE_CLEAR_REG); } static void Q40Init(void) { int i, idx; const int freq[] = {10000, 20000}; /* search a frequency that fits into the allowed error range */ idx = -1; for (i = 0; i < 2; i++) if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) <= catchRadius) idx = i; dmasound.hard = dmasound.soft; /*sound.hard.stereo=1;*/ /* no longer true */ dmasound.hard.size=8; if (idx > -1) { dmasound.soft.speed = freq[idx]; dmasound.trans_write = &transQ40Normal; } else dmasound.trans_write = &transQ40Expanding; Q40Silence(); if (dmasound.hard.speed > 20200) { /* squeeze the sound, we do that */ dmasound.hard.speed = 20000; dmasound.trans_write = &transQ40Compressing; } else if (dmasound.hard.speed > 10000) { dmasound.hard.speed = 20000; } else { dmasound.hard.speed = 10000; } expand_bal = -dmasound.soft.speed; } static int Q40SetFormat(int format) { /* Q40 sound supports only 8bit modes */ switch (format) { case AFMT_QUERY: return(dmasound.soft.format); case AFMT_MU_LAW: case AFMT_A_LAW: case AFMT_S8: case AFMT_U8: break; default: format = AFMT_S8; } dmasound.soft.format = format; dmasound.soft.size = 8; if (dmasound.minDev == SND_DEV_DSP) { dmasound.dsp.format = format; dmasound.dsp.size = 8; } Q40Init(); return(format); } static int Q40SetVolume(int volume) { return 0; } /*** Machine definitions *****************************************************/ static SETTINGS def_hard = { .format = AFMT_U8, .stereo = 0, .size = 8, .speed = 10000 } ; static SETTINGS def_soft = { .format = AFMT_U8, .stereo = 0, .size = 8, .speed = 8000 } ; static MACHINE machQ40 = { .name = "Q40", .name2 = "Q40", .owner = THIS_MODULE, .dma_alloc = Q40Alloc, .dma_free = Q40Free, .irqinit = Q40IrqInit, #ifdef MODULE .irqcleanup = Q40IrqCleanUp, #endif /* MODULE */ .init = Q40Init, .silence = Q40Silence, .setFormat = Q40SetFormat, .setVolume = Q40SetVolume, .play = Q40Play, .min_dsp_speed = 10000, .version = ((DMASOUND_Q40_REVISION<<8) | DMASOUND_Q40_EDITION), .hardware_afmts = AFMT_U8, /* h'ware-supported formats *only* here */ .capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */ }; /*** Config & Setup **********************************************************/ static int __init dmasound_q40_init(void) { if (MACH_IS_Q40) { dmasound.mach = machQ40; dmasound.mach.default_hard = def_hard ; dmasound.mach.default_soft = def_soft ; return dmasound_init(); } else return -ENODEV; } static void __exit dmasound_q40_cleanup(void) { dmasound_deinit(); } module_init(dmasound_q40_init); module_exit(dmasound_q40_cleanup); MODULE_DESCRIPTION("Q40/Q60 sound driver"); MODULE_LICENSE("GPL");
linux-master
sound/oss/dmasound/dmasound_q40.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Driver for Sound Core PDAudioCF soundcard * * Copyright (c) 2003 by Jaroslav Kysela <[email protected]> */ #include <sound/core.h> #include "pdaudiocf.h" #include <sound/initval.h> #include <asm/irq_regs.h> /* * */ irqreturn_t pdacf_interrupt(int irq, void *dev) { struct snd_pdacf *chip = dev; unsigned short stat; bool wake_thread = false; if ((chip->chip_status & (PDAUDIOCF_STAT_IS_STALE| PDAUDIOCF_STAT_IS_CONFIGURED| PDAUDIOCF_STAT_IS_SUSPENDED)) != PDAUDIOCF_STAT_IS_CONFIGURED) return IRQ_HANDLED; /* IRQ_NONE here? */ stat = inw(chip->port + PDAUDIOCF_REG_ISR); if (stat & (PDAUDIOCF_IRQLVL|PDAUDIOCF_IRQOVR)) { if (stat & PDAUDIOCF_IRQOVR) /* should never happen */ snd_printk(KERN_ERR "PDAUDIOCF SRAM buffer overrun detected!\n"); if (chip->pcm_substream) wake_thread = true; if (!(stat & PDAUDIOCF_IRQAKM)) stat |= PDAUDIOCF_IRQAKM; /* check rate */ } if (get_irq_regs() != NULL) snd_ak4117_check_rate_and_errors(chip->ak4117, 0); return wake_thread ? IRQ_WAKE_THREAD : IRQ_HANDLED; } static inline void pdacf_transfer_mono16(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port) { while (size-- > 0) { *dst++ = inw(rdp_port) ^ xor; inw(rdp_port); } } static inline void pdacf_transfer_mono32(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port) { register u16 val1, val2; while (size-- > 0) { val1 = inw(rdp_port); val2 = inw(rdp_port); inw(rdp_port); *dst++ = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor; } } static inline void pdacf_transfer_stereo16(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port) { while (size-- > 0) { *dst++ = inw(rdp_port) ^ xor; *dst++ = inw(rdp_port) ^ xor; } } static inline void pdacf_transfer_stereo32(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port) { register u16 val1, val2, val3; while (size-- > 0) { val1 = inw(rdp_port); val2 = inw(rdp_port); val3 = inw(rdp_port); *dst++ = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor; *dst++ = (((u32)val3 << 16) | (val2 & 0xff00)) ^ xor; } } static inline void pdacf_transfer_mono16sw(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port) { while (size-- > 0) { *dst++ = swab16(inw(rdp_port) ^ xor); inw(rdp_port); } } static inline void pdacf_transfer_mono32sw(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port) { register u16 val1, val2; while (size-- > 0) { val1 = inw(rdp_port); val2 = inw(rdp_port); inw(rdp_port); *dst++ = swab32((((val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor); } } static inline void pdacf_transfer_stereo16sw(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port) { while (size-- > 0) { *dst++ = swab16(inw(rdp_port) ^ xor); *dst++ = swab16(inw(rdp_port) ^ xor); } } static inline void pdacf_transfer_stereo32sw(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port) { register u16 val1, val2, val3; while (size-- > 0) { val1 = inw(rdp_port); val2 = inw(rdp_port); val3 = inw(rdp_port); *dst++ = swab32((((val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor); *dst++ = swab32((((u32)val3 << 16) | (val2 & 0xff00)) ^ xor); } } static inline void pdacf_transfer_mono24le(u8 *dst, u16 xor, unsigned int size, unsigned long rdp_port) { register u16 val1, val2; register u32 xval1; while (size-- > 0) { val1 = inw(rdp_port); val2 = inw(rdp_port); inw(rdp_port); xval1 = (((val2 & 0xff) << 8) | (val1 << 16)) ^ xor; *dst++ = (u8)(xval1 >> 8); *dst++ = (u8)(xval1 >> 16); *dst++ = (u8)(xval1 >> 24); } } static inline void pdacf_transfer_mono24be(u8 *dst, u16 xor, unsigned int size, unsigned long rdp_port) { register u16 val1, val2; register u32 xval1; while (size-- > 0) { val1 = inw(rdp_port); val2 = inw(rdp_port); inw(rdp_port); xval1 = (((val2 & 0xff) << 8) | (val1 << 16)) ^ xor; *dst++ = (u8)(xval1 >> 24); *dst++ = (u8)(xval1 >> 16); *dst++ = (u8)(xval1 >> 8); } } static inline void pdacf_transfer_stereo24le(u8 *dst, u32 xor, unsigned int size, unsigned long rdp_port) { register u16 val1, val2, val3; register u32 xval1, xval2; while (size-- > 0) { val1 = inw(rdp_port); val2 = inw(rdp_port); val3 = inw(rdp_port); xval1 = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor; xval2 = (((u32)val3 << 16) | (val2 & 0xff00)) ^ xor; *dst++ = (u8)(xval1 >> 8); *dst++ = (u8)(xval1 >> 16); *dst++ = (u8)(xval1 >> 24); *dst++ = (u8)(xval2 >> 8); *dst++ = (u8)(xval2 >> 16); *dst++ = (u8)(xval2 >> 24); } } static inline void pdacf_transfer_stereo24be(u8 *dst, u32 xor, unsigned int size, unsigned long rdp_port) { register u16 val1, val2, val3; register u32 xval1, xval2; while (size-- > 0) { val1 = inw(rdp_port); val2 = inw(rdp_port); val3 = inw(rdp_port); xval1 = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor; xval2 = (((u32)val3 << 16) | (val2 & 0xff00)) ^ xor; *dst++ = (u8)(xval1 >> 24); *dst++ = (u8)(xval1 >> 16); *dst++ = (u8)(xval1 >> 8); *dst++ = (u8)(xval2 >> 24); *dst++ = (u8)(xval2 >> 16); *dst++ = (u8)(xval2 >> 8); } } static void pdacf_transfer(struct snd_pdacf *chip, unsigned int size, unsigned int off) { unsigned long rdp_port = chip->port + PDAUDIOCF_REG_MD; unsigned int xor = chip->pcm_xor; if (chip->pcm_sample == 3) { if (chip->pcm_little) { if (chip->pcm_channels == 1) { pdacf_transfer_mono24le((char *)chip->pcm_area + (off * 3), xor, size, rdp_port); } else { pdacf_transfer_stereo24le((char *)chip->pcm_area + (off * 6), xor, size, rdp_port); } } else { if (chip->pcm_channels == 1) { pdacf_transfer_mono24be((char *)chip->pcm_area + (off * 3), xor, size, rdp_port); } else { pdacf_transfer_stereo24be((char *)chip->pcm_area + (off * 6), xor, size, rdp_port); } } return; } if (chip->pcm_swab == 0) { if (chip->pcm_channels == 1) { if (chip->pcm_frame == 2) { pdacf_transfer_mono16((u16 *)chip->pcm_area + off, xor, size, rdp_port); } else { pdacf_transfer_mono32((u32 *)chip->pcm_area + off, xor, size, rdp_port); } } else { if (chip->pcm_frame == 2) { pdacf_transfer_stereo16((u16 *)chip->pcm_area + (off * 2), xor, size, rdp_port); } else { pdacf_transfer_stereo32((u32 *)chip->pcm_area + (off * 2), xor, size, rdp_port); } } } else { if (chip->pcm_channels == 1) { if (chip->pcm_frame == 2) { pdacf_transfer_mono16sw((u16 *)chip->pcm_area + off, xor, size, rdp_port); } else { pdacf_transfer_mono32sw((u32 *)chip->pcm_area + off, xor, size, rdp_port); } } else { if (chip->pcm_frame == 2) { pdacf_transfer_stereo16sw((u16 *)chip->pcm_area + (off * 2), xor, size, rdp_port); } else { pdacf_transfer_stereo32sw((u32 *)chip->pcm_area + (off * 2), xor, size, rdp_port); } } } } irqreturn_t pdacf_threaded_irq(int irq, void *dev) { struct snd_pdacf *chip = dev; int size, off, cont, rdp, wdp; if ((chip->chip_status & (PDAUDIOCF_STAT_IS_STALE|PDAUDIOCF_STAT_IS_CONFIGURED)) != PDAUDIOCF_STAT_IS_CONFIGURED) return IRQ_HANDLED; if (chip->pcm_substream == NULL || chip->pcm_substream->runtime == NULL || !snd_pcm_running(chip->pcm_substream)) return IRQ_HANDLED; rdp = inw(chip->port + PDAUDIOCF_REG_RDP); wdp = inw(chip->port + PDAUDIOCF_REG_WDP); /* printk(KERN_DEBUG "TASKLET: rdp = %x, wdp = %x\n", rdp, wdp); */ size = wdp - rdp; if (size < 0) size += 0x10000; if (size == 0) size = 0x10000; size /= chip->pcm_frame; if (size > 64) size -= 32; #if 0 chip->pcm_hwptr += size; chip->pcm_hwptr %= chip->pcm_size; chip->pcm_tdone += size; if (chip->pcm_frame == 2) { unsigned long rdp_port = chip->port + PDAUDIOCF_REG_MD; while (size-- > 0) { inw(rdp_port); inw(rdp_port); } } else { unsigned long rdp_port = chip->port + PDAUDIOCF_REG_MD; while (size-- > 0) { inw(rdp_port); inw(rdp_port); inw(rdp_port); } } #else off = chip->pcm_hwptr + chip->pcm_tdone; off %= chip->pcm_size; chip->pcm_tdone += size; while (size > 0) { cont = chip->pcm_size - off; if (cont > size) cont = size; pdacf_transfer(chip, cont, off); off += cont; off %= chip->pcm_size; size -= cont; } #endif mutex_lock(&chip->reg_lock); while (chip->pcm_tdone >= chip->pcm_period) { chip->pcm_hwptr += chip->pcm_period; chip->pcm_hwptr %= chip->pcm_size; chip->pcm_tdone -= chip->pcm_period; mutex_unlock(&chip->reg_lock); snd_pcm_period_elapsed(chip->pcm_substream); mutex_lock(&chip->reg_lock); } mutex_unlock(&chip->reg_lock); return IRQ_HANDLED; }
linux-master
sound/pcmcia/pdaudiocf/pdaudiocf_irq.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Driver for Sound Core PDAudioCF soundcards * * PCM part * * Copyright (c) 2003 by Jaroslav Kysela <[email protected]> */ #include <linux/delay.h> #include <sound/core.h> #include <sound/asoundef.h> #include "pdaudiocf.h" /* * clear the SRAM contents */ static int pdacf_pcm_clear_sram(struct snd_pdacf *chip) { int max_loop = 64 * 1024; while (inw(chip->port + PDAUDIOCF_REG_RDP) != inw(chip->port + PDAUDIOCF_REG_WDP)) { if (max_loop-- < 0) return -EIO; inw(chip->port + PDAUDIOCF_REG_MD); } return 0; } /* * pdacf_pcm_trigger - trigger callback for capture */ static int pdacf_pcm_trigger(struct snd_pcm_substream *subs, int cmd) { struct snd_pdacf *chip = snd_pcm_substream_chip(subs); struct snd_pcm_runtime *runtime = subs->runtime; int inc, ret = 0, rate; unsigned short mask, val, tmp; if (chip->chip_status & PDAUDIOCF_STAT_IS_STALE) return -EBUSY; switch (cmd) { case SNDRV_PCM_TRIGGER_START: chip->pcm_hwptr = 0; chip->pcm_tdone = 0; fallthrough; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_RESUME: mask = 0; val = PDAUDIOCF_RECORD; inc = 1; rate = snd_ak4117_check_rate_and_errors(chip->ak4117, AK4117_CHECK_NO_STAT|AK4117_CHECK_NO_RATE); break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_SUSPEND: mask = PDAUDIOCF_RECORD; val = 0; inc = -1; rate = 0; break; default: return -EINVAL; } mutex_lock(&chip->reg_lock); chip->pcm_running += inc; tmp = pdacf_reg_read(chip, PDAUDIOCF_REG_SCR); if (chip->pcm_running) { if ((chip->ak4117->rcs0 & AK4117_UNLCK) || runtime->rate != rate) { chip->pcm_running -= inc; ret = -EIO; goto __end; } } tmp &= ~mask; tmp |= val; pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, tmp); __end: mutex_unlock(&chip->reg_lock); snd_ak4117_check_rate_and_errors(chip->ak4117, AK4117_CHECK_NO_RATE); return ret; } /* * pdacf_pcm_prepare - prepare callback for playback and capture */ static int pdacf_pcm_prepare(struct snd_pcm_substream *subs) { struct snd_pdacf *chip = snd_pcm_substream_chip(subs); struct snd_pcm_runtime *runtime = subs->runtime; u16 val, nval, aval; if (chip->chip_status & PDAUDIOCF_STAT_IS_STALE) return -EBUSY; chip->pcm_channels = runtime->channels; chip->pcm_little = snd_pcm_format_little_endian(runtime->format) > 0; #ifdef SNDRV_LITTLE_ENDIAN chip->pcm_swab = snd_pcm_format_big_endian(runtime->format) > 0; #else chip->pcm_swab = chip->pcm_little; #endif if (snd_pcm_format_unsigned(runtime->format)) chip->pcm_xor = 0x80008000; if (pdacf_pcm_clear_sram(chip) < 0) return -EIO; val = nval = pdacf_reg_read(chip, PDAUDIOCF_REG_SCR); nval &= ~(PDAUDIOCF_DATAFMT0|PDAUDIOCF_DATAFMT1); switch (runtime->format) { case SNDRV_PCM_FORMAT_S16_LE: case SNDRV_PCM_FORMAT_S16_BE: break; default: /* 24-bit */ nval |= PDAUDIOCF_DATAFMT0 | PDAUDIOCF_DATAFMT1; break; } aval = 0; chip->pcm_sample = 4; switch (runtime->format) { case SNDRV_PCM_FORMAT_S16_LE: case SNDRV_PCM_FORMAT_S16_BE: aval = AK4117_DIF_16R; chip->pcm_frame = 2; chip->pcm_sample = 2; break; case SNDRV_PCM_FORMAT_S24_3LE: case SNDRV_PCM_FORMAT_S24_3BE: chip->pcm_sample = 3; fallthrough; default: /* 24-bit */ aval = AK4117_DIF_24R; chip->pcm_frame = 3; chip->pcm_xor &= 0xffff0000; break; } if (val != nval) { snd_ak4117_reg_write(chip->ak4117, AK4117_REG_IO, AK4117_DIF2|AK4117_DIF1|AK4117_DIF0, aval); pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, nval); } val = pdacf_reg_read(chip, PDAUDIOCF_REG_IER); val &= ~(PDAUDIOCF_IRQLVLEN1); val |= PDAUDIOCF_IRQLVLEN0; pdacf_reg_write(chip, PDAUDIOCF_REG_IER, val); chip->pcm_size = runtime->buffer_size; chip->pcm_period = runtime->period_size; chip->pcm_area = runtime->dma_area; return 0; } /* * capture hw information */ static const struct snd_pcm_hardware pdacf_pcm_capture_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BATCH), .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE | SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE, .rates = SNDRV_PCM_RATE_32000 | 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 = 32000, .rate_max = 192000, .channels_min = 1, .channels_max = 2, .buffer_bytes_max = (512*1024), .period_bytes_min = 8*1024, .period_bytes_max = (64*1024), .periods_min = 2, .periods_max = 128, .fifo_size = 0, }; /* * pdacf_pcm_capture_open - open callback for capture */ static int pdacf_pcm_capture_open(struct snd_pcm_substream *subs) { struct snd_pcm_runtime *runtime = subs->runtime; struct snd_pdacf *chip = snd_pcm_substream_chip(subs); if (chip->chip_status & PDAUDIOCF_STAT_IS_STALE) return -EBUSY; runtime->hw = pdacf_pcm_capture_hw; runtime->private_data = chip; chip->pcm_substream = subs; return 0; } /* * pdacf_pcm_capture_close - close callback for capture */ static int pdacf_pcm_capture_close(struct snd_pcm_substream *subs) { struct snd_pdacf *chip = snd_pcm_substream_chip(subs); if (!chip) return -EINVAL; pdacf_reinit(chip, 0); chip->pcm_substream = NULL; return 0; } /* * pdacf_pcm_capture_pointer - pointer callback for capture */ static snd_pcm_uframes_t pdacf_pcm_capture_pointer(struct snd_pcm_substream *subs) { struct snd_pdacf *chip = snd_pcm_substream_chip(subs); return chip->pcm_hwptr; } /* * operators for PCM capture */ static const struct snd_pcm_ops pdacf_pcm_capture_ops = { .open = pdacf_pcm_capture_open, .close = pdacf_pcm_capture_close, .prepare = pdacf_pcm_prepare, .trigger = pdacf_pcm_trigger, .pointer = pdacf_pcm_capture_pointer, }; /* * snd_pdacf_pcm_new - create and initialize a pcm */ int snd_pdacf_pcm_new(struct snd_pdacf *chip) { struct snd_pcm *pcm; int err; err = snd_pcm_new(chip->card, "PDAudioCF", 0, 0, 1, &pcm); if (err < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pdacf_pcm_capture_ops); snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0); pcm->private_data = chip; pcm->info_flags = 0; pcm->nonatomic = true; strcpy(pcm->name, chip->card->shortname); chip->pcm = pcm; err = snd_ak4117_build(chip->ak4117, pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream); if (err < 0) return err; return 0; }
linux-master
sound/pcmcia/pdaudiocf/pdaudiocf_pcm.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Driver for Sound Core PDAudioCF soundcard * * Copyright (c) 2003 by Jaroslav Kysela <[email protected]> */ #include <linux/delay.h> #include <linux/slab.h> #include <sound/core.h> #include <sound/info.h> #include "pdaudiocf.h" #include <sound/initval.h> /* * */ static unsigned char pdacf_ak4117_read(void *private_data, unsigned char reg) { struct snd_pdacf *chip = private_data; unsigned long timeout; unsigned long flags; unsigned char res; spin_lock_irqsave(&chip->ak4117_lock, flags); timeout = 1000; while (pdacf_reg_read(chip, PDAUDIOCF_REG_SCR) & PDAUDIOCF_AK_SBP) { udelay(5); if (--timeout == 0) { spin_unlock_irqrestore(&chip->ak4117_lock, flags); snd_printk(KERN_ERR "AK4117 ready timeout (read)\n"); return 0; } } pdacf_reg_write(chip, PDAUDIOCF_REG_AK_IFR, (u16)reg << 8); timeout = 1000; while (pdacf_reg_read(chip, PDAUDIOCF_REG_SCR) & PDAUDIOCF_AK_SBP) { udelay(5); if (--timeout == 0) { spin_unlock_irqrestore(&chip->ak4117_lock, flags); snd_printk(KERN_ERR "AK4117 read timeout (read2)\n"); return 0; } } res = (unsigned char)pdacf_reg_read(chip, PDAUDIOCF_REG_AK_IFR); spin_unlock_irqrestore(&chip->ak4117_lock, flags); return res; } static void pdacf_ak4117_write(void *private_data, unsigned char reg, unsigned char val) { struct snd_pdacf *chip = private_data; unsigned long timeout; unsigned long flags; spin_lock_irqsave(&chip->ak4117_lock, flags); timeout = 1000; while (inw(chip->port + PDAUDIOCF_REG_SCR) & PDAUDIOCF_AK_SBP) { udelay(5); if (--timeout == 0) { spin_unlock_irqrestore(&chip->ak4117_lock, flags); snd_printk(KERN_ERR "AK4117 ready timeout (write)\n"); return; } } outw((u16)reg << 8 | val | (1<<13), chip->port + PDAUDIOCF_REG_AK_IFR); spin_unlock_irqrestore(&chip->ak4117_lock, flags); } #if 0 void pdacf_dump(struct snd_pdacf *chip) { printk(KERN_DEBUG "PDAUDIOCF DUMP (0x%lx):\n", chip->port); printk(KERN_DEBUG "WPD : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_WDP)); printk(KERN_DEBUG "RDP : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_RDP)); printk(KERN_DEBUG "TCR : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_TCR)); printk(KERN_DEBUG "SCR : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_SCR)); printk(KERN_DEBUG "ISR : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_ISR)); printk(KERN_DEBUG "IER : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_IER)); printk(KERN_DEBUG "AK_IFR : 0x%x\n", inw(chip->port + PDAUDIOCF_REG_AK_IFR)); } #endif static int pdacf_reset(struct snd_pdacf *chip, int powerdown) { u16 val; val = pdacf_reg_read(chip, PDAUDIOCF_REG_SCR); val |= PDAUDIOCF_PDN; val &= ~PDAUDIOCF_RECORD; /* for sure */ pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, val); udelay(5); val |= PDAUDIOCF_RST; pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, val); udelay(200); val &= ~PDAUDIOCF_RST; pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, val); udelay(5); if (!powerdown) { val &= ~PDAUDIOCF_PDN; pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, val); udelay(200); } return 0; } void pdacf_reinit(struct snd_pdacf *chip, int resume) { pdacf_reset(chip, 0); if (resume) pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, chip->suspend_reg_scr); snd_ak4117_reinit(chip->ak4117); pdacf_reg_write(chip, PDAUDIOCF_REG_TCR, chip->regmap[PDAUDIOCF_REG_TCR>>1]); pdacf_reg_write(chip, PDAUDIOCF_REG_IER, chip->regmap[PDAUDIOCF_REG_IER>>1]); } static void pdacf_proc_read(struct snd_info_entry * entry, struct snd_info_buffer *buffer) { struct snd_pdacf *chip = entry->private_data; u16 tmp; snd_iprintf(buffer, "PDAudioCF\n\n"); tmp = pdacf_reg_read(chip, PDAUDIOCF_REG_SCR); snd_iprintf(buffer, "FPGA revision : 0x%x\n", PDAUDIOCF_FPGAREV(tmp)); } static void pdacf_proc_init(struct snd_pdacf *chip) { snd_card_ro_proc_new(chip->card, "pdaudiocf", chip, pdacf_proc_read); } struct snd_pdacf *snd_pdacf_create(struct snd_card *card) { struct snd_pdacf *chip; chip = kzalloc(sizeof(*chip), GFP_KERNEL); if (chip == NULL) return NULL; chip->card = card; mutex_init(&chip->reg_lock); spin_lock_init(&chip->ak4117_lock); card->private_data = chip; pdacf_proc_init(chip); return chip; } static void snd_pdacf_ak4117_change(struct ak4117 *ak4117, unsigned char c0, unsigned char c1) { struct snd_pdacf *chip = ak4117->change_callback_private; u16 val; if (!(c0 & AK4117_UNLCK)) return; mutex_lock(&chip->reg_lock); val = chip->regmap[PDAUDIOCF_REG_SCR>>1]; if (ak4117->rcs0 & AK4117_UNLCK) val |= PDAUDIOCF_BLUE_LED_OFF; else val &= ~PDAUDIOCF_BLUE_LED_OFF; pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, val); mutex_unlock(&chip->reg_lock); } int snd_pdacf_ak4117_create(struct snd_pdacf *chip) { int err; u16 val; /* design note: if we unmask PLL unlock, parity, valid, audio or auto bit interrupts */ /* from AK4117 then INT1 pin from AK4117 will be high all time, because PCMCIA interrupts are */ /* egde based and FPGA does logical OR for all interrupt sources, we cannot use these */ /* high-rate sources */ static const unsigned char pgm[5] = { AK4117_XTL_24_576M | AK4117_EXCT, /* AK4117_REG_PWRDN */ AK4117_CM_PLL_XTAL | AK4117_PKCS_128fs | AK4117_XCKS_128fs, /* AK4117_REQ_CLOCK */ AK4117_EFH_1024LRCLK | AK4117_DIF_24R | AK4117_IPS, /* AK4117_REG_IO */ 0xff, /* AK4117_REG_INT0_MASK */ AK4117_MAUTO | AK4117_MAUD | AK4117_MULK | AK4117_MPAR | AK4117_MV, /* AK4117_REG_INT1_MASK */ }; err = pdacf_reset(chip, 0); if (err < 0) return err; err = snd_ak4117_create(chip->card, pdacf_ak4117_read, pdacf_ak4117_write, pgm, chip, &chip->ak4117); if (err < 0) return err; val = pdacf_reg_read(chip, PDAUDIOCF_REG_TCR); #if 1 /* normal operation */ val &= ~(PDAUDIOCF_ELIMAKMBIT|PDAUDIOCF_TESTDATASEL); #else /* debug */ val |= PDAUDIOCF_ELIMAKMBIT; val &= ~PDAUDIOCF_TESTDATASEL; #endif pdacf_reg_write(chip, PDAUDIOCF_REG_TCR, val); /* setup the FPGA to match AK4117 setup */ val = pdacf_reg_read(chip, PDAUDIOCF_REG_SCR); val &= ~(PDAUDIOCF_CLKDIV0 | PDAUDIOCF_CLKDIV1); /* use 24.576Mhz clock */ val &= ~(PDAUDIOCF_RED_LED_OFF|PDAUDIOCF_BLUE_LED_OFF); val |= PDAUDIOCF_DATAFMT0 | PDAUDIOCF_DATAFMT1; /* 24-bit data */ pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, val); /* setup LEDs and IRQ */ val = pdacf_reg_read(chip, PDAUDIOCF_REG_IER); val &= ~(PDAUDIOCF_IRQLVLEN0 | PDAUDIOCF_IRQLVLEN1); val &= ~(PDAUDIOCF_BLUEDUTY0 | PDAUDIOCF_REDDUTY0 | PDAUDIOCF_REDDUTY1); val |= PDAUDIOCF_BLUEDUTY1 | PDAUDIOCF_HALFRATE; val |= PDAUDIOCF_IRQOVREN | PDAUDIOCF_IRQAKMEN; pdacf_reg_write(chip, PDAUDIOCF_REG_IER, val); chip->ak4117->change_callback_private = chip; chip->ak4117->change_callback = snd_pdacf_ak4117_change; /* update LED status */ snd_pdacf_ak4117_change(chip->ak4117, AK4117_UNLCK, 0); return 0; } void snd_pdacf_powerdown(struct snd_pdacf *chip) { u16 val; val = pdacf_reg_read(chip, PDAUDIOCF_REG_SCR); chip->suspend_reg_scr = val; val |= PDAUDIOCF_RED_LED_OFF | PDAUDIOCF_BLUE_LED_OFF; pdacf_reg_write(chip, PDAUDIOCF_REG_SCR, val); /* disable interrupts, but use direct write to preserve old register value in chip->regmap */ val = inw(chip->port + PDAUDIOCF_REG_IER); val &= ~(PDAUDIOCF_IRQOVREN|PDAUDIOCF_IRQAKMEN|PDAUDIOCF_IRQLVLEN0|PDAUDIOCF_IRQLVLEN1); outw(val, chip->port + PDAUDIOCF_REG_IER); pdacf_reset(chip, 1); } #ifdef CONFIG_PM int snd_pdacf_suspend(struct snd_pdacf *chip) { u16 val; snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot); /* disable interrupts, but use direct write to preserve old register value in chip->regmap */ val = inw(chip->port + PDAUDIOCF_REG_IER); val &= ~(PDAUDIOCF_IRQOVREN|PDAUDIOCF_IRQAKMEN|PDAUDIOCF_IRQLVLEN0|PDAUDIOCF_IRQLVLEN1); outw(val, chip->port + PDAUDIOCF_REG_IER); chip->chip_status |= PDAUDIOCF_STAT_IS_SUSPENDED; /* ignore interrupts from now */ snd_pdacf_powerdown(chip); return 0; } static inline int check_signal(struct snd_pdacf *chip) { return (chip->ak4117->rcs0 & AK4117_UNLCK) == 0; } int snd_pdacf_resume(struct snd_pdacf *chip) { int timeout = 40; pdacf_reinit(chip, 1); /* wait for AK4117's PLL */ while (timeout-- > 0 && (snd_ak4117_external_rate(chip->ak4117) <= 0 || !check_signal(chip))) mdelay(1); chip->chip_status &= ~PDAUDIOCF_STAT_IS_SUSPENDED; snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0); return 0; } #endif
linux-master
sound/pcmcia/pdaudiocf/pdaudiocf_core.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Driver for Sound Core PDAudioCF soundcard * * Copyright (c) 2003 by Jaroslav Kysela <[email protected]> */ #include <sound/core.h> #include <linux/slab.h> #include <linux/module.h> #include <pcmcia/ciscode.h> #include <pcmcia/cisreg.h> #include "pdaudiocf.h" #include <sound/initval.h> #include <linux/init.h> /* */ #define CARD_NAME "PDAudio-CF" MODULE_AUTHOR("Jaroslav Kysela <[email protected]>"); MODULE_DESCRIPTION("Sound Core " CARD_NAME); MODULE_LICENSE("GPL"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable switches */ module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard."); /* */ static struct snd_card *card_list[SNDRV_CARDS]; /* * prototypes */ static int pdacf_config(struct pcmcia_device *link); static void snd_pdacf_detach(struct pcmcia_device *p_dev); static void pdacf_release(struct pcmcia_device *link) { free_irq(link->irq, link->priv); pcmcia_disable_device(link); } /* * destructor */ static int snd_pdacf_free(struct snd_pdacf *pdacf) { struct pcmcia_device *link = pdacf->p_dev; pdacf_release(link); card_list[pdacf->index] = NULL; pdacf->card = NULL; kfree(pdacf); return 0; } static int snd_pdacf_dev_free(struct snd_device *device) { struct snd_pdacf *chip = device->device_data; return snd_pdacf_free(chip); } /* * snd_pdacf_attach - attach callback for cs */ static int snd_pdacf_probe(struct pcmcia_device *link) { int i, err; struct snd_pdacf *pdacf; struct snd_card *card; static const struct snd_device_ops ops = { .dev_free = snd_pdacf_dev_free, }; snd_printdd(KERN_DEBUG "pdacf_attach called\n"); /* find an empty slot from the card list */ for (i = 0; i < SNDRV_CARDS; i++) { if (! card_list[i]) break; } if (i >= SNDRV_CARDS) { snd_printk(KERN_ERR "pdacf: too many cards found\n"); return -EINVAL; } if (! enable[i]) return -ENODEV; /* disabled explicitly */ /* ok, create a card instance */ err = snd_card_new(&link->dev, index[i], id[i], THIS_MODULE, 0, &card); if (err < 0) { snd_printk(KERN_ERR "pdacf: cannot create a card instance\n"); return err; } pdacf = snd_pdacf_create(card); if (!pdacf) { snd_card_free(card); return -ENOMEM; } err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, pdacf, &ops); if (err < 0) { kfree(pdacf); snd_card_free(card); return err; } pdacf->index = i; card_list[i] = card; pdacf->p_dev = link; link->priv = pdacf; link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO; link->resource[0]->end = 16; link->config_flags = CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ; link->config_index = 1; link->config_regs = PRESENT_OPTION; return pdacf_config(link); } /** * snd_pdacf_assign_resources - initialize the hardware and card instance. * @pdacf: context * @port: i/o port for the card * @irq: irq number for the card * * this function assigns the specified port and irq, boot the card, * create pcm and control instances, and initialize the rest hardware. * * returns 0 if successful, or a negative error code. */ static int snd_pdacf_assign_resources(struct snd_pdacf *pdacf, int port, int irq) { int err; struct snd_card *card = pdacf->card; snd_printdd(KERN_DEBUG "pdacf assign resources: port = 0x%x, irq = %d\n", port, irq); pdacf->port = port; pdacf->irq = irq; pdacf->chip_status |= PDAUDIOCF_STAT_IS_CONFIGURED; err = snd_pdacf_ak4117_create(pdacf); if (err < 0) return err; strcpy(card->driver, "PDAudio-CF"); sprintf(card->shortname, "Core Sound %s", card->driver); sprintf(card->longname, "%s at 0x%x, irq %i", card->shortname, port, irq); err = snd_pdacf_pcm_new(pdacf); if (err < 0) return err; err = snd_card_register(card); if (err < 0) return err; return 0; } /* * snd_pdacf_detach - detach callback for cs */ static void snd_pdacf_detach(struct pcmcia_device *link) { struct snd_pdacf *chip = link->priv; snd_printdd(KERN_DEBUG "pdacf_detach called\n"); if (chip->chip_status & PDAUDIOCF_STAT_IS_CONFIGURED) snd_pdacf_powerdown(chip); chip->chip_status |= PDAUDIOCF_STAT_IS_STALE; /* to be sure */ snd_card_disconnect(chip->card); snd_card_free_when_closed(chip->card); } /* * configuration callback */ static int pdacf_config(struct pcmcia_device *link) { struct snd_pdacf *pdacf = link->priv; int ret; snd_printdd(KERN_DEBUG "pdacf_config called\n"); link->config_index = 0x5; link->config_flags |= CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ; ret = pcmcia_request_io(link); if (ret) goto failed_preirq; ret = request_threaded_irq(link->irq, pdacf_interrupt, pdacf_threaded_irq, IRQF_SHARED, link->devname, link->priv); if (ret) goto failed_preirq; ret = pcmcia_enable_device(link); if (ret) goto failed; if (snd_pdacf_assign_resources(pdacf, link->resource[0]->start, link->irq) < 0) goto failed; pdacf->card->sync_irq = link->irq; return 0; failed: free_irq(link->irq, link->priv); failed_preirq: pcmcia_disable_device(link); return -ENODEV; } #ifdef CONFIG_PM static int pdacf_suspend(struct pcmcia_device *link) { struct snd_pdacf *chip = link->priv; snd_printdd(KERN_DEBUG "SUSPEND\n"); if (chip) { snd_printdd(KERN_DEBUG "snd_pdacf_suspend calling\n"); snd_pdacf_suspend(chip); } return 0; } static int pdacf_resume(struct pcmcia_device *link) { struct snd_pdacf *chip = link->priv; snd_printdd(KERN_DEBUG "RESUME\n"); if (pcmcia_dev_present(link)) { if (chip) { snd_printdd(KERN_DEBUG "calling snd_pdacf_resume\n"); snd_pdacf_resume(chip); } } snd_printdd(KERN_DEBUG "resume done!\n"); return 0; } #endif /* * Module entry points */ static const struct pcmcia_device_id snd_pdacf_ids[] = { /* this is too general PCMCIA_DEVICE_MANF_CARD(0x015d, 0x4c45), */ PCMCIA_DEVICE_PROD_ID12("Core Sound","PDAudio-CF",0x396d19d2,0x71717b49), PCMCIA_DEVICE_NULL }; MODULE_DEVICE_TABLE(pcmcia, snd_pdacf_ids); static struct pcmcia_driver pdacf_cs_driver = { .owner = THIS_MODULE, .name = "snd-pdaudiocf", .probe = snd_pdacf_probe, .remove = snd_pdacf_detach, .id_table = snd_pdacf_ids, #ifdef CONFIG_PM .suspend = pdacf_suspend, .resume = pdacf_resume, #endif }; module_pcmcia_driver(pdacf_cs_driver);
linux-master
sound/pcmcia/pdaudiocf/pdaudiocf.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Driver for Digigram VXpocket soundcards * * VX-pocket mixer * * Copyright (c) 2002 by Takashi Iwai <[email protected]> */ #include <sound/core.h> #include <sound/control.h> #include <sound/tlv.h> #include "vxpocket.h" #define MIC_LEVEL_MIN 0 #define MIC_LEVEL_MAX 8 /* * mic level control (for VXPocket) */ static int vx_mic_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = MIC_LEVEL_MAX; return 0; } static int vx_mic_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct vx_core *_chip = snd_kcontrol_chip(kcontrol); struct snd_vxpocket *chip = to_vxpocket(_chip); ucontrol->value.integer.value[0] = chip->mic_level; return 0; } static int vx_mic_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct vx_core *_chip = snd_kcontrol_chip(kcontrol); struct snd_vxpocket *chip = to_vxpocket(_chip); unsigned int val = ucontrol->value.integer.value[0]; if (val > MIC_LEVEL_MAX) return -EINVAL; mutex_lock(&_chip->mixer_mutex); if (chip->mic_level != ucontrol->value.integer.value[0]) { vx_set_mic_level(_chip, ucontrol->value.integer.value[0]); chip->mic_level = ucontrol->value.integer.value[0]; mutex_unlock(&_chip->mixer_mutex); return 1; } mutex_unlock(&_chip->mixer_mutex); return 0; } static const DECLARE_TLV_DB_SCALE(db_scale_mic, -21, 3, 0); static const struct snd_kcontrol_new vx_control_mic_level = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ), .name = "Mic Capture Volume", .info = vx_mic_level_info, .get = vx_mic_level_get, .put = vx_mic_level_put, .tlv = { .p = db_scale_mic }, }; /* * mic boost level control (for VXP440) */ #define vx_mic_boost_info snd_ctl_boolean_mono_info static int vx_mic_boost_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct vx_core *_chip = snd_kcontrol_chip(kcontrol); struct snd_vxpocket *chip = to_vxpocket(_chip); ucontrol->value.integer.value[0] = chip->mic_level; return 0; } static int vx_mic_boost_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct vx_core *_chip = snd_kcontrol_chip(kcontrol); struct snd_vxpocket *chip = to_vxpocket(_chip); int val = !!ucontrol->value.integer.value[0]; mutex_lock(&_chip->mixer_mutex); if (chip->mic_level != val) { vx_set_mic_boost(_chip, val); chip->mic_level = val; mutex_unlock(&_chip->mixer_mutex); return 1; } mutex_unlock(&_chip->mixer_mutex); return 0; } static const struct snd_kcontrol_new vx_control_mic_boost = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Mic Boost", .info = vx_mic_boost_info, .get = vx_mic_boost_get, .put = vx_mic_boost_put, }; int vxp_add_mic_controls(struct vx_core *_chip) { struct snd_vxpocket *chip = to_vxpocket(_chip); int err; /* mute input levels */ chip->mic_level = 0; switch (_chip->type) { case VX_TYPE_VXPOCKET: vx_set_mic_level(_chip, 0); break; case VX_TYPE_VXP440: vx_set_mic_boost(_chip, 0); break; } /* mic level */ switch (_chip->type) { case VX_TYPE_VXPOCKET: err = snd_ctl_add(_chip->card, snd_ctl_new1(&vx_control_mic_level, chip)); if (err < 0) return err; break; case VX_TYPE_VXP440: err = snd_ctl_add(_chip->card, snd_ctl_new1(&vx_control_mic_boost, chip)); if (err < 0) return err; break; } return 0; }
linux-master
sound/pcmcia/vx/vxp_mixer.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Driver for Digigram VXpocket soundcards * * lowlevel routines for VXpocket soundcards * * Copyright (c) 2002 by Takashi Iwai <[email protected]> */ #include <linux/delay.h> #include <linux/device.h> #include <linux/firmware.h> #include <linux/io.h> #include <sound/core.h> #include "vxpocket.h" static const int vxp_reg_offset[VX_REG_MAX] = { [VX_ICR] = 0x00, // ICR [VX_CVR] = 0x01, // CVR [VX_ISR] = 0x02, // ISR [VX_IVR] = 0x03, // IVR [VX_RXH] = 0x05, // RXH [VX_RXM] = 0x06, // RXM [VX_RXL] = 0x07, // RXL [VX_DMA] = 0x04, // DMA [VX_CDSP] = 0x08, // CDSP [VX_LOFREQ] = 0x09, // LFREQ [VX_HIFREQ] = 0x0a, // HFREQ [VX_DATA] = 0x0b, // DATA [VX_MICRO] = 0x0c, // MICRO [VX_DIALOG] = 0x0d, // DIALOG [VX_CSUER] = 0x0e, // CSUER [VX_RUER] = 0x0f, // RUER }; static inline unsigned long vxp_reg_addr(struct vx_core *_chip, int reg) { struct snd_vxpocket *chip = to_vxpocket(_chip); return chip->port + vxp_reg_offset[reg]; } /* * snd_vx_inb - read a byte from the register * @offset: register offset */ static unsigned char vxp_inb(struct vx_core *chip, int offset) { return inb(vxp_reg_addr(chip, offset)); } /* * snd_vx_outb - write a byte on the register * @offset: the register offset * @val: the value to write */ static void vxp_outb(struct vx_core *chip, int offset, unsigned char val) { outb(val, vxp_reg_addr(chip, offset)); } /* * redefine macros to call directly */ #undef vx_inb #define vx_inb(chip,reg) vxp_inb((struct vx_core *)(chip), VX_##reg) #undef vx_outb #define vx_outb(chip,reg,val) vxp_outb((struct vx_core *)(chip), VX_##reg,val) /* * vx_check_magic - check the magic word on xilinx * * returns zero if a magic word is detected, or a negative error code. */ static int vx_check_magic(struct vx_core *chip) { unsigned long end_time = jiffies + HZ / 5; int c; do { c = vx_inb(chip, CDSP); if (c == CDSP_MAGIC) return 0; msleep(10); } while (time_after_eq(end_time, jiffies)); snd_printk(KERN_ERR "cannot find xilinx magic word (%x)\n", c); return -EIO; } /* * vx_reset_dsp - reset the DSP */ #define XX_DSP_RESET_WAIT_TIME 2 /* ms */ static void vxp_reset_dsp(struct vx_core *_chip) { struct snd_vxpocket *chip = to_vxpocket(_chip); /* set the reset dsp bit to 1 */ vx_outb(chip, CDSP, chip->regCDSP | VXP_CDSP_DSP_RESET_MASK); vx_inb(chip, CDSP); mdelay(XX_DSP_RESET_WAIT_TIME); /* reset the bit */ chip->regCDSP &= ~VXP_CDSP_DSP_RESET_MASK; vx_outb(chip, CDSP, chip->regCDSP); vx_inb(chip, CDSP); mdelay(XX_DSP_RESET_WAIT_TIME); } /* * reset codec bit */ static void vxp_reset_codec(struct vx_core *_chip) { struct snd_vxpocket *chip = to_vxpocket(_chip); /* Set the reset CODEC bit to 1. */ vx_outb(chip, CDSP, chip->regCDSP | VXP_CDSP_CODEC_RESET_MASK); vx_inb(chip, CDSP); msleep(10); /* Set the reset CODEC bit to 0. */ chip->regCDSP &= ~VXP_CDSP_CODEC_RESET_MASK; vx_outb(chip, CDSP, chip->regCDSP); vx_inb(chip, CDSP); msleep(1); } /* * vx_load_xilinx_binary - load the xilinx binary image * the binary image is the binary array converted from the bitstream file. */ static int vxp_load_xilinx_binary(struct vx_core *_chip, const struct firmware *fw) { struct snd_vxpocket *chip = to_vxpocket(_chip); unsigned int i; int c; int regCSUER, regRUER; const unsigned char *image; unsigned char data; /* Switch to programmation mode */ chip->regDIALOG |= VXP_DLG_XILINX_REPROG_MASK; vx_outb(chip, DIALOG, chip->regDIALOG); /* Save register CSUER and RUER */ regCSUER = vx_inb(chip, CSUER); regRUER = vx_inb(chip, RUER); /* reset HF0 and HF1 */ vx_outb(chip, ICR, 0); /* Wait for answer HF2 equal to 1 */ snd_printdd(KERN_DEBUG "check ISR_HF2\n"); if (vx_check_isr(_chip, ISR_HF2, ISR_HF2, 20) < 0) goto _error; /* set HF1 for loading xilinx binary */ vx_outb(chip, ICR, ICR_HF1); image = fw->data; for (i = 0; i < fw->size; i++, image++) { data = *image; if (vx_wait_isr_bit(_chip, ISR_TX_EMPTY) < 0) goto _error; vx_outb(chip, TXL, data); /* wait for reading */ if (vx_wait_for_rx_full(_chip) < 0) goto _error; c = vx_inb(chip, RXL); if (c != (int)data) snd_printk(KERN_ERR "vxpocket: load xilinx mismatch at %d: 0x%x != 0x%x\n", i, c, (int)data); } /* reset HF1 */ vx_outb(chip, ICR, 0); /* wait for HF3 */ if (vx_check_isr(_chip, ISR_HF3, ISR_HF3, 20) < 0) goto _error; /* read the number of bytes received */ if (vx_wait_for_rx_full(_chip) < 0) goto _error; c = (int)vx_inb(chip, RXH) << 16; c |= (int)vx_inb(chip, RXM) << 8; c |= vx_inb(chip, RXL); snd_printdd(KERN_DEBUG "xilinx: dsp size received 0x%x, orig 0x%zx\n", c, fw->size); vx_outb(chip, ICR, ICR_HF0); /* TEMPO 250ms : wait until Xilinx is downloaded */ msleep(300); /* test magical word */ if (vx_check_magic(_chip) < 0) goto _error; /* Restore register 0x0E and 0x0F (thus replacing COR and FCSR) */ vx_outb(chip, CSUER, regCSUER); vx_outb(chip, RUER, regRUER); /* Reset the Xilinx's signal enabling IO access */ chip->regDIALOG |= VXP_DLG_XILINX_REPROG_MASK; vx_outb(chip, DIALOG, chip->regDIALOG); vx_inb(chip, DIALOG); msleep(10); chip->regDIALOG &= ~VXP_DLG_XILINX_REPROG_MASK; vx_outb(chip, DIALOG, chip->regDIALOG); vx_inb(chip, DIALOG); /* Reset of the Codec */ vxp_reset_codec(_chip); vx_reset_dsp(_chip); return 0; _error: vx_outb(chip, CSUER, regCSUER); vx_outb(chip, RUER, regRUER); chip->regDIALOG &= ~VXP_DLG_XILINX_REPROG_MASK; vx_outb(chip, DIALOG, chip->regDIALOG); return -EIO; } /* * vxp_load_dsp - load_dsp callback */ static int vxp_load_dsp(struct vx_core *vx, int index, const struct firmware *fw) { int err; switch (index) { case 0: /* xilinx boot */ err = vx_check_magic(vx); if (err < 0) return err; err = snd_vx_load_boot_image(vx, fw); if (err < 0) return err; return 0; case 1: /* xilinx image */ return vxp_load_xilinx_binary(vx, fw); case 2: /* DSP boot */ return snd_vx_dsp_boot(vx, fw); case 3: /* DSP image */ return snd_vx_dsp_load(vx, fw); default: snd_BUG(); return -EINVAL; } } /* * vx_test_and_ack - test and acknowledge interrupt * * called from irq hander, too * * spinlock held! */ static int vxp_test_and_ack(struct vx_core *_chip) { struct snd_vxpocket *chip = to_vxpocket(_chip); /* not booted yet? */ if (! (_chip->chip_status & VX_STAT_XILINX_LOADED)) return -ENXIO; if (! (vx_inb(chip, DIALOG) & VXP_DLG_MEMIRQ_MASK)) return -EIO; /* ok, interrupts generated, now ack it */ /* set ACQUIT bit up and down */ vx_outb(chip, DIALOG, chip->regDIALOG | VXP_DLG_ACK_MEMIRQ_MASK); /* useless read just to spend some time and maintain * the ACQUIT signal up for a while ( a bus cycle ) */ vx_inb(chip, DIALOG); vx_outb(chip, DIALOG, chip->regDIALOG & ~VXP_DLG_ACK_MEMIRQ_MASK); return 0; } /* * vx_validate_irq - enable/disable IRQ */ static void vxp_validate_irq(struct vx_core *_chip, int enable) { struct snd_vxpocket *chip = to_vxpocket(_chip); /* Set the interrupt enable bit to 1 in CDSP register */ if (enable) chip->regCDSP |= VXP_CDSP_VALID_IRQ_MASK; else chip->regCDSP &= ~VXP_CDSP_VALID_IRQ_MASK; vx_outb(chip, CDSP, chip->regCDSP); } /* * vx_setup_pseudo_dma - set up the pseudo dma read/write mode. * @do_write: 0 = read, 1 = set up for DMA write */ static void vx_setup_pseudo_dma(struct vx_core *_chip, int do_write) { struct snd_vxpocket *chip = to_vxpocket(_chip); /* Interrupt mode and HREQ pin enabled for host transmit / receive data transfers */ vx_outb(chip, ICR, do_write ? ICR_TREQ : ICR_RREQ); /* Reset the pseudo-dma register */ vx_inb(chip, ISR); vx_outb(chip, ISR, 0); /* Select DMA in read/write transfer mode and in 16-bit accesses */ chip->regDIALOG |= VXP_DLG_DMA16_SEL_MASK; chip->regDIALOG |= do_write ? VXP_DLG_DMAWRITE_SEL_MASK : VXP_DLG_DMAREAD_SEL_MASK; vx_outb(chip, DIALOG, chip->regDIALOG); } /* * vx_release_pseudo_dma - disable the pseudo-DMA mode */ static void vx_release_pseudo_dma(struct vx_core *_chip) { struct snd_vxpocket *chip = to_vxpocket(_chip); /* Disable DMA and 16-bit accesses */ chip->regDIALOG &= ~(VXP_DLG_DMAWRITE_SEL_MASK| VXP_DLG_DMAREAD_SEL_MASK| VXP_DLG_DMA16_SEL_MASK); vx_outb(chip, DIALOG, chip->regDIALOG); /* HREQ pin disabled. */ vx_outb(chip, ICR, 0); } /* * vx_pseudo_dma_write - write bulk data on pseudo-DMA mode * @count: data length to transfer in bytes * * data size must be aligned to 6 bytes to ensure the 24bit alignment on DSP. * NB: call with a certain lock! */ static void vxp_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, struct vx_pipe *pipe, int count) { long port = vxp_reg_addr(chip, VX_DMA); int offset = pipe->hw_ptr; unsigned short *addr = (unsigned short *)(runtime->dma_area + offset); vx_setup_pseudo_dma(chip, 1); if (offset + count >= pipe->buffer_bytes) { int length = pipe->buffer_bytes - offset; count -= length; length >>= 1; /* in 16bit words */ /* Transfer using pseudo-dma. */ for (; length > 0; length--) { outw(*addr, port); addr++; } addr = (unsigned short *)runtime->dma_area; pipe->hw_ptr = 0; } pipe->hw_ptr += count; count >>= 1; /* in 16bit words */ /* Transfer using pseudo-dma. */ for (; count > 0; count--) { outw(*addr, port); addr++; } vx_release_pseudo_dma(chip); } /* * vx_pseudo_dma_read - read bulk data on pseudo DMA mode * @offset: buffer offset in bytes * @count: data length to transfer in bytes * * the read length must be aligned to 6 bytes, as well as write. * NB: call with a certain lock! */ static void vxp_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, struct vx_pipe *pipe, int count) { struct snd_vxpocket *pchip = to_vxpocket(chip); long port = vxp_reg_addr(chip, VX_DMA); int offset = pipe->hw_ptr; unsigned short *addr = (unsigned short *)(runtime->dma_area + offset); if (snd_BUG_ON(count % 2)) return; vx_setup_pseudo_dma(chip, 0); if (offset + count >= pipe->buffer_bytes) { int length = pipe->buffer_bytes - offset; count -= length; length >>= 1; /* in 16bit words */ /* Transfer using pseudo-dma. */ for (; length > 0; length--) *addr++ = inw(port); addr = (unsigned short *)runtime->dma_area; pipe->hw_ptr = 0; } pipe->hw_ptr += count; count >>= 1; /* in 16bit words */ /* Transfer using pseudo-dma. */ for (; count > 1; count--) *addr++ = inw(port); /* Disable DMA */ pchip->regDIALOG &= ~VXP_DLG_DMAREAD_SEL_MASK; vx_outb(chip, DIALOG, pchip->regDIALOG); /* Read the last word (16 bits) */ *addr = inw(port); /* Disable 16-bit accesses */ pchip->regDIALOG &= ~VXP_DLG_DMA16_SEL_MASK; vx_outb(chip, DIALOG, pchip->regDIALOG); /* HREQ pin disabled. */ vx_outb(chip, ICR, 0); } /* * write a codec data (24bit) */ static void vxp_write_codec_reg(struct vx_core *chip, int codec, unsigned int data) { int i; /* Activate access to the corresponding codec register */ if (! codec) vx_inb(chip, LOFREQ); else vx_inb(chip, CODEC2); /* We have to send 24 bits (3 x 8 bits). Start with most signif. Bit */ for (i = 0; i < 24; i++, data <<= 1) vx_outb(chip, DATA, ((data & 0x800000) ? VX_DATA_CODEC_MASK : 0)); /* Terminate access to codec registers */ vx_inb(chip, HIFREQ); } /* * vx_set_mic_boost - set mic boost level (on vxp440 only) * @boost: 0 = 20dB, 1 = +38dB */ void vx_set_mic_boost(struct vx_core *chip, int boost) { struct snd_vxpocket *pchip = to_vxpocket(chip); if (chip->chip_status & VX_STAT_IS_STALE) return; mutex_lock(&chip->lock); if (pchip->regCDSP & P24_CDSP_MICS_SEL_MASK) { if (boost) { /* boost: 38 dB */ pchip->regCDSP &= ~P24_CDSP_MIC20_SEL_MASK; pchip->regCDSP |= P24_CDSP_MIC38_SEL_MASK; } else { /* minimum value: 20 dB */ pchip->regCDSP |= P24_CDSP_MIC20_SEL_MASK; pchip->regCDSP &= ~P24_CDSP_MIC38_SEL_MASK; } vx_outb(chip, CDSP, pchip->regCDSP); } mutex_unlock(&chip->lock); } /* * remap the linear value (0-8) to the actual value (0-15) */ static int vx_compute_mic_level(int level) { switch (level) { case 5: level = 6 ; break; case 6: level = 8 ; break; case 7: level = 11; break; case 8: level = 15; break; default: break ; } return level; } /* * vx_set_mic_level - set mic level (on vxpocket only) * @level: the mic level = 0 - 8 (max) */ void vx_set_mic_level(struct vx_core *chip, int level) { struct snd_vxpocket *pchip = to_vxpocket(chip); if (chip->chip_status & VX_STAT_IS_STALE) return; mutex_lock(&chip->lock); if (pchip->regCDSP & VXP_CDSP_MIC_SEL_MASK) { level = vx_compute_mic_level(level); vx_outb(chip, MICRO, level); } mutex_unlock(&chip->lock); } /* * change the input audio source */ static void vxp_change_audio_source(struct vx_core *_chip, int src) { struct snd_vxpocket *chip = to_vxpocket(_chip); switch (src) { case VX_AUDIO_SRC_DIGITAL: chip->regCDSP |= VXP_CDSP_DATAIN_SEL_MASK; vx_outb(chip, CDSP, chip->regCDSP); break; case VX_AUDIO_SRC_LINE: chip->regCDSP &= ~VXP_CDSP_DATAIN_SEL_MASK; if (_chip->type == VX_TYPE_VXP440) chip->regCDSP &= ~P24_CDSP_MICS_SEL_MASK; else chip->regCDSP &= ~VXP_CDSP_MIC_SEL_MASK; vx_outb(chip, CDSP, chip->regCDSP); break; case VX_AUDIO_SRC_MIC: chip->regCDSP &= ~VXP_CDSP_DATAIN_SEL_MASK; /* reset mic levels */ if (_chip->type == VX_TYPE_VXP440) { chip->regCDSP &= ~P24_CDSP_MICS_SEL_MASK; if (chip->mic_level) chip->regCDSP |= P24_CDSP_MIC38_SEL_MASK; else chip->regCDSP |= P24_CDSP_MIC20_SEL_MASK; vx_outb(chip, CDSP, chip->regCDSP); } else { chip->regCDSP |= VXP_CDSP_MIC_SEL_MASK; vx_outb(chip, CDSP, chip->regCDSP); vx_outb(chip, MICRO, vx_compute_mic_level(chip->mic_level)); } break; } } /* * change the clock source * source = INTERNAL_QUARTZ or UER_SYNC */ static void vxp_set_clock_source(struct vx_core *_chip, int source) { struct snd_vxpocket *chip = to_vxpocket(_chip); if (source == INTERNAL_QUARTZ) chip->regCDSP &= ~VXP_CDSP_CLOCKIN_SEL_MASK; else chip->regCDSP |= VXP_CDSP_CLOCKIN_SEL_MASK; vx_outb(chip, CDSP, chip->regCDSP); } /* * reset the board */ static void vxp_reset_board(struct vx_core *_chip, int cold_reset) { struct snd_vxpocket *chip = to_vxpocket(_chip); chip->regCDSP = 0; chip->regDIALOG = 0; } /* * callbacks */ /* exported */ const struct snd_vx_ops snd_vxpocket_ops = { .in8 = vxp_inb, .out8 = vxp_outb, .test_and_ack = vxp_test_and_ack, .validate_irq = vxp_validate_irq, .write_codec = vxp_write_codec_reg, .reset_codec = vxp_reset_codec, .change_audio_source = vxp_change_audio_source, .set_clock_source = vxp_set_clock_source, .load_dsp = vxp_load_dsp, .add_controls = vxp_add_mic_controls, .reset_dsp = vxp_reset_dsp, .reset_board = vxp_reset_board, .dma_write = vxp_dma_write, .dma_read = vxp_dma_read, };
linux-master
sound/pcmcia/vx/vxp_ops.c
// SPDX-License-Identifier: GPL-2.0-or-later /* * Driver for Digigram VXpocket V2/440 soundcards * * Copyright (c) 2002 by Takashi Iwai <[email protected]> */ #include <linux/init.h> #include <linux/module.h> #include <linux/slab.h> #include <sound/core.h> #include "vxpocket.h" #include <pcmcia/ciscode.h> #include <pcmcia/cisreg.h> #include <sound/initval.h> #include <sound/tlv.h> MODULE_AUTHOR("Takashi Iwai <[email protected]>"); MODULE_DESCRIPTION("Digigram VXPocket"); MODULE_LICENSE("GPL"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable switches */ static int ibl[SNDRV_CARDS]; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for VXPocket soundcard."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for VXPocket soundcard."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable VXPocket soundcard."); module_param_array(ibl, int, NULL, 0444); MODULE_PARM_DESC(ibl, "Capture IBL size for VXPocket soundcard."); /* */ static unsigned int card_alloc; /* */ static void vxpocket_release(struct pcmcia_device *link) { free_irq(link->irq, link->priv); pcmcia_disable_device(link); } /* * Hardware information */ /* VX-pocket V2 * * 1 DSP, 1 sync UER * 1 programmable clock (NIY) * 1 stereo analog input (line/micro) * 1 stereo analog output * Only output levels can be modified */ static const DECLARE_TLV_DB_SCALE(db_scale_old_vol, -11350, 50, 0); static const struct snd_vx_hardware vxpocket_hw = { .name = "VXPocket", .type = VX_TYPE_VXPOCKET, /* hardware specs */ .num_codecs = 1, .num_ins = 1, .num_outs = 1, .output_level_max = VX_ANALOG_OUT_LEVEL_MAX, .output_level_db_scale = db_scale_old_vol, }; /* VX-pocket 440 * * 1 DSP, 1 sync UER, 1 sync World Clock (NIY) * SMPTE (NIY) * 2 stereo analog input (line/micro) * 2 stereo analog output * Only output levels can be modified * UER, but only for the first two inputs and outputs. */ static const struct snd_vx_hardware vxp440_hw = { .name = "VXPocket440", .type = VX_TYPE_VXP440, /* hardware specs */ .num_codecs = 2, .num_ins = 2, .num_outs = 2, .output_level_max = VX_ANALOG_OUT_LEVEL_MAX, .output_level_db_scale = db_scale_old_vol, }; /* * create vxpocket instance */ static int snd_vxpocket_new(struct snd_card *card, int ibl, struct pcmcia_device *link, struct snd_vxpocket **chip_ret) { struct vx_core *chip; struct snd_vxpocket *vxp; chip = snd_vx_create(card, &vxpocket_hw, &snd_vxpocket_ops, sizeof(struct snd_vxpocket) - sizeof(struct vx_core)); if (!chip) return -ENOMEM; chip->ibl.size = ibl; vxp = to_vxpocket(chip); vxp->p_dev = link; link->priv = chip; link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO; link->resource[0]->end = 16; link->config_flags |= CONF_ENABLE_IRQ; link->config_index = 1; link->config_regs = PRESENT_OPTION; *chip_ret = vxp; return 0; } /** * snd_vxpocket_assign_resources - initialize the hardware and card instance. * @chip: VX core instance * @port: i/o port for the card * @irq: irq number for the card * * this function assigns the specified port and irq, boot the card, * create pcm and control instances, and initialize the rest hardware. * * returns 0 if successful, or a negative error code. */ static int snd_vxpocket_assign_resources(struct vx_core *chip, int port, int irq) { int err; struct snd_card *card = chip->card; struct snd_vxpocket *vxp = to_vxpocket(chip); snd_printdd(KERN_DEBUG "vxpocket assign resources: port = 0x%x, irq = %d\n", port, irq); vxp->port = port; sprintf(card->shortname, "Digigram %s", card->driver); sprintf(card->longname, "%s at 0x%x, irq %i", card->shortname, port, irq); chip->irq = irq; card->sync_irq = chip->irq; err = snd_vx_setup_firmware(chip); if (err < 0) return err; return 0; } /* * configuration callback */ static int vxpocket_config(struct pcmcia_device *link) { struct vx_core *chip = link->priv; int ret; snd_printdd(KERN_DEBUG "vxpocket_config called\n"); /* redefine hardware record according to the VERSION1 string */ if (!strcmp(link->prod_id[1], "VX-POCKET")) { snd_printdd("VX-pocket is detected\n"); } else { snd_printdd("VX-pocket 440 is detected\n"); /* overwrite the hardware information */ chip->hw = &vxp440_hw; chip->type = vxp440_hw.type; strcpy(chip->card->driver, vxp440_hw.name); } ret = pcmcia_request_io(link); if (ret) goto failed_preirq; ret = request_threaded_irq(link->irq, snd_vx_irq_handler, snd_vx_threaded_irq_handler, IRQF_SHARED, link->devname, link->priv); if (ret) goto failed_preirq; ret = pcmcia_enable_device(link); if (ret) goto failed; chip->dev = &link->dev; if (snd_vxpocket_assign_resources(chip, link->resource[0]->start, link->irq) < 0) goto failed; return 0; failed: free_irq(link->irq, link->priv); failed_preirq: pcmcia_disable_device(link); return -ENODEV; } #ifdef CONFIG_PM static int vxp_suspend(struct pcmcia_device *link) { struct vx_core *chip = link->priv; snd_printdd(KERN_DEBUG "SUSPEND\n"); if (chip) { snd_printdd(KERN_DEBUG "snd_vx_suspend calling\n"); snd_vx_suspend(chip); } return 0; } static int vxp_resume(struct pcmcia_device *link) { struct vx_core *chip = link->priv; snd_printdd(KERN_DEBUG "RESUME\n"); if (pcmcia_dev_present(link)) { //struct snd_vxpocket *vxp = (struct snd_vxpocket *)chip; if (chip) { snd_printdd(KERN_DEBUG "calling snd_vx_resume\n"); snd_vx_resume(chip); } } snd_printdd(KERN_DEBUG "resume done!\n"); return 0; } #endif /* */ static int vxpocket_probe(struct pcmcia_device *p_dev) { struct snd_card *card; struct snd_vxpocket *vxp; int i, err; /* find an empty slot from the card list */ for (i = 0; i < SNDRV_CARDS; i++) { if (!(card_alloc & (1 << i))) break; } if (i >= SNDRV_CARDS) { snd_printk(KERN_ERR "vxpocket: too many cards found\n"); return -EINVAL; } if (! enable[i]) return -ENODEV; /* disabled explicitly */ /* ok, create a card instance */ err = snd_card_new(&p_dev->dev, index[i], id[i], THIS_MODULE, 0, &card); if (err < 0) { snd_printk(KERN_ERR "vxpocket: cannot create a card instance\n"); return err; } err = snd_vxpocket_new(card, ibl[i], p_dev, &vxp); if (err < 0) { snd_card_free(card); return err; } card->private_data = vxp; vxp->index = i; card_alloc |= 1 << i; vxp->p_dev = p_dev; return vxpocket_config(p_dev); } static void vxpocket_detach(struct pcmcia_device *link) { struct snd_vxpocket *vxp; struct vx_core *chip; if (! link) return; vxp = link->priv; chip = (struct vx_core *)vxp; card_alloc &= ~(1 << vxp->index); chip->chip_status |= VX_STAT_IS_STALE; /* to be sure */ snd_card_disconnect(chip->card); vxpocket_release(link); snd_card_free_when_closed(chip->card); } /* * Module entry points */ static const struct pcmcia_device_id vxp_ids[] = { PCMCIA_DEVICE_MANF_CARD(0x01f1, 0x0100), PCMCIA_DEVICE_NULL }; MODULE_DEVICE_TABLE(pcmcia, vxp_ids); static struct pcmcia_driver vxp_cs_driver = { .owner = THIS_MODULE, .name = "snd-vxpocket", .probe = vxpocket_probe, .remove = vxpocket_detach, .id_table = vxp_ids, #ifdef CONFIG_PM .suspend = vxp_suspend, .resume = vxp_resume, #endif }; module_pcmcia_driver(vxp_cs_driver);
linux-master
sound/pcmcia/vx/vxpocket.c
// SPDX-License-Identifier: GPL-2.0-only #include <linux/slab.h> #include <linux/module.h> #include <linux/dma-mapping.h> #include <linux/dmaengine.h> #include <linux/dma/pxa-dma.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include <sound/pxa2xx-lib.h> #include <sound/dmaengine_pcm.h> static const struct snd_pcm_hardware pxa2xx_pcm_hardware = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME, .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE, .period_bytes_min = 32, .period_bytes_max = 8192 - 32, .periods_min = 1, .periods_max = 256, .buffer_bytes_max = 128 * 1024, .fifo_size = 32, }; int pxa2xx_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { struct dma_chan *chan = snd_dmaengine_pcm_get_chan(substream); struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_dmaengine_dai_dma_data *dma_params; struct dma_slave_config config; int ret; dma_params = snd_soc_dai_get_dma_data(asoc_rtd_to_cpu(rtd, 0), substream); if (!dma_params) return 0; ret = snd_hwparams_to_dma_slave_config(substream, params, &config); if (ret) return ret; snd_dmaengine_pcm_set_config_from_dai_data(substream, snd_soc_dai_get_dma_data(asoc_rtd_to_cpu(rtd, 0), substream), &config); ret = dmaengine_slave_config(chan, &config); if (ret) return ret; return 0; } EXPORT_SYMBOL(pxa2xx_pcm_hw_params); int pxa2xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd) { return snd_dmaengine_pcm_trigger(substream, cmd); } EXPORT_SYMBOL(pxa2xx_pcm_trigger); snd_pcm_uframes_t pxa2xx_pcm_pointer(struct snd_pcm_substream *substream) { return snd_dmaengine_pcm_pointer(substream); } EXPORT_SYMBOL(pxa2xx_pcm_pointer); int pxa2xx_pcm_prepare(struct snd_pcm_substream *substream) { return 0; } EXPORT_SYMBOL(pxa2xx_pcm_prepare); int pxa2xx_pcm_open(struct snd_pcm_substream *substream) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_pcm_runtime *runtime = substream->runtime; struct snd_dmaengine_dai_dma_data *dma_params; int ret; runtime->hw = pxa2xx_pcm_hardware; dma_params = snd_soc_dai_get_dma_data(asoc_rtd_to_cpu(rtd, 0), substream); if (!dma_params) return 0; /* * For mysterious reasons (and despite what the manual says) * playback samples are lost if the DMA count is not a multiple * of the DMA burst size. Let's add a rule to enforce that. */ ret = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 32); if (ret) return ret; ret = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 32); if (ret) return ret; ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); if (ret < 0) return ret; return snd_dmaengine_pcm_open( substream, dma_request_slave_channel(asoc_rtd_to_cpu(rtd, 0)->dev, dma_params->chan_name)); } EXPORT_SYMBOL(pxa2xx_pcm_open); int pxa2xx_pcm_close(struct snd_pcm_substream *substream) { return snd_dmaengine_pcm_close_release_chan(substream); } EXPORT_SYMBOL(pxa2xx_pcm_close); int pxa2xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm) { size_t size = pxa2xx_pcm_hardware.buffer_bytes_max; return snd_pcm_set_fixed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV_WC, pcm->card->dev, size); } EXPORT_SYMBOL(pxa2xx_pcm_preallocate_dma_buffer); int pxa2xx_soc_pcm_new(struct snd_soc_component *component, struct snd_soc_pcm_runtime *rtd) { struct snd_card *card = rtd->card->snd_card; struct snd_pcm *pcm = rtd->pcm; int ret; ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32)); if (ret) return ret; return pxa2xx_pcm_preallocate_dma_buffer(pcm); } EXPORT_SYMBOL(pxa2xx_soc_pcm_new); int pxa2xx_soc_pcm_open(struct snd_soc_component *component, struct snd_pcm_substream *substream) { return pxa2xx_pcm_open(substream); } EXPORT_SYMBOL(pxa2xx_soc_pcm_open); int pxa2xx_soc_pcm_close(struct snd_soc_component *component, struct snd_pcm_substream *substream) { return pxa2xx_pcm_close(substream); } EXPORT_SYMBOL(pxa2xx_soc_pcm_close); int pxa2xx_soc_pcm_hw_params(struct snd_soc_component *component, struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { return pxa2xx_pcm_hw_params(substream, params); } EXPORT_SYMBOL(pxa2xx_soc_pcm_hw_params); int pxa2xx_soc_pcm_prepare(struct snd_soc_component *component, struct snd_pcm_substream *substream) { return pxa2xx_pcm_prepare(substream); } EXPORT_SYMBOL(pxa2xx_soc_pcm_prepare); int pxa2xx_soc_pcm_trigger(struct snd_soc_component *component, struct snd_pcm_substream *substream, int cmd) { return pxa2xx_pcm_trigger(substream, cmd); } EXPORT_SYMBOL(pxa2xx_soc_pcm_trigger); snd_pcm_uframes_t pxa2xx_soc_pcm_pointer(struct snd_soc_component *component, struct snd_pcm_substream *substream) { return pxa2xx_pcm_pointer(substream); } EXPORT_SYMBOL(pxa2xx_soc_pcm_pointer); MODULE_AUTHOR("Nicolas Pitre"); MODULE_DESCRIPTION("Intel PXA2xx sound library"); MODULE_LICENSE("GPL");
linux-master
sound/arm/pxa2xx-pcm-lib.c
// SPDX-License-Identifier: GPL-2.0-only /* * linux/sound/arm/aaci.c - ARM PrimeCell AACI PL041 driver * * Copyright (C) 2003 Deep Blue Solutions Ltd, All Rights Reserved. * * Documentation: ARM DDI 0173B */ #include <linux/module.h> #include <linux/delay.h> #include <linux/init.h> #include <linux/ioport.h> #include <linux/device.h> #include <linux/spinlock.h> #include <linux/interrupt.h> #include <linux/err.h> #include <linux/amba/bus.h> #include <linux/io.h> #include <sound/core.h> #include <sound/initval.h> #include <sound/ac97_codec.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include "aaci.h" #define DRIVER_NAME "aaci-pl041" #define FRAME_PERIOD_US 21 /* * PM support is not complete. Turn it off. */ #undef CONFIG_PM static void aaci_ac97_select_codec(struct aaci *aaci, struct snd_ac97 *ac97) { u32 v, maincr = aaci->maincr | MAINCR_SCRA(ac97->num); /* * Ensure that the slot 1/2 RX registers are empty. */ v = readl(aaci->base + AACI_SLFR); if (v & SLFR_2RXV) readl(aaci->base + AACI_SL2RX); if (v & SLFR_1RXV) readl(aaci->base + AACI_SL1RX); if (maincr != readl(aaci->base + AACI_MAINCR)) { writel(maincr, aaci->base + AACI_MAINCR); readl(aaci->base + AACI_MAINCR); udelay(1); } } /* * P29: * The recommended use of programming the external codec through slot 1 * and slot 2 data is to use the channels during setup routines and the * slot register at any other time. The data written into slot 1, slot 2 * and slot 12 registers is transmitted only when their corresponding * SI1TxEn, SI2TxEn and SI12TxEn bits are set in the AACI_MAINCR * register. */ static void aaci_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) { struct aaci *aaci = ac97->private_data; int timeout; u32 v; if (ac97->num >= 4) return; mutex_lock(&aaci->ac97_sem); aaci_ac97_select_codec(aaci, ac97); /* * P54: You must ensure that AACI_SL2TX is always written * to, if required, before data is written to AACI_SL1TX. */ writel(val << 4, aaci->base + AACI_SL2TX); writel(reg << 12, aaci->base + AACI_SL1TX); /* Initially, wait one frame period */ udelay(FRAME_PERIOD_US); /* And then wait an additional eight frame periods for it to be sent */ timeout = FRAME_PERIOD_US * 8; do { udelay(1); v = readl(aaci->base + AACI_SLFR); } while ((v & (SLFR_1TXB|SLFR_2TXB)) && --timeout); if (v & (SLFR_1TXB|SLFR_2TXB)) dev_err(&aaci->dev->dev, "timeout waiting for write to complete\n"); mutex_unlock(&aaci->ac97_sem); } /* * Read an AC'97 register. */ static unsigned short aaci_ac97_read(struct snd_ac97 *ac97, unsigned short reg) { struct aaci *aaci = ac97->private_data; int timeout, retries = 10; u32 v; if (ac97->num >= 4) return ~0; mutex_lock(&aaci->ac97_sem); aaci_ac97_select_codec(aaci, ac97); /* * Write the register address to slot 1. */ writel((reg << 12) | (1 << 19), aaci->base + AACI_SL1TX); /* Initially, wait one frame period */ udelay(FRAME_PERIOD_US); /* And then wait an additional eight frame periods for it to be sent */ timeout = FRAME_PERIOD_US * 8; do { udelay(1); v = readl(aaci->base + AACI_SLFR); } while ((v & SLFR_1TXB) && --timeout); if (v & SLFR_1TXB) { dev_err(&aaci->dev->dev, "timeout on slot 1 TX busy\n"); v = ~0; goto out; } /* Now wait for the response frame */ udelay(FRAME_PERIOD_US); /* And then wait an additional eight frame periods for data */ timeout = FRAME_PERIOD_US * 8; do { udelay(1); cond_resched(); v = readl(aaci->base + AACI_SLFR) & (SLFR_1RXV|SLFR_2RXV); } while ((v != (SLFR_1RXV|SLFR_2RXV)) && --timeout); if (v != (SLFR_1RXV|SLFR_2RXV)) { dev_err(&aaci->dev->dev, "timeout on RX valid\n"); v = ~0; goto out; } do { v = readl(aaci->base + AACI_SL1RX) >> 12; if (v == reg) { v = readl(aaci->base + AACI_SL2RX) >> 4; break; } else if (--retries) { dev_warn(&aaci->dev->dev, "ac97 read back fail. retry\n"); continue; } else { dev_warn(&aaci->dev->dev, "wrong ac97 register read back (%x != %x)\n", v, reg); v = ~0; } } while (retries); out: mutex_unlock(&aaci->ac97_sem); return v; } static inline void aaci_chan_wait_ready(struct aaci_runtime *aacirun, unsigned long mask) { u32 val; int timeout = 5000; do { udelay(1); val = readl(aacirun->base + AACI_SR); } while (val & mask && timeout--); } /* * Interrupt support. */ static void aaci_fifo_irq(struct aaci *aaci, int channel, u32 mask) { if (mask & ISR_ORINTR) { dev_warn(&aaci->dev->dev, "RX overrun on chan %d\n", channel); writel(ICLR_RXOEC1 << channel, aaci->base + AACI_INTCLR); } if (mask & ISR_RXTOINTR) { dev_warn(&aaci->dev->dev, "RX timeout on chan %d\n", channel); writel(ICLR_RXTOFEC1 << channel, aaci->base + AACI_INTCLR); } if (mask & ISR_RXINTR) { struct aaci_runtime *aacirun = &aaci->capture; bool period_elapsed = false; void *ptr; if (!aacirun->substream || !aacirun->start) { dev_warn(&aaci->dev->dev, "RX interrupt???\n"); writel(0, aacirun->base + AACI_IE); return; } spin_lock(&aacirun->lock); ptr = aacirun->ptr; do { unsigned int len = aacirun->fifo_bytes; u32 val; if (aacirun->bytes <= 0) { aacirun->bytes += aacirun->period; period_elapsed = true; } if (!(aacirun->cr & CR_EN)) break; val = readl(aacirun->base + AACI_SR); if (!(val & SR_RXHF)) break; if (!(val & SR_RXFF)) len >>= 1; aacirun->bytes -= len; /* reading 16 bytes at a time */ for( ; len > 0; len -= 16) { asm( "ldmia %1, {r0, r1, r2, r3}\n\t" "stmia %0!, {r0, r1, r2, r3}" : "+r" (ptr) : "r" (aacirun->fifo) : "r0", "r1", "r2", "r3", "cc"); if (ptr >= aacirun->end) ptr = aacirun->start; } } while(1); aacirun->ptr = ptr; spin_unlock(&aacirun->lock); if (period_elapsed) snd_pcm_period_elapsed(aacirun->substream); } if (mask & ISR_URINTR) { dev_dbg(&aaci->dev->dev, "TX underrun on chan %d\n", channel); writel(ICLR_TXUEC1 << channel, aaci->base + AACI_INTCLR); } if (mask & ISR_TXINTR) { struct aaci_runtime *aacirun = &aaci->playback; bool period_elapsed = false; void *ptr; if (!aacirun->substream || !aacirun->start) { dev_warn(&aaci->dev->dev, "TX interrupt???\n"); writel(0, aacirun->base + AACI_IE); return; } spin_lock(&aacirun->lock); ptr = aacirun->ptr; do { unsigned int len = aacirun->fifo_bytes; u32 val; if (aacirun->bytes <= 0) { aacirun->bytes += aacirun->period; period_elapsed = true; } if (!(aacirun->cr & CR_EN)) break; val = readl(aacirun->base + AACI_SR); if (!(val & SR_TXHE)) break; if (!(val & SR_TXFE)) len >>= 1; aacirun->bytes -= len; /* writing 16 bytes at a time */ for ( ; len > 0; len -= 16) { asm( "ldmia %0!, {r0, r1, r2, r3}\n\t" "stmia %1, {r0, r1, r2, r3}" : "+r" (ptr) : "r" (aacirun->fifo) : "r0", "r1", "r2", "r3", "cc"); if (ptr >= aacirun->end) ptr = aacirun->start; } } while (1); aacirun->ptr = ptr; spin_unlock(&aacirun->lock); if (period_elapsed) snd_pcm_period_elapsed(aacirun->substream); } } static irqreturn_t aaci_irq(int irq, void *devid) { struct aaci *aaci = devid; u32 mask; int i; mask = readl(aaci->base + AACI_ALLINTS); if (mask) { u32 m = mask; for (i = 0; i < 4; i++, m >>= 7) { if (m & 0x7f) { aaci_fifo_irq(aaci, i, m); } } } return mask ? IRQ_HANDLED : IRQ_NONE; } /* * ALSA support. */ static const struct snd_pcm_hardware aaci_hw_info = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_RESUME, /* * ALSA doesn't support 18-bit or 20-bit packed into 32-bit * words. It also doesn't support 12-bit at all. */ .formats = SNDRV_PCM_FMTBIT_S16_LE, /* rates are setup from the AC'97 codec */ .channels_min = 2, .channels_max = 2, .buffer_bytes_max = 64 * 1024, .period_bytes_min = 256, .period_bytes_max = PAGE_SIZE, .periods_min = 4, .periods_max = PAGE_SIZE / 16, }; /* * We can support two and four channel audio. Unfortunately * six channel audio requires a non-standard channel ordering: * 2 -> FL(3), FR(4) * 4 -> FL(3), FR(4), SL(7), SR(8) * 6 -> FL(3), FR(4), SL(7), SR(8), C(6), LFE(9) (required) * FL(3), FR(4), C(6), SL(7), SR(8), LFE(9) (actual) * This requires an ALSA configuration file to correct. */ static int aaci_rule_channels(struct snd_pcm_hw_params *p, struct snd_pcm_hw_rule *rule) { static const unsigned int channel_list[] = { 2, 4, 6 }; struct aaci *aaci = rule->private; unsigned int mask = 1 << 0, slots; /* pcms[0] is the our 5.1 PCM instance. */ slots = aaci->ac97_bus->pcms[0].r[0].slots; if (slots & (1 << AC97_SLOT_PCM_SLEFT)) { mask |= 1 << 1; if (slots & (1 << AC97_SLOT_LFE)) mask |= 1 << 2; } return snd_interval_list(hw_param_interval(p, rule->var), ARRAY_SIZE(channel_list), channel_list, mask); } static int aaci_pcm_open(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct aaci *aaci = substream->private_data; struct aaci_runtime *aacirun; int ret = 0; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { aacirun = &aaci->playback; } else { aacirun = &aaci->capture; } aacirun->substream = substream; runtime->private_data = aacirun; runtime->hw = aaci_hw_info; runtime->hw.rates = aacirun->pcm->rates; snd_pcm_limit_hw_rates(runtime); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { runtime->hw.channels_max = 6; /* Add rule describing channel dependency. */ ret = snd_pcm_hw_rule_add(substream->runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, aaci_rule_channels, aaci, SNDRV_PCM_HW_PARAM_CHANNELS, -1); if (ret) return ret; if (aacirun->pcm->r[1].slots) snd_ac97_pcm_double_rate_rules(runtime); } /* * ALSA wants the byte-size of the FIFOs. As we only support * 16-bit samples, this is twice the FIFO depth irrespective * of whether it's in compact mode or not. */ runtime->hw.fifo_size = aaci->fifo_depth * 2; mutex_lock(&aaci->irq_lock); if (!aaci->users++) { ret = request_irq(aaci->dev->irq[0], aaci_irq, IRQF_SHARED, DRIVER_NAME, aaci); if (ret != 0) aaci->users--; } mutex_unlock(&aaci->irq_lock); return ret; } /* * Common ALSA stuff */ static int aaci_pcm_close(struct snd_pcm_substream *substream) { struct aaci *aaci = substream->private_data; struct aaci_runtime *aacirun = substream->runtime->private_data; WARN_ON(aacirun->cr & CR_EN); aacirun->substream = NULL; mutex_lock(&aaci->irq_lock); if (!--aaci->users) free_irq(aaci->dev->irq[0], aaci); mutex_unlock(&aaci->irq_lock); return 0; } static int aaci_pcm_hw_free(struct snd_pcm_substream *substream) { struct aaci_runtime *aacirun = substream->runtime->private_data; /* * This must not be called with the device enabled. */ WARN_ON(aacirun->cr & CR_EN); if (aacirun->pcm_open) snd_ac97_pcm_close(aacirun->pcm); aacirun->pcm_open = 0; return 0; } /* Channel to slot mask */ static const u32 channels_to_slotmask[] = { [2] = CR_SL3 | CR_SL4, [4] = CR_SL3 | CR_SL4 | CR_SL7 | CR_SL8, [6] = CR_SL3 | CR_SL4 | CR_SL7 | CR_SL8 | CR_SL6 | CR_SL9, }; static int aaci_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { struct aaci_runtime *aacirun = substream->runtime->private_data; struct aaci *aaci = substream->private_data; unsigned int channels = params_channels(params); unsigned int rate = params_rate(params); int dbl = rate > 48000; int err; aaci_pcm_hw_free(substream); if (aacirun->pcm_open) { snd_ac97_pcm_close(aacirun->pcm); aacirun->pcm_open = 0; } /* channels is already limited to 2, 4, or 6 by aaci_rule_channels */ if (dbl && channels != 2) return -EINVAL; err = snd_ac97_pcm_open(aacirun->pcm, rate, channels, aacirun->pcm->r[dbl].slots); aacirun->pcm_open = err == 0; aacirun->cr = CR_FEN | CR_COMPACT | CR_SZ16; aacirun->cr |= channels_to_slotmask[channels + dbl * 2]; /* * fifo_bytes is the number of bytes we transfer to/from * the FIFO, including padding. So that's x4. As we're * in compact mode, the FIFO is half the size. */ aacirun->fifo_bytes = aaci->fifo_depth * 4 / 2; return err; } static int aaci_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct aaci_runtime *aacirun = runtime->private_data; aacirun->period = snd_pcm_lib_period_bytes(substream); aacirun->start = runtime->dma_area; aacirun->end = aacirun->start + snd_pcm_lib_buffer_bytes(substream); aacirun->ptr = aacirun->start; aacirun->bytes = aacirun->period; return 0; } static snd_pcm_uframes_t aaci_pcm_pointer(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct aaci_runtime *aacirun = runtime->private_data; ssize_t bytes = aacirun->ptr - aacirun->start; return bytes_to_frames(runtime, bytes); } /* * Playback specific ALSA stuff */ static void aaci_pcm_playback_stop(struct aaci_runtime *aacirun) { u32 ie; ie = readl(aacirun->base + AACI_IE); ie &= ~(IE_URIE|IE_TXIE); writel(ie, aacirun->base + AACI_IE); aacirun->cr &= ~CR_EN; aaci_chan_wait_ready(aacirun, SR_TXB); writel(aacirun->cr, aacirun->base + AACI_TXCR); } static void aaci_pcm_playback_start(struct aaci_runtime *aacirun) { u32 ie; aaci_chan_wait_ready(aacirun, SR_TXB); aacirun->cr |= CR_EN; ie = readl(aacirun->base + AACI_IE); ie |= IE_URIE | IE_TXIE; writel(ie, aacirun->base + AACI_IE); writel(aacirun->cr, aacirun->base + AACI_TXCR); } static int aaci_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd) { struct aaci_runtime *aacirun = substream->runtime->private_data; unsigned long flags; int ret = 0; spin_lock_irqsave(&aacirun->lock, flags); switch (cmd) { case SNDRV_PCM_TRIGGER_START: aaci_pcm_playback_start(aacirun); break; case SNDRV_PCM_TRIGGER_RESUME: aaci_pcm_playback_start(aacirun); break; case SNDRV_PCM_TRIGGER_STOP: aaci_pcm_playback_stop(aacirun); break; case SNDRV_PCM_TRIGGER_SUSPEND: aaci_pcm_playback_stop(aacirun); break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: break; default: ret = -EINVAL; } spin_unlock_irqrestore(&aacirun->lock, flags); return ret; } static const struct snd_pcm_ops aaci_playback_ops = { .open = aaci_pcm_open, .close = aaci_pcm_close, .hw_params = aaci_pcm_hw_params, .hw_free = aaci_pcm_hw_free, .prepare = aaci_pcm_prepare, .trigger = aaci_pcm_playback_trigger, .pointer = aaci_pcm_pointer, }; static void aaci_pcm_capture_stop(struct aaci_runtime *aacirun) { u32 ie; aaci_chan_wait_ready(aacirun, SR_RXB); ie = readl(aacirun->base + AACI_IE); ie &= ~(IE_ORIE | IE_RXIE); writel(ie, aacirun->base+AACI_IE); aacirun->cr &= ~CR_EN; writel(aacirun->cr, aacirun->base + AACI_RXCR); } static void aaci_pcm_capture_start(struct aaci_runtime *aacirun) { u32 ie; aaci_chan_wait_ready(aacirun, SR_RXB); #ifdef DEBUG /* RX Timeout value: bits 28:17 in RXCR */ aacirun->cr |= 0xf << 17; #endif aacirun->cr |= CR_EN; writel(aacirun->cr, aacirun->base + AACI_RXCR); ie = readl(aacirun->base + AACI_IE); ie |= IE_ORIE |IE_RXIE; // overrun and rx interrupt -- half full writel(ie, aacirun->base + AACI_IE); } static int aaci_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd) { struct aaci_runtime *aacirun = substream->runtime->private_data; unsigned long flags; int ret = 0; spin_lock_irqsave(&aacirun->lock, flags); switch (cmd) { case SNDRV_PCM_TRIGGER_START: aaci_pcm_capture_start(aacirun); break; case SNDRV_PCM_TRIGGER_RESUME: aaci_pcm_capture_start(aacirun); break; case SNDRV_PCM_TRIGGER_STOP: aaci_pcm_capture_stop(aacirun); break; case SNDRV_PCM_TRIGGER_SUSPEND: aaci_pcm_capture_stop(aacirun); break; case SNDRV_PCM_TRIGGER_PAUSE_PUSH: break; case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: break; default: ret = -EINVAL; } spin_unlock_irqrestore(&aacirun->lock, flags); return ret; } static int aaci_pcm_capture_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct aaci *aaci = substream->private_data; aaci_pcm_prepare(substream); /* allow changing of sample rate */ aaci_ac97_write(aaci->ac97, AC97_EXTENDED_STATUS, 0x0001); /* VRA */ aaci_ac97_write(aaci->ac97, AC97_PCM_LR_ADC_RATE, runtime->rate); aaci_ac97_write(aaci->ac97, AC97_PCM_MIC_ADC_RATE, runtime->rate); /* Record select: Mic: 0, Aux: 3, Line: 4 */ aaci_ac97_write(aaci->ac97, AC97_REC_SEL, 0x0404); return 0; } static const struct snd_pcm_ops aaci_capture_ops = { .open = aaci_pcm_open, .close = aaci_pcm_close, .hw_params = aaci_pcm_hw_params, .hw_free = aaci_pcm_hw_free, .prepare = aaci_pcm_capture_prepare, .trigger = aaci_pcm_capture_trigger, .pointer = aaci_pcm_pointer, }; /* * Power Management. */ #ifdef CONFIG_PM static int aaci_do_suspend(struct snd_card *card) { struct aaci *aaci = card->private_data; snd_power_change_state(card, SNDRV_CTL_POWER_D3cold); return 0; } static int aaci_do_resume(struct snd_card *card) { snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } static int aaci_suspend(struct device *dev) { struct snd_card *card = dev_get_drvdata(dev); return card ? aaci_do_suspend(card) : 0; } static int aaci_resume(struct device *dev) { struct snd_card *card = dev_get_drvdata(dev); return card ? aaci_do_resume(card) : 0; } static SIMPLE_DEV_PM_OPS(aaci_dev_pm_ops, aaci_suspend, aaci_resume); #define AACI_DEV_PM_OPS (&aaci_dev_pm_ops) #else #define AACI_DEV_PM_OPS NULL #endif static const struct ac97_pcm ac97_defs[] = { [0] = { /* Front PCM */ .exclusive = 1, .r = { [0] = { .slots = (1 << AC97_SLOT_PCM_LEFT) | (1 << AC97_SLOT_PCM_RIGHT) | (1 << AC97_SLOT_PCM_CENTER) | (1 << AC97_SLOT_PCM_SLEFT) | (1 << AC97_SLOT_PCM_SRIGHT) | (1 << AC97_SLOT_LFE), }, [1] = { .slots = (1 << AC97_SLOT_PCM_LEFT) | (1 << AC97_SLOT_PCM_RIGHT) | (1 << AC97_SLOT_PCM_LEFT_0) | (1 << AC97_SLOT_PCM_RIGHT_0), }, }, }, [1] = { /* PCM in */ .stream = 1, .exclusive = 1, .r = { [0] = { .slots = (1 << AC97_SLOT_PCM_LEFT) | (1 << AC97_SLOT_PCM_RIGHT), }, }, }, [2] = { /* Mic in */ .stream = 1, .exclusive = 1, .r = { [0] = { .slots = (1 << AC97_SLOT_MIC), }, }, } }; static const struct snd_ac97_bus_ops aaci_bus_ops = { .write = aaci_ac97_write, .read = aaci_ac97_read, }; static int aaci_probe_ac97(struct aaci *aaci) { struct snd_ac97_template ac97_template; struct snd_ac97_bus *ac97_bus; struct snd_ac97 *ac97; int ret; /* * Assert AACIRESET for 2us */ writel(0, aaci->base + AACI_RESET); udelay(2); writel(RESET_NRST, aaci->base + AACI_RESET); /* * Give the AC'97 codec more than enough time * to wake up. (42us = ~2 frames at 48kHz.) */ udelay(FRAME_PERIOD_US * 2); ret = snd_ac97_bus(aaci->card, 0, &aaci_bus_ops, aaci, &ac97_bus); if (ret) goto out; ac97_bus->clock = 48000; aaci->ac97_bus = ac97_bus; memset(&ac97_template, 0, sizeof(struct snd_ac97_template)); ac97_template.private_data = aaci; ac97_template.num = 0; ac97_template.scaps = AC97_SCAP_SKIP_MODEM; ret = snd_ac97_mixer(ac97_bus, &ac97_template, &ac97); if (ret) goto out; aaci->ac97 = ac97; /* * Disable AC97 PC Beep input on audio codecs. */ if (ac97_is_audio(ac97)) snd_ac97_write_cache(ac97, AC97_PC_BEEP, 0x801e); ret = snd_ac97_pcm_assign(ac97_bus, ARRAY_SIZE(ac97_defs), ac97_defs); if (ret) goto out; aaci->playback.pcm = &ac97_bus->pcms[0]; aaci->capture.pcm = &ac97_bus->pcms[1]; out: return ret; } static void aaci_free_card(struct snd_card *card) { struct aaci *aaci = card->private_data; iounmap(aaci->base); } static struct aaci *aaci_init_card(struct amba_device *dev) { struct aaci *aaci; struct snd_card *card; int err; err = snd_card_new(&dev->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, THIS_MODULE, sizeof(struct aaci), &card); if (err < 0) return NULL; card->private_free = aaci_free_card; strscpy(card->driver, DRIVER_NAME, sizeof(card->driver)); strscpy(card->shortname, "ARM AC'97 Interface", sizeof(card->shortname)); snprintf(card->longname, sizeof(card->longname), "%s PL%03x rev%u at 0x%08llx, irq %d", card->shortname, amba_part(dev), amba_rev(dev), (unsigned long long)dev->res.start, dev->irq[0]); aaci = card->private_data; mutex_init(&aaci->ac97_sem); mutex_init(&aaci->irq_lock); aaci->card = card; aaci->dev = dev; /* Set MAINCR to allow slot 1 and 2 data IO */ aaci->maincr = MAINCR_IE | MAINCR_SL1RXEN | MAINCR_SL1TXEN | MAINCR_SL2RXEN | MAINCR_SL2TXEN; return aaci; } static int aaci_init_pcm(struct aaci *aaci) { struct snd_pcm *pcm; int ret; ret = snd_pcm_new(aaci->card, "AACI AC'97", 0, 1, 1, &pcm); if (ret == 0) { aaci->pcm = pcm; pcm->private_data = aaci; pcm->info_flags = 0; strscpy(pcm->name, DRIVER_NAME, sizeof(pcm->name)); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &aaci_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &aaci_capture_ops); snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, aaci->card->dev, 0, 64 * 1024); } return ret; } static unsigned int aaci_size_fifo(struct aaci *aaci) { struct aaci_runtime *aacirun = &aaci->playback; int i; /* * Enable the channel, but don't assign it to any slots, so * it won't empty onto the AC'97 link. */ writel(CR_FEN | CR_SZ16 | CR_EN, aacirun->base + AACI_TXCR); for (i = 0; !(readl(aacirun->base + AACI_SR) & SR_TXFF) && i < 4096; i++) writel(0, aacirun->fifo); writel(0, aacirun->base + AACI_TXCR); /* * Re-initialise the AACI after the FIFO depth test, to * ensure that the FIFOs are empty. Unfortunately, merely * disabling the channel doesn't clear the FIFO. */ writel(aaci->maincr & ~MAINCR_IE, aaci->base + AACI_MAINCR); readl(aaci->base + AACI_MAINCR); udelay(1); writel(aaci->maincr, aaci->base + AACI_MAINCR); /* * If we hit 4096 entries, we failed. Go back to the specified * fifo depth. */ if (i == 4096) i = 8; return i; } static int aaci_probe(struct amba_device *dev, const struct amba_id *id) { struct aaci *aaci; int ret, i; ret = amba_request_regions(dev, NULL); if (ret) return ret; aaci = aaci_init_card(dev); if (!aaci) { ret = -ENOMEM; goto out; } aaci->base = ioremap(dev->res.start, resource_size(&dev->res)); if (!aaci->base) { ret = -ENOMEM; goto out; } /* * Playback uses AACI channel 0 */ spin_lock_init(&aaci->playback.lock); aaci->playback.base = aaci->base + AACI_CSCH1; aaci->playback.fifo = aaci->base + AACI_DR1; /* * Capture uses AACI channel 0 */ spin_lock_init(&aaci->capture.lock); aaci->capture.base = aaci->base + AACI_CSCH1; aaci->capture.fifo = aaci->base + AACI_DR1; for (i = 0; i < 4; i++) { void __iomem *base = aaci->base + i * 0x14; writel(0, base + AACI_IE); writel(0, base + AACI_TXCR); writel(0, base + AACI_RXCR); } writel(0x1fff, aaci->base + AACI_INTCLR); writel(aaci->maincr, aaci->base + AACI_MAINCR); /* * Fix: ac97 read back fail errors by reading * from any arbitrary aaci register. */ readl(aaci->base + AACI_CSCH1); ret = aaci_probe_ac97(aaci); if (ret) goto out; /* * Size the FIFOs (must be multiple of 16). * This is the number of entries in the FIFO. */ aaci->fifo_depth = aaci_size_fifo(aaci); if (aaci->fifo_depth & 15) { printk(KERN_WARNING "AACI: FIFO depth %d not supported\n", aaci->fifo_depth); ret = -ENODEV; goto out; } ret = aaci_init_pcm(aaci); if (ret) goto out; ret = snd_card_register(aaci->card); if (ret == 0) { dev_info(&dev->dev, "%s\n", aaci->card->longname); dev_info(&dev->dev, "FIFO %u entries\n", aaci->fifo_depth); amba_set_drvdata(dev, aaci->card); return ret; } out: if (aaci) snd_card_free(aaci->card); amba_release_regions(dev); return ret; } static void aaci_remove(struct amba_device *dev) { struct snd_card *card = amba_get_drvdata(dev); if (card) { struct aaci *aaci = card->private_data; writel(0, aaci->base + AACI_MAINCR); snd_card_free(card); amba_release_regions(dev); } } static struct amba_id aaci_ids[] = { { .id = 0x00041041, .mask = 0x000fffff, }, { 0, 0 }, }; MODULE_DEVICE_TABLE(amba, aaci_ids); static struct amba_driver aaci_driver = { .drv = { .name = DRIVER_NAME, .pm = AACI_DEV_PM_OPS, }, .probe = aaci_probe, .remove = aaci_remove, .id_table = aaci_ids, }; module_amba_driver(aaci_driver); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("ARM PrimeCell PL041 Advanced Audio CODEC Interface driver");
linux-master
sound/arm/aaci.c
// SPDX-License-Identifier: GPL-2.0-only /* * linux/sound/pxa2xx-ac97.c -- AC97 support for the Intel PXA2xx chip. * * Author: Nicolas Pitre * Created: Dec 02, 2004 * Copyright: MontaVista Software Inc. */ #include <linux/init.h> #include <linux/io.h> #include <linux/module.h> #include <linux/platform_device.h> #include <linux/dmaengine.h> #include <linux/dma-mapping.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/ac97_codec.h> #include <sound/initval.h> #include <sound/pxa2xx-lib.h> #include <sound/dmaengine_pcm.h> #include <linux/platform_data/asoc-pxa.h> static void pxa2xx_ac97_legacy_reset(struct snd_ac97 *ac97) { if (!pxa2xx_ac97_try_cold_reset()) pxa2xx_ac97_try_warm_reset(); pxa2xx_ac97_finish_reset(); } static unsigned short pxa2xx_ac97_legacy_read(struct snd_ac97 *ac97, unsigned short reg) { int ret; ret = pxa2xx_ac97_read(ac97->num, reg); if (ret < 0) return 0; else return (unsigned short)(ret & 0xffff); } static void pxa2xx_ac97_legacy_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) { pxa2xx_ac97_write(ac97->num, reg, val); } static const struct snd_ac97_bus_ops pxa2xx_ac97_ops = { .read = pxa2xx_ac97_legacy_read, .write = pxa2xx_ac97_legacy_write, .reset = pxa2xx_ac97_legacy_reset, }; static struct snd_pcm *pxa2xx_ac97_pcm; static struct snd_ac97 *pxa2xx_ac97_ac97; static int pxa2xx_ac97_pcm_open(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; pxa2xx_audio_ops_t *platform_ops; int ret, i; ret = pxa2xx_pcm_open(substream); if (ret) return ret; runtime->hw.channels_min = 2; runtime->hw.channels_max = 2; i = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? AC97_RATES_FRONT_DAC : AC97_RATES_ADC; runtime->hw.rates = pxa2xx_ac97_ac97->rates[i]; snd_pcm_limit_hw_rates(runtime); platform_ops = substream->pcm->card->dev->platform_data; if (platform_ops && platform_ops->startup) { ret = platform_ops->startup(substream, platform_ops->priv); if (ret < 0) pxa2xx_pcm_close(substream); } return ret; } static int pxa2xx_ac97_pcm_close(struct snd_pcm_substream *substream) { pxa2xx_audio_ops_t *platform_ops; platform_ops = substream->pcm->card->dev->platform_data; if (platform_ops && platform_ops->shutdown) platform_ops->shutdown(substream, platform_ops->priv); return 0; } static int pxa2xx_ac97_pcm_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; int reg = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? AC97_PCM_FRONT_DAC_RATE : AC97_PCM_LR_ADC_RATE; int ret; ret = pxa2xx_pcm_prepare(substream); if (ret < 0) return ret; return snd_ac97_set_rate(pxa2xx_ac97_ac97, reg, runtime->rate); } #ifdef CONFIG_PM_SLEEP static int pxa2xx_ac97_do_suspend(struct snd_card *card) { pxa2xx_audio_ops_t *platform_ops = card->dev->platform_data; snd_power_change_state(card, SNDRV_CTL_POWER_D3cold); snd_ac97_suspend(pxa2xx_ac97_ac97); if (platform_ops && platform_ops->suspend) platform_ops->suspend(platform_ops->priv); return pxa2xx_ac97_hw_suspend(); } static int pxa2xx_ac97_do_resume(struct snd_card *card) { pxa2xx_audio_ops_t *platform_ops = card->dev->platform_data; int rc; rc = pxa2xx_ac97_hw_resume(); if (rc) return rc; if (platform_ops && platform_ops->resume) platform_ops->resume(platform_ops->priv); snd_ac97_resume(pxa2xx_ac97_ac97); snd_power_change_state(card, SNDRV_CTL_POWER_D0); return 0; } static int pxa2xx_ac97_suspend(struct device *dev) { struct snd_card *card = dev_get_drvdata(dev); int ret = 0; if (card) ret = pxa2xx_ac97_do_suspend(card); return ret; } static int pxa2xx_ac97_resume(struct device *dev) { struct snd_card *card = dev_get_drvdata(dev); int ret = 0; if (card) ret = pxa2xx_ac97_do_resume(card); return ret; } static SIMPLE_DEV_PM_OPS(pxa2xx_ac97_pm_ops, pxa2xx_ac97_suspend, pxa2xx_ac97_resume); #endif static const struct snd_pcm_ops pxa2xx_ac97_pcm_ops = { .open = pxa2xx_ac97_pcm_open, .close = pxa2xx_ac97_pcm_close, .hw_params = pxa2xx_pcm_hw_params, .prepare = pxa2xx_ac97_pcm_prepare, .trigger = pxa2xx_pcm_trigger, .pointer = pxa2xx_pcm_pointer, }; static int pxa2xx_ac97_pcm_new(struct snd_card *card) { struct snd_pcm *pcm; int ret; ret = snd_pcm_new(card, "PXA2xx-PCM", 0, 1, 1, &pcm); if (ret) goto out; ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32)); if (ret) goto out; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pxa2xx_ac97_pcm_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pxa2xx_ac97_pcm_ops); ret = pxa2xx_pcm_preallocate_dma_buffer(pcm); if (ret) goto out; pxa2xx_ac97_pcm = pcm; ret = 0; out: return ret; } static int pxa2xx_ac97_probe(struct platform_device *dev) { struct snd_card *card; struct snd_ac97_bus *ac97_bus; struct snd_ac97_template ac97_template; int ret; pxa2xx_audio_ops_t *pdata = dev->dev.platform_data; if (dev->id >= 0) { dev_err(&dev->dev, "PXA2xx has only one AC97 port.\n"); ret = -ENXIO; goto err_dev; } ret = snd_card_new(&dev->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, THIS_MODULE, 0, &card); if (ret < 0) goto err; strscpy(card->driver, dev->dev.driver->name, sizeof(card->driver)); ret = pxa2xx_ac97_pcm_new(card); if (ret) goto err; ret = pxa2xx_ac97_hw_probe(dev); if (ret) goto err; ret = snd_ac97_bus(card, 0, &pxa2xx_ac97_ops, NULL, &ac97_bus); if (ret) goto err_remove; memset(&ac97_template, 0, sizeof(ac97_template)); ret = snd_ac97_mixer(ac97_bus, &ac97_template, &pxa2xx_ac97_ac97); if (ret) goto err_remove; snprintf(card->shortname, sizeof(card->shortname), "%s", snd_ac97_get_short_name(pxa2xx_ac97_ac97)); snprintf(card->longname, sizeof(card->longname), "%s (%s)", dev->dev.driver->name, card->mixername); if (pdata && pdata->codec_pdata[0]) snd_ac97_dev_add_pdata(ac97_bus->codec[0], pdata->codec_pdata[0]); ret = snd_card_register(card); if (ret == 0) { platform_set_drvdata(dev, card); return 0; } err_remove: pxa2xx_ac97_hw_remove(dev); err: if (card) snd_card_free(card); err_dev: return ret; } static void pxa2xx_ac97_remove(struct platform_device *dev) { struct snd_card *card = platform_get_drvdata(dev); if (card) { snd_card_free(card); pxa2xx_ac97_hw_remove(dev); } } static struct platform_driver pxa2xx_ac97_driver = { .probe = pxa2xx_ac97_probe, .remove_new = pxa2xx_ac97_remove, .driver = { .name = "pxa2xx-ac97", #ifdef CONFIG_PM_SLEEP .pm = &pxa2xx_ac97_pm_ops, #endif }, }; module_platform_driver(pxa2xx_ac97_driver); MODULE_AUTHOR("Nicolas Pitre"); MODULE_DESCRIPTION("AC97 driver for the Intel PXA2xx chip"); MODULE_LICENSE("GPL"); MODULE_ALIAS("platform:pxa2xx-ac97");
linux-master
sound/arm/pxa2xx-ac97.c
// SPDX-License-Identifier: GPL-2.0-only /* * Based on sound/arm/pxa2xx-ac97.c and sound/soc/pxa/pxa2xx-ac97.c * which contain: * * Author: Nicolas Pitre * Created: Dec 02, 2004 * Copyright: MontaVista Software Inc. */ #include <linux/kernel.h> #include <linux/platform_device.h> #include <linux/interrupt.h> #include <linux/clk.h> #include <linux/delay.h> #include <linux/module.h> #include <linux/io.h> #include <linux/gpio.h> #include <linux/of_gpio.h> #include <linux/soc/pxa/cpu.h> #include <sound/pxa2xx-lib.h> #include <linux/platform_data/asoc-pxa.h> #include "pxa2xx-ac97-regs.h" static DEFINE_MUTEX(car_mutex); static DECLARE_WAIT_QUEUE_HEAD(gsr_wq); static volatile long gsr_bits; static struct clk *ac97_clk; static struct clk *ac97conf_clk; static int reset_gpio; static void __iomem *ac97_reg_base; /* * Beware PXA27x bugs: * * o Slot 12 read from modem space will hang controller. * o CDONE, SDONE interrupt fails after any slot 12 IO. * * We therefore have an hybrid approach for waiting on SDONE (interrupt or * 1 jiffy timeout if interrupt never comes). */ int pxa2xx_ac97_read(int slot, unsigned short reg) { int val = -ENODEV; u32 __iomem *reg_addr; if (slot > 0) return -ENODEV; mutex_lock(&car_mutex); /* set up primary or secondary codec space */ if (cpu_is_pxa25x() && reg == AC97_GPIO_STATUS) reg_addr = ac97_reg_base + (slot ? SMC_REG_BASE : PMC_REG_BASE); else reg_addr = ac97_reg_base + (slot ? SAC_REG_BASE : PAC_REG_BASE); reg_addr += (reg >> 1); /* start read access across the ac97 link */ writel(GSR_CDONE | GSR_SDONE, ac97_reg_base + GSR); gsr_bits = 0; val = (readl(reg_addr) & 0xffff); if (reg == AC97_GPIO_STATUS) goto out; if (wait_event_timeout(gsr_wq, (readl(ac97_reg_base + GSR) | gsr_bits) & GSR_SDONE, 1) <= 0 && !((readl(ac97_reg_base + GSR) | gsr_bits) & GSR_SDONE)) { printk(KERN_ERR "%s: read error (ac97_reg=%d GSR=%#lx)\n", __func__, reg, readl(ac97_reg_base + GSR) | gsr_bits); val = -ETIMEDOUT; goto out; } /* valid data now */ writel(GSR_CDONE | GSR_SDONE, ac97_reg_base + GSR); gsr_bits = 0; val = (readl(reg_addr) & 0xffff); /* but we've just started another cycle... */ wait_event_timeout(gsr_wq, (readl(ac97_reg_base + GSR) | gsr_bits) & GSR_SDONE, 1); out: mutex_unlock(&car_mutex); return val; } EXPORT_SYMBOL_GPL(pxa2xx_ac97_read); int pxa2xx_ac97_write(int slot, unsigned short reg, unsigned short val) { u32 __iomem *reg_addr; int ret = 0; mutex_lock(&car_mutex); /* set up primary or secondary codec space */ if (cpu_is_pxa25x() && reg == AC97_GPIO_STATUS) reg_addr = ac97_reg_base + (slot ? SMC_REG_BASE : PMC_REG_BASE); else reg_addr = ac97_reg_base + (slot ? SAC_REG_BASE : PAC_REG_BASE); reg_addr += (reg >> 1); writel(GSR_CDONE | GSR_SDONE, ac97_reg_base + GSR); gsr_bits = 0; writel(val, reg_addr); if (wait_event_timeout(gsr_wq, (readl(ac97_reg_base + GSR) | gsr_bits) & GSR_CDONE, 1) <= 0 && !((readl(ac97_reg_base + GSR) | gsr_bits) & GSR_CDONE)) { printk(KERN_ERR "%s: write error (ac97_reg=%d GSR=%#lx)\n", __func__, reg, readl(ac97_reg_base + GSR) | gsr_bits); ret = -EIO; } mutex_unlock(&car_mutex); return ret; } EXPORT_SYMBOL_GPL(pxa2xx_ac97_write); #ifdef CONFIG_PXA25x static inline void pxa_ac97_warm_pxa25x(void) { gsr_bits = 0; writel(readl(ac97_reg_base + GCR) | (GCR_WARM_RST), ac97_reg_base + GCR); } static inline void pxa_ac97_cold_pxa25x(void) { writel(readl(ac97_reg_base + GCR) & ( GCR_COLD_RST), ac97_reg_base + GCR); /* clear everything but nCRST */ writel(readl(ac97_reg_base + GCR) & (~GCR_COLD_RST), ac97_reg_base + GCR); /* then assert nCRST */ gsr_bits = 0; writel(GCR_COLD_RST, ac97_reg_base + GCR); } #endif #ifdef CONFIG_PXA27x static inline void pxa_ac97_warm_pxa27x(void) { gsr_bits = 0; /* warm reset broken on Bulverde, so manually keep AC97 reset high */ pxa27x_configure_ac97reset(reset_gpio, true); udelay(10); writel(readl(ac97_reg_base + GCR) | (GCR_WARM_RST), ac97_reg_base + GCR); pxa27x_configure_ac97reset(reset_gpio, false); udelay(500); } static inline void pxa_ac97_cold_pxa27x(void) { writel(readl(ac97_reg_base + GCR) & ( GCR_COLD_RST), ac97_reg_base + GCR); /* clear everything but nCRST */ writel(readl(ac97_reg_base + GCR) & (~GCR_COLD_RST), ac97_reg_base + GCR); /* then assert nCRST */ gsr_bits = 0; /* PXA27x Developers Manual section 13.5.2.2.1 */ clk_prepare_enable(ac97conf_clk); udelay(5); clk_disable_unprepare(ac97conf_clk); writel(GCR_COLD_RST | GCR_WARM_RST, ac97_reg_base + GCR); } #endif #ifdef CONFIG_PXA3xx static inline void pxa_ac97_warm_pxa3xx(void) { gsr_bits = 0; /* Can't use interrupts */ writel(readl(ac97_reg_base + GCR) | (GCR_WARM_RST), ac97_reg_base + GCR); } static inline void pxa_ac97_cold_pxa3xx(void) { /* Hold CLKBPB for 100us */ writel(0, ac97_reg_base + GCR); writel(GCR_CLKBPB, ac97_reg_base + GCR); udelay(100); writel(0, ac97_reg_base + GCR); writel(readl(ac97_reg_base + GCR) & ( GCR_COLD_RST), ac97_reg_base + GCR); /* clear everything but nCRST */ writel(readl(ac97_reg_base + GCR) & (~GCR_COLD_RST), ac97_reg_base + GCR); /* then assert nCRST */ gsr_bits = 0; /* Can't use interrupts on PXA3xx */ writel(readl(ac97_reg_base + GCR) & (~(GCR_PRIRDY_IEN|GCR_SECRDY_IEN)), ac97_reg_base + GCR); writel(GCR_WARM_RST | GCR_COLD_RST, ac97_reg_base + GCR); } #endif bool pxa2xx_ac97_try_warm_reset(void) { unsigned long gsr; unsigned int timeout = 100; #ifdef CONFIG_PXA25x if (cpu_is_pxa25x()) pxa_ac97_warm_pxa25x(); else #endif #ifdef CONFIG_PXA27x if (cpu_is_pxa27x()) pxa_ac97_warm_pxa27x(); else #endif #ifdef CONFIG_PXA3xx if (cpu_is_pxa3xx()) pxa_ac97_warm_pxa3xx(); else #endif snd_BUG(); while (!((readl(ac97_reg_base + GSR) | gsr_bits) & (GSR_PCR | GSR_SCR)) && timeout--) mdelay(1); gsr = readl(ac97_reg_base + GSR) | gsr_bits; if (!(gsr & (GSR_PCR | GSR_SCR))) { printk(KERN_INFO "%s: warm reset timeout (GSR=%#lx)\n", __func__, gsr); return false; } return true; } EXPORT_SYMBOL_GPL(pxa2xx_ac97_try_warm_reset); bool pxa2xx_ac97_try_cold_reset(void) { unsigned long gsr; unsigned int timeout = 1000; #ifdef CONFIG_PXA25x if (cpu_is_pxa25x()) pxa_ac97_cold_pxa25x(); else #endif #ifdef CONFIG_PXA27x if (cpu_is_pxa27x()) pxa_ac97_cold_pxa27x(); else #endif #ifdef CONFIG_PXA3xx if (cpu_is_pxa3xx()) pxa_ac97_cold_pxa3xx(); else #endif snd_BUG(); while (!((readl(ac97_reg_base + GSR) | gsr_bits) & (GSR_PCR | GSR_SCR)) && timeout--) mdelay(1); gsr = readl(ac97_reg_base + GSR) | gsr_bits; if (!(gsr & (GSR_PCR | GSR_SCR))) { printk(KERN_INFO "%s: cold reset timeout (GSR=%#lx)\n", __func__, gsr); return false; } return true; } EXPORT_SYMBOL_GPL(pxa2xx_ac97_try_cold_reset); void pxa2xx_ac97_finish_reset(void) { u32 gcr = readl(ac97_reg_base + GCR); gcr &= ~(GCR_PRIRDY_IEN|GCR_SECRDY_IEN); gcr |= GCR_SDONE_IE|GCR_CDONE_IE; writel(gcr, ac97_reg_base + GCR); } EXPORT_SYMBOL_GPL(pxa2xx_ac97_finish_reset); static irqreturn_t pxa2xx_ac97_irq(int irq, void *dev_id) { long status; status = readl(ac97_reg_base + GSR); if (status) { writel(status, ac97_reg_base + GSR); gsr_bits |= status; wake_up(&gsr_wq); /* Although we don't use those we still need to clear them since they tend to spuriously trigger when MMC is used (hardware bug? go figure)... */ if (cpu_is_pxa27x()) { writel(MISR_EOC, ac97_reg_base + MISR); writel(PISR_EOC, ac97_reg_base + PISR); writel(MCSR_EOC, ac97_reg_base + MCSR); } return IRQ_HANDLED; } return IRQ_NONE; } #ifdef CONFIG_PM int pxa2xx_ac97_hw_suspend(void) { writel(readl(ac97_reg_base + GCR) | (GCR_ACLINK_OFF), ac97_reg_base + GCR); clk_disable_unprepare(ac97_clk); return 0; } EXPORT_SYMBOL_GPL(pxa2xx_ac97_hw_suspend); int pxa2xx_ac97_hw_resume(void) { clk_prepare_enable(ac97_clk); return 0; } EXPORT_SYMBOL_GPL(pxa2xx_ac97_hw_resume); #endif int pxa2xx_ac97_hw_probe(struct platform_device *dev) { int ret; int irq; pxa2xx_audio_ops_t *pdata = dev->dev.platform_data; ac97_reg_base = devm_platform_ioremap_resource(dev, 0); if (IS_ERR(ac97_reg_base)) { dev_err(&dev->dev, "Missing MMIO resource\n"); return PTR_ERR(ac97_reg_base); } if (pdata) { switch (pdata->reset_gpio) { case 95: case 113: reset_gpio = pdata->reset_gpio; break; case 0: reset_gpio = 113; break; case -1: break; default: dev_err(&dev->dev, "Invalid reset GPIO %d\n", pdata->reset_gpio); } } else if (!pdata && dev->dev.of_node) { pdata = devm_kzalloc(&dev->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; pdata->reset_gpio = of_get_named_gpio(dev->dev.of_node, "reset-gpios", 0); if (pdata->reset_gpio == -ENOENT) pdata->reset_gpio = -1; else if (pdata->reset_gpio < 0) return pdata->reset_gpio; reset_gpio = pdata->reset_gpio; } else { if (cpu_is_pxa27x()) reset_gpio = 113; } if (cpu_is_pxa27x()) { /* * This gpio is needed for a work-around to a bug in the ac97 * controller during warm reset. The direction and level is set * here so that it is an output driven high when switching from * AC97_nRESET alt function to generic gpio. */ ret = gpio_request_one(reset_gpio, GPIOF_OUT_INIT_HIGH, "pxa27x ac97 reset"); if (ret < 0) { pr_err("%s: gpio_request_one() failed: %d\n", __func__, ret); goto err_conf; } pxa27x_configure_ac97reset(reset_gpio, false); ac97conf_clk = clk_get(&dev->dev, "AC97CONFCLK"); if (IS_ERR(ac97conf_clk)) { ret = PTR_ERR(ac97conf_clk); ac97conf_clk = NULL; goto err_conf; } } ac97_clk = clk_get(&dev->dev, "AC97CLK"); if (IS_ERR(ac97_clk)) { ret = PTR_ERR(ac97_clk); ac97_clk = NULL; goto err_clk; } ret = clk_prepare_enable(ac97_clk); if (ret) goto err_clk2; irq = platform_get_irq(dev, 0); if (irq < 0) { ret = irq; goto err_irq; } ret = request_irq(irq, pxa2xx_ac97_irq, 0, "AC97", NULL); if (ret < 0) goto err_irq; return 0; err_irq: writel(readl(ac97_reg_base + GCR) | (GCR_ACLINK_OFF), ac97_reg_base + GCR); err_clk2: clk_put(ac97_clk); ac97_clk = NULL; err_clk: if (ac97conf_clk) { clk_put(ac97conf_clk); ac97conf_clk = NULL; } err_conf: return ret; } EXPORT_SYMBOL_GPL(pxa2xx_ac97_hw_probe); void pxa2xx_ac97_hw_remove(struct platform_device *dev) { if (cpu_is_pxa27x()) gpio_free(reset_gpio); writel(readl(ac97_reg_base + GCR) | (GCR_ACLINK_OFF), ac97_reg_base + GCR); free_irq(platform_get_irq(dev, 0), NULL); if (ac97conf_clk) { clk_put(ac97conf_clk); ac97conf_clk = NULL; } clk_disable_unprepare(ac97_clk); clk_put(ac97_clk); ac97_clk = NULL; } EXPORT_SYMBOL_GPL(pxa2xx_ac97_hw_remove); u32 pxa2xx_ac97_read_modr(void) { if (!ac97_reg_base) return 0; return readl(ac97_reg_base + MODR); } EXPORT_SYMBOL_GPL(pxa2xx_ac97_read_modr); u32 pxa2xx_ac97_read_misr(void) { if (!ac97_reg_base) return 0; return readl(ac97_reg_base + MISR); } EXPORT_SYMBOL_GPL(pxa2xx_ac97_read_misr); MODULE_AUTHOR("Nicolas Pitre"); MODULE_DESCRIPTION("Intel/Marvell PXA sound library"); MODULE_LICENSE("GPL");
linux-master
sound/arm/pxa2xx-ac97-lib.c
// SPDX-License-Identifier: GPL-2.0-only /* * Driver for AMD7930 sound chips found on Sparcs. * Copyright (C) 2002, 2008 David S. Miller <[email protected]> * * Based entirely upon drivers/sbus/audio/amd7930.c which is: * Copyright (C) 1996,1997 Thomas K. Dyas ([email protected]) * * --- Notes from Thomas's original driver --- * This is the lowlevel driver for the AMD7930 audio chip found on all * sun4c machines and some sun4m machines. * * The amd7930 is actually an ISDN chip which has a very simple * integrated audio encoder/decoder. When Sun decided on what chip to * use for audio, they had the brilliant idea of using the amd7930 and * only connecting the audio encoder/decoder pins. * * Thanks to the AMD engineer who was able to get us the AMD79C30 * databook which has all the programming information and gain tables. * * Advanced Micro Devices' Am79C30A is an ISDN/audio chip used in the * SparcStation 1+. The chip provides microphone and speaker interfaces * which provide mono-channel audio at 8K samples per second via either * 8-bit A-law or 8-bit mu-law encoding. Also, the chip features an * ISDN BRI Line Interface Unit (LIU), I.430 S/T physical interface, * which performs basic D channel LAPD processing and provides raw * B channel data. The digital audio channel, the two ISDN B channels, * and two 64 Kbps channels to the microprocessor are all interconnected * via a multiplexer. * --- End of notes from Thoamas's original driver --- */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/slab.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/moduleparam.h> #include <linux/of.h> #include <linux/platform_device.h> #include <linux/io.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/info.h> #include <sound/control.h> #include <sound/initval.h> #include <asm/irq.h> static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for Sun AMD7930 soundcard."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for Sun AMD7930 soundcard."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable Sun AMD7930 soundcard."); MODULE_AUTHOR("Thomas K. Dyas and David S. Miller"); MODULE_DESCRIPTION("Sun AMD7930"); MODULE_LICENSE("GPL"); /* Device register layout. */ /* Register interface presented to the CPU by the amd7930. */ #define AMD7930_CR 0x00UL /* Command Register (W) */ #define AMD7930_IR AMD7930_CR /* Interrupt Register (R) */ #define AMD7930_DR 0x01UL /* Data Register (R/W) */ #define AMD7930_DSR1 0x02UL /* D-channel Status Register 1 (R) */ #define AMD7930_DER 0x03UL /* D-channel Error Register (R) */ #define AMD7930_DCTB 0x04UL /* D-channel Transmit Buffer (W) */ #define AMD7930_DCRB AMD7930_DCTB /* D-channel Receive Buffer (R) */ #define AMD7930_BBTB 0x05UL /* Bb-channel Transmit Buffer (W) */ #define AMD7930_BBRB AMD7930_BBTB /* Bb-channel Receive Buffer (R) */ #define AMD7930_BCTB 0x06UL /* Bc-channel Transmit Buffer (W) */ #define AMD7930_BCRB AMD7930_BCTB /* Bc-channel Receive Buffer (R) */ #define AMD7930_DSR2 0x07UL /* D-channel Status Register 2 (R) */ /* Indirect registers in the Main Audio Processor. */ struct amd7930_map { __u16 x[8]; __u16 r[8]; __u16 gx; __u16 gr; __u16 ger; __u16 stgr; __u16 ftgr; __u16 atgr; __u8 mmr1; __u8 mmr2; }; /* After an amd7930 interrupt, reading the Interrupt Register (ir) * clears the interrupt and returns a bitmask indicating which * interrupt source(s) require service. */ #define AMR_IR_DTTHRSH 0x01 /* D-channel xmit threshold */ #define AMR_IR_DRTHRSH 0x02 /* D-channel recv threshold */ #define AMR_IR_DSRI 0x04 /* D-channel packet status */ #define AMR_IR_DERI 0x08 /* D-channel error */ #define AMR_IR_BBUF 0x10 /* B-channel data xfer */ #define AMR_IR_LSRI 0x20 /* LIU status */ #define AMR_IR_DSR2I 0x40 /* D-channel buffer status */ #define AMR_IR_MLTFRMI 0x80 /* multiframe or PP */ /* The amd7930 has "indirect registers" which are accessed by writing * the register number into the Command Register and then reading or * writing values from the Data Register as appropriate. We define the * AMR_* macros to be the indirect register numbers and AM_* macros to * be bits in whatever register is referred to. */ /* Initialization */ #define AMR_INIT 0x21 #define AM_INIT_ACTIVE 0x01 #define AM_INIT_DATAONLY 0x02 #define AM_INIT_POWERDOWN 0x03 #define AM_INIT_DISABLE_INTS 0x04 #define AMR_INIT2 0x20 #define AM_INIT2_ENABLE_POWERDOWN 0x20 #define AM_INIT2_ENABLE_MULTIFRAME 0x10 /* Line Interface Unit */ #define AMR_LIU_LSR 0xA1 #define AM_LIU_LSR_STATE 0x07 #define AM_LIU_LSR_F3 0x08 #define AM_LIU_LSR_F7 0x10 #define AM_LIU_LSR_F8 0x20 #define AM_LIU_LSR_HSW 0x40 #define AM_LIU_LSR_HSW_CHG 0x80 #define AMR_LIU_LPR 0xA2 #define AMR_LIU_LMR1 0xA3 #define AM_LIU_LMR1_B1_ENABL 0x01 #define AM_LIU_LMR1_B2_ENABL 0x02 #define AM_LIU_LMR1_F_DISABL 0x04 #define AM_LIU_LMR1_FA_DISABL 0x08 #define AM_LIU_LMR1_REQ_ACTIV 0x10 #define AM_LIU_LMR1_F8_F3 0x20 #define AM_LIU_LMR1_LIU_ENABL 0x40 #define AMR_LIU_LMR2 0xA4 #define AM_LIU_LMR2_DECHO 0x01 #define AM_LIU_LMR2_DLOOP 0x02 #define AM_LIU_LMR2_DBACKOFF 0x04 #define AM_LIU_LMR2_EN_F3_INT 0x08 #define AM_LIU_LMR2_EN_F8_INT 0x10 #define AM_LIU_LMR2_EN_HSW_INT 0x20 #define AM_LIU_LMR2_EN_F7_INT 0x40 #define AMR_LIU_2_4 0xA5 #define AMR_LIU_MF 0xA6 #define AMR_LIU_MFSB 0xA7 #define AMR_LIU_MFQB 0xA8 /* Multiplexor */ #define AMR_MUX_MCR1 0x41 #define AMR_MUX_MCR2 0x42 #define AMR_MUX_MCR3 0x43 #define AM_MUX_CHANNEL_B1 0x01 #define AM_MUX_CHANNEL_B2 0x02 #define AM_MUX_CHANNEL_Ba 0x03 #define AM_MUX_CHANNEL_Bb 0x04 #define AM_MUX_CHANNEL_Bc 0x05 #define AM_MUX_CHANNEL_Bd 0x06 #define AM_MUX_CHANNEL_Be 0x07 #define AM_MUX_CHANNEL_Bf 0x08 #define AMR_MUX_MCR4 0x44 #define AM_MUX_MCR4_ENABLE_INTS 0x08 #define AM_MUX_MCR4_REVERSE_Bb 0x10 #define AM_MUX_MCR4_REVERSE_Bc 0x20 #define AMR_MUX_1_4 0x45 /* Main Audio Processor */ #define AMR_MAP_X 0x61 #define AMR_MAP_R 0x62 #define AMR_MAP_GX 0x63 #define AMR_MAP_GR 0x64 #define AMR_MAP_GER 0x65 #define AMR_MAP_STGR 0x66 #define AMR_MAP_FTGR_1_2 0x67 #define AMR_MAP_ATGR_1_2 0x68 #define AMR_MAP_MMR1 0x69 #define AM_MAP_MMR1_ALAW 0x01 #define AM_MAP_MMR1_GX 0x02 #define AM_MAP_MMR1_GR 0x04 #define AM_MAP_MMR1_GER 0x08 #define AM_MAP_MMR1_X 0x10 #define AM_MAP_MMR1_R 0x20 #define AM_MAP_MMR1_STG 0x40 #define AM_MAP_MMR1_LOOPBACK 0x80 #define AMR_MAP_MMR2 0x6A #define AM_MAP_MMR2_AINB 0x01 #define AM_MAP_MMR2_LS 0x02 #define AM_MAP_MMR2_ENABLE_DTMF 0x04 #define AM_MAP_MMR2_ENABLE_TONEGEN 0x08 #define AM_MAP_MMR2_ENABLE_TONERING 0x10 #define AM_MAP_MMR2_DISABLE_HIGHPASS 0x20 #define AM_MAP_MMR2_DISABLE_AUTOZERO 0x40 #define AMR_MAP_1_10 0x6B #define AMR_MAP_MMR3 0x6C #define AMR_MAP_STRA 0x6D #define AMR_MAP_STRF 0x6E #define AMR_MAP_PEAKX 0x70 #define AMR_MAP_PEAKR 0x71 #define AMR_MAP_15_16 0x72 /* Data Link Controller */ #define AMR_DLC_FRAR_1_2_3 0x81 #define AMR_DLC_SRAR_1_2_3 0x82 #define AMR_DLC_TAR 0x83 #define AMR_DLC_DRLR 0x84 #define AMR_DLC_DTCR 0x85 #define AMR_DLC_DMR1 0x86 #define AMR_DLC_DMR1_DTTHRSH_INT 0x01 #define AMR_DLC_DMR1_DRTHRSH_INT 0x02 #define AMR_DLC_DMR1_TAR_ENABL 0x04 #define AMR_DLC_DMR1_EORP_INT 0x08 #define AMR_DLC_DMR1_EN_ADDR1 0x10 #define AMR_DLC_DMR1_EN_ADDR2 0x20 #define AMR_DLC_DMR1_EN_ADDR3 0x40 #define AMR_DLC_DMR1_EN_ADDR4 0x80 #define AMR_DLC_DMR1_EN_ADDRS 0xf0 #define AMR_DLC_DMR2 0x87 #define AMR_DLC_DMR2_RABRT_INT 0x01 #define AMR_DLC_DMR2_RESID_INT 0x02 #define AMR_DLC_DMR2_COLL_INT 0x04 #define AMR_DLC_DMR2_FCS_INT 0x08 #define AMR_DLC_DMR2_OVFL_INT 0x10 #define AMR_DLC_DMR2_UNFL_INT 0x20 #define AMR_DLC_DMR2_OVRN_INT 0x40 #define AMR_DLC_DMR2_UNRN_INT 0x80 #define AMR_DLC_1_7 0x88 #define AMR_DLC_DRCR 0x89 #define AMR_DLC_RNGR1 0x8A #define AMR_DLC_RNGR2 0x8B #define AMR_DLC_FRAR4 0x8C #define AMR_DLC_SRAR4 0x8D #define AMR_DLC_DMR3 0x8E #define AMR_DLC_DMR3_VA_INT 0x01 #define AMR_DLC_DMR3_EOTP_INT 0x02 #define AMR_DLC_DMR3_LBRP_INT 0x04 #define AMR_DLC_DMR3_RBA_INT 0x08 #define AMR_DLC_DMR3_LBT_INT 0x10 #define AMR_DLC_DMR3_TBE_INT 0x20 #define AMR_DLC_DMR3_RPLOST_INT 0x40 #define AMR_DLC_DMR3_KEEP_FCS 0x80 #define AMR_DLC_DMR4 0x8F #define AMR_DLC_DMR4_RCV_1 0x00 #define AMR_DLC_DMR4_RCV_2 0x01 #define AMR_DLC_DMR4_RCV_4 0x02 #define AMR_DLC_DMR4_RCV_8 0x03 #define AMR_DLC_DMR4_RCV_16 0x01 #define AMR_DLC_DMR4_RCV_24 0x02 #define AMR_DLC_DMR4_RCV_30 0x03 #define AMR_DLC_DMR4_XMT_1 0x00 #define AMR_DLC_DMR4_XMT_2 0x04 #define AMR_DLC_DMR4_XMT_4 0x08 #define AMR_DLC_DMR4_XMT_8 0x0c #define AMR_DLC_DMR4_XMT_10 0x08 #define AMR_DLC_DMR4_XMT_14 0x0c #define AMR_DLC_DMR4_IDLE_MARK 0x00 #define AMR_DLC_DMR4_IDLE_FLAG 0x10 #define AMR_DLC_DMR4_ADDR_BOTH 0x00 #define AMR_DLC_DMR4_ADDR_1ST 0x20 #define AMR_DLC_DMR4_ADDR_2ND 0xa0 #define AMR_DLC_DMR4_CR_ENABLE 0x40 #define AMR_DLC_12_15 0x90 #define AMR_DLC_ASR 0x91 #define AMR_DLC_EFCR 0x92 #define AMR_DLC_EFCR_EXTEND_FIFO 0x01 #define AMR_DLC_EFCR_SEC_PKT_INT 0x02 #define AMR_DSR1_VADDR 0x01 #define AMR_DSR1_EORP 0x02 #define AMR_DSR1_PKT_IP 0x04 #define AMR_DSR1_DECHO_ON 0x08 #define AMR_DSR1_DLOOP_ON 0x10 #define AMR_DSR1_DBACK_OFF 0x20 #define AMR_DSR1_EOTP 0x40 #define AMR_DSR1_CXMT_ABRT 0x80 #define AMR_DSR2_LBRP 0x01 #define AMR_DSR2_RBA 0x02 #define AMR_DSR2_RPLOST 0x04 #define AMR_DSR2_LAST_BYTE 0x08 #define AMR_DSR2_TBE 0x10 #define AMR_DSR2_MARK_IDLE 0x20 #define AMR_DSR2_FLAG_IDLE 0x40 #define AMR_DSR2_SECOND_PKT 0x80 #define AMR_DER_RABRT 0x01 #define AMR_DER_RFRAME 0x02 #define AMR_DER_COLLISION 0x04 #define AMR_DER_FCS 0x08 #define AMR_DER_OVFL 0x10 #define AMR_DER_UNFL 0x20 #define AMR_DER_OVRN 0x40 #define AMR_DER_UNRN 0x80 /* Peripheral Port */ #define AMR_PP_PPCR1 0xC0 #define AMR_PP_PPSR 0xC1 #define AMR_PP_PPIER 0xC2 #define AMR_PP_MTDR 0xC3 #define AMR_PP_MRDR 0xC3 #define AMR_PP_CITDR0 0xC4 #define AMR_PP_CIRDR0 0xC4 #define AMR_PP_CITDR1 0xC5 #define AMR_PP_CIRDR1 0xC5 #define AMR_PP_PPCR2 0xC8 #define AMR_PP_PPCR3 0xC9 struct snd_amd7930 { spinlock_t lock; void __iomem *regs; u32 flags; #define AMD7930_FLAG_PLAYBACK 0x00000001 #define AMD7930_FLAG_CAPTURE 0x00000002 struct amd7930_map map; struct snd_card *card; struct snd_pcm *pcm; struct snd_pcm_substream *playback_substream; struct snd_pcm_substream *capture_substream; /* Playback/Capture buffer state. */ unsigned char *p_orig, *p_cur; int p_left; unsigned char *c_orig, *c_cur; int c_left; int rgain; int pgain; int mgain; struct platform_device *op; unsigned int irq; struct snd_amd7930 *next; }; static struct snd_amd7930 *amd7930_list; /* Idle the AMD7930 chip. The amd->lock is not held. */ static __inline__ void amd7930_idle(struct snd_amd7930 *amd) { unsigned long flags; spin_lock_irqsave(&amd->lock, flags); sbus_writeb(AMR_INIT, amd->regs + AMD7930_CR); sbus_writeb(0, amd->regs + AMD7930_DR); spin_unlock_irqrestore(&amd->lock, flags); } /* Enable chip interrupts. The amd->lock is not held. */ static __inline__ void amd7930_enable_ints(struct snd_amd7930 *amd) { unsigned long flags; spin_lock_irqsave(&amd->lock, flags); sbus_writeb(AMR_INIT, amd->regs + AMD7930_CR); sbus_writeb(AM_INIT_ACTIVE, amd->regs + AMD7930_DR); spin_unlock_irqrestore(&amd->lock, flags); } /* Disable chip interrupts. The amd->lock is not held. */ static __inline__ void amd7930_disable_ints(struct snd_amd7930 *amd) { unsigned long flags; spin_lock_irqsave(&amd->lock, flags); sbus_writeb(AMR_INIT, amd->regs + AMD7930_CR); sbus_writeb(AM_INIT_ACTIVE | AM_INIT_DISABLE_INTS, amd->regs + AMD7930_DR); spin_unlock_irqrestore(&amd->lock, flags); } /* Commit amd7930_map settings to the hardware. * The amd->lock is held and local interrupts are disabled. */ static void __amd7930_write_map(struct snd_amd7930 *amd) { struct amd7930_map *map = &amd->map; sbus_writeb(AMR_MAP_GX, amd->regs + AMD7930_CR); sbus_writeb(((map->gx >> 0) & 0xff), amd->regs + AMD7930_DR); sbus_writeb(((map->gx >> 8) & 0xff), amd->regs + AMD7930_DR); sbus_writeb(AMR_MAP_GR, amd->regs + AMD7930_CR); sbus_writeb(((map->gr >> 0) & 0xff), amd->regs + AMD7930_DR); sbus_writeb(((map->gr >> 8) & 0xff), amd->regs + AMD7930_DR); sbus_writeb(AMR_MAP_STGR, amd->regs + AMD7930_CR); sbus_writeb(((map->stgr >> 0) & 0xff), amd->regs + AMD7930_DR); sbus_writeb(((map->stgr >> 8) & 0xff), amd->regs + AMD7930_DR); sbus_writeb(AMR_MAP_GER, amd->regs + AMD7930_CR); sbus_writeb(((map->ger >> 0) & 0xff), amd->regs + AMD7930_DR); sbus_writeb(((map->ger >> 8) & 0xff), amd->regs + AMD7930_DR); sbus_writeb(AMR_MAP_MMR1, amd->regs + AMD7930_CR); sbus_writeb(map->mmr1, amd->regs + AMD7930_DR); sbus_writeb(AMR_MAP_MMR2, amd->regs + AMD7930_CR); sbus_writeb(map->mmr2, amd->regs + AMD7930_DR); } /* gx, gr & stg gains. this table must contain 256 elements with * the 0th being "infinity" (the magic value 9008). The remaining * elements match sun's gain curve (but with higher resolution): * -18 to 0dB in .16dB steps then 0 to 12dB in .08dB steps. */ static __const__ __u16 gx_coeff[256] = { 0x9008, 0x8b7c, 0x8b51, 0x8b45, 0x8b42, 0x8b3b, 0x8b36, 0x8b33, 0x8b32, 0x8b2a, 0x8b2b, 0x8b2c, 0x8b25, 0x8b23, 0x8b22, 0x8b22, 0x9122, 0x8b1a, 0x8aa3, 0x8aa3, 0x8b1c, 0x8aa6, 0x912d, 0x912b, 0x8aab, 0x8b12, 0x8aaa, 0x8ab2, 0x9132, 0x8ab4, 0x913c, 0x8abb, 0x9142, 0x9144, 0x9151, 0x8ad5, 0x8aeb, 0x8a79, 0x8a5a, 0x8a4a, 0x8b03, 0x91c2, 0x91bb, 0x8a3f, 0x8a33, 0x91b2, 0x9212, 0x9213, 0x8a2c, 0x921d, 0x8a23, 0x921a, 0x9222, 0x9223, 0x922d, 0x9231, 0x9234, 0x9242, 0x925b, 0x92dd, 0x92c1, 0x92b3, 0x92ab, 0x92a4, 0x92a2, 0x932b, 0x9341, 0x93d3, 0x93b2, 0x93a2, 0x943c, 0x94b2, 0x953a, 0x9653, 0x9782, 0x9e21, 0x9d23, 0x9cd2, 0x9c23, 0x9baa, 0x9bde, 0x9b33, 0x9b22, 0x9b1d, 0x9ab2, 0xa142, 0xa1e5, 0x9a3b, 0xa213, 0xa1a2, 0xa231, 0xa2eb, 0xa313, 0xa334, 0xa421, 0xa54b, 0xada4, 0xac23, 0xab3b, 0xaaab, 0xaa5c, 0xb1a3, 0xb2ca, 0xb3bd, 0xbe24, 0xbb2b, 0xba33, 0xc32b, 0xcb5a, 0xd2a2, 0xe31d, 0x0808, 0x72ba, 0x62c2, 0x5c32, 0x52db, 0x513e, 0x4cce, 0x43b2, 0x4243, 0x41b4, 0x3b12, 0x3bc3, 0x3df2, 0x34bd, 0x3334, 0x32c2, 0x3224, 0x31aa, 0x2a7b, 0x2aaa, 0x2b23, 0x2bba, 0x2c42, 0x2e23, 0x25bb, 0x242b, 0x240f, 0x231a, 0x22bb, 0x2241, 0x2223, 0x221f, 0x1a33, 0x1a4a, 0x1acd, 0x2132, 0x1b1b, 0x1b2c, 0x1b62, 0x1c12, 0x1c32, 0x1d1b, 0x1e71, 0x16b1, 0x1522, 0x1434, 0x1412, 0x1352, 0x1323, 0x1315, 0x12bc, 0x127a, 0x1235, 0x1226, 0x11a2, 0x1216, 0x0a2a, 0x11bc, 0x11d1, 0x1163, 0x0ac2, 0x0ab2, 0x0aab, 0x0b1b, 0x0b23, 0x0b33, 0x0c0f, 0x0bb3, 0x0c1b, 0x0c3e, 0x0cb1, 0x0d4c, 0x0ec1, 0x079a, 0x0614, 0x0521, 0x047c, 0x0422, 0x03b1, 0x03e3, 0x0333, 0x0322, 0x031c, 0x02aa, 0x02ba, 0x02f2, 0x0242, 0x0232, 0x0227, 0x0222, 0x021b, 0x01ad, 0x0212, 0x01b2, 0x01bb, 0x01cb, 0x01f6, 0x0152, 0x013a, 0x0133, 0x0131, 0x012c, 0x0123, 0x0122, 0x00a2, 0x011b, 0x011e, 0x0114, 0x00b1, 0x00aa, 0x00b3, 0x00bd, 0x00ba, 0x00c5, 0x00d3, 0x00f3, 0x0062, 0x0051, 0x0042, 0x003b, 0x0033, 0x0032, 0x002a, 0x002c, 0x0025, 0x0023, 0x0022, 0x001a, 0x0021, 0x001b, 0x001b, 0x001d, 0x0015, 0x0013, 0x0013, 0x0012, 0x0012, 0x000a, 0x000a, 0x0011, 0x0011, 0x000b, 0x000b, 0x000c, 0x000e, }; static __const__ __u16 ger_coeff[] = { 0x431f, /* 5. dB */ 0x331f, /* 5.5 dB */ 0x40dd, /* 6. dB */ 0x11dd, /* 6.5 dB */ 0x440f, /* 7. dB */ 0x411f, /* 7.5 dB */ 0x311f, /* 8. dB */ 0x5520, /* 8.5 dB */ 0x10dd, /* 9. dB */ 0x4211, /* 9.5 dB */ 0x410f, /* 10. dB */ 0x111f, /* 10.5 dB */ 0x600b, /* 11. dB */ 0x00dd, /* 11.5 dB */ 0x4210, /* 12. dB */ 0x110f, /* 13. dB */ 0x7200, /* 14. dB */ 0x2110, /* 15. dB */ 0x2200, /* 15.9 dB */ 0x000b, /* 16.9 dB */ 0x000f /* 18. dB */ }; /* Update amd7930_map settings and program them into the hardware. * The amd->lock is held and local interrupts are disabled. */ static void __amd7930_update_map(struct snd_amd7930 *amd) { struct amd7930_map *map = &amd->map; int level; map->gx = gx_coeff[amd->rgain]; map->stgr = gx_coeff[amd->mgain]; level = (amd->pgain * (256 + ARRAY_SIZE(ger_coeff))) >> 8; if (level >= 256) { map->ger = ger_coeff[level - 256]; map->gr = gx_coeff[255]; } else { map->ger = ger_coeff[0]; map->gr = gx_coeff[level]; } __amd7930_write_map(amd); } static irqreturn_t snd_amd7930_interrupt(int irq, void *dev_id) { struct snd_amd7930 *amd = dev_id; unsigned int elapsed; u8 ir; spin_lock(&amd->lock); elapsed = 0; ir = sbus_readb(amd->regs + AMD7930_IR); if (ir & AMR_IR_BBUF) { u8 byte; if (amd->flags & AMD7930_FLAG_PLAYBACK) { if (amd->p_left > 0) { byte = *(amd->p_cur++); amd->p_left--; sbus_writeb(byte, amd->regs + AMD7930_BBTB); if (amd->p_left == 0) elapsed |= AMD7930_FLAG_PLAYBACK; } else sbus_writeb(0, amd->regs + AMD7930_BBTB); } else if (amd->flags & AMD7930_FLAG_CAPTURE) { byte = sbus_readb(amd->regs + AMD7930_BBRB); if (amd->c_left > 0) { *(amd->c_cur++) = byte; amd->c_left--; if (amd->c_left == 0) elapsed |= AMD7930_FLAG_CAPTURE; } } } spin_unlock(&amd->lock); if (elapsed & AMD7930_FLAG_PLAYBACK) snd_pcm_period_elapsed(amd->playback_substream); else snd_pcm_period_elapsed(amd->capture_substream); return IRQ_HANDLED; } static int snd_amd7930_trigger(struct snd_amd7930 *amd, unsigned int flag, int cmd) { unsigned long flags; int result = 0; spin_lock_irqsave(&amd->lock, flags); if (cmd == SNDRV_PCM_TRIGGER_START) { if (!(amd->flags & flag)) { amd->flags |= flag; /* Enable B channel interrupts. */ sbus_writeb(AMR_MUX_MCR4, amd->regs + AMD7930_CR); sbus_writeb(AM_MUX_MCR4_ENABLE_INTS, amd->regs + AMD7930_DR); } } else if (cmd == SNDRV_PCM_TRIGGER_STOP) { if (amd->flags & flag) { amd->flags &= ~flag; /* Disable B channel interrupts. */ sbus_writeb(AMR_MUX_MCR4, amd->regs + AMD7930_CR); sbus_writeb(0, amd->regs + AMD7930_DR); } } else { result = -EINVAL; } spin_unlock_irqrestore(&amd->lock, flags); return result; } static int snd_amd7930_playback_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); return snd_amd7930_trigger(amd, AMD7930_FLAG_PLAYBACK, cmd); } static int snd_amd7930_capture_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); return snd_amd7930_trigger(amd, AMD7930_FLAG_CAPTURE, cmd); } static int snd_amd7930_playback_prepare(struct snd_pcm_substream *substream) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned long flags; u8 new_mmr1; spin_lock_irqsave(&amd->lock, flags); amd->flags |= AMD7930_FLAG_PLAYBACK; /* Setup the pseudo-dma transfer pointers. */ amd->p_orig = amd->p_cur = runtime->dma_area; amd->p_left = size; /* Put the chip into the correct encoding format. */ new_mmr1 = amd->map.mmr1; if (runtime->format == SNDRV_PCM_FORMAT_A_LAW) new_mmr1 |= AM_MAP_MMR1_ALAW; else new_mmr1 &= ~AM_MAP_MMR1_ALAW; if (new_mmr1 != amd->map.mmr1) { amd->map.mmr1 = new_mmr1; __amd7930_update_map(amd); } spin_unlock_irqrestore(&amd->lock, flags); return 0; } static int snd_amd7930_capture_prepare(struct snd_pcm_substream *substream) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; unsigned int size = snd_pcm_lib_buffer_bytes(substream); unsigned long flags; u8 new_mmr1; spin_lock_irqsave(&amd->lock, flags); amd->flags |= AMD7930_FLAG_CAPTURE; /* Setup the pseudo-dma transfer pointers. */ amd->c_orig = amd->c_cur = runtime->dma_area; amd->c_left = size; /* Put the chip into the correct encoding format. */ new_mmr1 = amd->map.mmr1; if (runtime->format == SNDRV_PCM_FORMAT_A_LAW) new_mmr1 |= AM_MAP_MMR1_ALAW; else new_mmr1 &= ~AM_MAP_MMR1_ALAW; if (new_mmr1 != amd->map.mmr1) { amd->map.mmr1 = new_mmr1; __amd7930_update_map(amd); } spin_unlock_irqrestore(&amd->lock, flags); return 0; } static snd_pcm_uframes_t snd_amd7930_playback_pointer(struct snd_pcm_substream *substream) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); size_t ptr; if (!(amd->flags & AMD7930_FLAG_PLAYBACK)) return 0; ptr = amd->p_cur - amd->p_orig; return bytes_to_frames(substream->runtime, ptr); } static snd_pcm_uframes_t snd_amd7930_capture_pointer(struct snd_pcm_substream *substream) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); size_t ptr; if (!(amd->flags & AMD7930_FLAG_CAPTURE)) return 0; ptr = amd->c_cur - amd->c_orig; return bytes_to_frames(substream->runtime, ptr); } /* Playback and capture have identical properties. */ static const struct snd_pcm_hardware snd_amd7930_pcm_hw = { .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_HALF_DUPLEX), .formats = SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW, .rates = SNDRV_PCM_RATE_8000, .rate_min = 8000, .rate_max = 8000, .channels_min = 1, .channels_max = 1, .buffer_bytes_max = (64*1024), .period_bytes_min = 1, .period_bytes_max = (64*1024), .periods_min = 1, .periods_max = 1024, }; static int snd_amd7930_playback_open(struct snd_pcm_substream *substream) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; amd->playback_substream = substream; runtime->hw = snd_amd7930_pcm_hw; return 0; } static int snd_amd7930_capture_open(struct snd_pcm_substream *substream) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; amd->capture_substream = substream; runtime->hw = snd_amd7930_pcm_hw; return 0; } static int snd_amd7930_playback_close(struct snd_pcm_substream *substream) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); amd->playback_substream = NULL; return 0; } static int snd_amd7930_capture_close(struct snd_pcm_substream *substream) { struct snd_amd7930 *amd = snd_pcm_substream_chip(substream); amd->capture_substream = NULL; return 0; } static const struct snd_pcm_ops snd_amd7930_playback_ops = { .open = snd_amd7930_playback_open, .close = snd_amd7930_playback_close, .prepare = snd_amd7930_playback_prepare, .trigger = snd_amd7930_playback_trigger, .pointer = snd_amd7930_playback_pointer, }; static const struct snd_pcm_ops snd_amd7930_capture_ops = { .open = snd_amd7930_capture_open, .close = snd_amd7930_capture_close, .prepare = snd_amd7930_capture_prepare, .trigger = snd_amd7930_capture_trigger, .pointer = snd_amd7930_capture_pointer, }; static int snd_amd7930_pcm(struct snd_amd7930 *amd) { struct snd_pcm *pcm; int err; if ((err = snd_pcm_new(amd->card, /* ID */ "sun_amd7930", /* device */ 0, /* playback count */ 1, /* capture count */ 1, &pcm)) < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_amd7930_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_amd7930_capture_ops); pcm->private_data = amd; pcm->info_flags = 0; strcpy(pcm->name, amd->card->shortname); amd->pcm = pcm; snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, NULL, 64*1024, 64*1024); return 0; } #define VOLUME_MONITOR 0 #define VOLUME_CAPTURE 1 #define VOLUME_PLAYBACK 2 static int snd_amd7930_info_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = 255; return 0; } static int snd_amd7930_get_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct snd_amd7930 *amd = snd_kcontrol_chip(kctl); int type = kctl->private_value; int *swval; switch (type) { case VOLUME_MONITOR: swval = &amd->mgain; break; case VOLUME_CAPTURE: swval = &amd->rgain; break; case VOLUME_PLAYBACK: default: swval = &amd->pgain; break; } ucontrol->value.integer.value[0] = *swval; return 0; } static int snd_amd7930_put_volume(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) { struct snd_amd7930 *amd = snd_kcontrol_chip(kctl); unsigned long flags; int type = kctl->private_value; int *swval, change; switch (type) { case VOLUME_MONITOR: swval = &amd->mgain; break; case VOLUME_CAPTURE: swval = &amd->rgain; break; case VOLUME_PLAYBACK: default: swval = &amd->pgain; break; } spin_lock_irqsave(&amd->lock, flags); if (*swval != ucontrol->value.integer.value[0]) { *swval = ucontrol->value.integer.value[0] & 0xff; __amd7930_update_map(amd); change = 1; } else change = 0; spin_unlock_irqrestore(&amd->lock, flags); return change; } static const struct snd_kcontrol_new amd7930_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Monitor Volume", .index = 0, .info = snd_amd7930_info_volume, .get = snd_amd7930_get_volume, .put = snd_amd7930_put_volume, .private_value = VOLUME_MONITOR, }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Volume", .index = 0, .info = snd_amd7930_info_volume, .get = snd_amd7930_get_volume, .put = snd_amd7930_put_volume, .private_value = VOLUME_CAPTURE, }, { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Playback Volume", .index = 0, .info = snd_amd7930_info_volume, .get = snd_amd7930_get_volume, .put = snd_amd7930_put_volume, .private_value = VOLUME_PLAYBACK, }, }; static int snd_amd7930_mixer(struct snd_amd7930 *amd) { struct snd_card *card; int idx, err; if (snd_BUG_ON(!amd || !amd->card)) return -EINVAL; card = amd->card; strcpy(card->mixername, card->shortname); for (idx = 0; idx < ARRAY_SIZE(amd7930_controls); idx++) { if ((err = snd_ctl_add(card, snd_ctl_new1(&amd7930_controls[idx], amd))) < 0) return err; } return 0; } static int snd_amd7930_free(struct snd_amd7930 *amd) { struct platform_device *op = amd->op; amd7930_idle(amd); if (amd->irq) free_irq(amd->irq, amd); if (amd->regs) of_iounmap(&op->resource[0], amd->regs, resource_size(&op->resource[0])); kfree(amd); return 0; } static int snd_amd7930_dev_free(struct snd_device *device) { struct snd_amd7930 *amd = device->device_data; return snd_amd7930_free(amd); } static const struct snd_device_ops snd_amd7930_dev_ops = { .dev_free = snd_amd7930_dev_free, }; static int snd_amd7930_create(struct snd_card *card, struct platform_device *op, int irq, int dev, struct snd_amd7930 **ramd) { struct snd_amd7930 *amd; unsigned long flags; int err; *ramd = NULL; amd = kzalloc(sizeof(*amd), GFP_KERNEL); if (amd == NULL) return -ENOMEM; spin_lock_init(&amd->lock); amd->card = card; amd->op = op; amd->regs = of_ioremap(&op->resource[0], 0, resource_size(&op->resource[0]), "amd7930"); if (!amd->regs) { snd_printk(KERN_ERR "amd7930-%d: Unable to map chip registers.\n", dev); kfree(amd); return -EIO; } amd7930_idle(amd); if (request_irq(irq, snd_amd7930_interrupt, IRQF_SHARED, "amd7930", amd)) { snd_printk(KERN_ERR "amd7930-%d: Unable to grab IRQ %d\n", dev, irq); snd_amd7930_free(amd); return -EBUSY; } amd->irq = irq; amd7930_enable_ints(amd); spin_lock_irqsave(&amd->lock, flags); amd->rgain = 128; amd->pgain = 200; amd->mgain = 0; memset(&amd->map, 0, sizeof(amd->map)); amd->map.mmr1 = (AM_MAP_MMR1_GX | AM_MAP_MMR1_GER | AM_MAP_MMR1_GR | AM_MAP_MMR1_STG); amd->map.mmr2 = (AM_MAP_MMR2_LS | AM_MAP_MMR2_AINB); __amd7930_update_map(amd); /* Always MUX audio (Ba) to channel Bb. */ sbus_writeb(AMR_MUX_MCR1, amd->regs + AMD7930_CR); sbus_writeb(AM_MUX_CHANNEL_Ba | (AM_MUX_CHANNEL_Bb << 4), amd->regs + AMD7930_DR); spin_unlock_irqrestore(&amd->lock, flags); err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, amd, &snd_amd7930_dev_ops); if (err < 0) { snd_amd7930_free(amd); return err; } *ramd = amd; return 0; } static int amd7930_sbus_probe(struct platform_device *op) { struct resource *rp = &op->resource[0]; static int dev_num; struct snd_card *card; struct snd_amd7930 *amd; int err, irq; irq = op->archdata.irqs[0]; if (dev_num >= SNDRV_CARDS) return -ENODEV; if (!enable[dev_num]) { dev_num++; return -ENOENT; } err = snd_card_new(&op->dev, index[dev_num], id[dev_num], THIS_MODULE, 0, &card); if (err < 0) return err; strcpy(card->driver, "AMD7930"); strcpy(card->shortname, "Sun AMD7930"); sprintf(card->longname, "%s at 0x%02lx:0x%08Lx, irq %d", card->shortname, rp->flags & 0xffL, (unsigned long long)rp->start, irq); if ((err = snd_amd7930_create(card, op, irq, dev_num, &amd)) < 0) goto out_err; err = snd_amd7930_pcm(amd); if (err < 0) goto out_err; err = snd_amd7930_mixer(amd); if (err < 0) goto out_err; err = snd_card_register(card); if (err < 0) goto out_err; amd->next = amd7930_list; amd7930_list = amd; dev_num++; return 0; out_err: snd_card_free(card); return err; } static const struct of_device_id amd7930_match[] = { { .name = "audio", }, {}, }; MODULE_DEVICE_TABLE(of, amd7930_match); static struct platform_driver amd7930_sbus_driver = { .driver = { .name = "audio", .of_match_table = amd7930_match, }, .probe = amd7930_sbus_probe, }; static int __init amd7930_init(void) { return platform_driver_register(&amd7930_sbus_driver); } static void __exit amd7930_exit(void) { struct snd_amd7930 *p = amd7930_list; while (p != NULL) { struct snd_amd7930 *next = p->next; snd_card_free(p->card); p = next; } amd7930_list = NULL; platform_driver_unregister(&amd7930_sbus_driver); } module_init(amd7930_init); module_exit(amd7930_exit);
linux-master
sound/sparc/amd7930.c
// SPDX-License-Identifier: GPL-2.0-only /* * Driver for DBRI sound chip found on Sparcs. * Copyright (C) 2004, 2005 Martin Habets ([email protected]) * * Converted to ring buffered version by Krzysztof Helt ([email protected]) * * Based entirely upon drivers/sbus/audio/dbri.c which is: * Copyright (C) 1997 Rudolf Koenig ([email protected]) * Copyright (C) 1998, 1999 Brent Baccala ([email protected]) * * This is the low level driver for the DBRI & MMCODEC duo used for ISDN & AUDIO * on Sun SPARCStation 10, 20, LX and Voyager models. * * - DBRI: AT&T T5900FX Dual Basic Rates ISDN Interface. It is a 32 channel * data time multiplexer with ISDN support (aka T7259) * Interfaces: SBus,ISDN NT & TE, CHI, 4 bits parallel. * CHI: (spelled ki) Concentration Highway Interface (AT&T or Intel bus ?). * Documentation: * - "STP 4000SBus Dual Basic Rate ISDN (DBRI) Transceiver" from * Sparc Technology Business (courtesy of Sun Support) * - Data sheet of the T7903, a newer but very similar ISA bus equivalent * available from the Lucent (formerly AT&T microelectronics) home * page. * - https://www.freesoft.org/Linux/DBRI/ * - MMCODEC: Crystal Semiconductor CS4215 16 bit Multimedia Audio Codec * Interfaces: CHI, Audio In & Out, 2 bits parallel * Documentation: from the Crystal Semiconductor home page. * * The DBRI is a 32 pipe machine, each pipe can transfer some bits between * memory and a serial device (long pipes, no. 0-15) or between two serial * devices (short pipes, no. 16-31), or simply send a fixed data to a serial * device (short pipes). * A timeslot defines the bit-offset and no. of bits read from a serial device. * The timeslots are linked to 6 circular lists, one for each direction for * each serial device (NT,TE,CHI). A timeslot is associated to 1 or 2 pipes * (the second one is a monitor/tee pipe, valid only for serial input). * * The mmcodec is connected via the CHI bus and needs the data & some * parameters (volume, output selection) time multiplexed in 8 byte * chunks. It also has a control mode, which serves for audio format setting. * * Looking at the CS4215 data sheet it is easy to set up 2 or 4 codecs on * the same CHI bus, so I thought perhaps it is possible to use the on-board * & the speakerbox codec simultaneously, giving 2 (not very independent :-) * audio devices. But the SUN HW group decided against it, at least on my * LX the speakerbox connector has at least 1 pin missing and 1 wrongly * connected. * * I've tried to stick to the following function naming conventions: * snd_* ALSA stuff * cs4215_* CS4215 codec specific stuff * dbri_* DBRI high-level stuff * other DBRI low-level stuff */ #include <linux/interrupt.h> #include <linux/delay.h> #include <linux/irq.h> #include <linux/io.h> #include <linux/dma-mapping.h> #include <linux/gfp.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/pcm_params.h> #include <sound/info.h> #include <sound/control.h> #include <sound/initval.h> #include <linux/of.h> #include <linux/platform_device.h> #include <linux/atomic.h> #include <linux/module.h> MODULE_AUTHOR("Rudolf Koenig, Brent Baccala and Martin Habets"); MODULE_DESCRIPTION("Sun DBRI"); MODULE_LICENSE("GPL"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ /* Enable this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for Sun DBRI soundcard."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for Sun DBRI soundcard."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable Sun DBRI soundcard."); #undef DBRI_DEBUG #define D_INT (1<<0) #define D_GEN (1<<1) #define D_CMD (1<<2) #define D_MM (1<<3) #define D_USR (1<<4) #define D_DESC (1<<5) static int dbri_debug; module_param(dbri_debug, int, 0644); MODULE_PARM_DESC(dbri_debug, "Debug value for Sun DBRI soundcard."); #ifdef DBRI_DEBUG static const char * const cmds[] = { "WAIT", "PAUSE", "JUMP", "IIQ", "REX", "SDP", "CDP", "DTS", "SSP", "CHI", "NT", "TE", "CDEC", "TEST", "CDM", "RESRV" }; #define dprintk(a, x...) if (dbri_debug & a) printk(KERN_DEBUG x) #else #define dprintk(a, x...) do { } while (0) #endif /* DBRI_DEBUG */ #define DBRI_CMD(cmd, intr, value) ((cmd << 28) | \ (intr << 27) | \ value) /*************************************************************************** CS4215 specific definitions and structures ****************************************************************************/ struct cs4215 { __u8 data[4]; /* Data mode: Time slots 5-8 */ __u8 ctrl[4]; /* Ctrl mode: Time slots 1-4 */ __u8 onboard; __u8 offset; /* Bit offset from frame sync to time slot 1 */ volatile __u32 status; volatile __u32 version; __u8 precision; /* In bits, either 8 or 16 */ __u8 channels; /* 1 or 2 */ }; /* * Control mode first */ /* Time Slot 1, Status register */ #define CS4215_CLB (1<<2) /* Control Latch Bit */ #define CS4215_OLB (1<<3) /* 1: line: 2.0V, speaker 4V */ /* 0: line: 2.8V, speaker 8V */ #define CS4215_MLB (1<<4) /* 1: Microphone: 20dB gain disabled */ #define CS4215_RSRVD_1 (1<<5) /* Time Slot 2, Data Format Register */ #define CS4215_DFR_LINEAR16 0 #define CS4215_DFR_ULAW 1 #define CS4215_DFR_ALAW 2 #define CS4215_DFR_LINEAR8 3 #define CS4215_DFR_STEREO (1<<2) static struct { unsigned short freq; unsigned char xtal; unsigned char csval; } CS4215_FREQ[] = { { 8000, (1 << 4), (0 << 3) }, { 16000, (1 << 4), (1 << 3) }, { 27429, (1 << 4), (2 << 3) }, /* Actually 24428.57 */ { 32000, (1 << 4), (3 << 3) }, /* { NA, (1 << 4), (4 << 3) }, */ /* { NA, (1 << 4), (5 << 3) }, */ { 48000, (1 << 4), (6 << 3) }, { 9600, (1 << 4), (7 << 3) }, { 5512, (2 << 4), (0 << 3) }, /* Actually 5512.5 */ { 11025, (2 << 4), (1 << 3) }, { 18900, (2 << 4), (2 << 3) }, { 22050, (2 << 4), (3 << 3) }, { 37800, (2 << 4), (4 << 3) }, { 44100, (2 << 4), (5 << 3) }, { 33075, (2 << 4), (6 << 3) }, { 6615, (2 << 4), (7 << 3) }, { 0, 0, 0} }; #define CS4215_HPF (1<<7) /* High Pass Filter, 1: Enabled */ #define CS4215_12_MASK 0xfcbf /* Mask off reserved bits in slot 1 & 2 */ /* Time Slot 3, Serial Port Control register */ #define CS4215_XEN (1<<0) /* 0: Enable serial output */ #define CS4215_XCLK (1<<1) /* 1: Master mode: Generate SCLK */ #define CS4215_BSEL_64 (0<<2) /* Bitrate: 64 bits per frame */ #define CS4215_BSEL_128 (1<<2) #define CS4215_BSEL_256 (2<<2) #define CS4215_MCK_MAST (0<<4) /* Master clock */ #define CS4215_MCK_XTL1 (1<<4) /* 24.576 MHz clock source */ #define CS4215_MCK_XTL2 (2<<4) /* 16.9344 MHz clock source */ #define CS4215_MCK_CLK1 (3<<4) /* Clockin, 256 x Fs */ #define CS4215_MCK_CLK2 (4<<4) /* Clockin, see DFR */ /* Time Slot 4, Test Register */ #define CS4215_DAD (1<<0) /* 0:Digital-Dig loop, 1:Dig-Analog-Dig loop */ #define CS4215_ENL (1<<1) /* Enable Loopback Testing */ /* Time Slot 5, Parallel Port Register */ /* Read only here and the same as the in data mode */ /* Time Slot 6, Reserved */ /* Time Slot 7, Version Register */ #define CS4215_VERSION_MASK 0xf /* Known versions 0/C, 1/D, 2/E */ /* Time Slot 8, Reserved */ /* * Data mode */ /* Time Slot 1-2: Left Channel Data, 2-3: Right Channel Data */ /* Time Slot 5, Output Setting */ #define CS4215_LO(v) v /* Left Output Attenuation 0x3f: -94.5 dB */ #define CS4215_LE (1<<6) /* Line Out Enable */ #define CS4215_HE (1<<7) /* Headphone Enable */ /* Time Slot 6, Output Setting */ #define CS4215_RO(v) v /* Right Output Attenuation 0x3f: -94.5 dB */ #define CS4215_SE (1<<6) /* Speaker Enable */ #define CS4215_ADI (1<<7) /* A/D Data Invalid: Busy in calibration */ /* Time Slot 7, Input Setting */ #define CS4215_LG(v) v /* Left Gain Setting 0xf: 22.5 dB */ #define CS4215_IS (1<<4) /* Input Select: 1=Microphone, 0=Line */ #define CS4215_OVR (1<<5) /* 1: Over range condition occurred */ #define CS4215_PIO0 (1<<6) /* Parallel I/O 0 */ #define CS4215_PIO1 (1<<7) /* Time Slot 8, Input Setting */ #define CS4215_RG(v) v /* Right Gain Setting 0xf: 22.5 dB */ #define CS4215_MA(v) (v<<4) /* Monitor Path Attenuation 0xf: mute */ /*************************************************************************** DBRI specific definitions and structures ****************************************************************************/ /* DBRI main registers */ #define REG0 0x00 /* Status and Control */ #define REG1 0x04 /* Mode and Interrupt */ #define REG2 0x08 /* Parallel IO */ #define REG3 0x0c /* Test */ #define REG8 0x20 /* Command Queue Pointer */ #define REG9 0x24 /* Interrupt Queue Pointer */ #define DBRI_NO_CMDS 64 #define DBRI_INT_BLK 64 #define DBRI_NO_DESCS 64 #define DBRI_NO_PIPES 32 #define DBRI_MAX_PIPE (DBRI_NO_PIPES - 1) #define DBRI_REC 0 #define DBRI_PLAY 1 #define DBRI_NO_STREAMS 2 /* One transmit/receive descriptor */ /* When ba != 0 descriptor is used */ struct dbri_mem { volatile __u32 word1; __u32 ba; /* Transmit/Receive Buffer Address */ __u32 nda; /* Next Descriptor Address */ volatile __u32 word4; }; /* This structure is in a DMA region where it can accessed by both * the CPU and the DBRI */ struct dbri_dma { s32 cmd[DBRI_NO_CMDS]; /* Place for commands */ volatile s32 intr[DBRI_INT_BLK]; /* Interrupt field */ struct dbri_mem desc[DBRI_NO_DESCS]; /* Xmit/receive descriptors */ }; #define dbri_dma_off(member, elem) \ ((u32)(unsigned long) \ (&(((struct dbri_dma *)0)->member[elem]))) enum in_or_out { PIPEinput, PIPEoutput }; struct dbri_pipe { u32 sdp; /* SDP command word */ int nextpipe; /* Next pipe in linked list */ int length; /* Length of timeslot (bits) */ int first_desc; /* Index of first descriptor */ int desc; /* Index of active descriptor */ volatile __u32 *recv_fixed_ptr; /* Ptr to receive fixed data */ }; /* Per stream (playback or record) information */ struct dbri_streaminfo { struct snd_pcm_substream *substream; u32 dvma_buffer; /* Device view of ALSA DMA buffer */ int size; /* Size of DMA buffer */ size_t offset; /* offset in user buffer */ int pipe; /* Data pipe used */ int left_gain; /* mixer elements */ int right_gain; }; /* This structure holds the information for both chips (DBRI & CS4215) */ struct snd_dbri { int regs_size, irq; /* Needed for unload */ struct platform_device *op; /* OF device info */ spinlock_t lock; struct dbri_dma *dma; /* Pointer to our DMA block */ dma_addr_t dma_dvma; /* DBRI visible DMA address */ void __iomem *regs; /* dbri HW regs */ int dbri_irqp; /* intr queue pointer */ struct dbri_pipe pipes[DBRI_NO_PIPES]; /* DBRI's 32 data pipes */ int next_desc[DBRI_NO_DESCS]; /* Index of next desc, or -1 */ spinlock_t cmdlock; /* Protects cmd queue accesses */ s32 *cmdptr; /* Pointer to the last queued cmd */ int chi_bpf; struct cs4215 mm; /* mmcodec special info */ /* per stream (playback/record) info */ struct dbri_streaminfo stream_info[DBRI_NO_STREAMS]; }; #define DBRI_MAX_VOLUME 63 /* Output volume */ #define DBRI_MAX_GAIN 15 /* Input gain */ /* DBRI Reg0 - Status Control Register - defines. (Page 17) */ #define D_P (1<<15) /* Program command & queue pointer valid */ #define D_G (1<<14) /* Allow 4-Word SBus Burst */ #define D_S (1<<13) /* Allow 16-Word SBus Burst */ #define D_E (1<<12) /* Allow 8-Word SBus Burst */ #define D_X (1<<7) /* Sanity Timer Disable */ #define D_T (1<<6) /* Permit activation of the TE interface */ #define D_N (1<<5) /* Permit activation of the NT interface */ #define D_C (1<<4) /* Permit activation of the CHI interface */ #define D_F (1<<3) /* Force Sanity Timer Time-Out */ #define D_D (1<<2) /* Disable Master Mode */ #define D_H (1<<1) /* Halt for Analysis */ #define D_R (1<<0) /* Soft Reset */ /* DBRI Reg1 - Mode and Interrupt Register - defines. (Page 18) */ #define D_LITTLE_END (1<<8) /* Byte Order */ #define D_BIG_END (0<<8) /* Byte Order */ #define D_MRR (1<<4) /* Multiple Error Ack on SBus (read only) */ #define D_MLE (1<<3) /* Multiple Late Error on SBus (read only) */ #define D_LBG (1<<2) /* Lost Bus Grant on SBus (read only) */ #define D_MBE (1<<1) /* Burst Error on SBus (read only) */ #define D_IR (1<<0) /* Interrupt Indicator (read only) */ /* DBRI Reg2 - Parallel IO Register - defines. (Page 18) */ #define D_ENPIO3 (1<<7) /* Enable Pin 3 */ #define D_ENPIO2 (1<<6) /* Enable Pin 2 */ #define D_ENPIO1 (1<<5) /* Enable Pin 1 */ #define D_ENPIO0 (1<<4) /* Enable Pin 0 */ #define D_ENPIO (0xf0) /* Enable all the pins */ #define D_PIO3 (1<<3) /* Pin 3: 1: Data mode, 0: Ctrl mode */ #define D_PIO2 (1<<2) /* Pin 2: 1: Onboard PDN */ #define D_PIO1 (1<<1) /* Pin 1: 0: Reset */ #define D_PIO0 (1<<0) /* Pin 0: 1: Speakerbox PDN */ /* DBRI Commands (Page 20) */ #define D_WAIT 0x0 /* Stop execution */ #define D_PAUSE 0x1 /* Flush long pipes */ #define D_JUMP 0x2 /* New command queue */ #define D_IIQ 0x3 /* Initialize Interrupt Queue */ #define D_REX 0x4 /* Report command execution via interrupt */ #define D_SDP 0x5 /* Setup Data Pipe */ #define D_CDP 0x6 /* Continue Data Pipe (reread NULL Pointer) */ #define D_DTS 0x7 /* Define Time Slot */ #define D_SSP 0x8 /* Set short Data Pipe */ #define D_CHI 0x9 /* Set CHI Global Mode */ #define D_NT 0xa /* NT Command */ #define D_TE 0xb /* TE Command */ #define D_CDEC 0xc /* Codec setup */ #define D_TEST 0xd /* No comment */ #define D_CDM 0xe /* CHI Data mode command */ /* Special bits for some commands */ #define D_PIPE(v) ((v)<<0) /* Pipe No.: 0-15 long, 16-21 short */ /* Setup Data Pipe */ /* IRM */ #define D_SDP_2SAME (1<<18) /* Report 2nd time in a row value received */ #define D_SDP_CHANGE (2<<18) /* Report any changes */ #define D_SDP_EVERY (3<<18) /* Report any changes */ #define D_SDP_EOL (1<<17) /* EOL interrupt enable */ #define D_SDP_IDLE (1<<16) /* HDLC idle interrupt enable */ /* Pipe data MODE */ #define D_SDP_MEM (0<<13) /* To/from memory */ #define D_SDP_HDLC (2<<13) #define D_SDP_HDLC_D (3<<13) /* D Channel (prio control) */ #define D_SDP_SER (4<<13) /* Serial to serial */ #define D_SDP_FIXED (6<<13) /* Short only */ #define D_SDP_MODE(v) ((v)&(7<<13)) #define D_SDP_TO_SER (1<<12) /* Direction */ #define D_SDP_FROM_SER (0<<12) /* Direction */ #define D_SDP_MSB (1<<11) /* Bit order within Byte */ #define D_SDP_LSB (0<<11) /* Bit order within Byte */ #define D_SDP_P (1<<10) /* Pointer Valid */ #define D_SDP_A (1<<8) /* Abort */ #define D_SDP_C (1<<7) /* Clear */ /* Define Time Slot */ #define D_DTS_VI (1<<17) /* Valid Input Time-Slot Descriptor */ #define D_DTS_VO (1<<16) /* Valid Output Time-Slot Descriptor */ #define D_DTS_INS (1<<15) /* Insert Time Slot */ #define D_DTS_DEL (0<<15) /* Delete Time Slot */ #define D_DTS_PRVIN(v) ((v)<<10) /* Previous In Pipe */ #define D_DTS_PRVOUT(v) ((v)<<5) /* Previous Out Pipe */ /* Time Slot defines */ #define D_TS_LEN(v) ((v)<<24) /* Number of bits in this time slot */ #define D_TS_CYCLE(v) ((v)<<14) /* Bit Count at start of TS */ #define D_TS_DI (1<<13) /* Data Invert */ #define D_TS_1CHANNEL (0<<10) /* Single Channel / Normal mode */ #define D_TS_MONITOR (2<<10) /* Monitor pipe */ #define D_TS_NONCONTIG (3<<10) /* Non contiguous mode */ #define D_TS_ANCHOR (7<<10) /* Starting short pipes */ #define D_TS_MON(v) ((v)<<5) /* Monitor Pipe */ #define D_TS_NEXT(v) ((v)<<0) /* Pipe no.: 0-15 long, 16-21 short */ /* Concentration Highway Interface Modes */ #define D_CHI_CHICM(v) ((v)<<16) /* Clock mode */ #define D_CHI_IR (1<<15) /* Immediate Interrupt Report */ #define D_CHI_EN (1<<14) /* CHIL Interrupt enabled */ #define D_CHI_OD (1<<13) /* Open Drain Enable */ #define D_CHI_FE (1<<12) /* Sample CHIFS on Rising Frame Edge */ #define D_CHI_FD (1<<11) /* Frame Drive */ #define D_CHI_BPF(v) ((v)<<0) /* Bits per Frame */ /* NT: These are here for completeness */ #define D_NT_FBIT (1<<17) /* Frame Bit */ #define D_NT_NBF (1<<16) /* Number of bad frames to loose framing */ #define D_NT_IRM_IMM (1<<15) /* Interrupt Report & Mask: Immediate */ #define D_NT_IRM_EN (1<<14) /* Interrupt Report & Mask: Enable */ #define D_NT_ISNT (1<<13) /* Configure interface as NT */ #define D_NT_FT (1<<12) /* Fixed Timing */ #define D_NT_EZ (1<<11) /* Echo Channel is Zeros */ #define D_NT_IFA (1<<10) /* Inhibit Final Activation */ #define D_NT_ACT (1<<9) /* Activate Interface */ #define D_NT_MFE (1<<8) /* Multiframe Enable */ #define D_NT_RLB(v) ((v)<<5) /* Remote Loopback */ #define D_NT_LLB(v) ((v)<<2) /* Local Loopback */ #define D_NT_FACT (1<<1) /* Force Activation */ #define D_NT_ABV (1<<0) /* Activate Bipolar Violation */ /* Codec Setup */ #define D_CDEC_CK(v) ((v)<<24) /* Clock Select */ #define D_CDEC_FED(v) ((v)<<12) /* FSCOD Falling Edge Delay */ #define D_CDEC_RED(v) ((v)<<0) /* FSCOD Rising Edge Delay */ /* Test */ #define D_TEST_RAM(v) ((v)<<16) /* RAM Pointer */ #define D_TEST_SIZE(v) ((v)<<11) /* */ #define D_TEST_ROMONOFF 0x5 /* Toggle ROM opcode monitor on/off */ #define D_TEST_PROC 0x6 /* Microprocessor test */ #define D_TEST_SER 0x7 /* Serial-Controller test */ #define D_TEST_RAMREAD 0x8 /* Copy from Ram to system memory */ #define D_TEST_RAMWRITE 0x9 /* Copy into Ram from system memory */ #define D_TEST_RAMBIST 0xa /* RAM Built-In Self Test */ #define D_TEST_MCBIST 0xb /* Microcontroller Built-In Self Test */ #define D_TEST_DUMP 0xe /* ROM Dump */ /* CHI Data Mode */ #define D_CDM_THI (1 << 8) /* Transmit Data on CHIDR Pin */ #define D_CDM_RHI (1 << 7) /* Receive Data on CHIDX Pin */ #define D_CDM_RCE (1 << 6) /* Receive on Rising Edge of CHICK */ #define D_CDM_XCE (1 << 2) /* Transmit Data on Rising Edge of CHICK */ #define D_CDM_XEN (1 << 1) /* Transmit Highway Enable */ #define D_CDM_REN (1 << 0) /* Receive Highway Enable */ /* The Interrupts */ #define D_INTR_BRDY 1 /* Buffer Ready for processing */ #define D_INTR_MINT 2 /* Marked Interrupt in RD/TD */ #define D_INTR_IBEG 3 /* Flag to idle transition detected (HDLC) */ #define D_INTR_IEND 4 /* Idle to flag transition detected (HDLC) */ #define D_INTR_EOL 5 /* End of List */ #define D_INTR_CMDI 6 /* Command has bean read */ #define D_INTR_XCMP 8 /* Transmission of frame complete */ #define D_INTR_SBRI 9 /* BRI status change info */ #define D_INTR_FXDT 10 /* Fixed data change */ #define D_INTR_CHIL 11 /* CHI lost frame sync (channel 36 only) */ #define D_INTR_COLL 11 /* Unrecoverable D-Channel collision */ #define D_INTR_DBYT 12 /* Dropped by frame slip */ #define D_INTR_RBYT 13 /* Repeated by frame slip */ #define D_INTR_LINT 14 /* Lost Interrupt */ #define D_INTR_UNDR 15 /* DMA underrun */ #define D_INTR_TE 32 #define D_INTR_NT 34 #define D_INTR_CHI 36 #define D_INTR_CMD 38 #define D_INTR_GETCHAN(v) (((v) >> 24) & 0x3f) #define D_INTR_GETCODE(v) (((v) >> 20) & 0xf) #define D_INTR_GETCMD(v) (((v) >> 16) & 0xf) #define D_INTR_GETVAL(v) ((v) & 0xffff) #define D_INTR_GETRVAL(v) ((v) & 0xfffff) #define D_P_0 0 /* TE receive anchor */ #define D_P_1 1 /* TE transmit anchor */ #define D_P_2 2 /* NT transmit anchor */ #define D_P_3 3 /* NT receive anchor */ #define D_P_4 4 /* CHI send data */ #define D_P_5 5 /* CHI receive data */ #define D_P_6 6 /* */ #define D_P_7 7 /* */ #define D_P_8 8 /* */ #define D_P_9 9 /* */ #define D_P_10 10 /* */ #define D_P_11 11 /* */ #define D_P_12 12 /* */ #define D_P_13 13 /* */ #define D_P_14 14 /* */ #define D_P_15 15 /* */ #define D_P_16 16 /* CHI anchor pipe */ #define D_P_17 17 /* CHI send */ #define D_P_18 18 /* CHI receive */ #define D_P_19 19 /* CHI receive */ #define D_P_20 20 /* CHI receive */ #define D_P_21 21 /* */ #define D_P_22 22 /* */ #define D_P_23 23 /* */ #define D_P_24 24 /* */ #define D_P_25 25 /* */ #define D_P_26 26 /* */ #define D_P_27 27 /* */ #define D_P_28 28 /* */ #define D_P_29 29 /* */ #define D_P_30 30 /* */ #define D_P_31 31 /* */ /* Transmit descriptor defines */ #define DBRI_TD_F (1 << 31) /* End of Frame */ #define DBRI_TD_D (1 << 30) /* Do not append CRC */ #define DBRI_TD_CNT(v) ((v) << 16) /* Number of valid bytes in the buffer */ #define DBRI_TD_B (1 << 15) /* Final interrupt */ #define DBRI_TD_M (1 << 14) /* Marker interrupt */ #define DBRI_TD_I (1 << 13) /* Transmit Idle Characters */ #define DBRI_TD_FCNT(v) (v) /* Flag Count */ #define DBRI_TD_UNR (1 << 3) /* Underrun: transmitter is out of data */ #define DBRI_TD_ABT (1 << 2) /* Abort: frame aborted */ #define DBRI_TD_TBC (1 << 0) /* Transmit buffer Complete */ #define DBRI_TD_STATUS(v) ((v) & 0xff) /* Transmit status */ /* Maximum buffer size per TD: almost 8KB */ #define DBRI_TD_MAXCNT ((1 << 13) - 4) /* Receive descriptor defines */ #define DBRI_RD_F (1 << 31) /* End of Frame */ #define DBRI_RD_C (1 << 30) /* Completed buffer */ #define DBRI_RD_B (1 << 15) /* Final interrupt */ #define DBRI_RD_M (1 << 14) /* Marker interrupt */ #define DBRI_RD_BCNT(v) (v) /* Buffer size */ #define DBRI_RD_CRC (1 << 7) /* 0: CRC is correct */ #define DBRI_RD_BBC (1 << 6) /* 1: Bad Byte received */ #define DBRI_RD_ABT (1 << 5) /* Abort: frame aborted */ #define DBRI_RD_OVRN (1 << 3) /* Overrun: data lost */ #define DBRI_RD_STATUS(v) ((v) & 0xff) /* Receive status */ #define DBRI_RD_CNT(v) (((v) >> 16) & 0x1fff) /* Valid bytes in the buffer */ /* stream_info[] access */ /* Translate the ALSA direction into the array index */ #define DBRI_STREAMNO(substream) \ (substream->stream == \ SNDRV_PCM_STREAM_PLAYBACK ? DBRI_PLAY: DBRI_REC) /* Return a pointer to dbri_streaminfo */ #define DBRI_STREAM(dbri, substream) \ &dbri->stream_info[DBRI_STREAMNO(substream)] /* * Short data pipes transmit LSB first. The CS4215 receives MSB first. Grrr. * So we have to reverse the bits. Note: not all bit lengths are supported */ static __u32 reverse_bytes(__u32 b, int len) { switch (len) { case 32: b = ((b & 0xffff0000) >> 16) | ((b & 0x0000ffff) << 16); fallthrough; case 16: b = ((b & 0xff00ff00) >> 8) | ((b & 0x00ff00ff) << 8); fallthrough; case 8: b = ((b & 0xf0f0f0f0) >> 4) | ((b & 0x0f0f0f0f) << 4); fallthrough; case 4: b = ((b & 0xcccccccc) >> 2) | ((b & 0x33333333) << 2); fallthrough; case 2: b = ((b & 0xaaaaaaaa) >> 1) | ((b & 0x55555555) << 1); case 1: case 0: break; default: printk(KERN_ERR "DBRI reverse_bytes: unsupported length\n"); } return b; } /* **************************************************************************** ************** DBRI initialization and command synchronization ************* **************************************************************************** Commands are sent to the DBRI by building a list of them in memory, then writing the address of the first list item to DBRI register 8. The list is terminated with a WAIT command, which generates a CPU interrupt to signal completion. Since the DBRI can run in parallel with the CPU, several means of synchronization present themselves. The method implemented here uses the dbri_cmdwait() to wait for execution of batch of sent commands. A circular command buffer is used here. A new command is being added while another can be executed. The scheme works by adding two WAIT commands after each sent batch of commands. When the next batch is prepared it is added after the WAIT commands then the WAITs are replaced with single JUMP command to the new batch. Then the DBRI is forced to reread the last WAIT command (replaced by the JUMP by then). If the DBRI is still executing previous commands the request to reread the WAIT command is ignored. Every time a routine wants to write commands to the DBRI, it must first call dbri_cmdlock() and get pointer to a free space in dbri->dma->cmd buffer. After this, the commands can be written to the buffer, and dbri_cmdsend() is called with the final pointer value to send them to the DBRI. */ #define MAXLOOPS 20 /* * Wait for the current command string to execute */ static void dbri_cmdwait(struct snd_dbri *dbri) { int maxloops = MAXLOOPS; unsigned long flags; /* Delay if previous commands are still being processed */ spin_lock_irqsave(&dbri->lock, flags); while ((--maxloops) > 0 && (sbus_readl(dbri->regs + REG0) & D_P)) { spin_unlock_irqrestore(&dbri->lock, flags); msleep_interruptible(1); spin_lock_irqsave(&dbri->lock, flags); } spin_unlock_irqrestore(&dbri->lock, flags); if (maxloops == 0) printk(KERN_ERR "DBRI: Chip never completed command buffer\n"); else dprintk(D_CMD, "Chip completed command buffer (%d)\n", MAXLOOPS - maxloops - 1); } /* * Lock the command queue and return pointer to space for len cmd words * It locks the cmdlock spinlock. */ static s32 *dbri_cmdlock(struct snd_dbri *dbri, int len) { u32 dvma_addr = (u32)dbri->dma_dvma; /* Space for 2 WAIT cmds (replaced later by 1 JUMP cmd) */ len += 2; spin_lock(&dbri->cmdlock); if (dbri->cmdptr - dbri->dma->cmd + len < DBRI_NO_CMDS - 2) return dbri->cmdptr + 2; else if (len < sbus_readl(dbri->regs + REG8) - dvma_addr) return dbri->dma->cmd; else printk(KERN_ERR "DBRI: no space for commands."); return NULL; } /* * Send prepared cmd string. It works by writing a JUMP cmd into * the last WAIT cmd and force DBRI to reread the cmd. * The JUMP cmd points to the new cmd string. * It also releases the cmdlock spinlock. * * Lock must be held before calling this. */ static void dbri_cmdsend(struct snd_dbri *dbri, s32 *cmd, int len) { u32 dvma_addr = (u32)dbri->dma_dvma; s32 tmp, addr; static int wait_id; wait_id++; wait_id &= 0xffff; /* restrict it to a 16 bit counter. */ *(cmd) = DBRI_CMD(D_WAIT, 1, wait_id); *(cmd+1) = DBRI_CMD(D_WAIT, 1, wait_id); /* Replace the last command with JUMP */ addr = dvma_addr + (cmd - len - dbri->dma->cmd) * sizeof(s32); *(dbri->cmdptr+1) = addr; *(dbri->cmdptr) = DBRI_CMD(D_JUMP, 0, 0); #ifdef DBRI_DEBUG if (cmd > dbri->cmdptr) { s32 *ptr; for (ptr = dbri->cmdptr; ptr < cmd+2; ptr++) dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr); } else { s32 *ptr = dbri->cmdptr; dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr); ptr++; dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr); for (ptr = dbri->dma->cmd; ptr < cmd+2; ptr++) dprintk(D_CMD, "cmd: %lx:%08x\n", (unsigned long)ptr, *ptr); } #endif /* Reread the last command */ tmp = sbus_readl(dbri->regs + REG0); tmp |= D_P; sbus_writel(tmp, dbri->regs + REG0); dbri->cmdptr = cmd; spin_unlock(&dbri->cmdlock); } /* Lock must be held when calling this */ static void dbri_reset(struct snd_dbri *dbri) { int i; u32 tmp; dprintk(D_GEN, "reset 0:%x 2:%x 8:%x 9:%x\n", sbus_readl(dbri->regs + REG0), sbus_readl(dbri->regs + REG2), sbus_readl(dbri->regs + REG8), sbus_readl(dbri->regs + REG9)); sbus_writel(D_R, dbri->regs + REG0); /* Soft Reset */ for (i = 0; (sbus_readl(dbri->regs + REG0) & D_R) && i < 64; i++) udelay(10); /* A brute approach - DBRI falls back to working burst size by itself * On SS20 D_S does not work, so do not try so high. */ tmp = sbus_readl(dbri->regs + REG0); tmp |= D_G | D_E; tmp &= ~D_S; sbus_writel(tmp, dbri->regs + REG0); } /* Lock must not be held before calling this */ static void dbri_initialize(struct snd_dbri *dbri) { u32 dvma_addr = (u32)dbri->dma_dvma; s32 *cmd; u32 dma_addr; unsigned long flags; int n; spin_lock_irqsave(&dbri->lock, flags); dbri_reset(dbri); /* Initialize pipes */ for (n = 0; n < DBRI_NO_PIPES; n++) dbri->pipes[n].desc = dbri->pipes[n].first_desc = -1; spin_lock_init(&dbri->cmdlock); /* * Initialize the interrupt ring buffer. */ dma_addr = dvma_addr + dbri_dma_off(intr, 0); dbri->dma->intr[0] = dma_addr; dbri->dbri_irqp = 1; /* * Set up the interrupt queue */ spin_lock(&dbri->cmdlock); cmd = dbri->cmdptr = dbri->dma->cmd; *(cmd++) = DBRI_CMD(D_IIQ, 0, 0); *(cmd++) = dma_addr; *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0); dbri->cmdptr = cmd; *(cmd++) = DBRI_CMD(D_WAIT, 1, 0); *(cmd++) = DBRI_CMD(D_WAIT, 1, 0); dma_addr = dvma_addr + dbri_dma_off(cmd, 0); sbus_writel(dma_addr, dbri->regs + REG8); spin_unlock(&dbri->cmdlock); spin_unlock_irqrestore(&dbri->lock, flags); dbri_cmdwait(dbri); } /* **************************************************************************** ************************** DBRI data pipe management *********************** **************************************************************************** While DBRI control functions use the command and interrupt buffers, the main data path takes the form of data pipes, which can be short (command and interrupt driven), or long (attached to DMA buffers). These functions provide a rudimentary means of setting up and managing the DBRI's pipes, but the calling functions have to make sure they respect the pipes' linked list ordering, among other things. The transmit and receive functions here interface closely with the transmit and receive interrupt code. */ static inline int pipe_active(struct snd_dbri *dbri, int pipe) { return ((pipe >= 0) && (dbri->pipes[pipe].desc != -1)); } /* reset_pipe(dbri, pipe) * * Called on an in-use pipe to clear anything being transmitted or received * Lock must be held before calling this. */ static void reset_pipe(struct snd_dbri *dbri, int pipe) { int sdp; int desc; s32 *cmd; if (pipe < 0 || pipe > DBRI_MAX_PIPE) { printk(KERN_ERR "DBRI: reset_pipe called with " "illegal pipe number\n"); return; } sdp = dbri->pipes[pipe].sdp; if (sdp == 0) { printk(KERN_ERR "DBRI: reset_pipe called " "on uninitialized pipe\n"); return; } cmd = dbri_cmdlock(dbri, 3); *(cmd++) = DBRI_CMD(D_SDP, 0, sdp | D_SDP_C | D_SDP_P); *(cmd++) = 0; *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0); dbri_cmdsend(dbri, cmd, 3); desc = dbri->pipes[pipe].first_desc; if (desc >= 0) do { dbri->dma->desc[desc].ba = 0; dbri->dma->desc[desc].nda = 0; desc = dbri->next_desc[desc]; } while (desc != -1 && desc != dbri->pipes[pipe].first_desc); dbri->pipes[pipe].desc = -1; dbri->pipes[pipe].first_desc = -1; } /* * Lock must be held before calling this. */ static void setup_pipe(struct snd_dbri *dbri, int pipe, int sdp) { if (pipe < 0 || pipe > DBRI_MAX_PIPE) { printk(KERN_ERR "DBRI: setup_pipe called " "with illegal pipe number\n"); return; } if ((sdp & 0xf800) != sdp) { printk(KERN_ERR "DBRI: setup_pipe called " "with strange SDP value\n"); /* sdp &= 0xf800; */ } /* If this is a fixed receive pipe, arrange for an interrupt * every time its data changes */ if (D_SDP_MODE(sdp) == D_SDP_FIXED && !(sdp & D_SDP_TO_SER)) sdp |= D_SDP_CHANGE; sdp |= D_PIPE(pipe); dbri->pipes[pipe].sdp = sdp; dbri->pipes[pipe].desc = -1; dbri->pipes[pipe].first_desc = -1; reset_pipe(dbri, pipe); } /* * Lock must be held before calling this. */ static void link_time_slot(struct snd_dbri *dbri, int pipe, int prevpipe, int nextpipe, int length, int cycle) { s32 *cmd; int val; if (pipe < 0 || pipe > DBRI_MAX_PIPE || prevpipe < 0 || prevpipe > DBRI_MAX_PIPE || nextpipe < 0 || nextpipe > DBRI_MAX_PIPE) { printk(KERN_ERR "DBRI: link_time_slot called with illegal pipe number\n"); return; } if (dbri->pipes[pipe].sdp == 0 || dbri->pipes[prevpipe].sdp == 0 || dbri->pipes[nextpipe].sdp == 0) { printk(KERN_ERR "DBRI: link_time_slot called " "on uninitialized pipe\n"); return; } dbri->pipes[prevpipe].nextpipe = pipe; dbri->pipes[pipe].nextpipe = nextpipe; dbri->pipes[pipe].length = length; cmd = dbri_cmdlock(dbri, 4); if (dbri->pipes[pipe].sdp & D_SDP_TO_SER) { /* Deal with CHI special case: * "If transmission on edges 0 or 1 is desired, then cycle n * (where n = # of bit times per frame...) must be used." * - DBRI data sheet, page 11 */ if (prevpipe == 16 && cycle == 0) cycle = dbri->chi_bpf; val = D_DTS_VO | D_DTS_INS | D_DTS_PRVOUT(prevpipe) | pipe; *(cmd++) = DBRI_CMD(D_DTS, 0, val); *(cmd++) = 0; *(cmd++) = D_TS_LEN(length) | D_TS_CYCLE(cycle) | D_TS_NEXT(nextpipe); } else { val = D_DTS_VI | D_DTS_INS | D_DTS_PRVIN(prevpipe) | pipe; *(cmd++) = DBRI_CMD(D_DTS, 0, val); *(cmd++) = D_TS_LEN(length) | D_TS_CYCLE(cycle) | D_TS_NEXT(nextpipe); *(cmd++) = 0; } *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0); dbri_cmdsend(dbri, cmd, 4); } #if 0 /* * Lock must be held before calling this. */ static void unlink_time_slot(struct snd_dbri *dbri, int pipe, enum in_or_out direction, int prevpipe, int nextpipe) { s32 *cmd; int val; if (pipe < 0 || pipe > DBRI_MAX_PIPE || prevpipe < 0 || prevpipe > DBRI_MAX_PIPE || nextpipe < 0 || nextpipe > DBRI_MAX_PIPE) { printk(KERN_ERR "DBRI: unlink_time_slot called with illegal pipe number\n"); return; } cmd = dbri_cmdlock(dbri, 4); if (direction == PIPEinput) { val = D_DTS_VI | D_DTS_DEL | D_DTS_PRVIN(prevpipe) | pipe; *(cmd++) = DBRI_CMD(D_DTS, 0, val); *(cmd++) = D_TS_NEXT(nextpipe); *(cmd++) = 0; } else { val = D_DTS_VO | D_DTS_DEL | D_DTS_PRVOUT(prevpipe) | pipe; *(cmd++) = DBRI_CMD(D_DTS, 0, val); *(cmd++) = 0; *(cmd++) = D_TS_NEXT(nextpipe); } *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0); dbri_cmdsend(dbri, cmd, 4); } #endif /* xmit_fixed() / recv_fixed() * * Transmit/receive data on a "fixed" pipe - i.e, one whose contents are not * expected to change much, and which we don't need to buffer. * The DBRI only interrupts us when the data changes (receive pipes), * or only changes the data when this function is called (transmit pipes). * Only short pipes (numbers 16-31) can be used in fixed data mode. * * These function operate on a 32-bit field, no matter how large * the actual time slot is. The interrupt handler takes care of bit * ordering and alignment. An 8-bit time slot will always end up * in the low-order 8 bits, filled either MSB-first or LSB-first, * depending on the settings passed to setup_pipe(). * * Lock must not be held before calling it. */ static void xmit_fixed(struct snd_dbri *dbri, int pipe, unsigned int data) { s32 *cmd; unsigned long flags; if (pipe < 16 || pipe > DBRI_MAX_PIPE) { printk(KERN_ERR "DBRI: xmit_fixed: Illegal pipe number\n"); return; } if (D_SDP_MODE(dbri->pipes[pipe].sdp) == 0) { printk(KERN_ERR "DBRI: xmit_fixed: " "Uninitialized pipe %d\n", pipe); return; } if (D_SDP_MODE(dbri->pipes[pipe].sdp) != D_SDP_FIXED) { printk(KERN_ERR "DBRI: xmit_fixed: Non-fixed pipe %d\n", pipe); return; } if (!(dbri->pipes[pipe].sdp & D_SDP_TO_SER)) { printk(KERN_ERR "DBRI: xmit_fixed: Called on receive pipe %d\n", pipe); return; } /* DBRI short pipes always transmit LSB first */ if (dbri->pipes[pipe].sdp & D_SDP_MSB) data = reverse_bytes(data, dbri->pipes[pipe].length); cmd = dbri_cmdlock(dbri, 3); *(cmd++) = DBRI_CMD(D_SSP, 0, pipe); *(cmd++) = data; *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0); spin_lock_irqsave(&dbri->lock, flags); dbri_cmdsend(dbri, cmd, 3); spin_unlock_irqrestore(&dbri->lock, flags); dbri_cmdwait(dbri); } static void recv_fixed(struct snd_dbri *dbri, int pipe, volatile __u32 *ptr) { if (pipe < 16 || pipe > DBRI_MAX_PIPE) { printk(KERN_ERR "DBRI: recv_fixed called with " "illegal pipe number\n"); return; } if (D_SDP_MODE(dbri->pipes[pipe].sdp) != D_SDP_FIXED) { printk(KERN_ERR "DBRI: recv_fixed called on " "non-fixed pipe %d\n", pipe); return; } if (dbri->pipes[pipe].sdp & D_SDP_TO_SER) { printk(KERN_ERR "DBRI: recv_fixed called on " "transmit pipe %d\n", pipe); return; } dbri->pipes[pipe].recv_fixed_ptr = ptr; } /* setup_descs() * * Setup transmit/receive data on a "long" pipe - i.e, one associated * with a DMA buffer. * * Only pipe numbers 0-15 can be used in this mode. * * This function takes a stream number pointing to a data buffer, * and work by building chains of descriptors which identify the * data buffers. Buffers too large for a single descriptor will * be spread across multiple descriptors. * * All descriptors create a ring buffer. * * Lock must be held before calling this. */ static int setup_descs(struct snd_dbri *dbri, int streamno, unsigned int period) { struct dbri_streaminfo *info = &dbri->stream_info[streamno]; u32 dvma_addr = (u32)dbri->dma_dvma; __u32 dvma_buffer; int desc; int len; int first_desc = -1; int last_desc = -1; if (info->pipe < 0 || info->pipe > 15) { printk(KERN_ERR "DBRI: setup_descs: Illegal pipe number\n"); return -2; } if (dbri->pipes[info->pipe].sdp == 0) { printk(KERN_ERR "DBRI: setup_descs: Uninitialized pipe %d\n", info->pipe); return -2; } dvma_buffer = info->dvma_buffer; len = info->size; if (streamno == DBRI_PLAY) { if (!(dbri->pipes[info->pipe].sdp & D_SDP_TO_SER)) { printk(KERN_ERR "DBRI: setup_descs: " "Called on receive pipe %d\n", info->pipe); return -2; } } else { if (dbri->pipes[info->pipe].sdp & D_SDP_TO_SER) { printk(KERN_ERR "DBRI: setup_descs: Called on transmit pipe %d\n", info->pipe); return -2; } /* Should be able to queue multiple buffers * to receive on a pipe */ if (pipe_active(dbri, info->pipe)) { printk(KERN_ERR "DBRI: recv_on_pipe: " "Called on active pipe %d\n", info->pipe); return -2; } /* Make sure buffer size is multiple of four */ len &= ~3; } /* Free descriptors if pipe has any */ desc = dbri->pipes[info->pipe].first_desc; if (desc >= 0) do { dbri->dma->desc[desc].ba = 0; dbri->dma->desc[desc].nda = 0; desc = dbri->next_desc[desc]; } while (desc != -1 && desc != dbri->pipes[info->pipe].first_desc); dbri->pipes[info->pipe].desc = -1; dbri->pipes[info->pipe].first_desc = -1; desc = 0; while (len > 0) { int mylen; for (; desc < DBRI_NO_DESCS; desc++) { if (!dbri->dma->desc[desc].ba) break; } if (desc == DBRI_NO_DESCS) { printk(KERN_ERR "DBRI: setup_descs: No descriptors\n"); return -1; } if (len > DBRI_TD_MAXCNT) mylen = DBRI_TD_MAXCNT; /* 8KB - 4 */ else mylen = len; if (mylen > period) mylen = period; dbri->next_desc[desc] = -1; dbri->dma->desc[desc].ba = dvma_buffer; dbri->dma->desc[desc].nda = 0; if (streamno == DBRI_PLAY) { dbri->dma->desc[desc].word1 = DBRI_TD_CNT(mylen); dbri->dma->desc[desc].word4 = 0; dbri->dma->desc[desc].word1 |= DBRI_TD_F | DBRI_TD_B; } else { dbri->dma->desc[desc].word1 = 0; dbri->dma->desc[desc].word4 = DBRI_RD_B | DBRI_RD_BCNT(mylen); } if (first_desc == -1) first_desc = desc; else { dbri->next_desc[last_desc] = desc; dbri->dma->desc[last_desc].nda = dvma_addr + dbri_dma_off(desc, desc); } last_desc = desc; dvma_buffer += mylen; len -= mylen; } if (first_desc == -1 || last_desc == -1) { printk(KERN_ERR "DBRI: setup_descs: " " Not enough descriptors available\n"); return -1; } dbri->dma->desc[last_desc].nda = dvma_addr + dbri_dma_off(desc, first_desc); dbri->next_desc[last_desc] = first_desc; dbri->pipes[info->pipe].first_desc = first_desc; dbri->pipes[info->pipe].desc = first_desc; #ifdef DBRI_DEBUG for (desc = first_desc; desc != -1;) { dprintk(D_DESC, "DESC %d: %08x %08x %08x %08x\n", desc, dbri->dma->desc[desc].word1, dbri->dma->desc[desc].ba, dbri->dma->desc[desc].nda, dbri->dma->desc[desc].word4); desc = dbri->next_desc[desc]; if (desc == first_desc) break; } #endif return 0; } /* **************************************************************************** ************************** DBRI - CHI interface **************************** **************************************************************************** The CHI is a four-wire (clock, frame sync, data in, data out) time-division multiplexed serial interface which the DBRI can operate in either master (give clock/frame sync) or slave (take clock/frame sync) mode. */ enum master_or_slave { CHImaster, CHIslave }; /* * Lock must not be held before calling it. */ static void reset_chi(struct snd_dbri *dbri, enum master_or_slave master_or_slave, int bits_per_frame) { s32 *cmd; int val; /* Set CHI Anchor: Pipe 16 */ cmd = dbri_cmdlock(dbri, 4); val = D_DTS_VO | D_DTS_VI | D_DTS_INS | D_DTS_PRVIN(16) | D_PIPE(16) | D_DTS_PRVOUT(16); *(cmd++) = DBRI_CMD(D_DTS, 0, val); *(cmd++) = D_TS_ANCHOR | D_TS_NEXT(16); *(cmd++) = D_TS_ANCHOR | D_TS_NEXT(16); *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0); dbri_cmdsend(dbri, cmd, 4); dbri->pipes[16].sdp = 1; dbri->pipes[16].nextpipe = 16; cmd = dbri_cmdlock(dbri, 4); if (master_or_slave == CHIslave) { /* Setup DBRI for CHI Slave - receive clock, frame sync (FS) * * CHICM = 0 (slave mode, 8 kHz frame rate) * IR = give immediate CHI status interrupt * EN = give CHI status interrupt upon change */ *(cmd++) = DBRI_CMD(D_CHI, 0, D_CHI_CHICM(0)); } else { /* Setup DBRI for CHI Master - generate clock, FS * * BPF = bits per 8 kHz frame * 12.288 MHz / CHICM_divisor = clock rate * FD = 1 - drive CHIFS on rising edge of CHICK */ int clockrate = bits_per_frame * 8; int divisor = 12288 / clockrate; if (divisor > 255 || divisor * clockrate != 12288) printk(KERN_ERR "DBRI: illegal bits_per_frame " "in setup_chi\n"); *(cmd++) = DBRI_CMD(D_CHI, 0, D_CHI_CHICM(divisor) | D_CHI_FD | D_CHI_BPF(bits_per_frame)); } dbri->chi_bpf = bits_per_frame; /* CHI Data Mode * * RCE = 0 - receive on falling edge of CHICK * XCE = 1 - transmit on rising edge of CHICK * XEN = 1 - enable transmitter * REN = 1 - enable receiver */ *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0); *(cmd++) = DBRI_CMD(D_CDM, 0, D_CDM_XCE | D_CDM_XEN | D_CDM_REN); *(cmd++) = DBRI_CMD(D_PAUSE, 0, 0); dbri_cmdsend(dbri, cmd, 4); } /* **************************************************************************** *********************** CS4215 audio codec management ********************** **************************************************************************** In the standard SPARC audio configuration, the CS4215 codec is attached to the DBRI via the CHI interface and few of the DBRI's PIO pins. * Lock must not be held before calling it. */ static void cs4215_setup_pipes(struct snd_dbri *dbri) { unsigned long flags; spin_lock_irqsave(&dbri->lock, flags); /* * Data mode: * Pipe 4: Send timeslots 1-4 (audio data) * Pipe 20: Send timeslots 5-8 (part of ctrl data) * Pipe 6: Receive timeslots 1-4 (audio data) * Pipe 21: Receive timeslots 6-7. We can only receive 20 bits via * interrupt, and the rest of the data (slot 5 and 8) is * not relevant for us (only for doublechecking). * * Control mode: * Pipe 17: Send timeslots 1-4 (slots 5-8 are read only) * Pipe 18: Receive timeslot 1 (clb). * Pipe 19: Receive timeslot 7 (version). */ setup_pipe(dbri, 4, D_SDP_MEM | D_SDP_TO_SER | D_SDP_MSB); setup_pipe(dbri, 20, D_SDP_FIXED | D_SDP_TO_SER | D_SDP_MSB); setup_pipe(dbri, 6, D_SDP_MEM | D_SDP_FROM_SER | D_SDP_MSB); setup_pipe(dbri, 21, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB); setup_pipe(dbri, 17, D_SDP_FIXED | D_SDP_TO_SER | D_SDP_MSB); setup_pipe(dbri, 18, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB); setup_pipe(dbri, 19, D_SDP_FIXED | D_SDP_FROM_SER | D_SDP_MSB); spin_unlock_irqrestore(&dbri->lock, flags); dbri_cmdwait(dbri); } static int cs4215_init_data(struct cs4215 *mm) { /* * No action, memory resetting only. * * Data Time Slot 5-8 * Speaker,Line and Headphone enable. Gain set to the half. * Input is mike. */ mm->data[0] = CS4215_LO(0x20) | CS4215_HE | CS4215_LE; mm->data[1] = CS4215_RO(0x20) | CS4215_SE; mm->data[2] = CS4215_LG(0x8) | CS4215_IS | CS4215_PIO0 | CS4215_PIO1; mm->data[3] = CS4215_RG(0x8) | CS4215_MA(0xf); /* * Control Time Slot 1-4 * 0: Default I/O voltage scale * 1: 8 bit ulaw, 8kHz, mono, high pass filter disabled * 2: Serial enable, CHI master, 128 bits per frame, clock 1 * 3: Tests disabled */ mm->ctrl[0] = CS4215_RSRVD_1 | CS4215_MLB; mm->ctrl[1] = CS4215_DFR_ULAW | CS4215_FREQ[0].csval; mm->ctrl[2] = CS4215_XCLK | CS4215_BSEL_128 | CS4215_FREQ[0].xtal; mm->ctrl[3] = 0; mm->status = 0; mm->version = 0xff; mm->precision = 8; /* For ULAW */ mm->channels = 1; return 0; } static void cs4215_setdata(struct snd_dbri *dbri, int muted) { if (muted) { dbri->mm.data[0] |= 63; dbri->mm.data[1] |= 63; dbri->mm.data[2] &= ~15; dbri->mm.data[3] &= ~15; } else { /* Start by setting the playback attenuation. */ struct dbri_streaminfo *info = &dbri->stream_info[DBRI_PLAY]; int left_gain = info->left_gain & 0x3f; int right_gain = info->right_gain & 0x3f; dbri->mm.data[0] &= ~0x3f; /* Reset the volume bits */ dbri->mm.data[1] &= ~0x3f; dbri->mm.data[0] |= (DBRI_MAX_VOLUME - left_gain); dbri->mm.data[1] |= (DBRI_MAX_VOLUME - right_gain); /* Now set the recording gain. */ info = &dbri->stream_info[DBRI_REC]; left_gain = info->left_gain & 0xf; right_gain = info->right_gain & 0xf; dbri->mm.data[2] |= CS4215_LG(left_gain); dbri->mm.data[3] |= CS4215_RG(right_gain); } xmit_fixed(dbri, 20, *(int *)dbri->mm.data); } /* * Set the CS4215 to data mode. */ static void cs4215_open(struct snd_dbri *dbri) { int data_width; u32 tmp; unsigned long flags; dprintk(D_MM, "cs4215_open: %d channels, %d bits\n", dbri->mm.channels, dbri->mm.precision); /* Temporarily mute outputs, and wait 1/8000 sec (125 us) * to make sure this takes. This avoids clicking noises. */ cs4215_setdata(dbri, 1); udelay(125); /* * Data mode: * Pipe 4: Send timeslots 1-4 (audio data) * Pipe 20: Send timeslots 5-8 (part of ctrl data) * Pipe 6: Receive timeslots 1-4 (audio data) * Pipe 21: Receive timeslots 6-7. We can only receive 20 bits via * interrupt, and the rest of the data (slot 5 and 8) is * not relevant for us (only for doublechecking). * * Just like in control mode, the time slots are all offset by eight * bits. The CS4215, it seems, observes TSIN (the delayed signal) * even if it's the CHI master. Don't ask me... */ spin_lock_irqsave(&dbri->lock, flags); tmp = sbus_readl(dbri->regs + REG0); tmp &= ~(D_C); /* Disable CHI */ sbus_writel(tmp, dbri->regs + REG0); /* Switch CS4215 to data mode - set PIO3 to 1 */ sbus_writel(D_ENPIO | D_PIO1 | D_PIO3 | (dbri->mm.onboard ? D_PIO0 : D_PIO2), dbri->regs + REG2); reset_chi(dbri, CHIslave, 128); /* Note: this next doesn't work for 8-bit stereo, because the two * channels would be on timeslots 1 and 3, with 2 and 4 idle. * (See CS4215 datasheet Fig 15) * * DBRI non-contiguous mode would be required to make this work. */ data_width = dbri->mm.channels * dbri->mm.precision; link_time_slot(dbri, 4, 16, 16, data_width, dbri->mm.offset); link_time_slot(dbri, 20, 4, 16, 32, dbri->mm.offset + 32); link_time_slot(dbri, 6, 16, 16, data_width, dbri->mm.offset); link_time_slot(dbri, 21, 6, 16, 16, dbri->mm.offset + 40); /* FIXME: enable CHI after _setdata? */ tmp = sbus_readl(dbri->regs + REG0); tmp |= D_C; /* Enable CHI */ sbus_writel(tmp, dbri->regs + REG0); spin_unlock_irqrestore(&dbri->lock, flags); cs4215_setdata(dbri, 0); } /* * Send the control information (i.e. audio format) */ static int cs4215_setctrl(struct snd_dbri *dbri) { int i, val; u32 tmp; unsigned long flags; /* FIXME - let the CPU do something useful during these delays */ /* Temporarily mute outputs, and wait 1/8000 sec (125 us) * to make sure this takes. This avoids clicking noises. */ cs4215_setdata(dbri, 1); udelay(125); /* * Enable Control mode: Set DBRI's PIO3 (4215's D/~C) to 0, then wait * 12 cycles <= 12/(5512.5*64) sec = 34.01 usec */ val = D_ENPIO | D_PIO1 | (dbri->mm.onboard ? D_PIO0 : D_PIO2); sbus_writel(val, dbri->regs + REG2); dprintk(D_MM, "cs4215_setctrl: reg2=0x%x\n", val); udelay(34); /* In Control mode, the CS4215 is a slave device, so the DBRI must * operate as CHI master, supplying clocking and frame synchronization. * * In Data mode, however, the CS4215 must be CHI master to insure * that its data stream is synchronous with its codec. * * The upshot of all this? We start by putting the DBRI into master * mode, program the CS4215 in Control mode, then switch the CS4215 * into Data mode and put the DBRI into slave mode. Various timing * requirements must be observed along the way. * * Oh, and one more thing, on a SPARCStation 20 (and maybe * others?), the addressing of the CS4215's time slots is * offset by eight bits, so we add eight to all the "cycle" * values in the Define Time Slot (DTS) commands. This is * done in hardware by a TI 248 that delays the DBRI->4215 * frame sync signal by eight clock cycles. Anybody know why? */ spin_lock_irqsave(&dbri->lock, flags); tmp = sbus_readl(dbri->regs + REG0); tmp &= ~D_C; /* Disable CHI */ sbus_writel(tmp, dbri->regs + REG0); reset_chi(dbri, CHImaster, 128); /* * Control mode: * Pipe 17: Send timeslots 1-4 (slots 5-8 are read only) * Pipe 18: Receive timeslot 1 (clb). * Pipe 19: Receive timeslot 7 (version). */ link_time_slot(dbri, 17, 16, 16, 32, dbri->mm.offset); link_time_slot(dbri, 18, 16, 16, 8, dbri->mm.offset); link_time_slot(dbri, 19, 18, 16, 8, dbri->mm.offset + 48); spin_unlock_irqrestore(&dbri->lock, flags); /* Wait for the chip to echo back CLB (Control Latch Bit) as zero */ dbri->mm.ctrl[0] &= ~CS4215_CLB; xmit_fixed(dbri, 17, *(int *)dbri->mm.ctrl); spin_lock_irqsave(&dbri->lock, flags); tmp = sbus_readl(dbri->regs + REG0); tmp |= D_C; /* Enable CHI */ sbus_writel(tmp, dbri->regs + REG0); spin_unlock_irqrestore(&dbri->lock, flags); for (i = 10; ((dbri->mm.status & 0xe4) != 0x20); --i) msleep_interruptible(1); if (i == 0) { dprintk(D_MM, "CS4215 didn't respond to CLB (0x%02x)\n", dbri->mm.status); return -1; } /* Disable changes to our copy of the version number, as we are about * to leave control mode. */ recv_fixed(dbri, 19, NULL); /* Terminate CS4215 control mode - data sheet says * "Set CLB=1 and send two more frames of valid control info" */ dbri->mm.ctrl[0] |= CS4215_CLB; xmit_fixed(dbri, 17, *(int *)dbri->mm.ctrl); /* Two frames of control info @ 8kHz frame rate = 250 us delay */ udelay(250); cs4215_setdata(dbri, 0); return 0; } /* * Setup the codec with the sampling rate, audio format and number of * channels. * As part of the process we resend the settings for the data * timeslots as well. */ static int cs4215_prepare(struct snd_dbri *dbri, unsigned int rate, snd_pcm_format_t format, unsigned int channels) { int freq_idx; int ret = 0; /* Lookup index for this rate */ for (freq_idx = 0; CS4215_FREQ[freq_idx].freq != 0; freq_idx++) { if (CS4215_FREQ[freq_idx].freq == rate) break; } if (CS4215_FREQ[freq_idx].freq != rate) { printk(KERN_WARNING "DBRI: Unsupported rate %d Hz\n", rate); return -1; } switch (format) { case SNDRV_PCM_FORMAT_MU_LAW: dbri->mm.ctrl[1] = CS4215_DFR_ULAW; dbri->mm.precision = 8; break; case SNDRV_PCM_FORMAT_A_LAW: dbri->mm.ctrl[1] = CS4215_DFR_ALAW; dbri->mm.precision = 8; break; case SNDRV_PCM_FORMAT_U8: dbri->mm.ctrl[1] = CS4215_DFR_LINEAR8; dbri->mm.precision = 8; break; case SNDRV_PCM_FORMAT_S16_BE: dbri->mm.ctrl[1] = CS4215_DFR_LINEAR16; dbri->mm.precision = 16; break; default: printk(KERN_WARNING "DBRI: Unsupported format %d\n", format); return -1; } /* Add rate parameters */ dbri->mm.ctrl[1] |= CS4215_FREQ[freq_idx].csval; dbri->mm.ctrl[2] = CS4215_XCLK | CS4215_BSEL_128 | CS4215_FREQ[freq_idx].xtal; dbri->mm.channels = channels; if (channels == 2) dbri->mm.ctrl[1] |= CS4215_DFR_STEREO; ret = cs4215_setctrl(dbri); if (ret == 0) cs4215_open(dbri); /* set codec to data mode */ return ret; } /* * */ static int cs4215_init(struct snd_dbri *dbri) { u32 reg2 = sbus_readl(dbri->regs + REG2); dprintk(D_MM, "cs4215_init: reg2=0x%x\n", reg2); /* Look for the cs4215 chips */ if (reg2 & D_PIO2) { dprintk(D_MM, "Onboard CS4215 detected\n"); dbri->mm.onboard = 1; } if (reg2 & D_PIO0) { dprintk(D_MM, "Speakerbox detected\n"); dbri->mm.onboard = 0; if (reg2 & D_PIO2) { printk(KERN_INFO "DBRI: Using speakerbox / " "ignoring onboard mmcodec.\n"); sbus_writel(D_ENPIO2, dbri->regs + REG2); } } if (!(reg2 & (D_PIO0 | D_PIO2))) { printk(KERN_ERR "DBRI: no mmcodec found.\n"); return -EIO; } cs4215_setup_pipes(dbri); cs4215_init_data(&dbri->mm); /* Enable capture of the status & version timeslots. */ recv_fixed(dbri, 18, &dbri->mm.status); recv_fixed(dbri, 19, &dbri->mm.version); dbri->mm.offset = dbri->mm.onboard ? 0 : 8; if (cs4215_setctrl(dbri) == -1 || dbri->mm.version == 0xff) { dprintk(D_MM, "CS4215 failed probe at offset %d\n", dbri->mm.offset); return -EIO; } dprintk(D_MM, "Found CS4215 at offset %d\n", dbri->mm.offset); return 0; } /* **************************************************************************** *************************** DBRI interrupt handler ************************* **************************************************************************** The DBRI communicates with the CPU mainly via a circular interrupt buffer. When an interrupt is signaled, the CPU walks through the buffer and calls dbri_process_one_interrupt() for each interrupt word. Complicated interrupts are handled by dedicated functions (which appear first in this file). Any pending interrupts can be serviced by calling dbri_process_interrupt_buffer(), which works even if the CPU's interrupts are disabled. */ /* xmit_descs() * * Starts transmitting the current TD's for recording/playing. * For playback, ALSA has filled the DMA memory with new data (we hope). */ static void xmit_descs(struct snd_dbri *dbri) { struct dbri_streaminfo *info; u32 dvma_addr; s32 *cmd; unsigned long flags; int first_td; if (dbri == NULL) return; /* Disabled */ dvma_addr = (u32)dbri->dma_dvma; info = &dbri->stream_info[DBRI_REC]; spin_lock_irqsave(&dbri->lock, flags); if (info->pipe >= 0) { first_td = dbri->pipes[info->pipe].first_desc; dprintk(D_DESC, "xmit_descs rec @ TD %d\n", first_td); /* Stream could be closed by the time we run. */ if (first_td >= 0) { cmd = dbri_cmdlock(dbri, 2); *(cmd++) = DBRI_CMD(D_SDP, 0, dbri->pipes[info->pipe].sdp | D_SDP_P | D_SDP_EVERY | D_SDP_C); *(cmd++) = dvma_addr + dbri_dma_off(desc, first_td); dbri_cmdsend(dbri, cmd, 2); /* Reset our admin of the pipe. */ dbri->pipes[info->pipe].desc = first_td; } } info = &dbri->stream_info[DBRI_PLAY]; if (info->pipe >= 0) { first_td = dbri->pipes[info->pipe].first_desc; dprintk(D_DESC, "xmit_descs play @ TD %d\n", first_td); /* Stream could be closed by the time we run. */ if (first_td >= 0) { cmd = dbri_cmdlock(dbri, 2); *(cmd++) = DBRI_CMD(D_SDP, 0, dbri->pipes[info->pipe].sdp | D_SDP_P | D_SDP_EVERY | D_SDP_C); *(cmd++) = dvma_addr + dbri_dma_off(desc, first_td); dbri_cmdsend(dbri, cmd, 2); /* Reset our admin of the pipe. */ dbri->pipes[info->pipe].desc = first_td; } } spin_unlock_irqrestore(&dbri->lock, flags); } /* transmission_complete_intr() * * Called by main interrupt handler when DBRI signals transmission complete * on a pipe (interrupt triggered by the B bit in a transmit descriptor). * * Walks through the pipe's list of transmit buffer descriptors and marks * them as available. Stops when the first descriptor is found without * TBC (Transmit Buffer Complete) set, or we've run through them all. * * The DMA buffers are not released. They form a ring buffer and * they are filled by ALSA while others are transmitted by DMA. * */ static void transmission_complete_intr(struct snd_dbri *dbri, int pipe) { struct dbri_streaminfo *info = &dbri->stream_info[DBRI_PLAY]; int td = dbri->pipes[pipe].desc; int status; while (td >= 0) { if (td >= DBRI_NO_DESCS) { printk(KERN_ERR "DBRI: invalid td on pipe %d\n", pipe); return; } status = DBRI_TD_STATUS(dbri->dma->desc[td].word4); if (!(status & DBRI_TD_TBC)) break; dprintk(D_INT, "TD %d, status 0x%02x\n", td, status); dbri->dma->desc[td].word4 = 0; /* Reset it for next time. */ info->offset += DBRI_RD_CNT(dbri->dma->desc[td].word1); td = dbri->next_desc[td]; dbri->pipes[pipe].desc = td; } /* Notify ALSA */ spin_unlock(&dbri->lock); snd_pcm_period_elapsed(info->substream); spin_lock(&dbri->lock); } static void reception_complete_intr(struct snd_dbri *dbri, int pipe) { struct dbri_streaminfo *info; int rd = dbri->pipes[pipe].desc; s32 status; if (rd < 0 || rd >= DBRI_NO_DESCS) { printk(KERN_ERR "DBRI: invalid rd on pipe %d\n", pipe); return; } dbri->pipes[pipe].desc = dbri->next_desc[rd]; status = dbri->dma->desc[rd].word1; dbri->dma->desc[rd].word1 = 0; /* Reset it for next time. */ info = &dbri->stream_info[DBRI_REC]; info->offset += DBRI_RD_CNT(status); /* FIXME: Check status */ dprintk(D_INT, "Recv RD %d, status 0x%02x, len %d\n", rd, DBRI_RD_STATUS(status), DBRI_RD_CNT(status)); /* Notify ALSA */ spin_unlock(&dbri->lock); snd_pcm_period_elapsed(info->substream); spin_lock(&dbri->lock); } static void dbri_process_one_interrupt(struct snd_dbri *dbri, int x) { int val = D_INTR_GETVAL(x); int channel = D_INTR_GETCHAN(x); int command = D_INTR_GETCMD(x); int code = D_INTR_GETCODE(x); #ifdef DBRI_DEBUG int rval = D_INTR_GETRVAL(x); #endif if (channel == D_INTR_CMD) { dprintk(D_CMD, "INTR: Command: %-5s Value:%d\n", cmds[command], val); } else { dprintk(D_INT, "INTR: Chan:%d Code:%d Val:%#x\n", channel, code, rval); } switch (code) { case D_INTR_CMDI: if (command != D_WAIT) printk(KERN_ERR "DBRI: Command read interrupt\n"); break; case D_INTR_BRDY: reception_complete_intr(dbri, channel); break; case D_INTR_XCMP: case D_INTR_MINT: transmission_complete_intr(dbri, channel); break; case D_INTR_UNDR: /* UNDR - Transmission underrun * resend SDP command with clear pipe bit (C) set */ { /* FIXME: do something useful in case of underrun */ printk(KERN_ERR "DBRI: Underrun error\n"); #if 0 s32 *cmd; int pipe = channel; int td = dbri->pipes[pipe].desc; dbri->dma->desc[td].word4 = 0; cmd = dbri_cmdlock(dbri, NoGetLock); *(cmd++) = DBRI_CMD(D_SDP, 0, dbri->pipes[pipe].sdp | D_SDP_P | D_SDP_C | D_SDP_2SAME); *(cmd++) = dbri->dma_dvma + dbri_dma_off(desc, td); dbri_cmdsend(dbri, cmd); #endif } break; case D_INTR_FXDT: /* FXDT - Fixed data change */ if (dbri->pipes[channel].sdp & D_SDP_MSB) val = reverse_bytes(val, dbri->pipes[channel].length); if (dbri->pipes[channel].recv_fixed_ptr) *(dbri->pipes[channel].recv_fixed_ptr) = val; break; default: if (channel != D_INTR_CMD) printk(KERN_WARNING "DBRI: Ignored Interrupt: %d (0x%x)\n", code, x); } } /* dbri_process_interrupt_buffer advances through the DBRI's interrupt * buffer until it finds a zero word (indicating nothing more to do * right now). Non-zero words require processing and are handed off * to dbri_process_one_interrupt AFTER advancing the pointer. */ static void dbri_process_interrupt_buffer(struct snd_dbri *dbri) { s32 x; while ((x = dbri->dma->intr[dbri->dbri_irqp]) != 0) { dbri->dma->intr[dbri->dbri_irqp] = 0; dbri->dbri_irqp++; if (dbri->dbri_irqp == DBRI_INT_BLK) dbri->dbri_irqp = 1; dbri_process_one_interrupt(dbri, x); } } static irqreturn_t snd_dbri_interrupt(int irq, void *dev_id) { struct snd_dbri *dbri = dev_id; static int errcnt; int x; if (dbri == NULL) return IRQ_NONE; spin_lock(&dbri->lock); /* * Read it, so the interrupt goes away. */ x = sbus_readl(dbri->regs + REG1); if (x & (D_MRR | D_MLE | D_LBG | D_MBE)) { u32 tmp; if (x & D_MRR) printk(KERN_ERR "DBRI: Multiple Error Ack on SBus reg1=0x%x\n", x); if (x & D_MLE) printk(KERN_ERR "DBRI: Multiple Late Error on SBus reg1=0x%x\n", x); if (x & D_LBG) printk(KERN_ERR "DBRI: Lost Bus Grant on SBus reg1=0x%x\n", x); if (x & D_MBE) printk(KERN_ERR "DBRI: Burst Error on SBus reg1=0x%x\n", x); /* Some of these SBus errors cause the chip's SBus circuitry * to be disabled, so just re-enable and try to keep going. * * The only one I've seen is MRR, which will be triggered * if you let a transmit pipe underrun, then try to CDP it. * * If these things persist, we reset the chip. */ if ((++errcnt) % 10 == 0) { dprintk(D_INT, "Interrupt errors exceeded.\n"); dbri_reset(dbri); } else { tmp = sbus_readl(dbri->regs + REG0); tmp &= ~(D_D); sbus_writel(tmp, dbri->regs + REG0); } } dbri_process_interrupt_buffer(dbri); spin_unlock(&dbri->lock); return IRQ_HANDLED; } /**************************************************************************** PCM Interface ****************************************************************************/ static const struct snd_pcm_hardware snd_dbri_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_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_BE, .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_5512, .rate_min = 5512, .rate_max = 48000, .channels_min = 1, .channels_max = 2, .buffer_bytes_max = 64 * 1024, .period_bytes_min = 1, .period_bytes_max = DBRI_TD_MAXCNT, .periods_min = 1, .periods_max = 1024, }; static int snd_hw_rule_format(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); struct snd_mask fmt; snd_mask_any(&fmt); if (c->min > 1) { fmt.bits[0] &= SNDRV_PCM_FMTBIT_S16_BE; return snd_mask_refine(f, &fmt); } return 0; } static int snd_hw_rule_channels(struct snd_pcm_hw_params *params, struct snd_pcm_hw_rule *rule) { struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); struct snd_mask *f = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); struct snd_interval ch; snd_interval_any(&ch); if (!(f->bits[0] & SNDRV_PCM_FMTBIT_S16_BE)) { ch.min = 1; ch.max = 1; ch.integer = 1; return snd_interval_refine(c, &ch); } return 0; } static int snd_dbri_open(struct snd_pcm_substream *substream) { struct snd_dbri *dbri = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); unsigned long flags; dprintk(D_USR, "open audio output.\n"); runtime->hw = snd_dbri_pcm_hw; spin_lock_irqsave(&dbri->lock, flags); info->substream = substream; info->offset = 0; info->dvma_buffer = 0; info->pipe = -1; spin_unlock_irqrestore(&dbri->lock, flags); snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, snd_hw_rule_format, NULL, SNDRV_PCM_HW_PARAM_FORMAT, -1); snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT, snd_hw_rule_channels, NULL, SNDRV_PCM_HW_PARAM_CHANNELS, -1); cs4215_open(dbri); return 0; } static int snd_dbri_close(struct snd_pcm_substream *substream) { struct snd_dbri *dbri = snd_pcm_substream_chip(substream); struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); dprintk(D_USR, "close audio output.\n"); info->substream = NULL; info->offset = 0; return 0; } static int snd_dbri_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { struct snd_pcm_runtime *runtime = substream->runtime; struct snd_dbri *dbri = snd_pcm_substream_chip(substream); struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); int direction; int ret; /* set sampling rate, audio format and number of channels */ ret = cs4215_prepare(dbri, params_rate(hw_params), params_format(hw_params), params_channels(hw_params)); if (ret != 0) return ret; /* hw_params can get called multiple times. Only map the DMA once. */ if (info->dvma_buffer == 0) { if (DBRI_STREAMNO(substream) == DBRI_PLAY) direction = DMA_TO_DEVICE; else direction = DMA_FROM_DEVICE; info->dvma_buffer = dma_map_single(&dbri->op->dev, runtime->dma_area, params_buffer_bytes(hw_params), direction); } direction = params_buffer_bytes(hw_params); dprintk(D_USR, "hw_params: %d bytes, dvma=%x\n", direction, info->dvma_buffer); return 0; } static int snd_dbri_hw_free(struct snd_pcm_substream *substream) { struct snd_dbri *dbri = snd_pcm_substream_chip(substream); struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); int direction; dprintk(D_USR, "hw_free.\n"); /* hw_free can get called multiple times. Only unmap the DMA once. */ if (info->dvma_buffer) { if (DBRI_STREAMNO(substream) == DBRI_PLAY) direction = DMA_TO_DEVICE; else direction = DMA_FROM_DEVICE; dma_unmap_single(&dbri->op->dev, info->dvma_buffer, substream->runtime->buffer_size, direction); info->dvma_buffer = 0; } if (info->pipe != -1) { reset_pipe(dbri, info->pipe); info->pipe = -1; } return 0; } static int snd_dbri_prepare(struct snd_pcm_substream *substream) { struct snd_dbri *dbri = snd_pcm_substream_chip(substream); struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); int ret; info->size = snd_pcm_lib_buffer_bytes(substream); if (DBRI_STREAMNO(substream) == DBRI_PLAY) info->pipe = 4; /* Send pipe */ else info->pipe = 6; /* Receive pipe */ spin_lock_irq(&dbri->lock); info->offset = 0; /* Setup the all the transmit/receive descriptors to cover the * whole DMA buffer. */ ret = setup_descs(dbri, DBRI_STREAMNO(substream), snd_pcm_lib_period_bytes(substream)); spin_unlock_irq(&dbri->lock); dprintk(D_USR, "prepare audio output. %d bytes\n", info->size); return ret; } static int snd_dbri_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_dbri *dbri = snd_pcm_substream_chip(substream); struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); int ret = 0; switch (cmd) { case SNDRV_PCM_TRIGGER_START: dprintk(D_USR, "start audio, period is %d bytes\n", (int)snd_pcm_lib_period_bytes(substream)); /* Re-submit the TDs. */ xmit_descs(dbri); break; case SNDRV_PCM_TRIGGER_STOP: dprintk(D_USR, "stop audio.\n"); reset_pipe(dbri, info->pipe); break; default: ret = -EINVAL; } return ret; } static snd_pcm_uframes_t snd_dbri_pointer(struct snd_pcm_substream *substream) { struct snd_dbri *dbri = snd_pcm_substream_chip(substream); struct dbri_streaminfo *info = DBRI_STREAM(dbri, substream); snd_pcm_uframes_t ret; ret = bytes_to_frames(substream->runtime, info->offset) % substream->runtime->buffer_size; dprintk(D_USR, "I/O pointer: %ld frames of %ld.\n", ret, substream->runtime->buffer_size); return ret; } static const struct snd_pcm_ops snd_dbri_ops = { .open = snd_dbri_open, .close = snd_dbri_close, .hw_params = snd_dbri_hw_params, .hw_free = snd_dbri_hw_free, .prepare = snd_dbri_prepare, .trigger = snd_dbri_trigger, .pointer = snd_dbri_pointer, }; static int snd_dbri_pcm(struct snd_card *card) { struct snd_pcm *pcm; int err; err = snd_pcm_new(card, /* ID */ "sun_dbri", /* device */ 0, /* playback count */ 1, /* capture count */ 1, &pcm); if (err < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_dbri_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_dbri_ops); pcm->private_data = card->private_data; pcm->info_flags = 0; strcpy(pcm->name, card->shortname); snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, NULL, 64 * 1024, 64 * 1024); return 0; } /***************************************************************************** Mixer interface *****************************************************************************/ static int snd_cs4215_info_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; if (kcontrol->private_value == DBRI_PLAY) uinfo->value.integer.max = DBRI_MAX_VOLUME; else uinfo->value.integer.max = DBRI_MAX_GAIN; return 0; } static int snd_cs4215_get_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol); struct dbri_streaminfo *info; if (snd_BUG_ON(!dbri)) return -EINVAL; info = &dbri->stream_info[kcontrol->private_value]; ucontrol->value.integer.value[0] = info->left_gain; ucontrol->value.integer.value[1] = info->right_gain; return 0; } static int snd_cs4215_put_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol); struct dbri_streaminfo *info = &dbri->stream_info[kcontrol->private_value]; unsigned int vol[2]; int changed = 0; vol[0] = ucontrol->value.integer.value[0]; vol[1] = ucontrol->value.integer.value[1]; if (kcontrol->private_value == DBRI_PLAY) { if (vol[0] > DBRI_MAX_VOLUME || vol[1] > DBRI_MAX_VOLUME) return -EINVAL; } else { if (vol[0] > DBRI_MAX_GAIN || vol[1] > DBRI_MAX_GAIN) return -EINVAL; } if (info->left_gain != vol[0]) { info->left_gain = vol[0]; changed = 1; } if (info->right_gain != vol[1]) { info->right_gain = vol[1]; changed = 1; } if (changed) { /* First mute outputs, and wait 1/8000 sec (125 us) * to make sure this takes. This avoids clicking noises. */ cs4215_setdata(dbri, 1); udelay(125); cs4215_setdata(dbri, 0); } return changed; } static int snd_cs4215_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; uinfo->type = (mask == 1) ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = mask; return 0; } static int snd_cs4215_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol); int elem = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; int invert = (kcontrol->private_value >> 24) & 1; if (snd_BUG_ON(!dbri)) return -EINVAL; if (elem < 4) ucontrol->value.integer.value[0] = (dbri->mm.data[elem] >> shift) & mask; else ucontrol->value.integer.value[0] = (dbri->mm.ctrl[elem - 4] >> shift) & mask; if (invert == 1) ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; return 0; } static int snd_cs4215_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_dbri *dbri = snd_kcontrol_chip(kcontrol); int elem = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; int invert = (kcontrol->private_value >> 24) & 1; int changed = 0; unsigned short val; if (snd_BUG_ON(!dbri)) return -EINVAL; val = (ucontrol->value.integer.value[0] & mask); if (invert == 1) val = mask - val; val <<= shift; if (elem < 4) { dbri->mm.data[elem] = (dbri->mm.data[elem] & ~(mask << shift)) | val; changed = (val != dbri->mm.data[elem]); } else { dbri->mm.ctrl[elem - 4] = (dbri->mm.ctrl[elem - 4] & ~(mask << shift)) | val; changed = (val != dbri->mm.ctrl[elem - 4]); } dprintk(D_GEN, "put_single: mask=0x%x, changed=%d, " "mixer-value=%ld, mm-value=0x%x\n", mask, changed, ucontrol->value.integer.value[0], dbri->mm.data[elem & 3]); if (changed) { /* First mute outputs, and wait 1/8000 sec (125 us) * to make sure this takes. This avoids clicking noises. */ cs4215_setdata(dbri, 1); udelay(125); cs4215_setdata(dbri, 0); } return changed; } /* Entries 0-3 map to the 4 data timeslots, entries 4-7 map to the 4 control timeslots. Shift is the bit offset in the timeslot, mask defines the number of bits. invert is a boolean for use with attenuation. */ #define CS4215_SINGLE(xname, entry, shift, mask, invert) \ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \ .info = snd_cs4215_info_single, \ .get = snd_cs4215_get_single, .put = snd_cs4215_put_single, \ .private_value = (entry) | ((shift) << 8) | ((mask) << 16) | \ ((invert) << 24) }, static const struct snd_kcontrol_new dbri_controls[] = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Playback Volume", .info = snd_cs4215_info_volume, .get = snd_cs4215_get_volume, .put = snd_cs4215_put_volume, .private_value = DBRI_PLAY, }, CS4215_SINGLE("Headphone switch", 0, 7, 1, 0) CS4215_SINGLE("Line out switch", 0, 6, 1, 0) CS4215_SINGLE("Speaker switch", 1, 6, 1, 0) { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Volume", .info = snd_cs4215_info_volume, .get = snd_cs4215_get_volume, .put = snd_cs4215_put_volume, .private_value = DBRI_REC, }, /* FIXME: mic/line switch */ CS4215_SINGLE("Line in switch", 2, 4, 1, 0) CS4215_SINGLE("High Pass Filter switch", 5, 7, 1, 0) CS4215_SINGLE("Monitor Volume", 3, 4, 0xf, 1) CS4215_SINGLE("Mic boost", 4, 4, 1, 1) }; static int snd_dbri_mixer(struct snd_card *card) { int idx, err; struct snd_dbri *dbri; if (snd_BUG_ON(!card || !card->private_data)) return -EINVAL; dbri = card->private_data; strcpy(card->mixername, card->shortname); for (idx = 0; idx < ARRAY_SIZE(dbri_controls); idx++) { err = snd_ctl_add(card, snd_ctl_new1(&dbri_controls[idx], dbri)); if (err < 0) return err; } for (idx = DBRI_REC; idx < DBRI_NO_STREAMS; idx++) { dbri->stream_info[idx].left_gain = 0; dbri->stream_info[idx].right_gain = 0; } return 0; } /**************************************************************************** /proc interface ****************************************************************************/ static void dbri_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_dbri *dbri = entry->private_data; snd_iprintf(buffer, "REG0: 0x%x\n", sbus_readl(dbri->regs + REG0)); snd_iprintf(buffer, "REG2: 0x%x\n", sbus_readl(dbri->regs + REG2)); snd_iprintf(buffer, "REG8: 0x%x\n", sbus_readl(dbri->regs + REG8)); snd_iprintf(buffer, "REG9: 0x%x\n", sbus_readl(dbri->regs + REG9)); } #ifdef DBRI_DEBUG static void dbri_debug_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_dbri *dbri = entry->private_data; int pipe; snd_iprintf(buffer, "debug=%d\n", dbri_debug); for (pipe = 0; pipe < 32; pipe++) { if (pipe_active(dbri, pipe)) { struct dbri_pipe *pptr = &dbri->pipes[pipe]; snd_iprintf(buffer, "Pipe %d: %s SDP=0x%x desc=%d, " "len=%d next %d\n", pipe, (pptr->sdp & D_SDP_TO_SER) ? "output" : "input", pptr->sdp, pptr->desc, pptr->length, pptr->nextpipe); } } } #endif static void snd_dbri_proc(struct snd_card *card) { struct snd_dbri *dbri = card->private_data; snd_card_ro_proc_new(card, "regs", dbri, dbri_regs_read); #ifdef DBRI_DEBUG snd_card_ro_proc_new(card, "debug", dbri, dbri_debug_read); #endif } /* **************************************************************************** **************************** Initialization ******************************** **************************************************************************** */ static void snd_dbri_free(struct snd_dbri *dbri); static int snd_dbri_create(struct snd_card *card, struct platform_device *op, int irq, int dev) { struct snd_dbri *dbri = card->private_data; int err; spin_lock_init(&dbri->lock); dbri->op = op; dbri->irq = irq; dbri->dma = dma_alloc_coherent(&op->dev, sizeof(struct dbri_dma), &dbri->dma_dvma, GFP_KERNEL); if (!dbri->dma) return -ENOMEM; dprintk(D_GEN, "DMA Cmd Block 0x%p (%pad)\n", dbri->dma, dbri->dma_dvma); /* Map the registers into memory. */ dbri->regs_size = resource_size(&op->resource[0]); dbri->regs = of_ioremap(&op->resource[0], 0, dbri->regs_size, "DBRI Registers"); if (!dbri->regs) { printk(KERN_ERR "DBRI: could not allocate registers\n"); dma_free_coherent(&op->dev, sizeof(struct dbri_dma), (void *)dbri->dma, dbri->dma_dvma); return -EIO; } err = request_irq(dbri->irq, snd_dbri_interrupt, IRQF_SHARED, "DBRI audio", dbri); if (err) { printk(KERN_ERR "DBRI: Can't get irq %d\n", dbri->irq); of_iounmap(&op->resource[0], dbri->regs, dbri->regs_size); dma_free_coherent(&op->dev, sizeof(struct dbri_dma), (void *)dbri->dma, dbri->dma_dvma); return err; } /* Do low level initialization of the DBRI and CS4215 chips */ dbri_initialize(dbri); err = cs4215_init(dbri); if (err) { snd_dbri_free(dbri); return err; } return 0; } static void snd_dbri_free(struct snd_dbri *dbri) { dprintk(D_GEN, "snd_dbri_free\n"); dbri_reset(dbri); if (dbri->irq) free_irq(dbri->irq, dbri); if (dbri->regs) of_iounmap(&dbri->op->resource[0], dbri->regs, dbri->regs_size); if (dbri->dma) dma_free_coherent(&dbri->op->dev, sizeof(struct dbri_dma), (void *)dbri->dma, dbri->dma_dvma); } static int dbri_probe(struct platform_device *op) { struct snd_dbri *dbri; struct resource *rp; struct snd_card *card; static int dev; int irq; int err; if (dev >= SNDRV_CARDS) return -ENODEV; if (!enable[dev]) { dev++; return -ENOENT; } irq = op->archdata.irqs[0]; if (irq <= 0) { printk(KERN_ERR "DBRI-%d: No IRQ.\n", dev); return -ENODEV; } err = snd_card_new(&op->dev, index[dev], id[dev], THIS_MODULE, sizeof(struct snd_dbri), &card); if (err < 0) return err; strcpy(card->driver, "DBRI"); strcpy(card->shortname, "Sun DBRI"); rp = &op->resource[0]; sprintf(card->longname, "%s at 0x%02lx:0x%016Lx, irq %d", card->shortname, rp->flags & 0xffL, (unsigned long long)rp->start, irq); err = snd_dbri_create(card, op, irq, dev); if (err < 0) { snd_card_free(card); return err; } dbri = card->private_data; err = snd_dbri_pcm(card); if (err < 0) goto _err; err = snd_dbri_mixer(card); if (err < 0) goto _err; /* /proc file handling */ snd_dbri_proc(card); dev_set_drvdata(&op->dev, card); err = snd_card_register(card); if (err < 0) goto _err; printk(KERN_INFO "audio%d at %p (irq %d) is DBRI(%c)+CS4215(%d)\n", dev, dbri->regs, dbri->irq, op->dev.of_node->name[9], dbri->mm.version); dev++; return 0; _err: snd_dbri_free(dbri); snd_card_free(card); return err; } static void dbri_remove(struct platform_device *op) { struct snd_card *card = dev_get_drvdata(&op->dev); snd_dbri_free(card->private_data); snd_card_free(card); } static const struct of_device_id dbri_match[] = { { .name = "SUNW,DBRIe", }, { .name = "SUNW,DBRIf", }, {}, }; MODULE_DEVICE_TABLE(of, dbri_match); static struct platform_driver dbri_sbus_driver = { .driver = { .name = "dbri", .of_match_table = dbri_match, }, .probe = dbri_probe, .remove_new = dbri_remove, }; module_platform_driver(dbri_sbus_driver);
linux-master
sound/sparc/dbri.c
// SPDX-License-Identifier: GPL-2.0-only /* * Driver for CS4231 sound chips found on Sparcs. * Copyright (C) 2002, 2008 David S. Miller <[email protected]> * * Based entirely upon drivers/sbus/audio/cs4231.c which is: * Copyright (C) 1996, 1997, 1998 Derrick J Brashear ([email protected]) * and also sound/isa/cs423x/cs4231_lib.c which is: * Copyright (c) by Jaroslav Kysela <[email protected]> */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/delay.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/moduleparam.h> #include <linux/irq.h> #include <linux/io.h> #include <linux/of.h> #include <linux/platform_device.h> #include <sound/core.h> #include <sound/pcm.h> #include <sound/info.h> #include <sound/control.h> #include <sound/timer.h> #include <sound/initval.h> #include <sound/pcm_params.h> #ifdef CONFIG_SBUS #define SBUS_SUPPORT #endif #if defined(CONFIG_PCI) && defined(CONFIG_SPARC64) #define EBUS_SUPPORT #include <linux/pci.h> #include <asm/ebus_dma.h> #endif static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ /* Enable this card */ static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for Sun CS4231 soundcard."); module_param_array(id, charp, NULL, 0444); MODULE_PARM_DESC(id, "ID string for Sun CS4231 soundcard."); module_param_array(enable, bool, NULL, 0444); MODULE_PARM_DESC(enable, "Enable Sun CS4231 soundcard."); MODULE_AUTHOR("Jaroslav Kysela, Derrick J. Brashear and David S. Miller"); MODULE_DESCRIPTION("Sun CS4231"); MODULE_LICENSE("GPL"); #ifdef SBUS_SUPPORT struct sbus_dma_info { spinlock_t lock; /* DMA access lock */ int dir; void __iomem *regs; }; #endif struct snd_cs4231; struct cs4231_dma_control { void (*prepare)(struct cs4231_dma_control *dma_cont, int dir); void (*enable)(struct cs4231_dma_control *dma_cont, int on); int (*request)(struct cs4231_dma_control *dma_cont, dma_addr_t bus_addr, size_t len); unsigned int (*address)(struct cs4231_dma_control *dma_cont); #ifdef EBUS_SUPPORT struct ebus_dma_info ebus_info; #endif #ifdef SBUS_SUPPORT struct sbus_dma_info sbus_info; #endif }; struct snd_cs4231 { spinlock_t lock; /* registers access lock */ void __iomem *port; struct cs4231_dma_control p_dma; struct cs4231_dma_control c_dma; u32 flags; #define CS4231_FLAG_EBUS 0x00000001 #define CS4231_FLAG_PLAYBACK 0x00000002 #define CS4231_FLAG_CAPTURE 0x00000004 struct snd_card *card; struct snd_pcm *pcm; struct snd_pcm_substream *playback_substream; unsigned int p_periods_sent; struct snd_pcm_substream *capture_substream; unsigned int c_periods_sent; struct snd_timer *timer; unsigned short mode; #define CS4231_MODE_NONE 0x0000 #define CS4231_MODE_PLAY 0x0001 #define CS4231_MODE_RECORD 0x0002 #define CS4231_MODE_TIMER 0x0004 #define CS4231_MODE_OPEN (CS4231_MODE_PLAY | CS4231_MODE_RECORD | \ CS4231_MODE_TIMER) unsigned char image[32]; /* registers image */ int mce_bit; int calibrate_mute; struct mutex mce_mutex; /* mutex for mce register */ struct mutex open_mutex; /* mutex for ALSA open/close */ struct platform_device *op; unsigned int irq[2]; unsigned int regs_size; struct snd_cs4231 *next; }; /* Eventually we can use sound/isa/cs423x/cs4231_lib.c directly, but for * now.... -DaveM */ /* IO ports */ #include <sound/cs4231-regs.h> /* XXX offsets are different than PC ISA chips... */ #define CS4231U(chip, x) ((chip)->port + ((c_d_c_CS4231##x) << 2)) /* SBUS DMA register defines. */ #define APCCSR 0x10UL /* APC DMA CSR */ #define APCCVA 0x20UL /* APC Capture DMA Address */ #define APCCC 0x24UL /* APC Capture Count */ #define APCCNVA 0x28UL /* APC Capture DMA Next Address */ #define APCCNC 0x2cUL /* APC Capture Next Count */ #define APCPVA 0x30UL /* APC Play DMA Address */ #define APCPC 0x34UL /* APC Play Count */ #define APCPNVA 0x38UL /* APC Play DMA Next Address */ #define APCPNC 0x3cUL /* APC Play Next Count */ /* Defines for SBUS DMA-routines */ #define APCVA 0x0UL /* APC DMA Address */ #define APCC 0x4UL /* APC Count */ #define APCNVA 0x8UL /* APC DMA Next Address */ #define APCNC 0xcUL /* APC Next Count */ #define APC_PLAY 0x30UL /* Play registers start at 0x30 */ #define APC_RECORD 0x20UL /* Record registers start at 0x20 */ /* APCCSR bits */ #define APC_INT_PENDING 0x800000 /* Interrupt Pending */ #define APC_PLAY_INT 0x400000 /* Playback interrupt */ #define APC_CAPT_INT 0x200000 /* Capture interrupt */ #define APC_GENL_INT 0x100000 /* General interrupt */ #define APC_XINT_ENA 0x80000 /* General ext int. enable */ #define APC_XINT_PLAY 0x40000 /* Playback ext intr */ #define APC_XINT_CAPT 0x20000 /* Capture ext intr */ #define APC_XINT_GENL 0x10000 /* Error ext intr */ #define APC_XINT_EMPT 0x8000 /* Pipe empty interrupt (0 write to pva) */ #define APC_XINT_PEMP 0x4000 /* Play pipe empty (pva and pnva not set) */ #define APC_XINT_PNVA 0x2000 /* Playback NVA dirty */ #define APC_XINT_PENA 0x1000 /* play pipe empty Int enable */ #define APC_XINT_COVF 0x800 /* Cap data dropped on floor */ #define APC_XINT_CNVA 0x400 /* Capture NVA dirty */ #define APC_XINT_CEMP 0x200 /* Capture pipe empty (cva and cnva not set) */ #define APC_XINT_CENA 0x100 /* Cap. pipe empty int enable */ #define APC_PPAUSE 0x80 /* Pause the play DMA */ #define APC_CPAUSE 0x40 /* Pause the capture DMA */ #define APC_CDC_RESET 0x20 /* CODEC RESET */ #define APC_PDMA_READY 0x08 /* Play DMA Go */ #define APC_CDMA_READY 0x04 /* Capture DMA Go */ #define APC_CHIP_RESET 0x01 /* Reset the chip */ /* EBUS DMA register offsets */ #define EBDMA_CSR 0x00UL /* Control/Status */ #define EBDMA_ADDR 0x04UL /* DMA Address */ #define EBDMA_COUNT 0x08UL /* DMA Count */ /* * Some variables */ static const unsigned char freq_bits[14] = { /* 5510 */ 0x00 | CS4231_XTAL2, /* 6620 */ 0x0E | CS4231_XTAL2, /* 8000 */ 0x00 | CS4231_XTAL1, /* 9600 */ 0x0E | CS4231_XTAL1, /* 11025 */ 0x02 | CS4231_XTAL2, /* 16000 */ 0x02 | CS4231_XTAL1, /* 18900 */ 0x04 | CS4231_XTAL2, /* 22050 */ 0x06 | CS4231_XTAL2, /* 27042 */ 0x04 | CS4231_XTAL1, /* 32000 */ 0x06 | CS4231_XTAL1, /* 33075 */ 0x0C | CS4231_XTAL2, /* 37800 */ 0x08 | CS4231_XTAL2, /* 44100 */ 0x0A | CS4231_XTAL2, /* 48000 */ 0x0C | CS4231_XTAL1 }; static const unsigned int rates[14] = { 5510, 6620, 8000, 9600, 11025, 16000, 18900, 22050, 27042, 32000, 33075, 37800, 44100, 48000 }; static const struct snd_pcm_hw_constraint_list hw_constraints_rates = { .count = ARRAY_SIZE(rates), .list = rates, }; static int snd_cs4231_xrate(struct snd_pcm_runtime *runtime) { return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates); } static const unsigned char snd_cs4231_original_image[32] = { 0x00, /* 00/00 - lic */ 0x00, /* 01/01 - ric */ 0x9f, /* 02/02 - la1ic */ 0x9f, /* 03/03 - ra1ic */ 0x9f, /* 04/04 - la2ic */ 0x9f, /* 05/05 - ra2ic */ 0xbf, /* 06/06 - loc */ 0xbf, /* 07/07 - roc */ 0x20, /* 08/08 - pdfr */ CS4231_AUTOCALIB, /* 09/09 - ic */ 0x00, /* 0a/10 - pc */ 0x00, /* 0b/11 - ti */ CS4231_MODE2, /* 0c/12 - mi */ 0x00, /* 0d/13 - lbc */ 0x00, /* 0e/14 - pbru */ 0x00, /* 0f/15 - pbrl */ 0x80, /* 10/16 - afei */ 0x01, /* 11/17 - afeii */ 0x9f, /* 12/18 - llic */ 0x9f, /* 13/19 - rlic */ 0x00, /* 14/20 - tlb */ 0x00, /* 15/21 - thb */ 0x00, /* 16/22 - la3mic/reserved */ 0x00, /* 17/23 - ra3mic/reserved */ 0x00, /* 18/24 - afs */ 0x00, /* 19/25 - lamoc/version */ 0x00, /* 1a/26 - mioc */ 0x00, /* 1b/27 - ramoc/reserved */ 0x20, /* 1c/28 - cdfr */ 0x00, /* 1d/29 - res4 */ 0x00, /* 1e/30 - cbru */ 0x00, /* 1f/31 - cbrl */ }; static u8 __cs4231_readb(struct snd_cs4231 *cp, void __iomem *reg_addr) { if (cp->flags & CS4231_FLAG_EBUS) return readb(reg_addr); else return sbus_readb(reg_addr); } static void __cs4231_writeb(struct snd_cs4231 *cp, u8 val, void __iomem *reg_addr) { if (cp->flags & CS4231_FLAG_EBUS) return writeb(val, reg_addr); else return sbus_writeb(val, reg_addr); } /* * Basic I/O functions */ static void snd_cs4231_ready(struct snd_cs4231 *chip) { int timeout; for (timeout = 250; timeout > 0; timeout--) { int val = __cs4231_readb(chip, CS4231U(chip, REGSEL)); if ((val & CS4231_INIT) == 0) break; udelay(100); } } static void snd_cs4231_dout(struct snd_cs4231 *chip, unsigned char reg, unsigned char value) { snd_cs4231_ready(chip); #ifdef CONFIG_SND_DEBUG if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT) snd_printdd("out: auto calibration time out - reg = 0x%x, " "value = 0x%x\n", reg, value); #endif __cs4231_writeb(chip, chip->mce_bit | reg, CS4231U(chip, REGSEL)); wmb(); __cs4231_writeb(chip, value, CS4231U(chip, REG)); mb(); } static inline void snd_cs4231_outm(struct snd_cs4231 *chip, unsigned char reg, unsigned char mask, unsigned char value) { unsigned char tmp = (chip->image[reg] & mask) | value; chip->image[reg] = tmp; if (!chip->calibrate_mute) snd_cs4231_dout(chip, reg, tmp); } static void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char value) { snd_cs4231_dout(chip, reg, value); chip->image[reg] = value; mb(); } static unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg) { snd_cs4231_ready(chip); #ifdef CONFIG_SND_DEBUG if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT) snd_printdd("in: auto calibration time out - reg = 0x%x\n", reg); #endif __cs4231_writeb(chip, chip->mce_bit | reg, CS4231U(chip, REGSEL)); mb(); return __cs4231_readb(chip, CS4231U(chip, REG)); } /* * CS4231 detection / MCE routines */ static void snd_cs4231_busy_wait(struct snd_cs4231 *chip) { int timeout; /* looks like this sequence is proper for CS4231A chip (GUS MAX) */ for (timeout = 5; timeout > 0; timeout--) __cs4231_readb(chip, CS4231U(chip, REGSEL)); /* end of cleanup sequence */ for (timeout = 500; timeout > 0; timeout--) { int val = __cs4231_readb(chip, CS4231U(chip, REGSEL)); if ((val & CS4231_INIT) == 0) break; msleep(1); } } static void snd_cs4231_mce_up(struct snd_cs4231 *chip) { unsigned long flags; int timeout; spin_lock_irqsave(&chip->lock, flags); snd_cs4231_ready(chip); #ifdef CONFIG_SND_DEBUG if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT) snd_printdd("mce_up - auto calibration time out (0)\n"); #endif chip->mce_bit |= CS4231_MCE; timeout = __cs4231_readb(chip, CS4231U(chip, REGSEL)); if (timeout == 0x80) snd_printdd("mce_up [%p]: serious init problem - " "codec still busy\n", chip->port); if (!(timeout & CS4231_MCE)) __cs4231_writeb(chip, chip->mce_bit | (timeout & 0x1f), CS4231U(chip, REGSEL)); spin_unlock_irqrestore(&chip->lock, flags); } static void snd_cs4231_mce_down(struct snd_cs4231 *chip) { unsigned long flags, timeout; int reg; snd_cs4231_busy_wait(chip); spin_lock_irqsave(&chip->lock, flags); #ifdef CONFIG_SND_DEBUG if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT) snd_printdd("mce_down [%p] - auto calibration time out (0)\n", CS4231U(chip, REGSEL)); #endif chip->mce_bit &= ~CS4231_MCE; reg = __cs4231_readb(chip, CS4231U(chip, REGSEL)); __cs4231_writeb(chip, chip->mce_bit | (reg & 0x1f), CS4231U(chip, REGSEL)); if (reg == 0x80) snd_printdd("mce_down [%p]: serious init problem " "- codec still busy\n", chip->port); if ((reg & CS4231_MCE) == 0) { spin_unlock_irqrestore(&chip->lock, flags); return; } /* * Wait for auto-calibration (AC) process to finish, i.e. ACI to go low. */ timeout = jiffies + msecs_to_jiffies(250); do { spin_unlock_irqrestore(&chip->lock, flags); msleep(1); spin_lock_irqsave(&chip->lock, flags); reg = snd_cs4231_in(chip, CS4231_TEST_INIT); reg &= CS4231_CALIB_IN_PROGRESS; } while (reg && time_before(jiffies, timeout)); spin_unlock_irqrestore(&chip->lock, flags); if (reg) snd_printk(KERN_ERR "mce_down - auto calibration time out (2)\n"); } static void snd_cs4231_advance_dma(struct cs4231_dma_control *dma_cont, struct snd_pcm_substream *substream, unsigned int *periods_sent) { struct snd_pcm_runtime *runtime = substream->runtime; while (1) { unsigned int period_size = snd_pcm_lib_period_bytes(substream); unsigned int offset = period_size * (*periods_sent); if (WARN_ON(period_size >= (1 << 24))) return; if (dma_cont->request(dma_cont, runtime->dma_addr + offset, period_size)) return; (*periods_sent) = ((*periods_sent) + 1) % runtime->periods; } } static void cs4231_dma_trigger(struct snd_pcm_substream *substream, unsigned int what, int on) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); struct cs4231_dma_control *dma_cont; if (what & CS4231_PLAYBACK_ENABLE) { dma_cont = &chip->p_dma; if (on) { dma_cont->prepare(dma_cont, 0); dma_cont->enable(dma_cont, 1); snd_cs4231_advance_dma(dma_cont, chip->playback_substream, &chip->p_periods_sent); } else { dma_cont->enable(dma_cont, 0); } } if (what & CS4231_RECORD_ENABLE) { dma_cont = &chip->c_dma; if (on) { dma_cont->prepare(dma_cont, 1); dma_cont->enable(dma_cont, 1); snd_cs4231_advance_dma(dma_cont, chip->capture_substream, &chip->c_periods_sent); } else { dma_cont->enable(dma_cont, 0); } } } static int snd_cs4231_trigger(struct snd_pcm_substream *substream, int cmd) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); int result = 0; switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_STOP: { unsigned int what = 0; struct snd_pcm_substream *s; unsigned long flags; snd_pcm_group_for_each_entry(s, substream) { if (s == chip->playback_substream) { what |= CS4231_PLAYBACK_ENABLE; snd_pcm_trigger_done(s, substream); } else if (s == chip->capture_substream) { what |= CS4231_RECORD_ENABLE; snd_pcm_trigger_done(s, substream); } } spin_lock_irqsave(&chip->lock, flags); if (cmd == SNDRV_PCM_TRIGGER_START) { cs4231_dma_trigger(substream, what, 1); chip->image[CS4231_IFACE_CTRL] |= what; } else { cs4231_dma_trigger(substream, what, 0); chip->image[CS4231_IFACE_CTRL] &= ~what; } snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]); spin_unlock_irqrestore(&chip->lock, flags); break; } default: result = -EINVAL; break; } return result; } /* * CODEC I/O */ static unsigned char snd_cs4231_get_rate(unsigned int rate) { int i; for (i = 0; i < 14; i++) if (rate == rates[i]) return freq_bits[i]; return freq_bits[13]; } static unsigned char snd_cs4231_get_format(struct snd_cs4231 *chip, int format, int channels) { unsigned char rformat; rformat = CS4231_LINEAR_8; switch (format) { case SNDRV_PCM_FORMAT_MU_LAW: rformat = CS4231_ULAW_8; break; case SNDRV_PCM_FORMAT_A_LAW: rformat = CS4231_ALAW_8; break; case SNDRV_PCM_FORMAT_S16_LE: rformat = CS4231_LINEAR_16; break; case SNDRV_PCM_FORMAT_S16_BE: rformat = CS4231_LINEAR_16_BIG; break; case SNDRV_PCM_FORMAT_IMA_ADPCM: rformat = CS4231_ADPCM_16; break; } if (channels > 1) rformat |= CS4231_STEREO; return rformat; } static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute) { unsigned long flags; mute = mute ? 1 : 0; spin_lock_irqsave(&chip->lock, flags); if (chip->calibrate_mute == mute) { spin_unlock_irqrestore(&chip->lock, flags); return; } if (!mute) { snd_cs4231_dout(chip, CS4231_LEFT_INPUT, chip->image[CS4231_LEFT_INPUT]); snd_cs4231_dout(chip, CS4231_RIGHT_INPUT, chip->image[CS4231_RIGHT_INPUT]); snd_cs4231_dout(chip, CS4231_LOOPBACK, chip->image[CS4231_LOOPBACK]); } snd_cs4231_dout(chip, CS4231_AUX1_LEFT_INPUT, mute ? 0x80 : chip->image[CS4231_AUX1_LEFT_INPUT]); snd_cs4231_dout(chip, CS4231_AUX1_RIGHT_INPUT, mute ? 0x80 : chip->image[CS4231_AUX1_RIGHT_INPUT]); snd_cs4231_dout(chip, CS4231_AUX2_LEFT_INPUT, mute ? 0x80 : chip->image[CS4231_AUX2_LEFT_INPUT]); snd_cs4231_dout(chip, CS4231_AUX2_RIGHT_INPUT, mute ? 0x80 : chip->image[CS4231_AUX2_RIGHT_INPUT]); snd_cs4231_dout(chip, CS4231_LEFT_OUTPUT, mute ? 0x80 : chip->image[CS4231_LEFT_OUTPUT]); snd_cs4231_dout(chip, CS4231_RIGHT_OUTPUT, mute ? 0x80 : chip->image[CS4231_RIGHT_OUTPUT]); snd_cs4231_dout(chip, CS4231_LEFT_LINE_IN, mute ? 0x80 : chip->image[CS4231_LEFT_LINE_IN]); snd_cs4231_dout(chip, CS4231_RIGHT_LINE_IN, mute ? 0x80 : chip->image[CS4231_RIGHT_LINE_IN]); snd_cs4231_dout(chip, CS4231_MONO_CTRL, mute ? 0xc0 : chip->image[CS4231_MONO_CTRL]); chip->calibrate_mute = mute; spin_unlock_irqrestore(&chip->lock, flags); } static void snd_cs4231_playback_format(struct snd_cs4231 *chip, struct snd_pcm_hw_params *params, unsigned char pdfr) { unsigned long flags; mutex_lock(&chip->mce_mutex); snd_cs4231_calibrate_mute(chip, 1); snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) ? (pdfr & 0xf0) | (chip->image[CS4231_REC_FORMAT] & 0x0f) : pdfr); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_down(chip); snd_cs4231_calibrate_mute(chip, 0); mutex_unlock(&chip->mce_mutex); } static void snd_cs4231_capture_format(struct snd_cs4231 *chip, struct snd_pcm_hw_params *params, unsigned char cdfr) { unsigned long flags; mutex_lock(&chip->mce_mutex); snd_cs4231_calibrate_mute(chip, 1); snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->lock, flags); if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) { snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, ((chip->image[CS4231_PLAYBK_FORMAT]) & 0xf0) | (cdfr & 0x0f)); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_down(chip); snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->lock, flags); } snd_cs4231_out(chip, CS4231_REC_FORMAT, cdfr); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_down(chip); snd_cs4231_calibrate_mute(chip, 0); mutex_unlock(&chip->mce_mutex); } /* * Timer interface */ static unsigned long snd_cs4231_timer_resolution(struct snd_timer *timer) { struct snd_cs4231 *chip = snd_timer_chip(timer); return chip->image[CS4231_PLAYBK_FORMAT] & 1 ? 9969 : 9920; } static int snd_cs4231_timer_start(struct snd_timer *timer) { unsigned long flags; unsigned int ticks; struct snd_cs4231 *chip = snd_timer_chip(timer); spin_lock_irqsave(&chip->lock, flags); ticks = timer->sticks; if ((chip->image[CS4231_ALT_FEATURE_1] & CS4231_TIMER_ENABLE) == 0 || (unsigned char)(ticks >> 8) != chip->image[CS4231_TIMER_HIGH] || (unsigned char)ticks != chip->image[CS4231_TIMER_LOW]) { snd_cs4231_out(chip, CS4231_TIMER_HIGH, chip->image[CS4231_TIMER_HIGH] = (unsigned char) (ticks >> 8)); snd_cs4231_out(chip, CS4231_TIMER_LOW, chip->image[CS4231_TIMER_LOW] = (unsigned char) ticks); snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] | CS4231_TIMER_ENABLE); } spin_unlock_irqrestore(&chip->lock, flags); return 0; } static int snd_cs4231_timer_stop(struct snd_timer *timer) { unsigned long flags; struct snd_cs4231 *chip = snd_timer_chip(timer); spin_lock_irqsave(&chip->lock, flags); chip->image[CS4231_ALT_FEATURE_1] &= ~CS4231_TIMER_ENABLE; snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1]); spin_unlock_irqrestore(&chip->lock, flags); return 0; } static void snd_cs4231_init(struct snd_cs4231 *chip) { unsigned long flags; snd_cs4231_mce_down(chip); #ifdef SNDRV_DEBUG_MCE snd_printdd("init: (1)\n"); #endif snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->lock, flags); chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO | CS4231_RECORD_ENABLE | CS4231_RECORD_PIO | CS4231_CALIB_MODE); chip->image[CS4231_IFACE_CTRL] |= CS4231_AUTOCALIB; snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_down(chip); #ifdef SNDRV_DEBUG_MCE snd_printdd("init: (2)\n"); #endif snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1]); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_down(chip); #ifdef SNDRV_DEBUG_MCE snd_printdd("init: (3) - afei = 0x%x\n", chip->image[CS4231_ALT_FEATURE_1]); #endif spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_ALT_FEATURE_2, chip->image[CS4231_ALT_FEATURE_2]); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, chip->image[CS4231_PLAYBK_FORMAT]); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_down(chip); #ifdef SNDRV_DEBUG_MCE snd_printdd("init: (4)\n"); #endif snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_REC_FORMAT, chip->image[CS4231_REC_FORMAT]); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_down(chip); #ifdef SNDRV_DEBUG_MCE snd_printdd("init: (5)\n"); #endif } static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode) { unsigned long flags; mutex_lock(&chip->open_mutex); if ((chip->mode & mode)) { mutex_unlock(&chip->open_mutex); return -EAGAIN; } if (chip->mode & CS4231_MODE_OPEN) { chip->mode |= mode; mutex_unlock(&chip->open_mutex); return 0; } /* ok. now enable and ack CODEC IRQ */ spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ | CS4231_RECORD_IRQ | CS4231_TIMER_IRQ); snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0); __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */ __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */ snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ | CS4231_RECORD_IRQ | CS4231_TIMER_IRQ); snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0); spin_unlock_irqrestore(&chip->lock, flags); chip->mode = mode; mutex_unlock(&chip->open_mutex); return 0; } static void snd_cs4231_close(struct snd_cs4231 *chip, unsigned int mode) { unsigned long flags; mutex_lock(&chip->open_mutex); chip->mode &= ~mode; if (chip->mode & CS4231_MODE_OPEN) { mutex_unlock(&chip->open_mutex); return; } snd_cs4231_calibrate_mute(chip, 1); /* disable IRQ */ spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0); __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */ __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */ /* now disable record & playback */ if (chip->image[CS4231_IFACE_CTRL] & (CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO | CS4231_RECORD_ENABLE | CS4231_RECORD_PIO)) { spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_up(chip); spin_lock_irqsave(&chip->lock, flags); chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO | CS4231_RECORD_ENABLE | CS4231_RECORD_PIO); snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_down(chip); spin_lock_irqsave(&chip->lock, flags); } /* clear IRQ again */ snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0); __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */ __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); /* clear IRQ */ spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_calibrate_mute(chip, 0); chip->mode = 0; mutex_unlock(&chip->open_mutex); } /* * timer open/close */ static int snd_cs4231_timer_open(struct snd_timer *timer) { struct snd_cs4231 *chip = snd_timer_chip(timer); snd_cs4231_open(chip, CS4231_MODE_TIMER); return 0; } static int snd_cs4231_timer_close(struct snd_timer *timer) { struct snd_cs4231 *chip = snd_timer_chip(timer); snd_cs4231_close(chip, CS4231_MODE_TIMER); return 0; } static const struct snd_timer_hardware snd_cs4231_timer_table = { .flags = SNDRV_TIMER_HW_AUTO, .resolution = 9945, .ticks = 65535, .open = snd_cs4231_timer_open, .close = snd_cs4231_timer_close, .c_resolution = snd_cs4231_timer_resolution, .start = snd_cs4231_timer_start, .stop = snd_cs4231_timer_stop, }; /* * ok.. exported functions.. */ static int snd_cs4231_playback_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); unsigned char new_pdfr; new_pdfr = snd_cs4231_get_format(chip, params_format(hw_params), params_channels(hw_params)) | snd_cs4231_get_rate(params_rate(hw_params)); snd_cs4231_playback_format(chip, hw_params, new_pdfr); return 0; } static int snd_cs4231_playback_prepare(struct snd_pcm_substream *substream) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; unsigned long flags; int ret = 0; spin_lock_irqsave(&chip->lock, flags); chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO); if (WARN_ON(runtime->period_size > 0xffff + 1)) { ret = -EINVAL; goto out; } chip->p_periods_sent = 0; out: spin_unlock_irqrestore(&chip->lock, flags); return ret; } static int snd_cs4231_capture_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *hw_params) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); unsigned char new_cdfr; new_cdfr = snd_cs4231_get_format(chip, params_format(hw_params), params_channels(hw_params)) | snd_cs4231_get_rate(params_rate(hw_params)); snd_cs4231_capture_format(chip, hw_params, new_cdfr); return 0; } static int snd_cs4231_capture_prepare(struct snd_pcm_substream *substream) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); unsigned long flags; spin_lock_irqsave(&chip->lock, flags); chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_RECORD_ENABLE | CS4231_RECORD_PIO); chip->c_periods_sent = 0; spin_unlock_irqrestore(&chip->lock, flags); return 0; } static void snd_cs4231_overrange(struct snd_cs4231 *chip) { unsigned long flags; unsigned char res; spin_lock_irqsave(&chip->lock, flags); res = snd_cs4231_in(chip, CS4231_TEST_INIT); spin_unlock_irqrestore(&chip->lock, flags); /* detect overrange only above 0dB; may be user selectable? */ if (res & (0x08 | 0x02)) chip->capture_substream->runtime->overrange++; } static void snd_cs4231_play_callback(struct snd_cs4231 *chip) { if (chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE) { snd_pcm_period_elapsed(chip->playback_substream); snd_cs4231_advance_dma(&chip->p_dma, chip->playback_substream, &chip->p_periods_sent); } } static void snd_cs4231_capture_callback(struct snd_cs4231 *chip) { if (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) { snd_pcm_period_elapsed(chip->capture_substream); snd_cs4231_advance_dma(&chip->c_dma, chip->capture_substream, &chip->c_periods_sent); } } static snd_pcm_uframes_t snd_cs4231_playback_pointer( struct snd_pcm_substream *substream) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); struct cs4231_dma_control *dma_cont = &chip->p_dma; size_t ptr; if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) return 0; ptr = dma_cont->address(dma_cont); if (ptr != 0) ptr -= substream->runtime->dma_addr; return bytes_to_frames(substream->runtime, ptr); } static snd_pcm_uframes_t snd_cs4231_capture_pointer( struct snd_pcm_substream *substream) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); struct cs4231_dma_control *dma_cont = &chip->c_dma; size_t ptr; if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE)) return 0; ptr = dma_cont->address(dma_cont); if (ptr != 0) ptr -= substream->runtime->dma_addr; return bytes_to_frames(substream->runtime, ptr); } static int snd_cs4231_probe(struct snd_cs4231 *chip) { unsigned long flags; int i; int id = 0; int vers = 0; unsigned char *ptr; for (i = 0; i < 50; i++) { mb(); if (__cs4231_readb(chip, CS4231U(chip, REGSEL)) & CS4231_INIT) msleep(2); else { spin_lock_irqsave(&chip->lock, flags); snd_cs4231_out(chip, CS4231_MISC_INFO, CS4231_MODE2); id = snd_cs4231_in(chip, CS4231_MISC_INFO) & 0x0f; vers = snd_cs4231_in(chip, CS4231_VERSION); spin_unlock_irqrestore(&chip->lock, flags); if (id == 0x0a) break; /* this is valid value */ } } snd_printdd("cs4231: port = %p, id = 0x%x\n", chip->port, id); if (id != 0x0a) return -ENODEV; /* no valid device found */ spin_lock_irqsave(&chip->lock, flags); /* clear any pendings IRQ */ __cs4231_readb(chip, CS4231U(chip, STATUS)); __cs4231_writeb(chip, 0, CS4231U(chip, STATUS)); mb(); spin_unlock_irqrestore(&chip->lock, flags); chip->image[CS4231_MISC_INFO] = CS4231_MODE2; chip->image[CS4231_IFACE_CTRL] = chip->image[CS4231_IFACE_CTRL] & ~CS4231_SINGLE_DMA; chip->image[CS4231_ALT_FEATURE_1] = 0x80; chip->image[CS4231_ALT_FEATURE_2] = 0x01; if (vers & 0x20) chip->image[CS4231_ALT_FEATURE_2] |= 0x02; ptr = (unsigned char *) &chip->image; snd_cs4231_mce_down(chip); spin_lock_irqsave(&chip->lock, flags); for (i = 0; i < 32; i++) /* ok.. fill all CS4231 registers */ snd_cs4231_out(chip, i, *ptr++); spin_unlock_irqrestore(&chip->lock, flags); snd_cs4231_mce_up(chip); snd_cs4231_mce_down(chip); mdelay(2); return 0; /* all things are ok.. */ } static const struct snd_pcm_hardware snd_cs4231_playback = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START, .formats = SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM | SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE, .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000, .rate_min = 5510, .rate_max = 48000, .channels_min = 1, .channels_max = 2, .buffer_bytes_max = 32 * 1024, .period_bytes_min = 64, .period_bytes_max = 32 * 1024, .periods_min = 1, .periods_max = 1024, }; static const struct snd_pcm_hardware snd_cs4231_capture = { .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START, .formats = SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM | SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE, .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000, .rate_min = 5510, .rate_max = 48000, .channels_min = 1, .channels_max = 2, .buffer_bytes_max = 32 * 1024, .period_bytes_min = 64, .period_bytes_max = 32 * 1024, .periods_min = 1, .periods_max = 1024, }; static int snd_cs4231_playback_open(struct snd_pcm_substream *substream) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; int err; runtime->hw = snd_cs4231_playback; err = snd_cs4231_open(chip, CS4231_MODE_PLAY); if (err < 0) return err; chip->playback_substream = substream; chip->p_periods_sent = 0; snd_pcm_set_sync(substream); snd_cs4231_xrate(runtime); return 0; } static int snd_cs4231_capture_open(struct snd_pcm_substream *substream) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; int err; runtime->hw = snd_cs4231_capture; err = snd_cs4231_open(chip, CS4231_MODE_RECORD); if (err < 0) return err; chip->capture_substream = substream; chip->c_periods_sent = 0; snd_pcm_set_sync(substream); snd_cs4231_xrate(runtime); return 0; } static int snd_cs4231_playback_close(struct snd_pcm_substream *substream) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); snd_cs4231_close(chip, CS4231_MODE_PLAY); chip->playback_substream = NULL; return 0; } static int snd_cs4231_capture_close(struct snd_pcm_substream *substream) { struct snd_cs4231 *chip = snd_pcm_substream_chip(substream); snd_cs4231_close(chip, CS4231_MODE_RECORD); chip->capture_substream = NULL; return 0; } /* XXX We can do some power-management, in particular on EBUS using * XXX the audio AUXIO register... */ static const struct snd_pcm_ops snd_cs4231_playback_ops = { .open = snd_cs4231_playback_open, .close = snd_cs4231_playback_close, .hw_params = snd_cs4231_playback_hw_params, .prepare = snd_cs4231_playback_prepare, .trigger = snd_cs4231_trigger, .pointer = snd_cs4231_playback_pointer, }; static const struct snd_pcm_ops snd_cs4231_capture_ops = { .open = snd_cs4231_capture_open, .close = snd_cs4231_capture_close, .hw_params = snd_cs4231_capture_hw_params, .prepare = snd_cs4231_capture_prepare, .trigger = snd_cs4231_trigger, .pointer = snd_cs4231_capture_pointer, }; static int snd_cs4231_pcm(struct snd_card *card) { struct snd_cs4231 *chip = card->private_data; struct snd_pcm *pcm; int err; err = snd_pcm_new(card, "CS4231", 0, 1, 1, &pcm); if (err < 0) return err; snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cs4231_playback_ops); snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cs4231_capture_ops); /* global setup */ pcm->private_data = chip; pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX; strcpy(pcm->name, "CS4231"); snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, &chip->op->dev, 64 * 1024, 128 * 1024); chip->pcm = pcm; return 0; } static int snd_cs4231_timer(struct snd_card *card) { struct snd_cs4231 *chip = card->private_data; struct snd_timer *timer; struct snd_timer_id tid; int err; /* Timer initialization */ tid.dev_class = SNDRV_TIMER_CLASS_CARD; tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE; tid.card = card->number; tid.device = 0; tid.subdevice = 0; err = snd_timer_new(card, "CS4231", &tid, &timer); if (err < 0) return err; strcpy(timer->name, "CS4231"); timer->private_data = chip; timer->hw = snd_cs4231_timer_table; chip->timer = timer; return 0; } /* * MIXER part */ static int snd_cs4231_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char * const texts[4] = { "Line", "CD", "Mic", "Mix" }; return snd_ctl_enum_info(uinfo, 2, 4, texts); } static int snd_cs4231_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; spin_lock_irqsave(&chip->lock, flags); ucontrol->value.enumerated.item[0] = (chip->image[CS4231_LEFT_INPUT] & CS4231_MIXS_ALL) >> 6; ucontrol->value.enumerated.item[1] = (chip->image[CS4231_RIGHT_INPUT] & CS4231_MIXS_ALL) >> 6; spin_unlock_irqrestore(&chip->lock, flags); return 0; } static int snd_cs4231_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; unsigned short left, right; int change; if (ucontrol->value.enumerated.item[0] > 3 || ucontrol->value.enumerated.item[1] > 3) return -EINVAL; left = ucontrol->value.enumerated.item[0] << 6; right = ucontrol->value.enumerated.item[1] << 6; spin_lock_irqsave(&chip->lock, flags); left = (chip->image[CS4231_LEFT_INPUT] & ~CS4231_MIXS_ALL) | left; right = (chip->image[CS4231_RIGHT_INPUT] & ~CS4231_MIXS_ALL) | right; change = left != chip->image[CS4231_LEFT_INPUT] || right != chip->image[CS4231_RIGHT_INPUT]; snd_cs4231_out(chip, CS4231_LEFT_INPUT, left); snd_cs4231_out(chip, CS4231_RIGHT_INPUT, right); spin_unlock_irqrestore(&chip->lock, flags); return change; } static int snd_cs4231_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { int mask = (kcontrol->private_value >> 16) & 0xff; uinfo->type = (mask == 1) ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = mask; return 0; } static int snd_cs4231_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; int invert = (kcontrol->private_value >> 24) & 0xff; spin_lock_irqsave(&chip->lock, flags); ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask; spin_unlock_irqrestore(&chip->lock, flags); if (invert) ucontrol->value.integer.value[0] = (mask - ucontrol->value.integer.value[0]); return 0; } static int snd_cs4231_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int reg = kcontrol->private_value & 0xff; int shift = (kcontrol->private_value >> 8) & 0xff; int mask = (kcontrol->private_value >> 16) & 0xff; int invert = (kcontrol->private_value >> 24) & 0xff; int change; unsigned short val; val = (ucontrol->value.integer.value[0] & mask); if (invert) val = mask - val; val <<= shift; spin_lock_irqsave(&chip->lock, flags); val = (chip->image[reg] & ~(mask << shift)) | val; change = val != chip->image[reg]; snd_cs4231_out(chip, reg, val); spin_unlock_irqrestore(&chip->lock, flags); return change; } static int snd_cs4231_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { int mask = (kcontrol->private_value >> 24) & 0xff; uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; uinfo->value.integer.max = mask; return 0; } static int snd_cs4231_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; int shift_right = (kcontrol->private_value >> 19) & 0x07; int mask = (kcontrol->private_value >> 24) & 0xff; int invert = (kcontrol->private_value >> 22) & 1; spin_lock_irqsave(&chip->lock, flags); ucontrol->value.integer.value[0] = (chip->image[left_reg] >> shift_left) & mask; ucontrol->value.integer.value[1] = (chip->image[right_reg] >> shift_right) & mask; spin_unlock_irqrestore(&chip->lock, flags); if (invert) { ucontrol->value.integer.value[0] = (mask - ucontrol->value.integer.value[0]); ucontrol->value.integer.value[1] = (mask - ucontrol->value.integer.value[1]); } return 0; } static int snd_cs4231_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol); unsigned long flags; int left_reg = kcontrol->private_value & 0xff; int right_reg = (kcontrol->private_value >> 8) & 0xff; int shift_left = (kcontrol->private_value >> 16) & 0x07; int shift_right = (kcontrol->private_value >> 19) & 0x07; int mask = (kcontrol->private_value >> 24) & 0xff; int invert = (kcontrol->private_value >> 22) & 1; int change; unsigned short val1, val2; val1 = ucontrol->value.integer.value[0] & mask; val2 = ucontrol->value.integer.value[1] & mask; if (invert) { val1 = mask - val1; val2 = mask - val2; } val1 <<= shift_left; val2 <<= shift_right; spin_lock_irqsave(&chip->lock, flags); val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1; val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2; change = val1 != chip->image[left_reg]; change |= val2 != chip->image[right_reg]; snd_cs4231_out(chip, left_reg, val1); snd_cs4231_out(chip, right_reg, val2); spin_unlock_irqrestore(&chip->lock, flags); return change; } #define CS4231_SINGLE(xname, xindex, reg, shift, mask, invert) \ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), .index = (xindex), \ .info = snd_cs4231_info_single, \ .get = snd_cs4231_get_single, .put = snd_cs4231_put_single, \ .private_value = (reg) | ((shift) << 8) | ((mask) << 16) | ((invert) << 24) } #define CS4231_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, \ shift_right, mask, invert) \ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), .index = (xindex), \ .info = snd_cs4231_info_double, \ .get = snd_cs4231_get_double, .put = snd_cs4231_put_double, \ .private_value = (left_reg) | ((right_reg) << 8) | ((shift_left) << 16) | \ ((shift_right) << 19) | ((mask) << 24) | ((invert) << 22) } static const struct snd_kcontrol_new snd_cs4231_controls[] = { CS4231_DOUBLE("PCM Playback Switch", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1), CS4231_DOUBLE("PCM Playback Volume", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1), CS4231_DOUBLE("Line Playback Switch", 0, CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1), CS4231_DOUBLE("Line Playback Volume", 0, CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1), CS4231_DOUBLE("Aux Playback Switch", 0, CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1), CS4231_DOUBLE("Aux Playback Volume", 0, CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1), CS4231_DOUBLE("Aux Playback Switch", 1, CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1), CS4231_DOUBLE("Aux Playback Volume", 1, CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1), CS4231_SINGLE("Mono Playback Switch", 0, CS4231_MONO_CTRL, 7, 1, 1), CS4231_SINGLE("Mono Playback Volume", 0, CS4231_MONO_CTRL, 0, 15, 1), CS4231_SINGLE("Mono Output Playback Switch", 0, CS4231_MONO_CTRL, 6, 1, 1), CS4231_SINGLE("Mono Output Playback Bypass", 0, CS4231_MONO_CTRL, 5, 1, 0), CS4231_DOUBLE("Capture Volume", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 0, 0, 15, 0), { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Capture Source", .info = snd_cs4231_info_mux, .get = snd_cs4231_get_mux, .put = snd_cs4231_put_mux, }, CS4231_DOUBLE("Mic Boost", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 5, 5, 1, 0), CS4231_SINGLE("Loopback Capture Switch", 0, CS4231_LOOPBACK, 0, 1, 0), CS4231_SINGLE("Loopback Capture Volume", 0, CS4231_LOOPBACK, 2, 63, 1), /* SPARC specific uses of XCTL{0,1} general purpose outputs. */ CS4231_SINGLE("Line Out Switch", 0, CS4231_PIN_CTRL, 6, 1, 1), CS4231_SINGLE("Headphone Out Switch", 0, CS4231_PIN_CTRL, 7, 1, 1) }; static int snd_cs4231_mixer(struct snd_card *card) { struct snd_cs4231 *chip = card->private_data; int err, idx; if (snd_BUG_ON(!chip || !chip->pcm)) return -EINVAL; strcpy(card->mixername, chip->pcm->name); for (idx = 0; idx < ARRAY_SIZE(snd_cs4231_controls); idx++) { err = snd_ctl_add(card, snd_ctl_new1(&snd_cs4231_controls[idx], chip)); if (err < 0) return err; } return 0; } static int dev; static int cs4231_attach_begin(struct platform_device *op, struct snd_card **rcard) { struct snd_card *card; struct snd_cs4231 *chip; int err; *rcard = NULL; if (dev >= SNDRV_CARDS) return -ENODEV; if (!enable[dev]) { dev++; return -ENOENT; } err = snd_card_new(&op->dev, index[dev], id[dev], THIS_MODULE, sizeof(struct snd_cs4231), &card); if (err < 0) return err; strcpy(card->driver, "CS4231"); strcpy(card->shortname, "Sun CS4231"); chip = card->private_data; chip->card = card; *rcard = card; return 0; } static int cs4231_attach_finish(struct snd_card *card) { struct snd_cs4231 *chip = card->private_data; int err; err = snd_cs4231_pcm(card); if (err < 0) goto out_err; err = snd_cs4231_mixer(card); if (err < 0) goto out_err; err = snd_cs4231_timer(card); if (err < 0) goto out_err; err = snd_card_register(card); if (err < 0) goto out_err; dev_set_drvdata(&chip->op->dev, chip); dev++; return 0; out_err: snd_card_free(card); return err; } #ifdef SBUS_SUPPORT static irqreturn_t snd_cs4231_sbus_interrupt(int irq, void *dev_id) { unsigned long flags; unsigned char status; u32 csr; struct snd_cs4231 *chip = dev_id; /*This is IRQ is not raised by the cs4231*/ if (!(__cs4231_readb(chip, CS4231U(chip, STATUS)) & CS4231_GLOBALIRQ)) return IRQ_NONE; /* ACK the APC interrupt. */ csr = sbus_readl(chip->port + APCCSR); sbus_writel(csr, chip->port + APCCSR); if ((csr & APC_PDMA_READY) && (csr & APC_PLAY_INT) && (csr & APC_XINT_PNVA) && !(csr & APC_XINT_EMPT)) snd_cs4231_play_callback(chip); if ((csr & APC_CDMA_READY) && (csr & APC_CAPT_INT) && (csr & APC_XINT_CNVA) && !(csr & APC_XINT_EMPT)) snd_cs4231_capture_callback(chip); status = snd_cs4231_in(chip, CS4231_IRQ_STATUS); if (status & CS4231_TIMER_IRQ) { if (chip->timer) snd_timer_interrupt(chip->timer, chip->timer->sticks); } if ((status & CS4231_RECORD_IRQ) && (csr & APC_CDMA_READY)) snd_cs4231_overrange(chip); /* ACK the CS4231 interrupt. */ spin_lock_irqsave(&chip->lock, flags); snd_cs4231_outm(chip, CS4231_IRQ_STATUS, ~CS4231_ALL_IRQS | ~status, 0); spin_unlock_irqrestore(&chip->lock, flags); return IRQ_HANDLED; } /* * SBUS DMA routines */ static int sbus_dma_request(struct cs4231_dma_control *dma_cont, dma_addr_t bus_addr, size_t len) { unsigned long flags; u32 test, csr; int err; struct sbus_dma_info *base = &dma_cont->sbus_info; if (len >= (1 << 24)) return -EINVAL; spin_lock_irqsave(&base->lock, flags); csr = sbus_readl(base->regs + APCCSR); err = -EINVAL; test = APC_CDMA_READY; if (base->dir == APC_PLAY) test = APC_PDMA_READY; if (!(csr & test)) goto out; err = -EBUSY; test = APC_XINT_CNVA; if (base->dir == APC_PLAY) test = APC_XINT_PNVA; if (!(csr & test)) goto out; err = 0; sbus_writel(bus_addr, base->regs + base->dir + APCNVA); sbus_writel(len, base->regs + base->dir + APCNC); out: spin_unlock_irqrestore(&base->lock, flags); return err; } static void sbus_dma_prepare(struct cs4231_dma_control *dma_cont, int d) { unsigned long flags; u32 csr, test; struct sbus_dma_info *base = &dma_cont->sbus_info; spin_lock_irqsave(&base->lock, flags); csr = sbus_readl(base->regs + APCCSR); test = APC_GENL_INT | APC_PLAY_INT | APC_XINT_ENA | APC_XINT_PLAY | APC_XINT_PEMP | APC_XINT_GENL | APC_XINT_PENA; if (base->dir == APC_RECORD) test = APC_GENL_INT | APC_CAPT_INT | APC_XINT_ENA | APC_XINT_CAPT | APC_XINT_CEMP | APC_XINT_GENL; csr |= test; sbus_writel(csr, base->regs + APCCSR); spin_unlock_irqrestore(&base->lock, flags); } static void sbus_dma_enable(struct cs4231_dma_control *dma_cont, int on) { unsigned long flags; u32 csr, shift; struct sbus_dma_info *base = &dma_cont->sbus_info; spin_lock_irqsave(&base->lock, flags); if (!on) { sbus_writel(0, base->regs + base->dir + APCNC); sbus_writel(0, base->regs + base->dir + APCNVA); if (base->dir == APC_PLAY) { sbus_writel(0, base->regs + base->dir + APCC); sbus_writel(0, base->regs + base->dir + APCVA); } udelay(1200); } csr = sbus_readl(base->regs + APCCSR); shift = 0; if (base->dir == APC_PLAY) shift = 1; if (on) csr &= ~(APC_CPAUSE << shift); else csr |= (APC_CPAUSE << shift); sbus_writel(csr, base->regs + APCCSR); if (on) csr |= (APC_CDMA_READY << shift); else csr &= ~(APC_CDMA_READY << shift); sbus_writel(csr, base->regs + APCCSR); spin_unlock_irqrestore(&base->lock, flags); } static unsigned int sbus_dma_addr(struct cs4231_dma_control *dma_cont) { struct sbus_dma_info *base = &dma_cont->sbus_info; return sbus_readl(base->regs + base->dir + APCVA); } /* * Init and exit routines */ static int snd_cs4231_sbus_free(struct snd_cs4231 *chip) { struct platform_device *op = chip->op; if (chip->irq[0]) free_irq(chip->irq[0], chip); if (chip->port) of_iounmap(&op->resource[0], chip->port, chip->regs_size); return 0; } static int snd_cs4231_sbus_dev_free(struct snd_device *device) { struct snd_cs4231 *cp = device->device_data; return snd_cs4231_sbus_free(cp); } static const struct snd_device_ops snd_cs4231_sbus_dev_ops = { .dev_free = snd_cs4231_sbus_dev_free, }; static int snd_cs4231_sbus_create(struct snd_card *card, struct platform_device *op, int dev) { struct snd_cs4231 *chip = card->private_data; int err; spin_lock_init(&chip->lock); spin_lock_init(&chip->c_dma.sbus_info.lock); spin_lock_init(&chip->p_dma.sbus_info.lock); mutex_init(&chip->mce_mutex); mutex_init(&chip->open_mutex); chip->op = op; chip->regs_size = resource_size(&op->resource[0]); memcpy(&chip->image, &snd_cs4231_original_image, sizeof(snd_cs4231_original_image)); chip->port = of_ioremap(&op->resource[0], 0, chip->regs_size, "cs4231"); if (!chip->port) { snd_printdd("cs4231-%d: Unable to map chip registers.\n", dev); return -EIO; } chip->c_dma.sbus_info.regs = chip->port; chip->p_dma.sbus_info.regs = chip->port; chip->c_dma.sbus_info.dir = APC_RECORD; chip->p_dma.sbus_info.dir = APC_PLAY; chip->p_dma.prepare = sbus_dma_prepare; chip->p_dma.enable = sbus_dma_enable; chip->p_dma.request = sbus_dma_request; chip->p_dma.address = sbus_dma_addr; chip->c_dma.prepare = sbus_dma_prepare; chip->c_dma.enable = sbus_dma_enable; chip->c_dma.request = sbus_dma_request; chip->c_dma.address = sbus_dma_addr; if (request_irq(op->archdata.irqs[0], snd_cs4231_sbus_interrupt, IRQF_SHARED, "cs4231", chip)) { snd_printdd("cs4231-%d: Unable to grab SBUS IRQ %d\n", dev, op->archdata.irqs[0]); snd_cs4231_sbus_free(chip); return -EBUSY; } chip->irq[0] = op->archdata.irqs[0]; if (snd_cs4231_probe(chip) < 0) { snd_cs4231_sbus_free(chip); return -ENODEV; } snd_cs4231_init(chip); err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &snd_cs4231_sbus_dev_ops); if (err < 0) { snd_cs4231_sbus_free(chip); return err; } return 0; } static int cs4231_sbus_probe(struct platform_device *op) { struct resource *rp = &op->resource[0]; struct snd_card *card; int err; err = cs4231_attach_begin(op, &card); if (err) return err; sprintf(card->longname, "%s at 0x%02lx:0x%016Lx, irq %d", card->shortname, rp->flags & 0xffL, (unsigned long long)rp->start, op->archdata.irqs[0]); err = snd_cs4231_sbus_create(card, op, dev); if (err < 0) { snd_card_free(card); return err; } return cs4231_attach_finish(card); } #endif #ifdef EBUS_SUPPORT static void snd_cs4231_ebus_play_callback(struct ebus_dma_info *p, int event, void *cookie) { struct snd_cs4231 *chip = cookie; snd_cs4231_play_callback(chip); } static void snd_cs4231_ebus_capture_callback(struct ebus_dma_info *p, int event, void *cookie) { struct snd_cs4231 *chip = cookie; snd_cs4231_capture_callback(chip); } /* * EBUS DMA wrappers */ static int _ebus_dma_request(struct cs4231_dma_control *dma_cont, dma_addr_t bus_addr, size_t len) { return ebus_dma_request(&dma_cont->ebus_info, bus_addr, len); } static void _ebus_dma_enable(struct cs4231_dma_control *dma_cont, int on) { ebus_dma_enable(&dma_cont->ebus_info, on); } static void _ebus_dma_prepare(struct cs4231_dma_control *dma_cont, int dir) { ebus_dma_prepare(&dma_cont->ebus_info, dir); } static unsigned int _ebus_dma_addr(struct cs4231_dma_control *dma_cont) { return ebus_dma_addr(&dma_cont->ebus_info); } /* * Init and exit routines */ static int snd_cs4231_ebus_free(struct snd_cs4231 *chip) { struct platform_device *op = chip->op; if (chip->c_dma.ebus_info.regs) { ebus_dma_unregister(&chip->c_dma.ebus_info); of_iounmap(&op->resource[2], chip->c_dma.ebus_info.regs, 0x10); } if (chip->p_dma.ebus_info.regs) { ebus_dma_unregister(&chip->p_dma.ebus_info); of_iounmap(&op->resource[1], chip->p_dma.ebus_info.regs, 0x10); } if (chip->port) of_iounmap(&op->resource[0], chip->port, 0x10); return 0; } static int snd_cs4231_ebus_dev_free(struct snd_device *device) { struct snd_cs4231 *cp = device->device_data; return snd_cs4231_ebus_free(cp); } static const struct snd_device_ops snd_cs4231_ebus_dev_ops = { .dev_free = snd_cs4231_ebus_dev_free, }; static int snd_cs4231_ebus_create(struct snd_card *card, struct platform_device *op, int dev) { struct snd_cs4231 *chip = card->private_data; int err; spin_lock_init(&chip->lock); spin_lock_init(&chip->c_dma.ebus_info.lock); spin_lock_init(&chip->p_dma.ebus_info.lock); mutex_init(&chip->mce_mutex); mutex_init(&chip->open_mutex); chip->flags |= CS4231_FLAG_EBUS; chip->op = op; memcpy(&chip->image, &snd_cs4231_original_image, sizeof(snd_cs4231_original_image)); strcpy(chip->c_dma.ebus_info.name, "cs4231(capture)"); chip->c_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER; chip->c_dma.ebus_info.callback = snd_cs4231_ebus_capture_callback; chip->c_dma.ebus_info.client_cookie = chip; chip->c_dma.ebus_info.irq = op->archdata.irqs[0]; strcpy(chip->p_dma.ebus_info.name, "cs4231(play)"); chip->p_dma.ebus_info.flags = EBUS_DMA_FLAG_USE_EBDMA_HANDLER; chip->p_dma.ebus_info.callback = snd_cs4231_ebus_play_callback; chip->p_dma.ebus_info.client_cookie = chip; chip->p_dma.ebus_info.irq = op->archdata.irqs[1]; chip->p_dma.prepare = _ebus_dma_prepare; chip->p_dma.enable = _ebus_dma_enable; chip->p_dma.request = _ebus_dma_request; chip->p_dma.address = _ebus_dma_addr; chip->c_dma.prepare = _ebus_dma_prepare; chip->c_dma.enable = _ebus_dma_enable; chip->c_dma.request = _ebus_dma_request; chip->c_dma.address = _ebus_dma_addr; chip->port = of_ioremap(&op->resource[0], 0, 0x10, "cs4231"); chip->p_dma.ebus_info.regs = of_ioremap(&op->resource[1], 0, 0x10, "cs4231_pdma"); chip->c_dma.ebus_info.regs = of_ioremap(&op->resource[2], 0, 0x10, "cs4231_cdma"); if (!chip->port || !chip->p_dma.ebus_info.regs || !chip->c_dma.ebus_info.regs) { snd_cs4231_ebus_free(chip); snd_printdd("cs4231-%d: Unable to map chip registers.\n", dev); return -EIO; } if (ebus_dma_register(&chip->c_dma.ebus_info)) { snd_cs4231_ebus_free(chip); snd_printdd("cs4231-%d: Unable to register EBUS capture DMA\n", dev); return -EBUSY; } if (ebus_dma_irq_enable(&chip->c_dma.ebus_info, 1)) { snd_cs4231_ebus_free(chip); snd_printdd("cs4231-%d: Unable to enable EBUS capture IRQ\n", dev); return -EBUSY; } if (ebus_dma_register(&chip->p_dma.ebus_info)) { snd_cs4231_ebus_free(chip); snd_printdd("cs4231-%d: Unable to register EBUS play DMA\n", dev); return -EBUSY; } if (ebus_dma_irq_enable(&chip->p_dma.ebus_info, 1)) { snd_cs4231_ebus_free(chip); snd_printdd("cs4231-%d: Unable to enable EBUS play IRQ\n", dev); return -EBUSY; } if (snd_cs4231_probe(chip) < 0) { snd_cs4231_ebus_free(chip); return -ENODEV; } snd_cs4231_init(chip); err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &snd_cs4231_ebus_dev_ops); if (err < 0) { snd_cs4231_ebus_free(chip); return err; } return 0; } static int cs4231_ebus_probe(struct platform_device *op) { struct snd_card *card; int err; err = cs4231_attach_begin(op, &card); if (err) return err; sprintf(card->longname, "%s at 0x%llx, irq %d", card->shortname, op->resource[0].start, op->archdata.irqs[0]); err = snd_cs4231_ebus_create(card, op, dev); if (err < 0) { snd_card_free(card); return err; } return cs4231_attach_finish(card); } #endif static int cs4231_probe(struct platform_device *op) { #ifdef EBUS_SUPPORT if (of_node_name_eq(op->dev.of_node->parent, "ebus")) return cs4231_ebus_probe(op); #endif #ifdef SBUS_SUPPORT if (of_node_name_eq(op->dev.of_node->parent, "sbus") || of_node_name_eq(op->dev.of_node->parent, "sbi")) return cs4231_sbus_probe(op); #endif return -ENODEV; } static void cs4231_remove(struct platform_device *op) { struct snd_cs4231 *chip = dev_get_drvdata(&op->dev); snd_card_free(chip->card); } static const struct of_device_id cs4231_match[] = { { .name = "SUNW,CS4231", }, { .name = "audio", .compatible = "SUNW,CS4231", }, {}, }; MODULE_DEVICE_TABLE(of, cs4231_match); static struct platform_driver cs4231_driver = { .driver = { .name = "audio", .of_match_table = cs4231_match, }, .probe = cs4231_probe, .remove_new = cs4231_remove, }; module_platform_driver(cs4231_driver);
linux-master
sound/sparc/cs4231.c
// SPDX-License-Identifier: GPL-2.0 #include <linux/kernel.h> #include <linux/of.h> #include <linux/stat.h> /* FIX UP */ #include "soundbus.h" static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) { struct soundbus_dev *sdev = to_soundbus_device(dev); struct platform_device *of = &sdev->ofdev; if (*sdev->modalias) return sysfs_emit(buf, "%s\n", sdev->modalias); else return sysfs_emit(buf, "of:N%pOFn%c%s\n", of->dev.of_node, 'T', of_node_get_device_type(of->dev.of_node)); } static DEVICE_ATTR_RO(modalias); static ssize_t name_show(struct device *dev, struct device_attribute *attr, char *buf) { struct soundbus_dev *sdev = to_soundbus_device(dev); struct platform_device *of = &sdev->ofdev; return sysfs_emit(buf, "%pOFn\n", of->dev.of_node); } static DEVICE_ATTR_RO(name); static ssize_t type_show(struct device *dev, struct device_attribute *attr, char *buf) { struct soundbus_dev *sdev = to_soundbus_device(dev); struct platform_device *of = &sdev->ofdev; return sysfs_emit(buf, "%s\n", of_node_get_device_type(of->dev.of_node)); } static DEVICE_ATTR_RO(type); struct attribute *soundbus_dev_attrs[] = { &dev_attr_name.attr, &dev_attr_type.attr, &dev_attr_modalias.attr, NULL, };
linux-master
sound/aoa/soundbus/sysfs.c
// SPDX-License-Identifier: GPL-2.0-only /* * soundbus * * Copyright 2006 Johannes Berg <[email protected]> */ #include <linux/module.h> #include "soundbus.h" MODULE_AUTHOR("Johannes Berg <[email protected]>"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Apple Soundbus"); struct soundbus_dev *soundbus_dev_get(struct soundbus_dev *dev) { struct device *tmp; if (!dev) return NULL; tmp = get_device(&dev->ofdev.dev); if (tmp) return to_soundbus_device(tmp); else return NULL; } EXPORT_SYMBOL_GPL(soundbus_dev_get); void soundbus_dev_put(struct soundbus_dev *dev) { if (dev) put_device(&dev->ofdev.dev); } EXPORT_SYMBOL_GPL(soundbus_dev_put); static int soundbus_probe(struct device *dev) { int error = -ENODEV; struct soundbus_driver *drv; struct soundbus_dev *soundbus_dev; drv = to_soundbus_driver(dev->driver); soundbus_dev = to_soundbus_device(dev); if (!drv->probe) return error; soundbus_dev_get(soundbus_dev); error = drv->probe(soundbus_dev); if (error) soundbus_dev_put(soundbus_dev); return error; } static int soundbus_uevent(const struct device *dev, struct kobj_uevent_env *env) { const struct soundbus_dev * soundbus_dev; const struct platform_device * of; const char *compat; int retval = 0; int cplen, seen = 0; if (!dev) return -ENODEV; soundbus_dev = to_soundbus_device(dev); if (!soundbus_dev) return -ENODEV; of = &soundbus_dev->ofdev; /* stuff we want to pass to /sbin/hotplug */ retval = add_uevent_var(env, "OF_NAME=%pOFn", of->dev.of_node); if (retval) return retval; retval = add_uevent_var(env, "OF_TYPE=%s", of_node_get_device_type(of->dev.of_node)); if (retval) return retval; /* Since the compatible field can contain pretty much anything * it's not really legal to split it out with commas. We split it * up using a number of environment variables instead. */ compat = of_get_property(of->dev.of_node, "compatible", &cplen); while (compat && cplen > 0) { int tmp = env->buflen; retval = add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat); if (retval) return retval; compat += env->buflen - tmp; cplen -= env->buflen - tmp; seen += 1; } retval = add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen); if (retval) return retval; retval = add_uevent_var(env, "MODALIAS=%s", soundbus_dev->modalias); return retval; } static void soundbus_device_remove(struct device *dev) { struct soundbus_dev * soundbus_dev = to_soundbus_device(dev); struct soundbus_driver * drv = to_soundbus_driver(dev->driver); if (dev->driver && drv->remove) drv->remove(soundbus_dev); soundbus_dev_put(soundbus_dev); } static void soundbus_device_shutdown(struct device *dev) { struct soundbus_dev * soundbus_dev = to_soundbus_device(dev); struct soundbus_driver * drv = to_soundbus_driver(dev->driver); if (dev->driver && drv->shutdown) drv->shutdown(soundbus_dev); } /* soundbus_dev_attrs is declared in sysfs.c */ ATTRIBUTE_GROUPS(soundbus_dev); static struct bus_type soundbus_bus_type = { .name = "aoa-soundbus", .probe = soundbus_probe, .uevent = soundbus_uevent, .remove = soundbus_device_remove, .shutdown = soundbus_device_shutdown, .dev_groups = soundbus_dev_groups, }; int soundbus_add_one(struct soundbus_dev *dev) { static int devcount; /* sanity checks */ if (!dev->attach_codec || !dev->ofdev.dev.of_node || dev->pcmname || dev->pcmid != -1) { printk(KERN_ERR "soundbus: adding device failed sanity check!\n"); return -EINVAL; } dev_set_name(&dev->ofdev.dev, "soundbus:%x", ++devcount); dev->ofdev.dev.bus = &soundbus_bus_type; return of_device_register(&dev->ofdev); } EXPORT_SYMBOL_GPL(soundbus_add_one); void soundbus_remove_one(struct soundbus_dev *dev) { of_device_unregister(&dev->ofdev); } EXPORT_SYMBOL_GPL(soundbus_remove_one); int soundbus_register_driver(struct soundbus_driver *drv) { /* initialize common driver fields */ drv->driver.name = drv->name; drv->driver.bus = &soundbus_bus_type; /* register with core */ return driver_register(&drv->driver); } EXPORT_SYMBOL_GPL(soundbus_register_driver); void soundbus_unregister_driver(struct soundbus_driver *drv) { driver_unregister(&drv->driver); } EXPORT_SYMBOL_GPL(soundbus_unregister_driver); static int __init soundbus_init(void) { return bus_register(&soundbus_bus_type); } static void __exit soundbus_exit(void) { bus_unregister(&soundbus_bus_type); } subsys_initcall(soundbus_init); module_exit(soundbus_exit);
linux-master
sound/aoa/soundbus/core.c
// SPDX-License-Identifier: GPL-2.0-only /* * i2sbus driver -- pcm routines * * Copyright 2006 Johannes Berg <[email protected]> */ #include <linux/io.h> #include <linux/delay.h> #include <linux/slab.h> #include <sound/core.h> #include <asm/macio.h> #include <linux/pci.h> #include <linux/module.h> #include "../soundbus.h" #include "i2sbus.h" static inline void get_pcm_info(struct i2sbus_dev *i2sdev, int in, struct pcm_info **pi, struct pcm_info **other) { if (in) { if (pi) *pi = &i2sdev->in; if (other) *other = &i2sdev->out; } else { if (pi) *pi = &i2sdev->out; if (other) *other = &i2sdev->in; } } static int clock_and_divisors(int mclk, int sclk, int rate, int *out) { /* sclk must be derived from mclk! */ if (mclk % sclk) return -1; /* derive sclk register value */ if (i2s_sf_sclkdiv(mclk / sclk, out)) return -1; if (I2S_CLOCK_SPEED_18MHz % (rate * mclk) == 0) { if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_18MHz / (rate * mclk), out)) { *out |= I2S_SF_CLOCK_SOURCE_18MHz; return 0; } } if (I2S_CLOCK_SPEED_45MHz % (rate * mclk) == 0) { if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_45MHz / (rate * mclk), out)) { *out |= I2S_SF_CLOCK_SOURCE_45MHz; return 0; } } if (I2S_CLOCK_SPEED_49MHz % (rate * mclk) == 0) { if (!i2s_sf_mclkdiv(I2S_CLOCK_SPEED_49MHz / (rate * mclk), out)) { *out |= I2S_SF_CLOCK_SOURCE_49MHz; return 0; } } return -1; } #define CHECK_RATE(rate) \ do { if (rates & SNDRV_PCM_RATE_ ##rate) { \ int dummy; \ if (clock_and_divisors(sysclock_factor, \ bus_factor, rate, &dummy)) \ rates &= ~SNDRV_PCM_RATE_ ##rate; \ } } while (0) static int i2sbus_pcm_open(struct i2sbus_dev *i2sdev, int in) { struct pcm_info *pi, *other; struct soundbus_dev *sdev; int masks_inited = 0, err; struct codec_info_item *cii, *rev; struct snd_pcm_hardware *hw; u64 formats = 0; unsigned int rates = 0; struct transfer_info v; int result = 0; int bus_factor = 0, sysclock_factor = 0; int found_this; mutex_lock(&i2sdev->lock); get_pcm_info(i2sdev, in, &pi, &other); hw = &pi->substream->runtime->hw; sdev = &i2sdev->sound; if (pi->active) { /* alsa messed up */ result = -EBUSY; goto out_unlock; } /* we now need to assign the hw */ list_for_each_entry(cii, &sdev->codec_list, list) { struct transfer_info *ti = cii->codec->transfers; bus_factor = cii->codec->bus_factor; sysclock_factor = cii->codec->sysclock_factor; while (ti->formats && ti->rates) { v = *ti; if (ti->transfer_in == in && cii->codec->usable(cii, ti, &v)) { if (masks_inited) { formats &= v.formats; rates &= v.rates; } else { formats = v.formats; rates = v.rates; masks_inited = 1; } } ti++; } } if (!masks_inited || !bus_factor || !sysclock_factor) { result = -ENODEV; goto out_unlock; } /* bus dependent stuff */ hw->info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_RESUME | SNDRV_PCM_INFO_JOINT_DUPLEX; CHECK_RATE(5512); CHECK_RATE(8000); CHECK_RATE(11025); CHECK_RATE(16000); CHECK_RATE(22050); CHECK_RATE(32000); CHECK_RATE(44100); CHECK_RATE(48000); CHECK_RATE(64000); CHECK_RATE(88200); CHECK_RATE(96000); CHECK_RATE(176400); CHECK_RATE(192000); hw->rates = rates; /* well. the codec might want 24 bits only, and we'll * ever only transfer 24 bits, but they are top-aligned! * So for alsa, we claim that we're doing full 32 bit * while in reality we'll ignore the lower 8 bits of * that when doing playback (they're transferred as 0 * as far as I know, no codecs we have are 32-bit capable * so I can't really test) and when doing recording we'll * always have those lower 8 bits recorded as 0 */ if (formats & SNDRV_PCM_FMTBIT_S24_BE) formats |= SNDRV_PCM_FMTBIT_S32_BE; if (formats & SNDRV_PCM_FMTBIT_U24_BE) formats |= SNDRV_PCM_FMTBIT_U32_BE; /* now mask off what we can support. I suppose we could * also support S24_3LE and some similar formats, but I * doubt there's a codec that would be able to use that, * so we don't support it here. */ hw->formats = formats & (SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_U16_BE | SNDRV_PCM_FMTBIT_S32_BE | SNDRV_PCM_FMTBIT_U32_BE); /* we need to set the highest and lowest rate possible. * These are the highest and lowest rates alsa can * support properly in its bitfield. * Below, we'll use that to restrict to the rate * currently in use (if any). */ hw->rate_min = 5512; hw->rate_max = 192000; /* if the other stream is active, then we can only * support what it is currently using. * FIXME: I lied. This comment is wrong. We can support * anything that works with the same serial format, ie. * when recording 24 bit sound we can well play 16 bit * sound at the same time iff using the same transfer mode. */ if (other->active) { /* FIXME: is this guaranteed by the alsa api? */ hw->formats &= pcm_format_to_bits(i2sdev->format); /* see above, restrict rates to the one we already have */ hw->rate_min = i2sdev->rate; hw->rate_max = i2sdev->rate; } hw->channels_min = 2; hw->channels_max = 2; /* these are somewhat arbitrary */ hw->buffer_bytes_max = 131072; hw->period_bytes_min = 256; hw->period_bytes_max = 16384; hw->periods_min = 3; hw->periods_max = MAX_DBDMA_COMMANDS; err = snd_pcm_hw_constraint_integer(pi->substream->runtime, SNDRV_PCM_HW_PARAM_PERIODS); if (err < 0) { result = err; goto out_unlock; } list_for_each_entry(cii, &sdev->codec_list, list) { if (cii->codec->open) { err = cii->codec->open(cii, pi->substream); if (err) { result = err; /* unwind */ found_this = 0; list_for_each_entry_reverse(rev, &sdev->codec_list, list) { if (found_this && rev->codec->close) { rev->codec->close(rev, pi->substream); } if (rev == cii) found_this = 1; } goto out_unlock; } } } out_unlock: mutex_unlock(&i2sdev->lock); return result; } #undef CHECK_RATE static int i2sbus_pcm_close(struct i2sbus_dev *i2sdev, int in) { struct codec_info_item *cii; struct pcm_info *pi; int err = 0, tmp; mutex_lock(&i2sdev->lock); get_pcm_info(i2sdev, in, &pi, NULL); list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { if (cii->codec->close) { tmp = cii->codec->close(cii, pi->substream); if (tmp) err = tmp; } } pi->substream = NULL; pi->active = 0; mutex_unlock(&i2sdev->lock); return err; } static void i2sbus_wait_for_stop(struct i2sbus_dev *i2sdev, struct pcm_info *pi) { unsigned long flags; DECLARE_COMPLETION_ONSTACK(done); long timeout; spin_lock_irqsave(&i2sdev->low_lock, flags); if (pi->dbdma_ring.stopping) { pi->stop_completion = &done; spin_unlock_irqrestore(&i2sdev->low_lock, flags); timeout = wait_for_completion_timeout(&done, HZ); spin_lock_irqsave(&i2sdev->low_lock, flags); pi->stop_completion = NULL; if (timeout == 0) { /* timeout expired, stop dbdma forcefully */ printk(KERN_ERR "i2sbus_wait_for_stop: timed out\n"); /* make sure RUN, PAUSE and S0 bits are cleared */ out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16); pi->dbdma_ring.stopping = 0; timeout = 10; while (in_le32(&pi->dbdma->status) & ACTIVE) { if (--timeout <= 0) break; udelay(1); } } } spin_unlock_irqrestore(&i2sdev->low_lock, flags); } #ifdef CONFIG_PM void i2sbus_wait_for_stop_both(struct i2sbus_dev *i2sdev) { struct pcm_info *pi; get_pcm_info(i2sdev, 0, &pi, NULL); i2sbus_wait_for_stop(i2sdev, pi); get_pcm_info(i2sdev, 1, &pi, NULL); i2sbus_wait_for_stop(i2sdev, pi); } #endif static inline int i2sbus_hw_free(struct snd_pcm_substream *substream, int in) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); struct pcm_info *pi; get_pcm_info(i2sdev, in, &pi, NULL); if (pi->dbdma_ring.stopping) i2sbus_wait_for_stop(i2sdev, pi); return 0; } static int i2sbus_playback_hw_free(struct snd_pcm_substream *substream) { return i2sbus_hw_free(substream, 0); } static int i2sbus_record_hw_free(struct snd_pcm_substream *substream) { return i2sbus_hw_free(substream, 1); } static int i2sbus_pcm_prepare(struct i2sbus_dev *i2sdev, int in) { /* whee. Hard work now. The user has selected a bitrate * and bit format, so now we have to program our * I2S controller appropriately. */ struct snd_pcm_runtime *runtime; struct dbdma_cmd *command; int i, periodsize, nperiods; dma_addr_t offset; struct bus_info bi; struct codec_info_item *cii; int sfr = 0; /* serial format register */ int dws = 0; /* data word sizes reg */ int input_16bit; struct pcm_info *pi, *other; int cnt; int result = 0; unsigned int cmd, stopaddr; mutex_lock(&i2sdev->lock); get_pcm_info(i2sdev, in, &pi, &other); if (pi->dbdma_ring.running) { result = -EBUSY; goto out_unlock; } if (pi->dbdma_ring.stopping) i2sbus_wait_for_stop(i2sdev, pi); if (!pi->substream || !pi->substream->runtime) { result = -EINVAL; goto out_unlock; } runtime = pi->substream->runtime; pi->active = 1; if (other->active && ((i2sdev->format != runtime->format) || (i2sdev->rate != runtime->rate))) { result = -EINVAL; goto out_unlock; } i2sdev->format = runtime->format; i2sdev->rate = runtime->rate; periodsize = snd_pcm_lib_period_bytes(pi->substream); nperiods = pi->substream->runtime->periods; pi->current_period = 0; /* generate dbdma command ring first */ command = pi->dbdma_ring.cmds; memset(command, 0, (nperiods + 2) * sizeof(struct dbdma_cmd)); /* commands to DMA to/from the ring */ /* * For input, we need to do a graceful stop; if we abort * the DMA, we end up with leftover bytes that corrupt * the next recording. To do this we set the S0 status * bit and wait for the DMA controller to stop. Each * command has a branch condition to * make it branch to a stop command if S0 is set. * On input we also need to wait for the S7 bit to be * set before turning off the DMA controller. * In fact we do the graceful stop for output as well. */ offset = runtime->dma_addr; cmd = (in? INPUT_MORE: OUTPUT_MORE) | BR_IFSET | INTR_ALWAYS; stopaddr = pi->dbdma_ring.bus_cmd_start + (nperiods + 1) * sizeof(struct dbdma_cmd); for (i = 0; i < nperiods; i++, command++, offset += periodsize) { command->command = cpu_to_le16(cmd); command->cmd_dep = cpu_to_le32(stopaddr); command->phy_addr = cpu_to_le32(offset); command->req_count = cpu_to_le16(periodsize); } /* branch back to beginning of ring */ command->command = cpu_to_le16(DBDMA_NOP | BR_ALWAYS); command->cmd_dep = cpu_to_le32(pi->dbdma_ring.bus_cmd_start); command++; /* set stop command */ command->command = cpu_to_le16(DBDMA_STOP); /* ok, let's set the serial format and stuff */ switch (runtime->format) { /* 16 bit formats */ case SNDRV_PCM_FORMAT_S16_BE: case SNDRV_PCM_FORMAT_U16_BE: /* FIXME: if we add different bus factors we need to * do more here!! */ bi.bus_factor = 0; list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { bi.bus_factor = cii->codec->bus_factor; break; } if (!bi.bus_factor) { result = -ENODEV; goto out_unlock; } input_16bit = 1; break; case SNDRV_PCM_FORMAT_S32_BE: case SNDRV_PCM_FORMAT_U32_BE: /* force 64x bus speed, otherwise the data cannot be * transferred quickly enough! */ bi.bus_factor = 64; input_16bit = 0; break; default: result = -EINVAL; goto out_unlock; } /* we assume all sysclocks are the same! */ list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { bi.sysclock_factor = cii->codec->sysclock_factor; break; } if (clock_and_divisors(bi.sysclock_factor, bi.bus_factor, runtime->rate, &sfr) < 0) { result = -EINVAL; goto out_unlock; } switch (bi.bus_factor) { case 32: sfr |= I2S_SF_SERIAL_FORMAT_I2S_32X; break; case 64: sfr |= I2S_SF_SERIAL_FORMAT_I2S_64X; break; } /* FIXME: THIS ASSUMES MASTER ALL THE TIME */ sfr |= I2S_SF_SCLK_MASTER; list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { int err = 0; if (cii->codec->prepare) err = cii->codec->prepare(cii, &bi, pi->substream); if (err) { result = err; goto out_unlock; } } /* codecs are fine with it, so set our clocks */ if (input_16bit) dws = (2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) | (2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) | I2S_DWS_DATA_IN_16BIT | I2S_DWS_DATA_OUT_16BIT; else dws = (2 << I2S_DWS_NUM_CHANNELS_IN_SHIFT) | (2 << I2S_DWS_NUM_CHANNELS_OUT_SHIFT) | I2S_DWS_DATA_IN_24BIT | I2S_DWS_DATA_OUT_24BIT; /* early exit if already programmed correctly */ /* not locking these is fine since we touch them only in this function */ if (in_le32(&i2sdev->intfregs->serial_format) == sfr && in_le32(&i2sdev->intfregs->data_word_sizes) == dws) goto out_unlock; /* let's notify the codecs about clocks going away. * For now we only do mastering on the i2s cell... */ list_for_each_entry(cii, &i2sdev->sound.codec_list, list) if (cii->codec->switch_clock) cii->codec->switch_clock(cii, CLOCK_SWITCH_PREPARE_SLAVE); i2sbus_control_enable(i2sdev->control, i2sdev); i2sbus_control_cell(i2sdev->control, i2sdev, 1); out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED); i2sbus_control_clock(i2sdev->control, i2sdev, 0); msleep(1); /* wait for clock stopped. This can apparently take a while... */ cnt = 100; while (cnt-- && !(in_le32(&i2sdev->intfregs->intr_ctl) & I2S_PENDING_CLOCKS_STOPPED)) { msleep(5); } out_le32(&i2sdev->intfregs->intr_ctl, I2S_PENDING_CLOCKS_STOPPED); /* not locking these is fine since we touch them only in this function */ out_le32(&i2sdev->intfregs->serial_format, sfr); out_le32(&i2sdev->intfregs->data_word_sizes, dws); i2sbus_control_enable(i2sdev->control, i2sdev); i2sbus_control_cell(i2sdev->control, i2sdev, 1); i2sbus_control_clock(i2sdev->control, i2sdev, 1); msleep(1); list_for_each_entry(cii, &i2sdev->sound.codec_list, list) if (cii->codec->switch_clock) cii->codec->switch_clock(cii, CLOCK_SWITCH_SLAVE); out_unlock: mutex_unlock(&i2sdev->lock); return result; } #ifdef CONFIG_PM void i2sbus_pcm_prepare_both(struct i2sbus_dev *i2sdev) { i2sbus_pcm_prepare(i2sdev, 0); i2sbus_pcm_prepare(i2sdev, 1); } #endif static int i2sbus_pcm_trigger(struct i2sbus_dev *i2sdev, int in, int cmd) { struct codec_info_item *cii; struct pcm_info *pi; int result = 0; unsigned long flags; spin_lock_irqsave(&i2sdev->low_lock, flags); get_pcm_info(i2sdev, in, &pi, NULL); switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_RESUME: if (pi->dbdma_ring.running) { result = -EALREADY; goto out_unlock; } list_for_each_entry(cii, &i2sdev->sound.codec_list, list) if (cii->codec->start) cii->codec->start(cii, pi->substream); pi->dbdma_ring.running = 1; if (pi->dbdma_ring.stopping) { /* Clear the S0 bit, then see if we stopped yet */ out_le32(&pi->dbdma->control, 1 << 16); if (in_le32(&pi->dbdma->status) & ACTIVE) { /* possible race here? */ udelay(10); if (in_le32(&pi->dbdma->status) & ACTIVE) { pi->dbdma_ring.stopping = 0; goto out_unlock; /* keep running */ } } } /* make sure RUN, PAUSE and S0 bits are cleared */ out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16); /* set branch condition select register */ out_le32(&pi->dbdma->br_sel, (1 << 16) | 1); /* write dma command buffer address to the dbdma chip */ out_le32(&pi->dbdma->cmdptr, pi->dbdma_ring.bus_cmd_start); /* initialize the frame count and current period */ pi->current_period = 0; pi->frame_count = in_le32(&i2sdev->intfregs->frame_count); /* set the DMA controller running */ out_le32(&pi->dbdma->control, (RUN << 16) | RUN); /* off you go! */ break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_SUSPEND: if (!pi->dbdma_ring.running) { result = -EALREADY; goto out_unlock; } pi->dbdma_ring.running = 0; /* Set the S0 bit to make the DMA branch to the stop cmd */ out_le32(&pi->dbdma->control, (1 << 16) | 1); pi->dbdma_ring.stopping = 1; list_for_each_entry(cii, &i2sdev->sound.codec_list, list) if (cii->codec->stop) cii->codec->stop(cii, pi->substream); break; default: result = -EINVAL; goto out_unlock; } out_unlock: spin_unlock_irqrestore(&i2sdev->low_lock, flags); return result; } static snd_pcm_uframes_t i2sbus_pcm_pointer(struct i2sbus_dev *i2sdev, int in) { struct pcm_info *pi; u32 fc; get_pcm_info(i2sdev, in, &pi, NULL); fc = in_le32(&i2sdev->intfregs->frame_count); fc = fc - pi->frame_count; if (fc >= pi->substream->runtime->buffer_size) fc %= pi->substream->runtime->buffer_size; return fc; } static inline void handle_interrupt(struct i2sbus_dev *i2sdev, int in) { struct pcm_info *pi; u32 fc, nframes; u32 status; int timeout, i; int dma_stopped = 0; struct snd_pcm_runtime *runtime; spin_lock(&i2sdev->low_lock); get_pcm_info(i2sdev, in, &pi, NULL); if (!pi->dbdma_ring.running && !pi->dbdma_ring.stopping) goto out_unlock; i = pi->current_period; runtime = pi->substream->runtime; while (pi->dbdma_ring.cmds[i].xfer_status) { if (le16_to_cpu(pi->dbdma_ring.cmds[i].xfer_status) & BT) /* * BT is the branch taken bit. If it took a branch * it is because we set the S0 bit to make it * branch to the stop command. */ dma_stopped = 1; pi->dbdma_ring.cmds[i].xfer_status = 0; if (++i >= runtime->periods) { i = 0; pi->frame_count += runtime->buffer_size; } pi->current_period = i; /* * Check the frame count. The DMA tends to get a bit * ahead of the frame counter, which confuses the core. */ fc = in_le32(&i2sdev->intfregs->frame_count); nframes = i * runtime->period_size; if (fc < pi->frame_count + nframes) pi->frame_count = fc - nframes; } if (dma_stopped) { timeout = 1000; for (;;) { status = in_le32(&pi->dbdma->status); if (!(status & ACTIVE) && (!in || (status & 0x80))) break; if (--timeout <= 0) { printk(KERN_ERR "i2sbus: timed out " "waiting for DMA to stop!\n"); break; } udelay(1); } /* Turn off DMA controller, clear S0 bit */ out_le32(&pi->dbdma->control, (RUN | PAUSE | 1) << 16); pi->dbdma_ring.stopping = 0; if (pi->stop_completion) complete(pi->stop_completion); } if (!pi->dbdma_ring.running) goto out_unlock; spin_unlock(&i2sdev->low_lock); /* may call _trigger again, hence needs to be unlocked */ snd_pcm_period_elapsed(pi->substream); return; out_unlock: spin_unlock(&i2sdev->low_lock); } irqreturn_t i2sbus_tx_intr(int irq, void *devid) { handle_interrupt((struct i2sbus_dev *)devid, 0); return IRQ_HANDLED; } irqreturn_t i2sbus_rx_intr(int irq, void *devid) { handle_interrupt((struct i2sbus_dev *)devid, 1); return IRQ_HANDLED; } static int i2sbus_playback_open(struct snd_pcm_substream *substream) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); if (!i2sdev) return -EINVAL; i2sdev->out.substream = substream; return i2sbus_pcm_open(i2sdev, 0); } static int i2sbus_playback_close(struct snd_pcm_substream *substream) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); int err; if (!i2sdev) return -EINVAL; if (i2sdev->out.substream != substream) return -EINVAL; err = i2sbus_pcm_close(i2sdev, 0); if (!err) i2sdev->out.substream = NULL; return err; } static int i2sbus_playback_prepare(struct snd_pcm_substream *substream) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); if (!i2sdev) return -EINVAL; if (i2sdev->out.substream != substream) return -EINVAL; return i2sbus_pcm_prepare(i2sdev, 0); } static int i2sbus_playback_trigger(struct snd_pcm_substream *substream, int cmd) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); if (!i2sdev) return -EINVAL; if (i2sdev->out.substream != substream) return -EINVAL; return i2sbus_pcm_trigger(i2sdev, 0, cmd); } static snd_pcm_uframes_t i2sbus_playback_pointer(struct snd_pcm_substream *substream) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); if (!i2sdev) return -EINVAL; if (i2sdev->out.substream != substream) return 0; return i2sbus_pcm_pointer(i2sdev, 0); } static const struct snd_pcm_ops i2sbus_playback_ops = { .open = i2sbus_playback_open, .close = i2sbus_playback_close, .hw_free = i2sbus_playback_hw_free, .prepare = i2sbus_playback_prepare, .trigger = i2sbus_playback_trigger, .pointer = i2sbus_playback_pointer, }; static int i2sbus_record_open(struct snd_pcm_substream *substream) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); if (!i2sdev) return -EINVAL; i2sdev->in.substream = substream; return i2sbus_pcm_open(i2sdev, 1); } static int i2sbus_record_close(struct snd_pcm_substream *substream) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); int err; if (!i2sdev) return -EINVAL; if (i2sdev->in.substream != substream) return -EINVAL; err = i2sbus_pcm_close(i2sdev, 1); if (!err) i2sdev->in.substream = NULL; return err; } static int i2sbus_record_prepare(struct snd_pcm_substream *substream) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); if (!i2sdev) return -EINVAL; if (i2sdev->in.substream != substream) return -EINVAL; return i2sbus_pcm_prepare(i2sdev, 1); } static int i2sbus_record_trigger(struct snd_pcm_substream *substream, int cmd) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); if (!i2sdev) return -EINVAL; if (i2sdev->in.substream != substream) return -EINVAL; return i2sbus_pcm_trigger(i2sdev, 1, cmd); } static snd_pcm_uframes_t i2sbus_record_pointer(struct snd_pcm_substream *substream) { struct i2sbus_dev *i2sdev = snd_pcm_substream_chip(substream); if (!i2sdev) return -EINVAL; if (i2sdev->in.substream != substream) return 0; return i2sbus_pcm_pointer(i2sdev, 1); } static const struct snd_pcm_ops i2sbus_record_ops = { .open = i2sbus_record_open, .close = i2sbus_record_close, .hw_free = i2sbus_record_hw_free, .prepare = i2sbus_record_prepare, .trigger = i2sbus_record_trigger, .pointer = i2sbus_record_pointer, }; static void i2sbus_private_free(struct snd_pcm *pcm) { struct i2sbus_dev *i2sdev = snd_pcm_chip(pcm); struct codec_info_item *p, *tmp; i2sdev->sound.pcm = NULL; i2sdev->out.created = 0; i2sdev->in.created = 0; list_for_each_entry_safe(p, tmp, &i2sdev->sound.codec_list, list) { printk(KERN_ERR "i2sbus: a codec didn't unregister!\n"); list_del(&p->list); module_put(p->codec->owner); kfree(p); } soundbus_dev_put(&i2sdev->sound); module_put(THIS_MODULE); } int i2sbus_attach_codec(struct soundbus_dev *dev, struct snd_card *card, struct codec_info *ci, void *data) { int err, in = 0, out = 0; struct transfer_info *tmp; struct i2sbus_dev *i2sdev = soundbus_dev_to_i2sbus_dev(dev); struct codec_info_item *cii; if (!dev->pcmname || dev->pcmid == -1) { printk(KERN_ERR "i2sbus: pcm name and id must be set!\n"); return -EINVAL; } list_for_each_entry(cii, &dev->codec_list, list) { if (cii->codec_data == data) return -EALREADY; } if (!ci->transfers || !ci->transfers->formats || !ci->transfers->rates || !ci->usable) return -EINVAL; /* we currently code the i2s transfer on the clock, and support only * 32 and 64 */ if (ci->bus_factor != 32 && ci->bus_factor != 64) return -EINVAL; /* If you want to fix this, you need to keep track of what transport infos * are to be used, which codecs they belong to, and then fix all the * sysclock/busclock stuff above to depend on which is usable */ list_for_each_entry(cii, &dev->codec_list, list) { if (cii->codec->sysclock_factor != ci->sysclock_factor) { printk(KERN_DEBUG "cannot yet handle multiple different sysclocks!\n"); return -EINVAL; } if (cii->codec->bus_factor != ci->bus_factor) { printk(KERN_DEBUG "cannot yet handle multiple different bus clocks!\n"); return -EINVAL; } } tmp = ci->transfers; while (tmp->formats && tmp->rates) { if (tmp->transfer_in) in = 1; else out = 1; tmp++; } cii = kzalloc(sizeof(struct codec_info_item), GFP_KERNEL); if (!cii) return -ENOMEM; /* use the private data to point to the codec info */ cii->sdev = soundbus_dev_get(dev); cii->codec = ci; cii->codec_data = data; if (!cii->sdev) { printk(KERN_DEBUG "i2sbus: failed to get soundbus dev reference\n"); err = -ENODEV; goto out_free_cii; } if (!try_module_get(THIS_MODULE)) { printk(KERN_DEBUG "i2sbus: failed to get module reference!\n"); err = -EBUSY; goto out_put_sdev; } if (!try_module_get(ci->owner)) { printk(KERN_DEBUG "i2sbus: failed to get module reference to codec owner!\n"); err = -EBUSY; goto out_put_this_module; } if (!dev->pcm) { err = snd_pcm_new(card, dev->pcmname, dev->pcmid, 0, 0, &dev->pcm); if (err) { printk(KERN_DEBUG "i2sbus: failed to create pcm\n"); goto out_put_ci_module; } } /* ALSA yet again sucks. * If it is ever fixed, remove this line. See below. */ out = in = 1; if (!i2sdev->out.created && out) { if (dev->pcm->card != card) { /* eh? */ printk(KERN_ERR "Can't attach same bus to different cards!\n"); err = -EINVAL; goto out_put_ci_module; } err = snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK, 1); if (err) goto out_put_ci_module; snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_PLAYBACK, &i2sbus_playback_ops); dev->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].dev->parent = &dev->ofdev.dev; i2sdev->out.created = 1; } if (!i2sdev->in.created && in) { if (dev->pcm->card != card) { printk(KERN_ERR "Can't attach same bus to different cards!\n"); err = -EINVAL; goto out_put_ci_module; } err = snd_pcm_new_stream(dev->pcm, SNDRV_PCM_STREAM_CAPTURE, 1); if (err) goto out_put_ci_module; snd_pcm_set_ops(dev->pcm, SNDRV_PCM_STREAM_CAPTURE, &i2sbus_record_ops); dev->pcm->streams[SNDRV_PCM_STREAM_CAPTURE].dev->parent = &dev->ofdev.dev; i2sdev->in.created = 1; } /* so we have to register the pcm after adding any substream * to it because alsa doesn't create the devices for the * substreams when we add them later. * Therefore, force in and out on both busses (above) and * register the pcm now instead of just after creating it. */ err = snd_device_register(card, dev->pcm); if (err) { printk(KERN_ERR "i2sbus: error registering new pcm\n"); goto out_put_ci_module; } /* no errors any more, so let's add this to our list */ list_add(&cii->list, &dev->codec_list); dev->pcm->private_data = i2sdev; dev->pcm->private_free = i2sbus_private_free; /* well, we really should support scatter/gather DMA */ snd_pcm_set_managed_buffer_all( dev->pcm, SNDRV_DMA_TYPE_DEV, &macio_get_pci_dev(i2sdev->macio)->dev, 64 * 1024, 64 * 1024); return 0; out_put_ci_module: module_put(ci->owner); out_put_this_module: module_put(THIS_MODULE); out_put_sdev: soundbus_dev_put(dev); out_free_cii: kfree(cii); return err; } void i2sbus_detach_codec(struct soundbus_dev *dev, void *data) { struct codec_info_item *cii = NULL, *i; list_for_each_entry(i, &dev->codec_list, list) { if (i->codec_data == data) { cii = i; break; } } if (cii) { list_del(&cii->list); module_put(cii->codec->owner); kfree(cii); } /* no more codecs, but still a pcm? */ if (list_empty(&dev->codec_list) && dev->pcm) { /* the actual cleanup is done by the callback above! */ snd_device_free(dev->pcm->card, dev->pcm); } }
linux-master
sound/aoa/soundbus/i2sbus/pcm.c
// SPDX-License-Identifier: GPL-2.0-only /* * i2sbus driver -- bus control routines * * Copyright 2006 Johannes Berg <[email protected]> */ #include <linux/kernel.h> #include <linux/delay.h> #include <linux/slab.h> #include <linux/io.h> #include <asm/prom.h> #include <asm/macio.h> #include <asm/pmac_feature.h> #include <asm/pmac_pfunc.h> #include <asm/keylargo.h> #include "i2sbus.h" int i2sbus_control_init(struct macio_dev* dev, struct i2sbus_control **c) { *c = kzalloc(sizeof(struct i2sbus_control), GFP_KERNEL); if (!*c) return -ENOMEM; INIT_LIST_HEAD(&(*c)->list); (*c)->macio = dev->bus->chip; return 0; } void i2sbus_control_destroy(struct i2sbus_control *c) { kfree(c); } /* this is serialised externally */ int i2sbus_control_add_dev(struct i2sbus_control *c, struct i2sbus_dev *i2sdev) { struct device_node *np; np = i2sdev->sound.ofdev.dev.of_node; i2sdev->enable = pmf_find_function(np, "enable"); i2sdev->cell_enable = pmf_find_function(np, "cell-enable"); i2sdev->clock_enable = pmf_find_function(np, "clock-enable"); i2sdev->cell_disable = pmf_find_function(np, "cell-disable"); i2sdev->clock_disable = pmf_find_function(np, "clock-disable"); /* if the bus number is not 0 or 1 we absolutely need to use * the platform functions -- there's nothing in Darwin that * would allow seeing a system behind what the FCRs are then, * and I don't want to go parsing a bunch of platform functions * by hand to try finding a system... */ if (i2sdev->bus_number != 0 && i2sdev->bus_number != 1 && (!i2sdev->enable || !i2sdev->cell_enable || !i2sdev->clock_enable || !i2sdev->cell_disable || !i2sdev->clock_disable)) { pmf_put_function(i2sdev->enable); pmf_put_function(i2sdev->cell_enable); pmf_put_function(i2sdev->clock_enable); pmf_put_function(i2sdev->cell_disable); pmf_put_function(i2sdev->clock_disable); return -ENODEV; } list_add(&i2sdev->item, &c->list); return 0; } void i2sbus_control_remove_dev(struct i2sbus_control *c, struct i2sbus_dev *i2sdev) { /* this is serialised externally */ list_del(&i2sdev->item); if (list_empty(&c->list)) i2sbus_control_destroy(c); } int i2sbus_control_enable(struct i2sbus_control *c, struct i2sbus_dev *i2sdev) { struct pmf_args args = { .count = 0 }; struct macio_chip *macio = c->macio; if (i2sdev->enable) return pmf_call_one(i2sdev->enable, &args); if (macio == NULL || macio->base == NULL) return -ENODEV; switch (i2sdev->bus_number) { case 0: /* these need to be locked or done through * newly created feature calls! */ MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_ENABLE); break; case 1: MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_ENABLE); break; default: return -ENODEV; } return 0; } int i2sbus_control_cell(struct i2sbus_control *c, struct i2sbus_dev *i2sdev, int enable) { struct pmf_args args = { .count = 0 }; struct macio_chip *macio = c->macio; switch (enable) { case 0: if (i2sdev->cell_disable) return pmf_call_one(i2sdev->cell_disable, &args); break; case 1: if (i2sdev->cell_enable) return pmf_call_one(i2sdev->cell_enable, &args); break; default: printk(KERN_ERR "i2sbus: INVALID CELL ENABLE VALUE\n"); return -ENODEV; } if (macio == NULL || macio->base == NULL) return -ENODEV; switch (i2sdev->bus_number) { case 0: if (enable) MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_CELL_ENABLE); else MACIO_BIC(KEYLARGO_FCR1, KL1_I2S0_CELL_ENABLE); break; case 1: if (enable) MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_CELL_ENABLE); else MACIO_BIC(KEYLARGO_FCR1, KL1_I2S1_CELL_ENABLE); break; default: return -ENODEV; } return 0; } int i2sbus_control_clock(struct i2sbus_control *c, struct i2sbus_dev *i2sdev, int enable) { struct pmf_args args = { .count = 0 }; struct macio_chip *macio = c->macio; switch (enable) { case 0: if (i2sdev->clock_disable) return pmf_call_one(i2sdev->clock_disable, &args); break; case 1: if (i2sdev->clock_enable) return pmf_call_one(i2sdev->clock_enable, &args); break; default: printk(KERN_ERR "i2sbus: INVALID CLOCK ENABLE VALUE\n"); return -ENODEV; } if (macio == NULL || macio->base == NULL) return -ENODEV; switch (i2sdev->bus_number) { case 0: if (enable) MACIO_BIS(KEYLARGO_FCR1, KL1_I2S0_CLK_ENABLE_BIT); else MACIO_BIC(KEYLARGO_FCR1, KL1_I2S0_CLK_ENABLE_BIT); break; case 1: if (enable) MACIO_BIS(KEYLARGO_FCR1, KL1_I2S1_CLK_ENABLE_BIT); else MACIO_BIC(KEYLARGO_FCR1, KL1_I2S1_CLK_ENABLE_BIT); break; default: return -ENODEV; } return 0; }
linux-master
sound/aoa/soundbus/i2sbus/control.c
// SPDX-License-Identifier: GPL-2.0-only /* * i2sbus driver * * Copyright 2006-2008 Johannes Berg <[email protected]> */ #include <linux/module.h> #include <linux/slab.h> #include <linux/pci.h> #include <linux/interrupt.h> #include <linux/dma-mapping.h> #include <linux/of_address.h> #include <linux/of_irq.h> #include <sound/core.h> #include <asm/macio.h> #include <asm/dbdma.h> #include "../soundbus.h" #include "i2sbus.h" MODULE_LICENSE("GPL"); MODULE_AUTHOR("Johannes Berg <[email protected]>"); MODULE_DESCRIPTION("Apple Soundbus: I2S support"); static int force; module_param(force, int, 0444); MODULE_PARM_DESC(force, "Force loading i2sbus even when" " no layout-id property is present"); static const struct of_device_id i2sbus_match[] = { { .name = "i2s" }, { } }; MODULE_DEVICE_TABLE(of, i2sbus_match); static int alloc_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev, struct dbdma_command_mem *r, int numcmds) { /* one more for rounding, one for branch back, one for stop command */ r->size = (numcmds + 3) * sizeof(struct dbdma_cmd); /* We use the PCI APIs for now until the generic one gets fixed * enough or until we get some macio-specific versions */ r->space = dma_alloc_coherent(&macio_get_pci_dev(i2sdev->macio)->dev, r->size, &r->bus_addr, GFP_KERNEL); if (!r->space) return -ENOMEM; r->cmds = (void*)DBDMA_ALIGN(r->space); r->bus_cmd_start = r->bus_addr + (dma_addr_t)((char*)r->cmds - (char*)r->space); return 0; } static void free_dbdma_descriptor_ring(struct i2sbus_dev *i2sdev, struct dbdma_command_mem *r) { if (!r->space) return; dma_free_coherent(&macio_get_pci_dev(i2sdev->macio)->dev, r->size, r->space, r->bus_addr); } static void i2sbus_release_dev(struct device *dev) { struct i2sbus_dev *i2sdev; int i; i2sdev = container_of(dev, struct i2sbus_dev, sound.ofdev.dev); iounmap(i2sdev->intfregs); iounmap(i2sdev->out.dbdma); iounmap(i2sdev->in.dbdma); for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) release_and_free_resource(i2sdev->allocated_resource[i]); free_dbdma_descriptor_ring(i2sdev, &i2sdev->out.dbdma_ring); free_dbdma_descriptor_ring(i2sdev, &i2sdev->in.dbdma_ring); for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) free_irq(i2sdev->interrupts[i], i2sdev); i2sbus_control_remove_dev(i2sdev->control, i2sdev); mutex_destroy(&i2sdev->lock); kfree(i2sdev); } static irqreturn_t i2sbus_bus_intr(int irq, void *devid) { struct i2sbus_dev *dev = devid; u32 intreg; spin_lock(&dev->low_lock); intreg = in_le32(&dev->intfregs->intr_ctl); /* acknowledge interrupt reasons */ out_le32(&dev->intfregs->intr_ctl, intreg); spin_unlock(&dev->low_lock); return IRQ_HANDLED; } /* * XXX FIXME: We test the layout_id's here to get the proper way of * mapping in various registers, thanks to bugs in Apple device-trees. * We could instead key off the machine model and the name of the i2s * node (i2s-a). This we'll do when we move it all to macio_asic.c * and have that export items for each sub-node too. */ static int i2sbus_get_and_fixup_rsrc(struct device_node *np, int index, int layout, struct resource *res) { struct device_node *parent; int pindex, rc = -ENXIO; const u32 *reg; /* Machines with layout 76 and 36 (K2 based) have a weird device * tree what we need to special case. * Normal machines just fetch the resource from the i2s-X node. * Darwin further divides normal machines into old and new layouts * with a subtely different code path but that doesn't seem necessary * in practice, they just bloated it. In addition, even on our K2 * case the i2s-modem node, if we ever want to handle it, uses the * normal layout */ if (layout != 76 && layout != 36) return of_address_to_resource(np, index, res); parent = of_get_parent(np); pindex = (index == aoa_resource_i2smmio) ? 0 : 1; rc = of_address_to_resource(parent, pindex, res); if (rc) goto bail; reg = of_get_property(np, "reg", NULL); if (reg == NULL) { rc = -ENXIO; goto bail; } res->start += reg[index * 2]; res->end = res->start + reg[index * 2 + 1] - 1; bail: of_node_put(parent); return rc; } /* Returns 1 if added, 0 for otherwise; don't return a negative value! */ /* FIXME: look at device node refcounting */ static int i2sbus_add_dev(struct macio_dev *macio, struct i2sbus_control *control, struct device_node *np) { struct i2sbus_dev *dev; struct device_node *child, *sound = NULL; struct resource *r; int i, layout = 0, rlen, ok = force; char node_name[6]; static const char *rnames[] = { "i2sbus: %pOFn (control)", "i2sbus: %pOFn (tx)", "i2sbus: %pOFn (rx)" }; static const irq_handler_t ints[] = { i2sbus_bus_intr, i2sbus_tx_intr, i2sbus_rx_intr }; if (snprintf(node_name, sizeof(node_name), "%pOFn", np) != 5) return 0; if (strncmp(node_name, "i2s-", 4)) return 0; dev = kzalloc(sizeof(struct i2sbus_dev), GFP_KERNEL); if (!dev) return 0; i = 0; for_each_child_of_node(np, child) { if (of_node_name_eq(child, "sound")) { i++; sound = child; } } if (i == 1) { const u32 *id = of_get_property(sound, "layout-id", NULL); if (id) { layout = *id; snprintf(dev->sound.modalias, 32, "sound-layout-%d", layout); ok = 1; } else { id = of_get_property(sound, "device-id", NULL); /* * We probably cannot handle all device-id machines, * so restrict to those we do handle for now. */ if (id && (*id == 22 || *id == 14 || *id == 35 || *id == 31 || *id == 44)) { snprintf(dev->sound.modalias, 32, "aoa-device-id-%d", *id); ok = 1; layout = -1; } } } /* for the time being, until we can handle non-layout-id * things in some fabric, refuse to attach if there is no * layout-id property or we haven't been forced to attach. * When there are two i2s busses and only one has a layout-id, * then this depends on the order, but that isn't important * either as the second one in that case is just a modem. */ if (!ok) { kfree(dev); return 0; } mutex_init(&dev->lock); spin_lock_init(&dev->low_lock); dev->sound.ofdev.archdata.dma_mask = macio->ofdev.archdata.dma_mask; dev->sound.ofdev.dev.of_node = np; dev->sound.ofdev.dev.dma_mask = &dev->sound.ofdev.archdata.dma_mask; dev->sound.ofdev.dev.parent = &macio->ofdev.dev; dev->sound.ofdev.dev.release = i2sbus_release_dev; dev->sound.attach_codec = i2sbus_attach_codec; dev->sound.detach_codec = i2sbus_detach_codec; dev->sound.pcmid = -1; dev->macio = macio; dev->control = control; dev->bus_number = node_name[4] - 'a'; INIT_LIST_HEAD(&dev->sound.codec_list); for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) { dev->interrupts[i] = -1; snprintf(dev->rnames[i], sizeof(dev->rnames[i]), rnames[i], np); } for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) { int irq = irq_of_parse_and_map(np, i); if (request_irq(irq, ints[i], 0, dev->rnames[i], dev)) goto err; dev->interrupts[i] = irq; } /* Resource handling is problematic as some device-trees contain * useless crap (ugh ugh ugh). We work around that here by calling * specific functions for calculating the appropriate resources. * * This will all be moved to macio_asic.c at one point */ for (i = aoa_resource_i2smmio; i <= aoa_resource_rxdbdma; i++) { if (i2sbus_get_and_fixup_rsrc(np,i,layout,&dev->resources[i])) goto err; /* If only we could use our resource dev->resources[i]... * but request_resource doesn't know about parents and * contained resources... */ dev->allocated_resource[i] = request_mem_region(dev->resources[i].start, resource_size(&dev->resources[i]), dev->rnames[i]); if (!dev->allocated_resource[i]) { printk(KERN_ERR "i2sbus: failed to claim resource %d!\n", i); goto err; } } r = &dev->resources[aoa_resource_i2smmio]; rlen = resource_size(r); if (rlen < sizeof(struct i2s_interface_regs)) goto err; dev->intfregs = ioremap(r->start, rlen); r = &dev->resources[aoa_resource_txdbdma]; rlen = resource_size(r); if (rlen < sizeof(struct dbdma_regs)) goto err; dev->out.dbdma = ioremap(r->start, rlen); r = &dev->resources[aoa_resource_rxdbdma]; rlen = resource_size(r); if (rlen < sizeof(struct dbdma_regs)) goto err; dev->in.dbdma = ioremap(r->start, rlen); if (!dev->intfregs || !dev->out.dbdma || !dev->in.dbdma) goto err; if (alloc_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring, MAX_DBDMA_COMMANDS)) goto err; if (alloc_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring, MAX_DBDMA_COMMANDS)) goto err; if (i2sbus_control_add_dev(dev->control, dev)) { printk(KERN_ERR "i2sbus: control layer didn't like bus\n"); goto err; } if (soundbus_add_one(&dev->sound)) { printk(KERN_DEBUG "i2sbus: device registration error!\n"); if (dev->sound.ofdev.dev.kobj.state_initialized) { soundbus_dev_put(&dev->sound); return 0; } goto err; } /* enable this cell */ i2sbus_control_cell(dev->control, dev, 1); i2sbus_control_enable(dev->control, dev); i2sbus_control_clock(dev->control, dev, 1); return 1; err: for (i=0;i<3;i++) if (dev->interrupts[i] != -1) free_irq(dev->interrupts[i], dev); free_dbdma_descriptor_ring(dev, &dev->out.dbdma_ring); free_dbdma_descriptor_ring(dev, &dev->in.dbdma_ring); iounmap(dev->intfregs); iounmap(dev->out.dbdma); iounmap(dev->in.dbdma); for (i=0;i<3;i++) release_and_free_resource(dev->allocated_resource[i]); mutex_destroy(&dev->lock); kfree(dev); return 0; } static int i2sbus_probe(struct macio_dev* dev, const struct of_device_id *match) { struct device_node *np = NULL; int got = 0, err; struct i2sbus_control *control = NULL; err = i2sbus_control_init(dev, &control); if (err) return err; if (!control) { printk(KERN_ERR "i2sbus_control_init API breakage\n"); return -ENODEV; } while ((np = of_get_next_child(dev->ofdev.dev.of_node, np))) { if (of_device_is_compatible(np, "i2sbus") || of_device_is_compatible(np, "i2s-modem")) { got += i2sbus_add_dev(dev, control, np); } } if (!got) { /* found none, clean up */ i2sbus_control_destroy(control); return -ENODEV; } dev_set_drvdata(&dev->ofdev.dev, control); return 0; } static int i2sbus_remove(struct macio_dev* dev) { struct i2sbus_control *control = dev_get_drvdata(&dev->ofdev.dev); struct i2sbus_dev *i2sdev, *tmp; list_for_each_entry_safe(i2sdev, tmp, &control->list, item) soundbus_remove_one(&i2sdev->sound); return 0; } #ifdef CONFIG_PM static int i2sbus_suspend(struct macio_dev* dev, pm_message_t state) { struct i2sbus_control *control = dev_get_drvdata(&dev->ofdev.dev); struct codec_info_item *cii; struct i2sbus_dev* i2sdev; int err, ret = 0; list_for_each_entry(i2sdev, &control->list, item) { /* Notify codecs */ list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { err = 0; if (cii->codec->suspend) err = cii->codec->suspend(cii, state); if (err) ret = err; } /* wait until streams are stopped */ i2sbus_wait_for_stop_both(i2sdev); } return ret; } static int i2sbus_resume(struct macio_dev* dev) { struct i2sbus_control *control = dev_get_drvdata(&dev->ofdev.dev); struct codec_info_item *cii; struct i2sbus_dev* i2sdev; int err, ret = 0; list_for_each_entry(i2sdev, &control->list, item) { /* reset i2s bus format etc. */ i2sbus_pcm_prepare_both(i2sdev); /* Notify codecs so they can re-initialize */ list_for_each_entry(cii, &i2sdev->sound.codec_list, list) { err = 0; if (cii->codec->resume) err = cii->codec->resume(cii); if (err) ret = err; } } return ret; } #endif /* CONFIG_PM */ static int i2sbus_shutdown(struct macio_dev* dev) { return 0; } static struct macio_driver i2sbus_drv = { .driver = { .name = "soundbus-i2s", .owner = THIS_MODULE, .of_match_table = i2sbus_match, }, .probe = i2sbus_probe, .remove = i2sbus_remove, #ifdef CONFIG_PM .suspend = i2sbus_suspend, .resume = i2sbus_resume, #endif .shutdown = i2sbus_shutdown, }; static int __init soundbus_i2sbus_init(void) { return macio_register_driver(&i2sbus_drv); } static void __exit soundbus_i2sbus_exit(void) { macio_unregister_driver(&i2sbus_drv); } module_init(soundbus_i2sbus_init); module_exit(soundbus_i2sbus_exit);
linux-master
sound/aoa/soundbus/i2sbus/core.c
// SPDX-License-Identifier: GPL-2.0-only /* * Apple Onboard Audio driver -- layout/machine id fabric * * Copyright 2006-2008 Johannes Berg <[email protected]> * * This fabric module looks for sound codecs based on the * layout-id or device-id property in the device tree. */ #include <asm/prom.h> #include <linux/list.h> #include <linux/module.h> #include <linux/slab.h> #include "../aoa.h" #include "../soundbus/soundbus.h" MODULE_AUTHOR("Johannes Berg <[email protected]>"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Layout-ID fabric for snd-aoa"); #define MAX_CODECS_PER_BUS 2 /* These are the connections the layout fabric * knows about. It doesn't really care about the * input ones, but I thought I'd separate them * to give them proper names. The thing is that * Apple usually will distinguish the active output * by GPIOs, while the active input is set directly * on the codec. Hence we here tell the codec what * we think is connected. This information is hard- * coded below ... */ #define CC_SPEAKERS (1<<0) #define CC_HEADPHONE (1<<1) #define CC_LINEOUT (1<<2) #define CC_DIGITALOUT (1<<3) #define CC_LINEIN (1<<4) #define CC_MICROPHONE (1<<5) #define CC_DIGITALIN (1<<6) /* pretty bogus but users complain... * This is a flag saying that the LINEOUT * should be renamed to HEADPHONE. * be careful with input detection! */ #define CC_LINEOUT_LABELLED_HEADPHONE (1<<7) struct codec_connection { /* CC_ flags from above */ int connected; /* codec dependent bit to be set in the aoa_codec.connected field. * This intentionally doesn't have any generic flags because the * fabric has to know the codec anyway and all codecs might have * different connectors */ int codec_bit; }; struct codec_connect_info { char *name; struct codec_connection *connections; }; #define LAYOUT_FLAG_COMBO_LINEOUT_SPDIF (1<<0) struct layout { unsigned int layout_id, device_id; struct codec_connect_info codecs[MAX_CODECS_PER_BUS]; int flags; /* if busname is not assigned, we use 'Master' below, * so that our layout table doesn't need to be filled * too much. * We only assign these two if we expect to find more * than one soundbus, i.e. on those machines with * multiple layout-ids */ char *busname; int pcmid; }; MODULE_ALIAS("sound-layout-36"); MODULE_ALIAS("sound-layout-41"); MODULE_ALIAS("sound-layout-45"); MODULE_ALIAS("sound-layout-47"); MODULE_ALIAS("sound-layout-48"); MODULE_ALIAS("sound-layout-49"); MODULE_ALIAS("sound-layout-50"); MODULE_ALIAS("sound-layout-51"); MODULE_ALIAS("sound-layout-56"); MODULE_ALIAS("sound-layout-57"); MODULE_ALIAS("sound-layout-58"); MODULE_ALIAS("sound-layout-60"); MODULE_ALIAS("sound-layout-61"); MODULE_ALIAS("sound-layout-62"); MODULE_ALIAS("sound-layout-64"); MODULE_ALIAS("sound-layout-65"); MODULE_ALIAS("sound-layout-66"); MODULE_ALIAS("sound-layout-67"); MODULE_ALIAS("sound-layout-68"); MODULE_ALIAS("sound-layout-69"); MODULE_ALIAS("sound-layout-70"); MODULE_ALIAS("sound-layout-72"); MODULE_ALIAS("sound-layout-76"); MODULE_ALIAS("sound-layout-80"); MODULE_ALIAS("sound-layout-82"); MODULE_ALIAS("sound-layout-84"); MODULE_ALIAS("sound-layout-86"); MODULE_ALIAS("sound-layout-90"); MODULE_ALIAS("sound-layout-92"); MODULE_ALIAS("sound-layout-94"); MODULE_ALIAS("sound-layout-96"); MODULE_ALIAS("sound-layout-98"); MODULE_ALIAS("sound-layout-100"); MODULE_ALIAS("aoa-device-id-14"); MODULE_ALIAS("aoa-device-id-22"); MODULE_ALIAS("aoa-device-id-31"); MODULE_ALIAS("aoa-device-id-35"); MODULE_ALIAS("aoa-device-id-44"); /* onyx with all but microphone connected */ static struct codec_connection onyx_connections_nomic[] = { { .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT, .codec_bit = 0, }, { .connected = CC_DIGITALOUT, .codec_bit = 1, }, { .connected = CC_LINEIN, .codec_bit = 2, }, {} /* terminate array by .connected == 0 */ }; /* onyx on machines without headphone */ static struct codec_connection onyx_connections_noheadphones[] = { { .connected = CC_SPEAKERS | CC_LINEOUT | CC_LINEOUT_LABELLED_HEADPHONE, .codec_bit = 0, }, { .connected = CC_DIGITALOUT, .codec_bit = 1, }, /* FIXME: are these correct? probably not for all the machines * below ... If not this will need separating. */ { .connected = CC_LINEIN, .codec_bit = 2, }, { .connected = CC_MICROPHONE, .codec_bit = 3, }, {} /* terminate array by .connected == 0 */ }; /* onyx on machines with real line-out */ static struct codec_connection onyx_connections_reallineout[] = { { .connected = CC_SPEAKERS | CC_LINEOUT | CC_HEADPHONE, .codec_bit = 0, }, { .connected = CC_DIGITALOUT, .codec_bit = 1, }, { .connected = CC_LINEIN, .codec_bit = 2, }, {} /* terminate array by .connected == 0 */ }; /* tas on machines without line out */ static struct codec_connection tas_connections_nolineout[] = { { .connected = CC_SPEAKERS | CC_HEADPHONE, .codec_bit = 0, }, { .connected = CC_LINEIN, .codec_bit = 2, }, { .connected = CC_MICROPHONE, .codec_bit = 3, }, {} /* terminate array by .connected == 0 */ }; /* tas on machines with neither line out nor line in */ static struct codec_connection tas_connections_noline[] = { { .connected = CC_SPEAKERS | CC_HEADPHONE, .codec_bit = 0, }, { .connected = CC_MICROPHONE, .codec_bit = 3, }, {} /* terminate array by .connected == 0 */ }; /* tas on machines without microphone */ static struct codec_connection tas_connections_nomic[] = { { .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT, .codec_bit = 0, }, { .connected = CC_LINEIN, .codec_bit = 2, }, {} /* terminate array by .connected == 0 */ }; /* tas on machines with everything connected */ static struct codec_connection tas_connections_all[] = { { .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT, .codec_bit = 0, }, { .connected = CC_LINEIN, .codec_bit = 2, }, { .connected = CC_MICROPHONE, .codec_bit = 3, }, {} /* terminate array by .connected == 0 */ }; static struct codec_connection toonie_connections[] = { { .connected = CC_SPEAKERS | CC_HEADPHONE, .codec_bit = 0, }, {} /* terminate array by .connected == 0 */ }; static struct codec_connection topaz_input[] = { { .connected = CC_DIGITALIN, .codec_bit = 0, }, {} /* terminate array by .connected == 0 */ }; static struct codec_connection topaz_output[] = { { .connected = CC_DIGITALOUT, .codec_bit = 1, }, {} /* terminate array by .connected == 0 */ }; static struct codec_connection topaz_inout[] = { { .connected = CC_DIGITALIN, .codec_bit = 0, }, { .connected = CC_DIGITALOUT, .codec_bit = 1, }, {} /* terminate array by .connected == 0 */ }; static struct layout layouts[] = { /* last PowerBooks (15" Oct 2005) */ { .layout_id = 82, .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, .codecs[1] = { .name = "topaz", .connections = topaz_input, }, }, /* PowerMac9,1 */ { .layout_id = 60, .codecs[0] = { .name = "onyx", .connections = onyx_connections_reallineout, }, }, /* PowerMac9,1 */ { .layout_id = 61, .codecs[0] = { .name = "topaz", .connections = topaz_input, }, }, /* PowerBook5,7 */ { .layout_id = 64, .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, }, /* PowerBook5,7 */ { .layout_id = 65, .codecs[0] = { .name = "topaz", .connections = topaz_input, }, }, /* PowerBook5,9 [17" Oct 2005] */ { .layout_id = 84, .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, .codecs[1] = { .name = "topaz", .connections = topaz_input, }, }, /* PowerMac8,1 */ { .layout_id = 45, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, .codecs[1] = { .name = "topaz", .connections = topaz_input, }, }, /* Quad PowerMac (analog in, analog/digital out) */ { .layout_id = 68, .codecs[0] = { .name = "onyx", .connections = onyx_connections_nomic, }, }, /* Quad PowerMac (digital in) */ { .layout_id = 69, .codecs[0] = { .name = "topaz", .connections = topaz_input, }, .busname = "digital in", .pcmid = 1 }, /* Early 2005 PowerBook (PowerBook 5,6) */ { .layout_id = 70, .codecs[0] = { .name = "tas", .connections = tas_connections_nolineout, }, }, /* PowerBook 5,4 */ { .layout_id = 51, .codecs[0] = { .name = "tas", .connections = tas_connections_nolineout, }, }, /* PowerBook6,1 */ { .device_id = 31, .codecs[0] = { .name = "tas", .connections = tas_connections_nolineout, }, }, /* PowerBook6,5 */ { .device_id = 44, .codecs[0] = { .name = "tas", .connections = tas_connections_all, }, }, /* PowerBook6,7 */ { .layout_id = 80, .codecs[0] = { .name = "tas", .connections = tas_connections_noline, }, }, /* PowerBook6,8 */ { .layout_id = 72, .codecs[0] = { .name = "tas", .connections = tas_connections_nolineout, }, }, /* PowerMac8,2 */ { .layout_id = 86, .codecs[0] = { .name = "onyx", .connections = onyx_connections_nomic, }, .codecs[1] = { .name = "topaz", .connections = topaz_input, }, }, /* PowerBook6,7 */ { .layout_id = 92, .codecs[0] = { .name = "tas", .connections = tas_connections_nolineout, }, }, /* PowerMac10,1 (Mac Mini) */ { .layout_id = 58, .codecs[0] = { .name = "toonie", .connections = toonie_connections, }, }, { .layout_id = 96, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, }, /* unknown, untested, but this comes from Apple */ { .layout_id = 41, .codecs[0] = { .name = "tas", .connections = tas_connections_all, }, }, { .layout_id = 36, .codecs[0] = { .name = "tas", .connections = tas_connections_nomic, }, .codecs[1] = { .name = "topaz", .connections = topaz_inout, }, }, { .layout_id = 47, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, }, { .layout_id = 48, .codecs[0] = { .name = "topaz", .connections = topaz_input, }, }, { .layout_id = 49, .codecs[0] = { .name = "onyx", .connections = onyx_connections_nomic, }, }, { .layout_id = 50, .codecs[0] = { .name = "topaz", .connections = topaz_input, }, }, { .layout_id = 56, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, }, { .layout_id = 57, .codecs[0] = { .name = "topaz", .connections = topaz_input, }, }, { .layout_id = 62, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, .codecs[1] = { .name = "topaz", .connections = topaz_output, }, }, { .layout_id = 66, .codecs[0] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, }, { .layout_id = 67, .codecs[0] = { .name = "topaz", .connections = topaz_input, }, }, { .layout_id = 76, .codecs[0] = { .name = "tas", .connections = tas_connections_nomic, }, .codecs[1] = { .name = "topaz", .connections = topaz_inout, }, }, { .layout_id = 90, .codecs[0] = { .name = "tas", .connections = tas_connections_noline, }, }, { .layout_id = 94, .codecs[0] = { .name = "onyx", /* but it has an external mic?? how to select? */ .connections = onyx_connections_noheadphones, }, }, { .layout_id = 98, .codecs[0] = { .name = "toonie", .connections = toonie_connections, }, }, { .layout_id = 100, .codecs[0] = { .name = "topaz", .connections = topaz_input, }, .codecs[1] = { .name = "onyx", .connections = onyx_connections_noheadphones, }, }, /* PowerMac3,4 */ { .device_id = 14, .codecs[0] = { .name = "tas", .connections = tas_connections_noline, }, }, /* PowerMac3,6 */ { .device_id = 22, .codecs[0] = { .name = "tas", .connections = tas_connections_all, }, }, /* PowerBook5,2 */ { .device_id = 35, .codecs[0] = { .name = "tas", .connections = tas_connections_all, }, }, {} }; static struct layout *find_layout_by_id(unsigned int id) { struct layout *l; l = layouts; while (l->codecs[0].name) { if (l->layout_id == id) return l; l++; } return NULL; } static struct layout *find_layout_by_device(unsigned int id) { struct layout *l; l = layouts; while (l->codecs[0].name) { if (l->device_id == id) return l; l++; } return NULL; } static void use_layout(struct layout *l) { int i; for (i=0; i<MAX_CODECS_PER_BUS; i++) { if (l->codecs[i].name) { request_module("snd-aoa-codec-%s", l->codecs[i].name); } } /* now we wait for the codecs to call us back */ } struct layout_dev; struct layout_dev_ptr { struct layout_dev *ptr; }; struct layout_dev { struct list_head list; struct soundbus_dev *sdev; struct device_node *sound; struct aoa_codec *codecs[MAX_CODECS_PER_BUS]; struct layout *layout; struct gpio_runtime gpio; /* we need these for headphone/lineout detection */ struct snd_kcontrol *headphone_ctrl; struct snd_kcontrol *lineout_ctrl; struct snd_kcontrol *speaker_ctrl; struct snd_kcontrol *master_ctrl; struct snd_kcontrol *headphone_detected_ctrl; struct snd_kcontrol *lineout_detected_ctrl; struct layout_dev_ptr selfptr_headphone; struct layout_dev_ptr selfptr_lineout; u32 have_lineout_detect:1, have_headphone_detect:1, switch_on_headphone:1, switch_on_lineout:1; }; static LIST_HEAD(layouts_list); static int layouts_list_items; /* this can go away but only if we allow multiple cards, * make the fabric handle all the card stuff, etc... */ static struct layout_dev *layout_device; #define control_info snd_ctl_boolean_mono_info #define AMP_CONTROL(n, description) \ static int n##_control_get(struct snd_kcontrol *kcontrol, \ struct snd_ctl_elem_value *ucontrol) \ { \ struct gpio_runtime *gpio = snd_kcontrol_chip(kcontrol); \ if (gpio->methods && gpio->methods->get_##n) \ ucontrol->value.integer.value[0] = \ gpio->methods->get_##n(gpio); \ return 0; \ } \ static int n##_control_put(struct snd_kcontrol *kcontrol, \ struct snd_ctl_elem_value *ucontrol) \ { \ struct gpio_runtime *gpio = snd_kcontrol_chip(kcontrol); \ if (gpio->methods && gpio->methods->set_##n) \ gpio->methods->set_##n(gpio, \ !!ucontrol->value.integer.value[0]); \ return 1; \ } \ static const struct snd_kcontrol_new n##_ctl = { \ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ .name = description, \ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ .info = control_info, \ .get = n##_control_get, \ .put = n##_control_put, \ } AMP_CONTROL(headphone, "Headphone Switch"); AMP_CONTROL(speakers, "Speakers Switch"); AMP_CONTROL(lineout, "Line-Out Switch"); AMP_CONTROL(master, "Master Switch"); static int detect_choice_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct layout_dev *ldev = snd_kcontrol_chip(kcontrol); switch (kcontrol->private_value) { case 0: ucontrol->value.integer.value[0] = ldev->switch_on_headphone; break; case 1: ucontrol->value.integer.value[0] = ldev->switch_on_lineout; break; default: return -ENODEV; } return 0; } static int detect_choice_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct layout_dev *ldev = snd_kcontrol_chip(kcontrol); switch (kcontrol->private_value) { case 0: ldev->switch_on_headphone = !!ucontrol->value.integer.value[0]; break; case 1: ldev->switch_on_lineout = !!ucontrol->value.integer.value[0]; break; default: return -ENODEV; } return 1; } static const struct snd_kcontrol_new headphone_detect_choice = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Headphone Detect Autoswitch", .info = control_info, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .get = detect_choice_get, .put = detect_choice_put, .private_value = 0, }; static const struct snd_kcontrol_new lineout_detect_choice = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line-Out Detect Autoswitch", .info = control_info, .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .get = detect_choice_get, .put = detect_choice_put, .private_value = 1, }; static int detected_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct layout_dev *ldev = snd_kcontrol_chip(kcontrol); int v; switch (kcontrol->private_value) { case 0: v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_HEADPHONE); break; case 1: v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_LINE_OUT); break; default: return -ENODEV; } ucontrol->value.integer.value[0] = v; return 0; } static const struct snd_kcontrol_new headphone_detected = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Headphone Detected", .info = control_info, .access = SNDRV_CTL_ELEM_ACCESS_READ, .get = detected_get, .private_value = 0, }; static const struct snd_kcontrol_new lineout_detected = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Line-Out Detected", .info = control_info, .access = SNDRV_CTL_ELEM_ACCESS_READ, .get = detected_get, .private_value = 1, }; static int check_codec(struct aoa_codec *codec, struct layout_dev *ldev, struct codec_connect_info *cci) { const u32 *ref; char propname[32]; struct codec_connection *cc; /* if the codec has a 'codec' node, we require a reference */ if (of_node_name_eq(codec->node, "codec")) { snprintf(propname, sizeof(propname), "platform-%s-codec-ref", codec->name); ref = of_get_property(ldev->sound, propname, NULL); if (!ref) { printk(KERN_INFO "snd-aoa-fabric-layout: " "required property %s not present\n", propname); return -ENODEV; } if (*ref != codec->node->phandle) { printk(KERN_INFO "snd-aoa-fabric-layout: " "%s doesn't match!\n", propname); return -ENODEV; } } else { if (layouts_list_items != 1) { printk(KERN_INFO "snd-aoa-fabric-layout: " "more than one soundbus, but no references.\n"); return -ENODEV; } } codec->soundbus_dev = ldev->sdev; codec->gpio = &ldev->gpio; cc = cci->connections; if (!cc) return -EINVAL; printk(KERN_INFO "snd-aoa-fabric-layout: can use this codec\n"); codec->connected = 0; codec->fabric_data = cc; while (cc->connected) { codec->connected |= 1<<cc->codec_bit; cc++; } return 0; } static int layout_found_codec(struct aoa_codec *codec) { struct layout_dev *ldev; int i; list_for_each_entry(ldev, &layouts_list, list) { for (i=0; i<MAX_CODECS_PER_BUS; i++) { if (!ldev->layout->codecs[i].name) continue; if (strcmp(ldev->layout->codecs[i].name, codec->name) == 0) { if (check_codec(codec, ldev, &ldev->layout->codecs[i]) == 0) return 0; } } } return -ENODEV; } static void layout_remove_codec(struct aoa_codec *codec) { int i; /* here remove the codec from the layout dev's * codec reference */ codec->soundbus_dev = NULL; codec->gpio = NULL; for (i=0; i<MAX_CODECS_PER_BUS; i++) { } } static void layout_notify(void *data) { struct layout_dev_ptr *dptr = data; struct layout_dev *ldev; int v, update; struct snd_kcontrol *detected, *c; struct snd_card *card = aoa_get_card(); ldev = dptr->ptr; if (data == &ldev->selfptr_headphone) { v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_HEADPHONE); detected = ldev->headphone_detected_ctrl; update = ldev->switch_on_headphone; if (update) { ldev->gpio.methods->set_speakers(&ldev->gpio, !v); ldev->gpio.methods->set_headphone(&ldev->gpio, v); ldev->gpio.methods->set_lineout(&ldev->gpio, 0); } } else if (data == &ldev->selfptr_lineout) { v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_LINE_OUT); detected = ldev->lineout_detected_ctrl; update = ldev->switch_on_lineout; if (update) { ldev->gpio.methods->set_speakers(&ldev->gpio, !v); ldev->gpio.methods->set_headphone(&ldev->gpio, 0); ldev->gpio.methods->set_lineout(&ldev->gpio, v); } } else return; if (detected) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &detected->id); if (update) { c = ldev->headphone_ctrl; if (c) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id); c = ldev->speaker_ctrl; if (c) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id); c = ldev->lineout_ctrl; if (c) snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id); } } static void layout_attached_codec(struct aoa_codec *codec) { struct codec_connection *cc; struct snd_kcontrol *ctl; int headphones, lineout; struct layout_dev *ldev = layout_device; /* need to add this codec to our codec array! */ cc = codec->fabric_data; headphones = codec->gpio->methods->get_detect(codec->gpio, AOA_NOTIFY_HEADPHONE); lineout = codec->gpio->methods->get_detect(codec->gpio, AOA_NOTIFY_LINE_OUT); if (codec->gpio->methods->set_master) { ctl = snd_ctl_new1(&master_ctl, codec->gpio); ldev->master_ctrl = ctl; aoa_snd_ctl_add(ctl); } while (cc->connected) { if (cc->connected & CC_SPEAKERS) { if (headphones <= 0 && lineout <= 0) ldev->gpio.methods->set_speakers(codec->gpio, 1); ctl = snd_ctl_new1(&speakers_ctl, codec->gpio); ldev->speaker_ctrl = ctl; aoa_snd_ctl_add(ctl); } if (cc->connected & CC_HEADPHONE) { if (headphones == 1) ldev->gpio.methods->set_headphone(codec->gpio, 1); ctl = snd_ctl_new1(&headphone_ctl, codec->gpio); ldev->headphone_ctrl = ctl; aoa_snd_ctl_add(ctl); ldev->have_headphone_detect = !ldev->gpio.methods ->set_notify(&ldev->gpio, AOA_NOTIFY_HEADPHONE, layout_notify, &ldev->selfptr_headphone); if (ldev->have_headphone_detect) { ctl = snd_ctl_new1(&headphone_detect_choice, ldev); aoa_snd_ctl_add(ctl); ctl = snd_ctl_new1(&headphone_detected, ldev); ldev->headphone_detected_ctrl = ctl; aoa_snd_ctl_add(ctl); } } if (cc->connected & CC_LINEOUT) { if (lineout == 1) ldev->gpio.methods->set_lineout(codec->gpio, 1); ctl = snd_ctl_new1(&lineout_ctl, codec->gpio); if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) strscpy(ctl->id.name, "Headphone Switch", sizeof(ctl->id.name)); ldev->lineout_ctrl = ctl; aoa_snd_ctl_add(ctl); ldev->have_lineout_detect = !ldev->gpio.methods ->set_notify(&ldev->gpio, AOA_NOTIFY_LINE_OUT, layout_notify, &ldev->selfptr_lineout); if (ldev->have_lineout_detect) { ctl = snd_ctl_new1(&lineout_detect_choice, ldev); if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) strscpy(ctl->id.name, "Headphone Detect Autoswitch", sizeof(ctl->id.name)); aoa_snd_ctl_add(ctl); ctl = snd_ctl_new1(&lineout_detected, ldev); if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) strscpy(ctl->id.name, "Headphone Detected", sizeof(ctl->id.name)); ldev->lineout_detected_ctrl = ctl; aoa_snd_ctl_add(ctl); } } cc++; } /* now update initial state */ if (ldev->have_headphone_detect) layout_notify(&ldev->selfptr_headphone); if (ldev->have_lineout_detect) layout_notify(&ldev->selfptr_lineout); } static struct aoa_fabric layout_fabric = { .name = "SoundByLayout", .owner = THIS_MODULE, .found_codec = layout_found_codec, .remove_codec = layout_remove_codec, .attached_codec = layout_attached_codec, }; static int aoa_fabric_layout_probe(struct soundbus_dev *sdev) { struct device_node *sound = NULL; const unsigned int *id; struct layout *layout = NULL; struct layout_dev *ldev = NULL; int err; /* hm, currently we can only have one ... */ if (layout_device) return -ENODEV; /* by breaking out we keep a reference */ for_each_child_of_node(sdev->ofdev.dev.of_node, sound) { if (of_node_is_type(sound, "soundchip")) break; } if (!sound) return -ENODEV; id = of_get_property(sound, "layout-id", NULL); if (id) { layout = find_layout_by_id(*id); } else { id = of_get_property(sound, "device-id", NULL); if (id) layout = find_layout_by_device(*id); } if (!layout) { printk(KERN_ERR "snd-aoa-fabric-layout: unknown layout\n"); goto outnodev; } ldev = kzalloc(sizeof(struct layout_dev), GFP_KERNEL); if (!ldev) goto outnodev; layout_device = ldev; ldev->sdev = sdev; ldev->sound = sound; ldev->layout = layout; ldev->gpio.node = sound->parent; switch (layout->layout_id) { case 0: /* anything with device_id, not layout_id */ case 41: /* that unknown machine no one seems to have */ case 51: /* PowerBook5,4 */ case 58: /* Mac Mini */ ldev->gpio.methods = ftr_gpio_methods; printk(KERN_DEBUG "snd-aoa-fabric-layout: Using direct GPIOs\n"); break; default: ldev->gpio.methods = pmf_gpio_methods; printk(KERN_DEBUG "snd-aoa-fabric-layout: Using PMF GPIOs\n"); } ldev->selfptr_headphone.ptr = ldev; ldev->selfptr_lineout.ptr = ldev; dev_set_drvdata(&sdev->ofdev.dev, ldev); list_add(&ldev->list, &layouts_list); layouts_list_items++; /* assign these before registering ourselves, so * callbacks that are done during registration * already have the values */ sdev->pcmid = ldev->layout->pcmid; if (ldev->layout->busname) { sdev->pcmname = ldev->layout->busname; } else { sdev->pcmname = "Master"; } ldev->gpio.methods->init(&ldev->gpio); err = aoa_fabric_register(&layout_fabric, &sdev->ofdev.dev); if (err && err != -EALREADY) { printk(KERN_INFO "snd-aoa-fabric-layout: can't use," " another fabric is active!\n"); goto outlistdel; } use_layout(layout); ldev->switch_on_headphone = 1; ldev->switch_on_lineout = 1; return 0; outlistdel: /* we won't be using these then... */ ldev->gpio.methods->exit(&ldev->gpio); /* reset if we didn't use it */ sdev->pcmname = NULL; sdev->pcmid = -1; list_del(&ldev->list); layouts_list_items--; kfree(ldev); outnodev: of_node_put(sound); layout_device = NULL; return -ENODEV; } static void aoa_fabric_layout_remove(struct soundbus_dev *sdev) { struct layout_dev *ldev = dev_get_drvdata(&sdev->ofdev.dev); int i; for (i=0; i<MAX_CODECS_PER_BUS; i++) { if (ldev->codecs[i]) { aoa_fabric_unlink_codec(ldev->codecs[i]); } ldev->codecs[i] = NULL; } list_del(&ldev->list); layouts_list_items--; of_node_put(ldev->sound); ldev->gpio.methods->set_notify(&ldev->gpio, AOA_NOTIFY_HEADPHONE, NULL, NULL); ldev->gpio.methods->set_notify(&ldev->gpio, AOA_NOTIFY_LINE_OUT, NULL, NULL); ldev->gpio.methods->exit(&ldev->gpio); layout_device = NULL; kfree(ldev); sdev->pcmid = -1; sdev->pcmname = NULL; } #ifdef CONFIG_PM_SLEEP static int aoa_fabric_layout_suspend(struct device *dev) { struct layout_dev *ldev = dev_get_drvdata(dev); if (ldev->gpio.methods && ldev->gpio.methods->all_amps_off) ldev->gpio.methods->all_amps_off(&ldev->gpio); return 0; } static int aoa_fabric_layout_resume(struct device *dev) { struct layout_dev *ldev = dev_get_drvdata(dev); if (ldev->gpio.methods && ldev->gpio.methods->all_amps_restore) ldev->gpio.methods->all_amps_restore(&ldev->gpio); return 0; } static SIMPLE_DEV_PM_OPS(aoa_fabric_layout_pm_ops, aoa_fabric_layout_suspend, aoa_fabric_layout_resume); #endif static struct soundbus_driver aoa_soundbus_driver = { .name = "snd_aoa_soundbus_drv", .owner = THIS_MODULE, .probe = aoa_fabric_layout_probe, .remove = aoa_fabric_layout_remove, .driver = { .owner = THIS_MODULE, #ifdef CONFIG_PM_SLEEP .pm = &aoa_fabric_layout_pm_ops, #endif } }; static int __init aoa_fabric_layout_init(void) { return soundbus_register_driver(&aoa_soundbus_driver); } static void __exit aoa_fabric_layout_exit(void) { soundbus_unregister_driver(&aoa_soundbus_driver); aoa_fabric_unregister(&layout_fabric); } module_init(aoa_fabric_layout_init); module_exit(aoa_fabric_layout_exit);
linux-master
sound/aoa/fabrics/layout.c
// SPDX-License-Identifier: GPL-2.0-only /* * Apple Onboard Audio driver for tas codec * * Copyright 2006 Johannes Berg <[email protected]> * * Open questions: * - How to distinguish between 3004 and versions? * * FIXMEs: * - This codec driver doesn't honour the 'connected' * property of the aoa_codec struct, hence if * it is used in machines where not everything is * connected it will display wrong mixer elements. * - Driver assumes that the microphone is always * monaureal and connected to the right channel of * the input. This should also be a codec-dependent * flag, maybe the codec should have 3 different * bits for the three different possibilities how * it can be hooked up... * But as long as I don't see any hardware hooked * up that way... * - As Apple notes in their code, the tas3004 seems * to delay the right channel by one sample. You can * see this when for example recording stereo in * audacity, or recording the tas output via cable * on another machine (use a sinus generator or so). * I tried programming the BiQuads but couldn't * make the delay work, maybe someone can read the * datasheet and fix it. The relevant Apple comment * is in AppleTAS3004Audio.cpp lines 1637 ff. Note * that their comment describing how they program * the filters sucks... * * Other things: * - this should actually register *two* aoa_codec * structs since it has two inputs. Then it must * use the prepare callback to forbid running the * secondary output on a different clock. * Also, whatever bus knows how to do this must * provide two soundbus_dev devices and the fabric * must be able to link them correctly. * * I don't even know if Apple ever uses the second * port on the tas3004 though, I don't think their * i2s controllers can even do it. OTOH, they all * derive the clocks from common clocks, so it * might just be possible. The framework allows the * codec to refine the transfer_info items in the * usable callback, so we can simply remove the * rates the second instance is not using when it * actually is in use. * Maybe we'll need to make the sound busses have * a 'clock group id' value so the codec can * determine if the two outputs can be driven at * the same time. But that is likely overkill, up * to the fabric to not link them up incorrectly, * and up to the hardware designer to not wire * them up in some weird unusable way. */ #include <linux/i2c.h> #include <asm/pmac_low_i2c.h> #include <asm/prom.h> #include <linux/delay.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/slab.h> MODULE_AUTHOR("Johannes Berg <[email protected]>"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("tas codec driver for snd-aoa"); #include "tas.h" #include "tas-gain-table.h" #include "tas-basstreble.h" #include "../aoa.h" #include "../soundbus/soundbus.h" #define PFX "snd-aoa-codec-tas: " struct tas { struct aoa_codec codec; struct i2c_client *i2c; u32 mute_l:1, mute_r:1 , controls_created:1 , drc_enabled:1, hw_enabled:1; u8 cached_volume_l, cached_volume_r; u8 mixer_l[3], mixer_r[3]; u8 bass, treble; u8 acr; int drc_range; /* protects hardware access against concurrency from * userspace when hitting controls and during * codec init/suspend/resume */ struct mutex mtx; }; static int tas_reset_init(struct tas *tas); static struct tas *codec_to_tas(struct aoa_codec *codec) { return container_of(codec, struct tas, codec); } static inline int tas_write_reg(struct tas *tas, u8 reg, u8 len, u8 *data) { if (len == 1) return i2c_smbus_write_byte_data(tas->i2c, reg, *data); else return i2c_smbus_write_i2c_block_data(tas->i2c, reg, len, data); } static void tas3004_set_drc(struct tas *tas) { unsigned char val[6]; if (tas->drc_enabled) val[0] = 0x50; /* 3:1 above threshold */ else val[0] = 0x51; /* disabled */ val[1] = 0x02; /* 1:1 below threshold */ if (tas->drc_range > 0xef) val[2] = 0xef; else if (tas->drc_range < 0) val[2] = 0x00; else val[2] = tas->drc_range; val[3] = 0xb0; val[4] = 0x60; val[5] = 0xa0; tas_write_reg(tas, TAS_REG_DRC, 6, val); } static void tas_set_treble(struct tas *tas) { u8 tmp; tmp = tas3004_treble(tas->treble); tas_write_reg(tas, TAS_REG_TREBLE, 1, &tmp); } static void tas_set_bass(struct tas *tas) { u8 tmp; tmp = tas3004_bass(tas->bass); tas_write_reg(tas, TAS_REG_BASS, 1, &tmp); } static void tas_set_volume(struct tas *tas) { u8 block[6]; int tmp; u8 left, right; left = tas->cached_volume_l; right = tas->cached_volume_r; if (left > 177) left = 177; if (right > 177) right = 177; if (tas->mute_l) left = 0; if (tas->mute_r) right = 0; /* analysing the volume and mixer tables shows * that they are similar enough when we shift * the mixer table down by 4 bits. The error * is miniscule, in just one item the error * is 1, at a value of 0x07f17b (mixer table * value is 0x07f17a) */ tmp = tas_gaintable[left]; block[0] = tmp>>20; block[1] = tmp>>12; block[2] = tmp>>4; tmp = tas_gaintable[right]; block[3] = tmp>>20; block[4] = tmp>>12; block[5] = tmp>>4; tas_write_reg(tas, TAS_REG_VOL, 6, block); } static void tas_set_mixer(struct tas *tas) { u8 block[9]; int tmp, i; u8 val; for (i=0;i<3;i++) { val = tas->mixer_l[i]; if (val > 177) val = 177; tmp = tas_gaintable[val]; block[3*i+0] = tmp>>16; block[3*i+1] = tmp>>8; block[3*i+2] = tmp; } tas_write_reg(tas, TAS_REG_LMIX, 9, block); for (i=0;i<3;i++) { val = tas->mixer_r[i]; if (val > 177) val = 177; tmp = tas_gaintable[val]; block[3*i+0] = tmp>>16; block[3*i+1] = tmp>>8; block[3*i+2] = tmp; } tas_write_reg(tas, TAS_REG_RMIX, 9, block); } /* alsa stuff */ static int tas_dev_register(struct snd_device *dev) { return 0; } static const struct snd_device_ops ops = { .dev_register = tas_dev_register, }; static int tas_snd_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; uinfo->value.integer.max = 177; return 0; } static int tas_snd_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); ucontrol->value.integer.value[0] = tas->cached_volume_l; ucontrol->value.integer.value[1] = tas->cached_volume_r; mutex_unlock(&tas->mtx); return 0; } static int tas_snd_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); if (ucontrol->value.integer.value[0] < 0 || ucontrol->value.integer.value[0] > 177) return -EINVAL; if (ucontrol->value.integer.value[1] < 0 || ucontrol->value.integer.value[1] > 177) return -EINVAL; mutex_lock(&tas->mtx); if (tas->cached_volume_l == ucontrol->value.integer.value[0] && tas->cached_volume_r == ucontrol->value.integer.value[1]) { mutex_unlock(&tas->mtx); return 0; } tas->cached_volume_l = ucontrol->value.integer.value[0]; tas->cached_volume_r = ucontrol->value.integer.value[1]; if (tas->hw_enabled) tas_set_volume(tas); mutex_unlock(&tas->mtx); return 1; } static const struct snd_kcontrol_new volume_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Volume", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = tas_snd_vol_info, .get = tas_snd_vol_get, .put = tas_snd_vol_put, }; #define tas_snd_mute_info snd_ctl_boolean_stereo_info static int tas_snd_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); ucontrol->value.integer.value[0] = !tas->mute_l; ucontrol->value.integer.value[1] = !tas->mute_r; mutex_unlock(&tas->mtx); return 0; } static int tas_snd_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); if (tas->mute_l == !ucontrol->value.integer.value[0] && tas->mute_r == !ucontrol->value.integer.value[1]) { mutex_unlock(&tas->mtx); return 0; } tas->mute_l = !ucontrol->value.integer.value[0]; tas->mute_r = !ucontrol->value.integer.value[1]; if (tas->hw_enabled) tas_set_volume(tas); mutex_unlock(&tas->mtx); return 1; } static const struct snd_kcontrol_new mute_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Switch", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = tas_snd_mute_info, .get = tas_snd_mute_get, .put = tas_snd_mute_put, }; static int tas_snd_mixer_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = 0; uinfo->value.integer.max = 177; return 0; } static int tas_snd_mixer_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); int idx = kcontrol->private_value; mutex_lock(&tas->mtx); ucontrol->value.integer.value[0] = tas->mixer_l[idx]; ucontrol->value.integer.value[1] = tas->mixer_r[idx]; mutex_unlock(&tas->mtx); return 0; } static int tas_snd_mixer_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); int idx = kcontrol->private_value; mutex_lock(&tas->mtx); if (tas->mixer_l[idx] == ucontrol->value.integer.value[0] && tas->mixer_r[idx] == ucontrol->value.integer.value[1]) { mutex_unlock(&tas->mtx); return 0; } tas->mixer_l[idx] = ucontrol->value.integer.value[0]; tas->mixer_r[idx] = ucontrol->value.integer.value[1]; if (tas->hw_enabled) tas_set_mixer(tas); mutex_unlock(&tas->mtx); return 1; } #define MIXER_CONTROL(n,descr,idx) \ static const struct snd_kcontrol_new n##_control = { \ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ .name = descr " Playback Volume", \ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ .info = tas_snd_mixer_info, \ .get = tas_snd_mixer_get, \ .put = tas_snd_mixer_put, \ .private_value = idx, \ } MIXER_CONTROL(pcm1, "PCM", 0); MIXER_CONTROL(monitor, "Monitor", 2); static int tas_snd_drc_range_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 0; uinfo->value.integer.max = TAS3004_DRC_MAX; return 0; } static int tas_snd_drc_range_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); ucontrol->value.integer.value[0] = tas->drc_range; mutex_unlock(&tas->mtx); return 0; } static int tas_snd_drc_range_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); if (ucontrol->value.integer.value[0] < 0 || ucontrol->value.integer.value[0] > TAS3004_DRC_MAX) return -EINVAL; mutex_lock(&tas->mtx); if (tas->drc_range == ucontrol->value.integer.value[0]) { mutex_unlock(&tas->mtx); return 0; } tas->drc_range = ucontrol->value.integer.value[0]; if (tas->hw_enabled) tas3004_set_drc(tas); mutex_unlock(&tas->mtx); return 1; } static const struct snd_kcontrol_new drc_range_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "DRC Range", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = tas_snd_drc_range_info, .get = tas_snd_drc_range_get, .put = tas_snd_drc_range_put, }; #define tas_snd_drc_switch_info snd_ctl_boolean_mono_info static int tas_snd_drc_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); ucontrol->value.integer.value[0] = tas->drc_enabled; mutex_unlock(&tas->mtx); return 0; } static int tas_snd_drc_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); if (tas->drc_enabled == ucontrol->value.integer.value[0]) { mutex_unlock(&tas->mtx); return 0; } tas->drc_enabled = !!ucontrol->value.integer.value[0]; if (tas->hw_enabled) tas3004_set_drc(tas); mutex_unlock(&tas->mtx); return 1; } static const struct snd_kcontrol_new drc_switch_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "DRC Range Switch", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = tas_snd_drc_switch_info, .get = tas_snd_drc_switch_get, .put = tas_snd_drc_switch_put, }; static int tas_snd_capture_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char * const texts[] = { "Line-In", "Microphone" }; return snd_ctl_enum_info(uinfo, 1, 2, texts); } static int tas_snd_capture_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); ucontrol->value.enumerated.item[0] = !!(tas->acr & TAS_ACR_INPUT_B); mutex_unlock(&tas->mtx); return 0; } static int tas_snd_capture_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); int oldacr; if (ucontrol->value.enumerated.item[0] > 1) return -EINVAL; mutex_lock(&tas->mtx); oldacr = tas->acr; /* * Despite what the data sheet says in one place, the * TAS_ACR_B_MONAUREAL bit forces mono output even when * input A (line in) is selected. */ tas->acr &= ~(TAS_ACR_INPUT_B | TAS_ACR_B_MONAUREAL); if (ucontrol->value.enumerated.item[0]) tas->acr |= TAS_ACR_INPUT_B | TAS_ACR_B_MONAUREAL | TAS_ACR_B_MON_SEL_RIGHT; if (oldacr == tas->acr) { mutex_unlock(&tas->mtx); return 0; } if (tas->hw_enabled) tas_write_reg(tas, TAS_REG_ACR, 1, &tas->acr); mutex_unlock(&tas->mtx); return 1; } static const struct snd_kcontrol_new capture_source_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, /* If we name this 'Input Source', it properly shows up in * alsamixer as a selection, * but it's shown under the * 'Playback' category. * If I name it 'Capture Source', it shows up in strange * ways (two bools of which one can be selected at a * time) but at least it's shown in the 'Capture' * category. * I was told that this was due to backward compatibility, * but I don't understand then why the mangling is *not* * done when I name it "Input Source"..... */ .name = "Capture Source", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = tas_snd_capture_source_info, .get = tas_snd_capture_source_get, .put = tas_snd_capture_source_put, }; static int tas_snd_treble_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = TAS3004_TREBLE_MIN; uinfo->value.integer.max = TAS3004_TREBLE_MAX; return 0; } static int tas_snd_treble_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); ucontrol->value.integer.value[0] = tas->treble; mutex_unlock(&tas->mtx); return 0; } static int tas_snd_treble_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); if (ucontrol->value.integer.value[0] < TAS3004_TREBLE_MIN || ucontrol->value.integer.value[0] > TAS3004_TREBLE_MAX) return -EINVAL; mutex_lock(&tas->mtx); if (tas->treble == ucontrol->value.integer.value[0]) { mutex_unlock(&tas->mtx); return 0; } tas->treble = ucontrol->value.integer.value[0]; if (tas->hw_enabled) tas_set_treble(tas); mutex_unlock(&tas->mtx); return 1; } static const struct snd_kcontrol_new treble_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Treble", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = tas_snd_treble_info, .get = tas_snd_treble_get, .put = tas_snd_treble_put, }; static int tas_snd_bass_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = TAS3004_BASS_MIN; uinfo->value.integer.max = TAS3004_BASS_MAX; return 0; } static int tas_snd_bass_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); mutex_lock(&tas->mtx); ucontrol->value.integer.value[0] = tas->bass; mutex_unlock(&tas->mtx); return 0; } static int tas_snd_bass_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct tas *tas = snd_kcontrol_chip(kcontrol); if (ucontrol->value.integer.value[0] < TAS3004_BASS_MIN || ucontrol->value.integer.value[0] > TAS3004_BASS_MAX) return -EINVAL; mutex_lock(&tas->mtx); if (tas->bass == ucontrol->value.integer.value[0]) { mutex_unlock(&tas->mtx); return 0; } tas->bass = ucontrol->value.integer.value[0]; if (tas->hw_enabled) tas_set_bass(tas); mutex_unlock(&tas->mtx); return 1; } static const struct snd_kcontrol_new bass_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Bass", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = tas_snd_bass_info, .get = tas_snd_bass_get, .put = tas_snd_bass_put, }; static struct transfer_info tas_transfers[] = { { /* input */ .formats = SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S24_BE, .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .transfer_in = 1, }, { /* output */ .formats = SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S24_BE, .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .transfer_in = 0, }, {} }; static int tas_usable(struct codec_info_item *cii, struct transfer_info *ti, struct transfer_info *out) { return 1; } static int tas_reset_init(struct tas *tas) { u8 tmp; tas->codec.gpio->methods->all_amps_off(tas->codec.gpio); msleep(5); tas->codec.gpio->methods->set_hw_reset(tas->codec.gpio, 0); msleep(5); tas->codec.gpio->methods->set_hw_reset(tas->codec.gpio, 1); msleep(20); tas->codec.gpio->methods->set_hw_reset(tas->codec.gpio, 0); msleep(10); tas->codec.gpio->methods->all_amps_restore(tas->codec.gpio); tmp = TAS_MCS_SCLK64 | TAS_MCS_SPORT_MODE_I2S | TAS_MCS_SPORT_WL_24BIT; if (tas_write_reg(tas, TAS_REG_MCS, 1, &tmp)) goto outerr; tas->acr |= TAS_ACR_ANALOG_PDOWN; if (tas_write_reg(tas, TAS_REG_ACR, 1, &tas->acr)) goto outerr; tmp = 0; if (tas_write_reg(tas, TAS_REG_MCS2, 1, &tmp)) goto outerr; tas3004_set_drc(tas); /* Set treble & bass to 0dB */ tas->treble = TAS3004_TREBLE_ZERO; tas->bass = TAS3004_BASS_ZERO; tas_set_treble(tas); tas_set_bass(tas); tas->acr &= ~TAS_ACR_ANALOG_PDOWN; if (tas_write_reg(tas, TAS_REG_ACR, 1, &tas->acr)) goto outerr; return 0; outerr: return -ENODEV; } static int tas_switch_clock(struct codec_info_item *cii, enum clock_switch clock) { struct tas *tas = cii->codec_data; switch(clock) { case CLOCK_SWITCH_PREPARE_SLAVE: /* Clocks are going away, mute mute mute */ tas->codec.gpio->methods->all_amps_off(tas->codec.gpio); tas->hw_enabled = 0; break; case CLOCK_SWITCH_SLAVE: /* Clocks are back, re-init the codec */ mutex_lock(&tas->mtx); tas_reset_init(tas); tas_set_volume(tas); tas_set_mixer(tas); tas->hw_enabled = 1; tas->codec.gpio->methods->all_amps_restore(tas->codec.gpio); mutex_unlock(&tas->mtx); break; default: /* doesn't happen as of now */ return -EINVAL; } return 0; } #ifdef CONFIG_PM /* we are controlled via i2c and assume that is always up * If that wasn't the case, we'd have to suspend once * our i2c device is suspended, and then take note of that! */ static int tas_suspend(struct tas *tas) { mutex_lock(&tas->mtx); tas->hw_enabled = 0; tas->acr |= TAS_ACR_ANALOG_PDOWN; tas_write_reg(tas, TAS_REG_ACR, 1, &tas->acr); mutex_unlock(&tas->mtx); return 0; } static int tas_resume(struct tas *tas) { /* reset codec */ mutex_lock(&tas->mtx); tas_reset_init(tas); tas_set_volume(tas); tas_set_mixer(tas); tas->hw_enabled = 1; mutex_unlock(&tas->mtx); return 0; } static int _tas_suspend(struct codec_info_item *cii, pm_message_t state) { return tas_suspend(cii->codec_data); } static int _tas_resume(struct codec_info_item *cii) { return tas_resume(cii->codec_data); } #else /* CONFIG_PM */ #define _tas_suspend NULL #define _tas_resume NULL #endif /* CONFIG_PM */ static struct codec_info tas_codec_info = { .transfers = tas_transfers, /* in theory, we can drive it at 512 too... * but so far the framework doesn't allow * for that and I don't see much point in it. */ .sysclock_factor = 256, /* same here, could be 32 for just one 16 bit format */ .bus_factor = 64, .owner = THIS_MODULE, .usable = tas_usable, .switch_clock = tas_switch_clock, .suspend = _tas_suspend, .resume = _tas_resume, }; static int tas_init_codec(struct aoa_codec *codec) { struct tas *tas = codec_to_tas(codec); int err; if (!tas->codec.gpio || !tas->codec.gpio->methods) { printk(KERN_ERR PFX "gpios not assigned!!\n"); return -EINVAL; } mutex_lock(&tas->mtx); if (tas_reset_init(tas)) { printk(KERN_ERR PFX "tas failed to initialise\n"); mutex_unlock(&tas->mtx); return -ENXIO; } tas->hw_enabled = 1; mutex_unlock(&tas->mtx); if (tas->codec.soundbus_dev->attach_codec(tas->codec.soundbus_dev, aoa_get_card(), &tas_codec_info, tas)) { printk(KERN_ERR PFX "error attaching tas to soundbus\n"); return -ENODEV; } if (aoa_snd_device_new(SNDRV_DEV_CODEC, tas, &ops)) { printk(KERN_ERR PFX "failed to create tas snd device!\n"); return -ENODEV; } err = aoa_snd_ctl_add(snd_ctl_new1(&volume_control, tas)); if (err) goto error; err = aoa_snd_ctl_add(snd_ctl_new1(&mute_control, tas)); if (err) goto error; err = aoa_snd_ctl_add(snd_ctl_new1(&pcm1_control, tas)); if (err) goto error; err = aoa_snd_ctl_add(snd_ctl_new1(&monitor_control, tas)); if (err) goto error; err = aoa_snd_ctl_add(snd_ctl_new1(&capture_source_control, tas)); if (err) goto error; err = aoa_snd_ctl_add(snd_ctl_new1(&drc_range_control, tas)); if (err) goto error; err = aoa_snd_ctl_add(snd_ctl_new1(&drc_switch_control, tas)); if (err) goto error; err = aoa_snd_ctl_add(snd_ctl_new1(&treble_control, tas)); if (err) goto error; err = aoa_snd_ctl_add(snd_ctl_new1(&bass_control, tas)); if (err) goto error; return 0; error: tas->codec.soundbus_dev->detach_codec(tas->codec.soundbus_dev, tas); snd_device_free(aoa_get_card(), tas); return err; } static void tas_exit_codec(struct aoa_codec *codec) { struct tas *tas = codec_to_tas(codec); if (!tas->codec.soundbus_dev) return; tas->codec.soundbus_dev->detach_codec(tas->codec.soundbus_dev, tas); } static int tas_i2c_probe(struct i2c_client *client) { struct device_node *node = client->dev.of_node; struct tas *tas; tas = kzalloc(sizeof(struct tas), GFP_KERNEL); if (!tas) return -ENOMEM; mutex_init(&tas->mtx); tas->i2c = client; i2c_set_clientdata(client, tas); /* seems that half is a saner default */ tas->drc_range = TAS3004_DRC_MAX / 2; strscpy(tas->codec.name, "tas", MAX_CODEC_NAME_LEN); tas->codec.owner = THIS_MODULE; tas->codec.init = tas_init_codec; tas->codec.exit = tas_exit_codec; tas->codec.node = of_node_get(node); if (aoa_codec_register(&tas->codec)) { goto fail; } printk(KERN_DEBUG "snd-aoa-codec-tas: tas found, addr 0x%02x on %pOF\n", (unsigned int)client->addr, node); return 0; fail: mutex_destroy(&tas->mtx); kfree(tas); return -EINVAL; } static void tas_i2c_remove(struct i2c_client *client) { struct tas *tas = i2c_get_clientdata(client); u8 tmp = TAS_ACR_ANALOG_PDOWN; aoa_codec_unregister(&tas->codec); of_node_put(tas->codec.node); /* power down codec chip */ tas_write_reg(tas, TAS_REG_ACR, 1, &tmp); mutex_destroy(&tas->mtx); kfree(tas); } static const struct i2c_device_id tas_i2c_id[] = { { "MAC,tas3004", 0 }, { } }; MODULE_DEVICE_TABLE(i2c,tas_i2c_id); static struct i2c_driver tas_driver = { .driver = { .name = "aoa_codec_tas", }, .probe = tas_i2c_probe, .remove = tas_i2c_remove, .id_table = tas_i2c_id, }; module_i2c_driver(tas_driver);
linux-master
sound/aoa/codecs/tas.c
// SPDX-License-Identifier: GPL-2.0-only /* * Apple Onboard Audio driver for Onyx codec * * Copyright 2006 Johannes Berg <[email protected]> * * This is a driver for the pcm3052 codec chip (codenamed Onyx) * that is present in newer Apple hardware (with digital output). * * The Onyx codec has the following connections (listed by the bit * to be used in aoa_codec.connected): * 0: analog output * 1: digital output * 2: line input * 3: microphone input * Note that even though I know of no machine that has for example * the digital output connected but not the analog, I have handled * all the different cases in the code so that this driver may serve * as a good example of what to do. * * NOTE: This driver assumes that there's at most one chip to be * used with one alsa card, in form of creating all kinds * of mixer elements without regard for their existence. * But snd-aoa assumes that there's at most one card, so * this means you can only have one onyx on a system. This * should probably be fixed by changing the assumption of * having just a single card on a system, and making the * 'card' pointer accessible to anyone who needs it instead * of hiding it in the aoa_snd_* functions... */ #include <linux/delay.h> #include <linux/module.h> #include <linux/slab.h> MODULE_AUTHOR("Johannes Berg <[email protected]>"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("pcm3052 (onyx) codec driver for snd-aoa"); #include "onyx.h" #include "../aoa.h" #include "../soundbus/soundbus.h" #define PFX "snd-aoa-codec-onyx: " struct onyx { /* cache registers 65 to 80, they are write-only! */ u8 cache[16]; struct i2c_client *i2c; struct aoa_codec codec; u32 initialised:1, spdif_locked:1, analog_locked:1, original_mute:2; int open_count; struct codec_info *codec_info; /* mutex serializes concurrent access to the device * and this structure. */ struct mutex mutex; }; #define codec_to_onyx(c) container_of(c, struct onyx, codec) /* both return 0 if all ok, else on error */ static int onyx_read_register(struct onyx *onyx, u8 reg, u8 *value) { s32 v; if (reg != ONYX_REG_CONTROL) { *value = onyx->cache[reg-FIRSTREGISTER]; return 0; } v = i2c_smbus_read_byte_data(onyx->i2c, reg); if (v < 0) { *value = 0; return -1; } *value = (u8)v; onyx->cache[ONYX_REG_CONTROL-FIRSTREGISTER] = *value; return 0; } static int onyx_write_register(struct onyx *onyx, u8 reg, u8 value) { int result; result = i2c_smbus_write_byte_data(onyx->i2c, reg, value); if (!result) onyx->cache[reg-FIRSTREGISTER] = value; return result; } /* alsa stuff */ static int onyx_dev_register(struct snd_device *dev) { return 0; } static const struct snd_device_ops ops = { .dev_register = onyx_dev_register, }; /* this is necessary because most alsa mixer programs * can't properly handle the negative range */ #define VOLUME_RANGE_SHIFT 128 static int onyx_snd_vol_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 2; uinfo->value.integer.min = -128 + VOLUME_RANGE_SHIFT; uinfo->value.integer.max = -1 + VOLUME_RANGE_SHIFT; return 0; } static int onyx_snd_vol_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); s8 l, r; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l); onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r); mutex_unlock(&onyx->mutex); ucontrol->value.integer.value[0] = l + VOLUME_RANGE_SHIFT; ucontrol->value.integer.value[1] = r + VOLUME_RANGE_SHIFT; return 0; } static int onyx_snd_vol_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); s8 l, r; if (ucontrol->value.integer.value[0] < -128 + VOLUME_RANGE_SHIFT || ucontrol->value.integer.value[0] > -1 + VOLUME_RANGE_SHIFT) return -EINVAL; if (ucontrol->value.integer.value[1] < -128 + VOLUME_RANGE_SHIFT || ucontrol->value.integer.value[1] > -1 + VOLUME_RANGE_SHIFT) return -EINVAL; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l); onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r); if (l + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[0] && r + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[1]) { mutex_unlock(&onyx->mutex); return 0; } onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, ucontrol->value.integer.value[0] - VOLUME_RANGE_SHIFT); onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, ucontrol->value.integer.value[1] - VOLUME_RANGE_SHIFT); mutex_unlock(&onyx->mutex); return 1; } static const struct snd_kcontrol_new volume_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Volume", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = onyx_snd_vol_info, .get = onyx_snd_vol_get, .put = onyx_snd_vol_put, }; /* like above, this is necessary because a lot * of alsa mixer programs don't handle ranges * that don't start at 0 properly. * even alsamixer is one of them... */ #define INPUTGAIN_RANGE_SHIFT (-3) static int onyx_snd_inputgain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; uinfo->count = 1; uinfo->value.integer.min = 3 + INPUTGAIN_RANGE_SHIFT; uinfo->value.integer.max = 28 + INPUTGAIN_RANGE_SHIFT; return 0; } static int onyx_snd_inputgain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); u8 ig; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &ig); mutex_unlock(&onyx->mutex); ucontrol->value.integer.value[0] = (ig & ONYX_ADC_PGA_GAIN_MASK) + INPUTGAIN_RANGE_SHIFT; return 0; } static int onyx_snd_inputgain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); u8 v, n; if (ucontrol->value.integer.value[0] < 3 + INPUTGAIN_RANGE_SHIFT || ucontrol->value.integer.value[0] > 28 + INPUTGAIN_RANGE_SHIFT) return -EINVAL; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v); n = v; n &= ~ONYX_ADC_PGA_GAIN_MASK; n |= (ucontrol->value.integer.value[0] - INPUTGAIN_RANGE_SHIFT) & ONYX_ADC_PGA_GAIN_MASK; onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, n); mutex_unlock(&onyx->mutex); return n != v; } static const struct snd_kcontrol_new inputgain_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Capture Volume", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = onyx_snd_inputgain_info, .get = onyx_snd_inputgain_get, .put = onyx_snd_inputgain_put, }; static int onyx_snd_capture_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { static const char * const texts[] = { "Line-In", "Microphone" }; return snd_ctl_enum_info(uinfo, 1, 2, texts); } static int onyx_snd_capture_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); s8 v; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v); mutex_unlock(&onyx->mutex); ucontrol->value.enumerated.item[0] = !!(v&ONYX_ADC_INPUT_MIC); return 0; } static void onyx_set_capture_source(struct onyx *onyx, int mic) { s8 v; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v); v &= ~ONYX_ADC_INPUT_MIC; if (mic) v |= ONYX_ADC_INPUT_MIC; onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, v); mutex_unlock(&onyx->mutex); } static int onyx_snd_capture_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { if (ucontrol->value.enumerated.item[0] > 1) return -EINVAL; onyx_set_capture_source(snd_kcontrol_chip(kcontrol), ucontrol->value.enumerated.item[0]); return 1; } static const struct snd_kcontrol_new capture_source_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, /* If we name this 'Input Source', it properly shows up in * alsamixer as a selection, * but it's shown under the * 'Playback' category. * If I name it 'Capture Source', it shows up in strange * ways (two bools of which one can be selected at a * time) but at least it's shown in the 'Capture' * category. * I was told that this was due to backward compatibility, * but I don't understand then why the mangling is *not* * done when I name it "Input Source"..... */ .name = "Capture Source", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = onyx_snd_capture_source_info, .get = onyx_snd_capture_source_get, .put = onyx_snd_capture_source_put, }; #define onyx_snd_mute_info snd_ctl_boolean_stereo_info static int onyx_snd_mute_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); u8 c; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &c); mutex_unlock(&onyx->mutex); ucontrol->value.integer.value[0] = !(c & ONYX_MUTE_LEFT); ucontrol->value.integer.value[1] = !(c & ONYX_MUTE_RIGHT); return 0; } static int onyx_snd_mute_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); u8 v = 0, c = 0; int err = -EBUSY; mutex_lock(&onyx->mutex); if (onyx->analog_locked) goto out_unlock; onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v); c = v; c &= ~(ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT); if (!ucontrol->value.integer.value[0]) c |= ONYX_MUTE_LEFT; if (!ucontrol->value.integer.value[1]) c |= ONYX_MUTE_RIGHT; err = onyx_write_register(onyx, ONYX_REG_DAC_CONTROL, c); out_unlock: mutex_unlock(&onyx->mutex); return !err ? (v != c) : err; } static const struct snd_kcontrol_new mute_control = { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "Master Playback Switch", .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .info = onyx_snd_mute_info, .get = onyx_snd_mute_get, .put = onyx_snd_mute_put, }; #define onyx_snd_single_bit_info snd_ctl_boolean_mono_info #define FLAG_POLARITY_INVERT 1 #define FLAG_SPDIFLOCK 2 static int onyx_snd_single_bit_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); u8 c; long int pv = kcontrol->private_value; u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT; u8 address = (pv >> 8) & 0xff; u8 mask = pv & 0xff; mutex_lock(&onyx->mutex); onyx_read_register(onyx, address, &c); mutex_unlock(&onyx->mutex); ucontrol->value.integer.value[0] = !!(c & mask) ^ polarity; return 0; } static int onyx_snd_single_bit_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); u8 v = 0, c = 0; int err; long int pv = kcontrol->private_value; u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT; u8 spdiflock = (pv >> 16) & FLAG_SPDIFLOCK; u8 address = (pv >> 8) & 0xff; u8 mask = pv & 0xff; mutex_lock(&onyx->mutex); if (spdiflock && onyx->spdif_locked) { /* even if alsamixer doesn't care.. */ err = -EBUSY; goto out_unlock; } onyx_read_register(onyx, address, &v); c = v; c &= ~(mask); if (!!ucontrol->value.integer.value[0] ^ polarity) c |= mask; err = onyx_write_register(onyx, address, c); out_unlock: mutex_unlock(&onyx->mutex); return !err ? (v != c) : err; } #define SINGLE_BIT(n, type, description, address, mask, flags) \ static const struct snd_kcontrol_new n##_control = { \ .iface = SNDRV_CTL_ELEM_IFACE_##type, \ .name = description, \ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ .info = onyx_snd_single_bit_info, \ .get = onyx_snd_single_bit_get, \ .put = onyx_snd_single_bit_put, \ .private_value = (flags << 16) | (address << 8) | mask \ } SINGLE_BIT(spdif, MIXER, SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), ONYX_REG_DIG_INFO4, ONYX_SPDIF_ENABLE, FLAG_SPDIFLOCK); SINGLE_BIT(ovr1, MIXER, "Oversampling Rate", ONYX_REG_DAC_CONTROL, ONYX_OVR1, 0); SINGLE_BIT(flt0, MIXER, "Fast Digital Filter Rolloff", ONYX_REG_DAC_FILTER, ONYX_ROLLOFF_FAST, FLAG_POLARITY_INVERT); SINGLE_BIT(hpf, MIXER, "Highpass Filter", ONYX_REG_ADC_HPF_BYPASS, ONYX_HPF_DISABLE, FLAG_POLARITY_INVERT); SINGLE_BIT(dm12, MIXER, "Digital De-Emphasis", ONYX_REG_DAC_DEEMPH, ONYX_DIGDEEMPH_CTRL, 0); static int onyx_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) { uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; uinfo->count = 1; return 0; } static int onyx_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { /* datasheet page 30, all others are 0 */ ucontrol->value.iec958.status[0] = 0x3e; ucontrol->value.iec958.status[1] = 0xff; ucontrol->value.iec958.status[3] = 0x3f; ucontrol->value.iec958.status[4] = 0x0f; return 0; } static const struct snd_kcontrol_new onyx_spdif_mask = { .access = SNDRV_CTL_ELEM_ACCESS_READ, .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK), .info = onyx_spdif_info, .get = onyx_spdif_mask_get, }; static int onyx_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); u8 v; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v); ucontrol->value.iec958.status[0] = v & 0x3e; onyx_read_register(onyx, ONYX_REG_DIG_INFO2, &v); ucontrol->value.iec958.status[1] = v; onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v); ucontrol->value.iec958.status[3] = v & 0x3f; onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v); ucontrol->value.iec958.status[4] = v & 0x0f; mutex_unlock(&onyx->mutex); return 0; } static int onyx_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct onyx *onyx = snd_kcontrol_chip(kcontrol); u8 v; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v); v = (v & ~0x3e) | (ucontrol->value.iec958.status[0] & 0x3e); onyx_write_register(onyx, ONYX_REG_DIG_INFO1, v); v = ucontrol->value.iec958.status[1]; onyx_write_register(onyx, ONYX_REG_DIG_INFO2, v); onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v); v = (v & ~0x3f) | (ucontrol->value.iec958.status[3] & 0x3f); onyx_write_register(onyx, ONYX_REG_DIG_INFO3, v); onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v); v = (v & ~0x0f) | (ucontrol->value.iec958.status[4] & 0x0f); onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v); mutex_unlock(&onyx->mutex); return 1; } static const struct snd_kcontrol_new onyx_spdif_ctrl = { .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), .info = onyx_spdif_info, .get = onyx_spdif_get, .put = onyx_spdif_put, }; /* our registers */ static const u8 register_map[] = { ONYX_REG_DAC_ATTEN_LEFT, ONYX_REG_DAC_ATTEN_RIGHT, ONYX_REG_CONTROL, ONYX_REG_DAC_CONTROL, ONYX_REG_DAC_DEEMPH, ONYX_REG_DAC_FILTER, ONYX_REG_DAC_OUTPHASE, ONYX_REG_ADC_CONTROL, ONYX_REG_ADC_HPF_BYPASS, ONYX_REG_DIG_INFO1, ONYX_REG_DIG_INFO2, ONYX_REG_DIG_INFO3, ONYX_REG_DIG_INFO4 }; static const u8 initial_values[ARRAY_SIZE(register_map)] = { 0x80, 0x80, /* muted */ ONYX_MRST | ONYX_SRST, /* but handled specially! */ ONYX_MUTE_LEFT | ONYX_MUTE_RIGHT, 0, /* no deemphasis */ ONYX_DAC_FILTER_ALWAYS, ONYX_OUTPHASE_INVERTED, (-1 /*dB*/ + 8) & 0xF, /* line in selected, -1 dB gain*/ ONYX_ADC_HPF_ALWAYS, (1<<2), /* pcm audio */ 2, /* category: pcm coder */ 0, /* sampling frequency 44.1 kHz, clock accuracy level II */ 1 /* 24 bit depth */ }; /* reset registers of chip, either to initial or to previous values */ static int onyx_register_init(struct onyx *onyx) { int i; u8 val; u8 regs[sizeof(initial_values)]; if (!onyx->initialised) { memcpy(regs, initial_values, sizeof(initial_values)); if (onyx_read_register(onyx, ONYX_REG_CONTROL, &val)) return -1; val &= ~ONYX_SILICONVERSION; val |= initial_values[3]; regs[3] = val; } else { for (i=0; i<sizeof(register_map); i++) regs[i] = onyx->cache[register_map[i]-FIRSTREGISTER]; } for (i=0; i<sizeof(register_map); i++) { if (onyx_write_register(onyx, register_map[i], regs[i])) return -1; } onyx->initialised = 1; return 0; } static struct transfer_info onyx_transfers[] = { /* this is first so we can skip it if no input is present... * No hardware exists with that, but it's here as an example * of what to do :) */ { /* analog input */ .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S24_BE, .rates = SNDRV_PCM_RATE_8000_96000, .transfer_in = 1, .must_be_clock_source = 0, .tag = 0, }, { /* if analog and digital are currently off, anything should go, * so this entry describes everything we can do... */ .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S24_BE #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE | SNDRV_PCM_FMTBIT_COMPRESSED_16BE #endif , .rates = SNDRV_PCM_RATE_8000_96000, .tag = 0, }, { /* analog output */ .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S24_BE, .rates = SNDRV_PCM_RATE_8000_96000, .transfer_in = 0, .must_be_clock_source = 0, .tag = 1, }, { /* digital pcm output, also possible for analog out */ .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S24_BE, .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .transfer_in = 0, .must_be_clock_source = 0, .tag = 2, }, #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE /* Once alsa gets supports for this kind of thing we can add it... */ { /* digital compressed output */ .formats = SNDRV_PCM_FMTBIT_COMPRESSED_16BE, .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, .tag = 2, }, #endif {} }; static int onyx_usable(struct codec_info_item *cii, struct transfer_info *ti, struct transfer_info *out) { u8 v; struct onyx *onyx = cii->codec_data; int spdif_enabled, analog_enabled; mutex_lock(&onyx->mutex); onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v); spdif_enabled = !!(v & ONYX_SPDIF_ENABLE); onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v); analog_enabled = (v & (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT)) != (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT); mutex_unlock(&onyx->mutex); switch (ti->tag) { case 0: return 1; case 1: return analog_enabled; case 2: return spdif_enabled; } return 1; } static int onyx_prepare(struct codec_info_item *cii, struct bus_info *bi, struct snd_pcm_substream *substream) { u8 v; struct onyx *onyx = cii->codec_data; int err = -EBUSY; mutex_lock(&onyx->mutex); #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE if (substream->runtime->format == SNDRV_PCM_FMTBIT_COMPRESSED_16BE) { /* mute and lock analog output */ onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v); if (onyx_write_register(onyx, ONYX_REG_DAC_CONTROL, v | ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT)) goto out_unlock; onyx->analog_locked = 1; err = 0; goto out_unlock; } #endif switch (substream->runtime->rate) { case 32000: case 44100: case 48000: /* these rates are ok for all outputs */ /* FIXME: program spdif channel control bits here so that * userspace doesn't have to if it only plays pcm! */ err = 0; goto out_unlock; default: /* got some rate that the digital output can't do, * so disable and lock it */ onyx_read_register(cii->codec_data, ONYX_REG_DIG_INFO4, &v); if (onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v & ~ONYX_SPDIF_ENABLE)) goto out_unlock; onyx->spdif_locked = 1; err = 0; goto out_unlock; } out_unlock: mutex_unlock(&onyx->mutex); return err; } static int onyx_open(struct codec_info_item *cii, struct snd_pcm_substream *substream) { struct onyx *onyx = cii->codec_data; mutex_lock(&onyx->mutex); onyx->open_count++; mutex_unlock(&onyx->mutex); return 0; } static int onyx_close(struct codec_info_item *cii, struct snd_pcm_substream *substream) { struct onyx *onyx = cii->codec_data; mutex_lock(&onyx->mutex); onyx->open_count--; if (!onyx->open_count) onyx->spdif_locked = onyx->analog_locked = 0; mutex_unlock(&onyx->mutex); return 0; } static int onyx_switch_clock(struct codec_info_item *cii, enum clock_switch what) { struct onyx *onyx = cii->codec_data; mutex_lock(&onyx->mutex); /* this *MUST* be more elaborate later... */ switch (what) { case CLOCK_SWITCH_PREPARE_SLAVE: onyx->codec.gpio->methods->all_amps_off(onyx->codec.gpio); break; case CLOCK_SWITCH_SLAVE: onyx->codec.gpio->methods->all_amps_restore(onyx->codec.gpio); break; default: /* silence warning */ break; } mutex_unlock(&onyx->mutex); return 0; } #ifdef CONFIG_PM static int onyx_suspend(struct codec_info_item *cii, pm_message_t state) { struct onyx *onyx = cii->codec_data; u8 v; int err = -ENXIO; mutex_lock(&onyx->mutex); if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v)) goto out_unlock; onyx_write_register(onyx, ONYX_REG_CONTROL, v | ONYX_ADPSV | ONYX_DAPSV); /* Apple does a sleep here but the datasheet says to do it on resume */ err = 0; out_unlock: mutex_unlock(&onyx->mutex); return err; } static int onyx_resume(struct codec_info_item *cii) { struct onyx *onyx = cii->codec_data; u8 v; int err = -ENXIO; mutex_lock(&onyx->mutex); /* reset codec */ onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0); msleep(1); onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1); msleep(1); onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0); msleep(1); /* take codec out of suspend (if it still is after reset) */ if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v)) goto out_unlock; onyx_write_register(onyx, ONYX_REG_CONTROL, v & ~(ONYX_ADPSV | ONYX_DAPSV)); /* FIXME: should divide by sample rate, but 8k is the lowest we go */ msleep(2205000/8000); /* reset all values */ onyx_register_init(onyx); err = 0; out_unlock: mutex_unlock(&onyx->mutex); return err; } #endif /* CONFIG_PM */ static struct codec_info onyx_codec_info = { .transfers = onyx_transfers, .sysclock_factor = 256, .bus_factor = 64, .owner = THIS_MODULE, .usable = onyx_usable, .prepare = onyx_prepare, .open = onyx_open, .close = onyx_close, .switch_clock = onyx_switch_clock, #ifdef CONFIG_PM .suspend = onyx_suspend, .resume = onyx_resume, #endif }; static int onyx_init_codec(struct aoa_codec *codec) { struct onyx *onyx = codec_to_onyx(codec); struct snd_kcontrol *ctl; struct codec_info *ci = &onyx_codec_info; u8 v; int err; if (!onyx->codec.gpio || !onyx->codec.gpio->methods) { printk(KERN_ERR PFX "gpios not assigned!!\n"); return -EINVAL; } onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0); msleep(1); onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1); msleep(1); onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0); msleep(1); if (onyx_register_init(onyx)) { printk(KERN_ERR PFX "failed to initialise onyx registers\n"); return -ENODEV; } if (aoa_snd_device_new(SNDRV_DEV_CODEC, onyx, &ops)) { printk(KERN_ERR PFX "failed to create onyx snd device!\n"); return -ENODEV; } /* nothing connected? what a joke! */ if ((onyx->codec.connected & 0xF) == 0) return -ENOTCONN; /* if no inputs are present... */ if ((onyx->codec.connected & 0xC) == 0) { if (!onyx->codec_info) onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL); if (!onyx->codec_info) return -ENOMEM; ci = onyx->codec_info; *ci = onyx_codec_info; ci->transfers++; } /* if no outputs are present... */ if ((onyx->codec.connected & 3) == 0) { if (!onyx->codec_info) onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL); if (!onyx->codec_info) return -ENOMEM; ci = onyx->codec_info; /* this is fine as there have to be inputs * if we end up in this part of the code */ *ci = onyx_codec_info; ci->transfers[1].formats = 0; } if (onyx->codec.soundbus_dev->attach_codec(onyx->codec.soundbus_dev, aoa_get_card(), ci, onyx)) { printk(KERN_ERR PFX "error creating onyx pcm\n"); return -ENODEV; } #define ADDCTL(n) \ do { \ ctl = snd_ctl_new1(&n, onyx); \ if (ctl) { \ ctl->id.device = \ onyx->codec.soundbus_dev->pcm->device; \ err = aoa_snd_ctl_add(ctl); \ if (err) \ goto error; \ } \ } while (0) if (onyx->codec.soundbus_dev->pcm) { /* give the user appropriate controls * depending on what inputs are connected */ if ((onyx->codec.connected & 0xC) == 0xC) ADDCTL(capture_source_control); else if (onyx->codec.connected & 4) onyx_set_capture_source(onyx, 0); else onyx_set_capture_source(onyx, 1); if (onyx->codec.connected & 0xC) ADDCTL(inputgain_control); /* depending on what output is connected, * give the user appropriate controls */ if (onyx->codec.connected & 1) { ADDCTL(volume_control); ADDCTL(mute_control); ADDCTL(ovr1_control); ADDCTL(flt0_control); ADDCTL(hpf_control); ADDCTL(dm12_control); /* spdif control defaults to off */ } if (onyx->codec.connected & 2) { ADDCTL(onyx_spdif_mask); ADDCTL(onyx_spdif_ctrl); } if ((onyx->codec.connected & 3) == 3) ADDCTL(spdif_control); /* if only S/PDIF is connected, enable it unconditionally */ if ((onyx->codec.connected & 3) == 2) { onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v); v |= ONYX_SPDIF_ENABLE; onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v); } } #undef ADDCTL printk(KERN_INFO PFX "attached to onyx codec via i2c\n"); return 0; error: onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx); snd_device_free(aoa_get_card(), onyx); return err; } static void onyx_exit_codec(struct aoa_codec *codec) { struct onyx *onyx = codec_to_onyx(codec); if (!onyx->codec.soundbus_dev) { printk(KERN_ERR PFX "onyx_exit_codec called without soundbus_dev!\n"); return; } onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx); } static int onyx_i2c_probe(struct i2c_client *client) { struct device_node *node = client->dev.of_node; struct onyx *onyx; u8 dummy; onyx = kzalloc(sizeof(struct onyx), GFP_KERNEL); if (!onyx) return -ENOMEM; mutex_init(&onyx->mutex); onyx->i2c = client; i2c_set_clientdata(client, onyx); /* we try to read from register ONYX_REG_CONTROL * to check if the codec is present */ if (onyx_read_register(onyx, ONYX_REG_CONTROL, &dummy) != 0) { printk(KERN_ERR PFX "failed to read control register\n"); goto fail; } strscpy(onyx->codec.name, "onyx", MAX_CODEC_NAME_LEN); onyx->codec.owner = THIS_MODULE; onyx->codec.init = onyx_init_codec; onyx->codec.exit = onyx_exit_codec; onyx->codec.node = of_node_get(node); if (aoa_codec_register(&onyx->codec)) { goto fail; } printk(KERN_DEBUG PFX "created and attached onyx instance\n"); return 0; fail: kfree(onyx); return -ENODEV; } static void onyx_i2c_remove(struct i2c_client *client) { struct onyx *onyx = i2c_get_clientdata(client); aoa_codec_unregister(&onyx->codec); of_node_put(onyx->codec.node); kfree(onyx->codec_info); kfree(onyx); } static const struct i2c_device_id onyx_i2c_id[] = { { "MAC,pcm3052", 0 }, { } }; MODULE_DEVICE_TABLE(i2c,onyx_i2c_id); static struct i2c_driver onyx_driver = { .driver = { .name = "aoa_codec_onyx", }, .probe = onyx_i2c_probe, .remove = onyx_i2c_remove, .id_table = onyx_i2c_id, }; module_i2c_driver(onyx_driver);
linux-master
sound/aoa/codecs/onyx.c
// SPDX-License-Identifier: GPL-2.0-only /* * Apple Onboard Audio driver for Toonie codec * * Copyright 2006 Johannes Berg <[email protected]> * * This is a driver for the toonie codec chip. This chip is present * on the Mac Mini and is nothing but a DAC. */ #include <linux/delay.h> #include <linux/module.h> #include <linux/slab.h> MODULE_AUTHOR("Johannes Berg <[email protected]>"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("toonie codec driver for snd-aoa"); #include "../aoa.h" #include "../soundbus/soundbus.h" #define PFX "snd-aoa-codec-toonie: " struct toonie { struct aoa_codec codec; }; #define codec_to_toonie(c) container_of(c, struct toonie, codec) static int toonie_dev_register(struct snd_device *dev) { return 0; } static const struct snd_device_ops ops = { .dev_register = toonie_dev_register, }; static struct transfer_info toonie_transfers[] = { /* This thing *only* has analog output, * the rates are taken from Info.plist * from Darwin. */ { .formats = SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S24_BE, .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000, }, {} }; static int toonie_usable(struct codec_info_item *cii, struct transfer_info *ti, struct transfer_info *out) { return 1; } #ifdef CONFIG_PM static int toonie_suspend(struct codec_info_item *cii, pm_message_t state) { /* can we turn it off somehow? */ return 0; } static int toonie_resume(struct codec_info_item *cii) { return 0; } #endif /* CONFIG_PM */ static struct codec_info toonie_codec_info = { .transfers = toonie_transfers, .sysclock_factor = 256, .bus_factor = 64, .owner = THIS_MODULE, .usable = toonie_usable, #ifdef CONFIG_PM .suspend = toonie_suspend, .resume = toonie_resume, #endif }; static int toonie_init_codec(struct aoa_codec *codec) { struct toonie *toonie = codec_to_toonie(codec); /* nothing connected? what a joke! */ if (toonie->codec.connected != 1) return -ENOTCONN; if (aoa_snd_device_new(SNDRV_DEV_CODEC, toonie, &ops)) { printk(KERN_ERR PFX "failed to create toonie snd device!\n"); return -ENODEV; } if (toonie->codec.soundbus_dev->attach_codec(toonie->codec.soundbus_dev, aoa_get_card(), &toonie_codec_info, toonie)) { printk(KERN_ERR PFX "error creating toonie pcm\n"); snd_device_free(aoa_get_card(), toonie); return -ENODEV; } return 0; } static void toonie_exit_codec(struct aoa_codec *codec) { struct toonie *toonie = codec_to_toonie(codec); if (!toonie->codec.soundbus_dev) { printk(KERN_ERR PFX "toonie_exit_codec called without soundbus_dev!\n"); return; } toonie->codec.soundbus_dev->detach_codec(toonie->codec.soundbus_dev, toonie); } static struct toonie *toonie; static int __init toonie_init(void) { toonie = kzalloc(sizeof(struct toonie), GFP_KERNEL); if (!toonie) return -ENOMEM; strscpy(toonie->codec.name, "toonie", sizeof(toonie->codec.name)); toonie->codec.owner = THIS_MODULE; toonie->codec.init = toonie_init_codec; toonie->codec.exit = toonie_exit_codec; if (aoa_codec_register(&toonie->codec)) { kfree(toonie); return -EINVAL; } return 0; } static void __exit toonie_exit(void) { aoa_codec_unregister(&toonie->codec); kfree(toonie); } module_init(toonie_init); module_exit(toonie_exit);
linux-master
sound/aoa/codecs/toonie.c
// SPDX-License-Identifier: GPL-2.0-only /* * Apple Onboard Audio feature call GPIO control * * Copyright 2006 Johannes Berg <[email protected]> * * This file contains the GPIO control routines for * direct (through feature calls) access to the GPIO * registers. */ #include <linux/of_irq.h> #include <linux/interrupt.h> #include <asm/pmac_feature.h> #include "../aoa.h" /* TODO: these are lots of global variables * that aren't used on most machines... * Move them into a dynamically allocated * structure and use that. */ /* these are the GPIO numbers (register addresses as offsets into * the GPIO space) */ static int headphone_mute_gpio; static int master_mute_gpio; static int amp_mute_gpio; static int lineout_mute_gpio; static int hw_reset_gpio; static int lineout_detect_gpio; static int headphone_detect_gpio; static int linein_detect_gpio; /* see the SWITCH_GPIO macro */ static int headphone_mute_gpio_activestate; static int master_mute_gpio_activestate; static int amp_mute_gpio_activestate; static int lineout_mute_gpio_activestate; static int hw_reset_gpio_activestate; static int lineout_detect_gpio_activestate; static int headphone_detect_gpio_activestate; static int linein_detect_gpio_activestate; /* node pointers that we save when getting the GPIO number * to get the interrupt later */ static struct device_node *lineout_detect_node; static struct device_node *linein_detect_node; static struct device_node *headphone_detect_node; static int lineout_detect_irq; static int linein_detect_irq; static int headphone_detect_irq; static struct device_node *get_gpio(char *name, char *altname, int *gpioptr, int *gpioactiveptr) { struct device_node *np, *gpio; const u32 *reg; const char *audio_gpio; *gpioptr = -1; /* check if we can get it the easy way ... */ np = of_find_node_by_name(NULL, name); if (!np) { /* some machines have only gpioX/extint-gpioX nodes, * and an audio-gpio property saying what it is ... * So what we have to do is enumerate all children * of the gpio node and check them all. */ gpio = of_find_node_by_name(NULL, "gpio"); if (!gpio) return NULL; while ((np = of_get_next_child(gpio, np))) { audio_gpio = of_get_property(np, "audio-gpio", NULL); if (!audio_gpio) continue; if (strcmp(audio_gpio, name) == 0) break; if (altname && (strcmp(audio_gpio, altname) == 0)) break; } of_node_put(gpio); /* still not found, assume not there */ if (!np) return NULL; } reg = of_get_property(np, "reg", NULL); if (!reg) { of_node_put(np); return NULL; } *gpioptr = *reg; /* this is a hack, usually the GPIOs 'reg' property * should have the offset based from the GPIO space * which is at 0x50, but apparently not always... */ if (*gpioptr < 0x50) *gpioptr += 0x50; reg = of_get_property(np, "audio-gpio-active-state", NULL); if (!reg) /* Apple seems to default to 1, but * that doesn't seem right at least on most * machines. So until proven that the opposite * is necessary, we default to 0 * (which, incidentally, snd-powermac also does...) */ *gpioactiveptr = 0; else *gpioactiveptr = *reg; return np; } static void get_irq(struct device_node * np, int *irqptr) { if (np) *irqptr = irq_of_parse_and_map(np, 0); else *irqptr = 0; } /* 0x4 is outenable, 0x1 is out, thus 4 or 5 */ #define SWITCH_GPIO(name, v, on) \ (((v)&~1) | ((on)? \ (name##_gpio_activestate==0?4:5): \ (name##_gpio_activestate==0?5:4))) #define FTR_GPIO(name, bit) \ static void ftr_gpio_set_##name(struct gpio_runtime *rt, int on)\ { \ int v; \ \ if (unlikely(!rt)) return; \ \ if (name##_mute_gpio < 0) \ return; \ \ v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, \ name##_mute_gpio, \ 0); \ \ /* muted = !on... */ \ v = SWITCH_GPIO(name##_mute, v, !on); \ \ pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, \ name##_mute_gpio, v); \ \ rt->implementation_private &= ~(1<<bit); \ rt->implementation_private |= (!!on << bit); \ } \ static int ftr_gpio_get_##name(struct gpio_runtime *rt) \ { \ if (unlikely(!rt)) return 0; \ return (rt->implementation_private>>bit)&1; \ } FTR_GPIO(headphone, 0); FTR_GPIO(amp, 1); FTR_GPIO(lineout, 2); FTR_GPIO(master, 3); static void ftr_gpio_set_hw_reset(struct gpio_runtime *rt, int on) { int v; if (unlikely(!rt)) return; if (hw_reset_gpio < 0) return; v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, hw_reset_gpio, 0); v = SWITCH_GPIO(hw_reset, v, on); pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, hw_reset_gpio, v); } static struct gpio_methods methods; static void ftr_gpio_all_amps_off(struct gpio_runtime *rt) { int saved; if (unlikely(!rt)) return; saved = rt->implementation_private; ftr_gpio_set_headphone(rt, 0); ftr_gpio_set_amp(rt, 0); ftr_gpio_set_lineout(rt, 0); if (methods.set_master) ftr_gpio_set_master(rt, 0); rt->implementation_private = saved; } static void ftr_gpio_all_amps_restore(struct gpio_runtime *rt) { int s; if (unlikely(!rt)) return; s = rt->implementation_private; ftr_gpio_set_headphone(rt, (s>>0)&1); ftr_gpio_set_amp(rt, (s>>1)&1); ftr_gpio_set_lineout(rt, (s>>2)&1); if (methods.set_master) ftr_gpio_set_master(rt, (s>>3)&1); } static void ftr_handle_notify(struct work_struct *work) { struct gpio_notification *notif = container_of(work, struct gpio_notification, work.work); mutex_lock(&notif->mutex); if (notif->notify) notif->notify(notif->data); mutex_unlock(&notif->mutex); } static void gpio_enable_dual_edge(int gpio) { int v; if (gpio == -1) return; v = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, gpio, 0); v |= 0x80; /* enable dual edge */ pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, gpio, v); } static void ftr_gpio_init(struct gpio_runtime *rt) { get_gpio("headphone-mute", NULL, &headphone_mute_gpio, &headphone_mute_gpio_activestate); get_gpio("amp-mute", NULL, &amp_mute_gpio, &amp_mute_gpio_activestate); get_gpio("lineout-mute", NULL, &lineout_mute_gpio, &lineout_mute_gpio_activestate); get_gpio("hw-reset", "audio-hw-reset", &hw_reset_gpio, &hw_reset_gpio_activestate); if (get_gpio("master-mute", NULL, &master_mute_gpio, &master_mute_gpio_activestate)) { methods.set_master = ftr_gpio_set_master; methods.get_master = ftr_gpio_get_master; } headphone_detect_node = get_gpio("headphone-detect", NULL, &headphone_detect_gpio, &headphone_detect_gpio_activestate); /* go Apple, and thanks for giving these different names * across the board... */ lineout_detect_node = get_gpio("lineout-detect", "line-output-detect", &lineout_detect_gpio, &lineout_detect_gpio_activestate); linein_detect_node = get_gpio("linein-detect", "line-input-detect", &linein_detect_gpio, &linein_detect_gpio_activestate); gpio_enable_dual_edge(headphone_detect_gpio); gpio_enable_dual_edge(lineout_detect_gpio); gpio_enable_dual_edge(linein_detect_gpio); get_irq(headphone_detect_node, &headphone_detect_irq); get_irq(lineout_detect_node, &lineout_detect_irq); get_irq(linein_detect_node, &linein_detect_irq); ftr_gpio_all_amps_off(rt); rt->implementation_private = 0; INIT_DELAYED_WORK(&rt->headphone_notify.work, ftr_handle_notify); INIT_DELAYED_WORK(&rt->line_in_notify.work, ftr_handle_notify); INIT_DELAYED_WORK(&rt->line_out_notify.work, ftr_handle_notify); mutex_init(&rt->headphone_notify.mutex); mutex_init(&rt->line_in_notify.mutex); mutex_init(&rt->line_out_notify.mutex); } static void ftr_gpio_exit(struct gpio_runtime *rt) { ftr_gpio_all_amps_off(rt); rt->implementation_private = 0; if (rt->headphone_notify.notify) free_irq(headphone_detect_irq, &rt->headphone_notify); if (rt->line_in_notify.gpio_private) free_irq(linein_detect_irq, &rt->line_in_notify); if (rt->line_out_notify.gpio_private) free_irq(lineout_detect_irq, &rt->line_out_notify); cancel_delayed_work_sync(&rt->headphone_notify.work); cancel_delayed_work_sync(&rt->line_in_notify.work); cancel_delayed_work_sync(&rt->line_out_notify.work); mutex_destroy(&rt->headphone_notify.mutex); mutex_destroy(&rt->line_in_notify.mutex); mutex_destroy(&rt->line_out_notify.mutex); } static irqreturn_t ftr_handle_notify_irq(int xx, void *data) { struct gpio_notification *notif = data; schedule_delayed_work(&notif->work, 0); return IRQ_HANDLED; } static int ftr_set_notify(struct gpio_runtime *rt, enum notify_type type, notify_func_t notify, void *data) { struct gpio_notification *notif; notify_func_t old; int irq; char *name; int err = -EBUSY; switch (type) { case AOA_NOTIFY_HEADPHONE: notif = &rt->headphone_notify; name = "headphone-detect"; irq = headphone_detect_irq; break; case AOA_NOTIFY_LINE_IN: notif = &rt->line_in_notify; name = "linein-detect"; irq = linein_detect_irq; break; case AOA_NOTIFY_LINE_OUT: notif = &rt->line_out_notify; name = "lineout-detect"; irq = lineout_detect_irq; break; default: return -EINVAL; } if (!irq) return -ENODEV; mutex_lock(&notif->mutex); old = notif->notify; if (!old && !notify) { err = 0; goto out_unlock; } if (old && notify) { if (old == notify && notif->data == data) err = 0; goto out_unlock; } if (old && !notify) free_irq(irq, notif); if (!old && notify) { err = request_irq(irq, ftr_handle_notify_irq, 0, name, notif); if (err) goto out_unlock; } notif->notify = notify; notif->data = data; err = 0; out_unlock: mutex_unlock(&notif->mutex); return err; } static int ftr_get_detect(struct gpio_runtime *rt, enum notify_type type) { int gpio, ret, active; switch (type) { case AOA_NOTIFY_HEADPHONE: gpio = headphone_detect_gpio; active = headphone_detect_gpio_activestate; break; case AOA_NOTIFY_LINE_IN: gpio = linein_detect_gpio; active = linein_detect_gpio_activestate; break; case AOA_NOTIFY_LINE_OUT: gpio = lineout_detect_gpio; active = lineout_detect_gpio_activestate; break; default: return -EINVAL; } if (gpio == -1) return -ENODEV; ret = pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, gpio, 0); if (ret < 0) return ret; return ((ret >> 1) & 1) == active; } static struct gpio_methods methods = { .init = ftr_gpio_init, .exit = ftr_gpio_exit, .all_amps_off = ftr_gpio_all_amps_off, .all_amps_restore = ftr_gpio_all_amps_restore, .set_headphone = ftr_gpio_set_headphone, .set_speakers = ftr_gpio_set_amp, .set_lineout = ftr_gpio_set_lineout, .set_hw_reset = ftr_gpio_set_hw_reset, .get_headphone = ftr_gpio_get_headphone, .get_speakers = ftr_gpio_get_amp, .get_lineout = ftr_gpio_get_lineout, .set_notify = ftr_set_notify, .get_detect = ftr_get_detect, }; struct gpio_methods *ftr_gpio_methods = &methods; EXPORT_SYMBOL_GPL(ftr_gpio_methods);
linux-master
sound/aoa/core/gpio-feature.c
// SPDX-License-Identifier: GPL-2.0-only /* * Apple Onboard Audio Alsa helpers * * Copyright 2006 Johannes Berg <[email protected]> */ #include <linux/module.h> #include "alsa.h" static int index = -1; module_param(index, int, 0444); MODULE_PARM_DESC(index, "index for AOA sound card."); static struct aoa_card *aoa_card; int aoa_alsa_init(char *name, struct module *mod, struct device *dev) { struct snd_card *alsa_card; int err; if (aoa_card) /* cannot be EEXIST due to usage in aoa_fabric_register */ return -EBUSY; err = snd_card_new(dev, index, name, mod, sizeof(struct aoa_card), &alsa_card); if (err < 0) return err; aoa_card = alsa_card->private_data; aoa_card->alsa_card = alsa_card; strscpy(alsa_card->driver, "AppleOnbdAudio", sizeof(alsa_card->driver)); strscpy(alsa_card->shortname, name, sizeof(alsa_card->shortname)); strscpy(alsa_card->longname, name, sizeof(alsa_card->longname)); strscpy(alsa_card->mixername, name, sizeof(alsa_card->mixername)); err = snd_card_register(aoa_card->alsa_card); if (err < 0) { printk(KERN_ERR "snd-aoa: couldn't register alsa card\n"); snd_card_free(aoa_card->alsa_card); aoa_card = NULL; return err; } return 0; } struct snd_card *aoa_get_card(void) { if (aoa_card) return aoa_card->alsa_card; return NULL; } EXPORT_SYMBOL_GPL(aoa_get_card); void aoa_alsa_cleanup(void) { if (aoa_card) { snd_card_free(aoa_card->alsa_card); aoa_card = NULL; } } int aoa_snd_device_new(enum snd_device_type type, void *device_data, const struct snd_device_ops *ops) { struct snd_card *card = aoa_get_card(); int err; if (!card) return -ENOMEM; err = snd_device_new(card, type, device_data, ops); if (err) { printk(KERN_ERR "snd-aoa: failed to create snd device (%d)\n", err); return err; } err = snd_device_register(card, device_data); if (err) { printk(KERN_ERR "snd-aoa: failed to register " "snd device (%d)\n", err); printk(KERN_ERR "snd-aoa: have you forgotten the " "dev_register callback?\n"); snd_device_free(card, device_data); } return err; } EXPORT_SYMBOL_GPL(aoa_snd_device_new); int aoa_snd_ctl_add(struct snd_kcontrol* control) { int err; if (!aoa_card) return -ENODEV; err = snd_ctl_add(aoa_card->alsa_card, control); if (err) printk(KERN_ERR "snd-aoa: failed to add alsa control (%d)\n", err); return err; } EXPORT_SYMBOL_GPL(aoa_snd_ctl_add);
linux-master
sound/aoa/core/alsa.c
// SPDX-License-Identifier: GPL-2.0-only /* * Apple Onboard Audio driver core * * Copyright 2006 Johannes Berg <[email protected]> */ #include <linux/init.h> #include <linux/module.h> #include <linux/list.h> #include "../aoa.h" #include "alsa.h" MODULE_DESCRIPTION("Apple Onboard Audio Sound Driver"); MODULE_AUTHOR("Johannes Berg <[email protected]>"); MODULE_LICENSE("GPL"); /* We allow only one fabric. This simplifies things, * and more don't really make that much sense */ static struct aoa_fabric *fabric; static LIST_HEAD(codec_list); static int attach_codec_to_fabric(struct aoa_codec *c) { int err; if (!try_module_get(c->owner)) return -EBUSY; /* found_codec has to be assigned */ err = -ENOENT; if (fabric->found_codec) err = fabric->found_codec(c); if (err) { module_put(c->owner); printk(KERN_ERR "snd-aoa: fabric didn't like codec %s\n", c->name); return err; } c->fabric = fabric; err = 0; if (c->init) err = c->init(c); if (err) { printk(KERN_ERR "snd-aoa: codec %s didn't init\n", c->name); c->fabric = NULL; if (fabric->remove_codec) fabric->remove_codec(c); module_put(c->owner); return err; } if (fabric->attached_codec) fabric->attached_codec(c); return 0; } int aoa_codec_register(struct aoa_codec *codec) { int err = 0; /* if there's a fabric already, we can tell if we * will want to have this codec, so propagate error * through. Otherwise, this will happen later... */ if (fabric) err = attach_codec_to_fabric(codec); if (!err) list_add(&codec->list, &codec_list); return err; } EXPORT_SYMBOL_GPL(aoa_codec_register); void aoa_codec_unregister(struct aoa_codec *codec) { list_del(&codec->list); if (codec->fabric && codec->exit) codec->exit(codec); if (fabric && fabric->remove_codec) fabric->remove_codec(codec); codec->fabric = NULL; module_put(codec->owner); } EXPORT_SYMBOL_GPL(aoa_codec_unregister); int aoa_fabric_register(struct aoa_fabric *new_fabric, struct device *dev) { struct aoa_codec *c; int err; /* allow querying for presence of fabric * (i.e. do this test first!) */ if (new_fabric == fabric) { err = -EALREADY; goto attach; } if (fabric) return -EEXIST; if (!new_fabric) return -EINVAL; err = aoa_alsa_init(new_fabric->name, new_fabric->owner, dev); if (err) return err; fabric = new_fabric; attach: list_for_each_entry(c, &codec_list, list) { if (c->fabric != fabric) attach_codec_to_fabric(c); } return err; } EXPORT_SYMBOL_GPL(aoa_fabric_register); void aoa_fabric_unregister(struct aoa_fabric *old_fabric) { struct aoa_codec *c; if (fabric != old_fabric) return; list_for_each_entry(c, &codec_list, list) { if (c->fabric) aoa_fabric_unlink_codec(c); } aoa_alsa_cleanup(); fabric = NULL; } EXPORT_SYMBOL_GPL(aoa_fabric_unregister); void aoa_fabric_unlink_codec(struct aoa_codec *codec) { if (!codec->fabric) { printk(KERN_ERR "snd-aoa: fabric unassigned " "in aoa_fabric_unlink_codec\n"); dump_stack(); return; } if (codec->exit) codec->exit(codec); if (codec->fabric->remove_codec) codec->fabric->remove_codec(codec); codec->fabric = NULL; module_put(codec->owner); } EXPORT_SYMBOL_GPL(aoa_fabric_unlink_codec); static int __init aoa_init(void) { return 0; } static void __exit aoa_exit(void) { aoa_alsa_cleanup(); } module_init(aoa_init); module_exit(aoa_exit);
linux-master
sound/aoa/core/core.c
// SPDX-License-Identifier: GPL-2.0-only /* * Apple Onboard Audio pmf GPIOs * * Copyright 2006 Johannes Berg <[email protected]> */ #include <linux/slab.h> #include <asm/pmac_feature.h> #include <asm/pmac_pfunc.h> #include "../aoa.h" #define PMF_GPIO(name, bit) \ static void pmf_gpio_set_##name(struct gpio_runtime *rt, int on)\ { \ struct pmf_args args = { .count = 1, .u[0].v = !on }; \ int rc; \ \ if (unlikely(!rt)) return; \ rc = pmf_call_function(rt->node, #name "-mute", &args); \ if (rc && rc != -ENODEV) \ printk(KERN_WARNING "pmf_gpio_set_" #name \ " failed, rc: %d\n", rc); \ rt->implementation_private &= ~(1<<bit); \ rt->implementation_private |= (!!on << bit); \ } \ static int pmf_gpio_get_##name(struct gpio_runtime *rt) \ { \ if (unlikely(!rt)) return 0; \ return (rt->implementation_private>>bit)&1; \ } PMF_GPIO(headphone, 0); PMF_GPIO(amp, 1); PMF_GPIO(lineout, 2); static void pmf_gpio_set_hw_reset(struct gpio_runtime *rt, int on) { struct pmf_args args = { .count = 1, .u[0].v = !!on }; int rc; if (unlikely(!rt)) return; rc = pmf_call_function(rt->node, "hw-reset", &args); if (rc) printk(KERN_WARNING "pmf_gpio_set_hw_reset" " failed, rc: %d\n", rc); } static void pmf_gpio_all_amps_off(struct gpio_runtime *rt) { int saved; if (unlikely(!rt)) return; saved = rt->implementation_private; pmf_gpio_set_headphone(rt, 0); pmf_gpio_set_amp(rt, 0); pmf_gpio_set_lineout(rt, 0); rt->implementation_private = saved; } static void pmf_gpio_all_amps_restore(struct gpio_runtime *rt) { int s; if (unlikely(!rt)) return; s = rt->implementation_private; pmf_gpio_set_headphone(rt, (s>>0)&1); pmf_gpio_set_amp(rt, (s>>1)&1); pmf_gpio_set_lineout(rt, (s>>2)&1); } static void pmf_handle_notify(struct work_struct *work) { struct gpio_notification *notif = container_of(work, struct gpio_notification, work.work); mutex_lock(&notif->mutex); if (notif->notify) notif->notify(notif->data); mutex_unlock(&notif->mutex); } static void pmf_gpio_init(struct gpio_runtime *rt) { pmf_gpio_all_amps_off(rt); rt->implementation_private = 0; INIT_DELAYED_WORK(&rt->headphone_notify.work, pmf_handle_notify); INIT_DELAYED_WORK(&rt->line_in_notify.work, pmf_handle_notify); INIT_DELAYED_WORK(&rt->line_out_notify.work, pmf_handle_notify); mutex_init(&rt->headphone_notify.mutex); mutex_init(&rt->line_in_notify.mutex); mutex_init(&rt->line_out_notify.mutex); } static void pmf_gpio_exit(struct gpio_runtime *rt) { pmf_gpio_all_amps_off(rt); rt->implementation_private = 0; if (rt->headphone_notify.gpio_private) pmf_unregister_irq_client(rt->headphone_notify.gpio_private); if (rt->line_in_notify.gpio_private) pmf_unregister_irq_client(rt->line_in_notify.gpio_private); if (rt->line_out_notify.gpio_private) pmf_unregister_irq_client(rt->line_out_notify.gpio_private); /* make sure no work is pending before freeing * all things */ cancel_delayed_work_sync(&rt->headphone_notify.work); cancel_delayed_work_sync(&rt->line_in_notify.work); cancel_delayed_work_sync(&rt->line_out_notify.work); mutex_destroy(&rt->headphone_notify.mutex); mutex_destroy(&rt->line_in_notify.mutex); mutex_destroy(&rt->line_out_notify.mutex); kfree(rt->headphone_notify.gpio_private); kfree(rt->line_in_notify.gpio_private); kfree(rt->line_out_notify.gpio_private); } static void pmf_handle_notify_irq(void *data) { struct gpio_notification *notif = data; schedule_delayed_work(&notif->work, 0); } static int pmf_set_notify(struct gpio_runtime *rt, enum notify_type type, notify_func_t notify, void *data) { struct gpio_notification *notif; notify_func_t old; struct pmf_irq_client *irq_client; char *name; int err = -EBUSY; switch (type) { case AOA_NOTIFY_HEADPHONE: notif = &rt->headphone_notify; name = "headphone-detect"; break; case AOA_NOTIFY_LINE_IN: notif = &rt->line_in_notify; name = "linein-detect"; break; case AOA_NOTIFY_LINE_OUT: notif = &rt->line_out_notify; name = "lineout-detect"; break; default: return -EINVAL; } mutex_lock(&notif->mutex); old = notif->notify; if (!old && !notify) { err = 0; goto out_unlock; } if (old && notify) { if (old == notify && notif->data == data) err = 0; goto out_unlock; } if (old && !notify) { irq_client = notif->gpio_private; pmf_unregister_irq_client(irq_client); kfree(irq_client); notif->gpio_private = NULL; } if (!old && notify) { irq_client = kzalloc(sizeof(struct pmf_irq_client), GFP_KERNEL); if (!irq_client) { err = -ENOMEM; goto out_unlock; } irq_client->data = notif; irq_client->handler = pmf_handle_notify_irq; irq_client->owner = THIS_MODULE; err = pmf_register_irq_client(rt->node, name, irq_client); if (err) { printk(KERN_ERR "snd-aoa: gpio layer failed to" " register %s irq (%d)\n", name, err); kfree(irq_client); goto out_unlock; } notif->gpio_private = irq_client; } notif->notify = notify; notif->data = data; err = 0; out_unlock: mutex_unlock(&notif->mutex); return err; } static int pmf_get_detect(struct gpio_runtime *rt, enum notify_type type) { char *name; int err = -EBUSY, ret; struct pmf_args args = { .count = 1, .u[0].p = &ret }; switch (type) { case AOA_NOTIFY_HEADPHONE: name = "headphone-detect"; break; case AOA_NOTIFY_LINE_IN: name = "linein-detect"; break; case AOA_NOTIFY_LINE_OUT: name = "lineout-detect"; break; default: return -EINVAL; } err = pmf_call_function(rt->node, name, &args); if (err) return err; return ret; } static struct gpio_methods methods = { .init = pmf_gpio_init, .exit = pmf_gpio_exit, .all_amps_off = pmf_gpio_all_amps_off, .all_amps_restore = pmf_gpio_all_amps_restore, .set_headphone = pmf_gpio_set_headphone, .set_speakers = pmf_gpio_set_amp, .set_lineout = pmf_gpio_set_lineout, .set_hw_reset = pmf_gpio_set_hw_reset, .get_headphone = pmf_gpio_get_headphone, .get_speakers = pmf_gpio_get_amp, .get_lineout = pmf_gpio_get_lineout, .set_notify = pmf_set_notify, .get_detect = pmf_get_detect, }; struct gpio_methods *pmf_gpio_methods = &methods; EXPORT_SYMBOL_GPL(pmf_gpio_methods);
linux-master
sound/aoa/core/gpio-pmf.c