The original driver was written by Florian Faber in 2012. This patch represents the updated version of the original driver.
List of updates since the initial driver version: - Update deprecated API calls, so it could be sent upstream - Fix codestyle issues - Fix memory allocation issues - Add locking - Remove support for other models of Marian sound cards, which I was unable to test and which are not documented anywhere.
Despite lacking of special equipment required for recording and playing MIDI/MADI, I was able to test the driver and fix some issues using the integrated and external loopbacks. Now the driver seems to work well.
Signed-off-by: Ivan Orlov ivan.orlov0322@gmail.com --- V1 -> V2: - Remove redundant documentation fix
MAINTAINERS | 7 + sound/pci/Kconfig | 10 + sound/pci/Makefile | 2 + sound/pci/marianm2.c | 1785 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 1804 insertions(+) create mode 100644 sound/pci/marianm2.c
diff --git a/MAINTAINERS b/MAINTAINERS index 90f13281d297..1e04a6c25a55 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -12621,6 +12621,13 @@ L: linux-mips@vger.kernel.org S: Maintained F: arch/mips/boot/dts/img/pistachio*
+MARIAN SERAPH M2 SOUND CARD DRIVER +M: Ivan Orlov ivan.orlov0322@gmail.com +L: alsa-devel@alsa-project.org (moderated for non-subscribers) +S: Maintained +F: Documentation/sound/cards/marian-m2.rst +F: sound/pci/marianm2.c + MARVELL 88E6XXX ETHERNET SWITCH FABRIC DRIVER M: Andrew Lunn andrew@lunn.ch L: netdev@vger.kernel.org diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig index 787868c9e91b..e3dad79743e5 100644 --- a/sound/pci/Kconfig +++ b/sound/pci/Kconfig @@ -222,6 +222,16 @@ config SND_CMIPCI To compile this driver as a module, choose M here: the module will be called snd-cmipci.
+config SND_MARIANM2 + tristate "MARIAN Seraph M2" + select SND_PCM + help + Say Y to include support for MARIAN Seraph M2 sound card + file:Documentation/sound/cards/marian-m2.rst. + + To compile this driver as a module, choose M here: the module + will be called snd-marianm2 + config SND_OXYGEN_LIB tristate
diff --git a/sound/pci/Makefile b/sound/pci/Makefile index 04cac7469139..4d2f52c98a74 100644 --- a/sound/pci/Makefile +++ b/sound/pci/Makefile @@ -22,6 +22,7 @@ snd-fm801-objs := fm801.o snd-intel8x0-objs := intel8x0.o snd-intel8x0m-objs := intel8x0m.o snd-maestro3-objs := maestro3.o +snd-marianm2-objs := marianm2.o snd-rme32-objs := rme32.o snd-rme96-objs := rme96.o snd-sis7019-objs := sis7019.o @@ -48,6 +49,7 @@ obj-$(CONFIG_SND_FM801) += snd-fm801.o obj-$(CONFIG_SND_INTEL8X0) += snd-intel8x0.o obj-$(CONFIG_SND_INTEL8X0M) += snd-intel8x0m.o obj-$(CONFIG_SND_MAESTRO3) += snd-maestro3.o +obj-$(CONFIG_SND_MARIANM2) += snd-marianm2.o obj-$(CONFIG_SND_RME32) += snd-rme32.o obj-$(CONFIG_SND_RME96) += snd-rme96.o obj-$(CONFIG_SND_SIS7019) += snd-sis7019.o diff --git a/sound/pci/marianm2.c b/sound/pci/marianm2.c new file mode 100644 index 000000000000..1ffa47cded3f --- /dev/null +++ b/sound/pci/marianm2.c @@ -0,0 +1,1785 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * ALSA driver for MARIAN Seraph audio interfaces + * + * Copyright (c) 2012 Florian Faber faberman@linuxproaudio.org, + * 2023 Ivan Orlov ivan.orlov0322@gmail.com + */ + +#include <sound/core.h> +#include <sound/control.h> +#include <sound/pcm.h> +#include <sound/pcm_params.h> +#include <sound/core.h> +#include <sound/pcm.h> +#include <sound/initval.h> +#include <sound/info.h> +#include <linux/delay.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/interrupt.h> + +#define DEBUG + +#define M2_CHANNELS_COUNT 128 + +#define M2_FRAME_SIZE (M2_CHANNELS_COUNT * 4) +#define SUBSTREAM_PERIOD_SIZE (2048 * M2_FRAME_SIZE) +#define SUBSTREAM_BUF_SIZE (2 * SUBSTREAM_PERIOD_SIZE) + +#define SERAPH_RD_IRQ_STATUS 0x00 +#define SERAPH_RD_HWPOINTER 0x8C + +#define SERAPH_WR_DMA_ADR 0x04 +#define SERAPH_WR_ENABLE_CAPTURE 0x08 +#define SERAPH_WR_ENABLE_PLAYBACK 0x0C +#define SERAPH_WR_DMA_BLOCKS 0x10 + +#define M2_DISABLE_PLAY_IRQ BIT(1) +#define M2_DISABLE_CAPT_IRQ BIT(2) +#define M2_ENABLE_LOOPBACK BIT(3) +#define SERAPH_WR_DMA_ENABLE 0x84 +#define SERAPH_WR_IE_ENABLE 0xAC + +#define PCI_VENDOR_ID_MARIAN 0x1382 +#define PCI_DEVICE_ID_MARIAN_SERAPH_M2 0x5021 + +#define RATE_SLOW 54000 +#define RATE_FAST 108000 + +#define SPEEDMODE_SLOW 1 +#define SPEEDMODE_FAST 2 + +#define MARIAN_PORTS_TYPE_INPUT 0 +#define MARIAN_PORTS_TYPE_OUTPUT 1 + +#define MARIAN_SPI_CLOCK_DIVIDER 0x74 + +#define ERR_DEAD_WRITE BIT(0) +#define ERR_DEAD_READ BIT(1) +#define ERR_DATA_LOST BIT(2) +#define ERR_PAGE_CONF BIT(3) +#define ERR_INT_PLAY BIT(10) +#define ERR_INT_REC BIT(13) + +#define STATUS_ST_READY BIT(4) +#define STATUS_INT_PLAY BIT(8) +#define STATUS_INT_PPLAY BIT(9) +#define STATUS_INT_REC BIT(11) +#define STATUS_INT_PREC BIT(12) +#define STATUS_INT_PREP BIT(14) +#define WCLOCK_NEW_VAL BIT(31) +#define SPI_ALL_READY BIT(31) + +#define M2_CLOCK_SRC_CNT 4 +#define M2_CLOCK_SRC_DCO 1 +#define M2_CLOCK_SRC_SYNCBUS 2 +#define M2_CLOCK_SRC_MADI1 4 +#define M2_CLOCK_SRC_MADI2 5 + +#define M2_SYNC_STATE_CNT 3 +#define M2_CHNL_MODE_CNT 2 +#define M2_FRAME_MODE_CNT 2 + +#define M2_INP1_SYNC_CTL_ID 0 +#define M2_INP1_CM_CTL_ID 0 +#define M2_INP1_FM_CTL_ID 0 +#define M2_INP1_FREQ_CTL_ID 4 +#define M2_OUT1_CM_CTL_ID 0 +#define M2_OUT1_FM_CTL_ID 0 +#define M2_INP2_SYNC_CTL_ID 1 +#define M2_INP2_CM_CTL_ID 1 +#define M2_INP2_FM_CTL_ID 1 +#define M2_INP2_FREQ_CTL_ID 5 +#define M2_OUT2_CM_CTL_ID 1 +#define M2_OUT2_FM_CTL_ID 1 + +// MADI FPGA register 0x40 +// Use internal (=0) or external PLL (=1) +#define M2_PLL 2 + +// MADI FPGA register 0x41 +// Enable both MADI transmitters (=1) +#define M2_TX_ENABLE 0 +// Use int (=0) or 32bit IEEE float (=1) +#define M2_INT_FLOAT 4 +// Big endian (=0), little endian (=1) +#define M2_ENDIANNESS 5 +// MSB first (=0), LSB first (=1) +#define M2_BIT_ORDER 6 + +// MADI FPGA register 0x42 +// Send 56ch (=0) or 64ch (=1) MADI frames +#define M2_PORT1_MODE 0 +// Send 48kHz (=0) or 96kHz (=1) MADI frames +#define M2_PORT1_FRAME 1 +// Send 56ch (=0) or 64ch (=1) MADI frames +#define M2_PORT2_MODE 2 +// Send 48kHz (=0) or 96kHz (=1) MADI frames +#define M2_PORT2_FRAME 3 + +struct marian_card_descriptor; +struct marian_card; + +struct marian_card_descriptor { + char *name; + char *port_names; + unsigned int speedmode_max; + unsigned int ch_in; + unsigned int ch_out; + unsigned int midi_in; + unsigned int midi_out; + unsigned int serial_in; + unsigned int serial_out; + unsigned int wck_in; + unsigned int wck_out; + + unsigned int dma_bufsize; + + void (*hw_constraints_func)(struct marian_card *marian, + struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params); + /* custom function to set up ALSA controls */ + void (*create_controls)(struct marian_card *marian); + /* init is called after probing the card */ + int (*init_card)(struct marian_card *marian); + void (*free_card)(struct marian_card *marian); + /* prepare is called when ALSA is opening the card */ + void (*prepare)(struct marian_card *marian); + void (*set_speedmode)(struct marian_card *marian, unsigned int speedmode); + void (*proc_status)(struct marian_card *marian, struct snd_info_buffer *buffer); + void (*proc_ports)(struct marian_card *marian, struct snd_info_buffer *buffer, + unsigned int type); + + struct snd_pcm_hardware info_playback; + struct snd_pcm_hardware info_capture; +}; + +struct marian_card { + struct marian_card_descriptor *desc; + + struct snd_pcm_substream *playback_substream; + struct snd_pcm_substream *capture_substream; + + struct snd_card *card; + struct snd_pcm *pcm; + struct snd_dma_buffer dmabuf; + + struct snd_dma_buffer playback_buf; + struct snd_dma_buffer capture_buf; + + struct pci_dev *pci; + unsigned long port; + void __iomem *iobase; + int irq; + + unsigned int idx; + + /* hardware registers lock */ + spinlock_t reglock; + + /* spinlock for SPI communication */ + spinlock_t spi_lock; + + /* mutex for frequency measurement */ + struct mutex freq_mutex; + + /* Enables or disables hardware loopback */ + int loopback; + + unsigned int stream_open; + + /* speed mode: 1, 2, 4 times FS */ + unsigned int speedmode; + + /* 0..15, meaning depending on the card type */ + unsigned int clock_source; + + /* Frequency of the internal oscillator (Hertz) */ + unsigned int dco; + /* [0..1) part of the internal oscillator frequency (milli Hertz) */ + unsigned int dco_millis; + + /* [-200 .. 200] Two semitone 'musical' adjustment */ + int detune; + + /* WCK input termination on (1)/off (0) */ + unsigned int wck_term; + + /* WCK output source */ + unsigned int wck_output; + + void *card_specific; +}; + +enum CLOCK_SOURCE { + CLOCK_SRC_INTERNAL = 0, + CLOCK_SRC_SYNCBUS = 1, + CLOCK_SRC_INP1 = 2, + CLOCK_SRC_INP2 = 3, + CLOCK_SRC_INP3 = 4, +}; + +enum m2_num_mode { + M2_NUM_MODE_INT = 0, + M2_NUM_MODE_FLOAT = 1, +}; + +enum m2_endianness_mode { + M2_BE = 0, + M2_LE = 1, +}; + +struct m2_specific { + u8 shadow_40; + u8 shadow_41; + u8 shadow_42; + u8 frame; +}; + +static const struct pci_device_id snd_marian_ids[] = { + {PCI_DEVICE(PCI_VENDOR_ID_MARIAN, PCI_DEVICE_ID_MARIAN_SERAPH_M2), 0, 0, 6}, + { } +}; + +MODULE_DEVICE_TABLE(pci, snd_marian_ids); + +static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; // Index 0-MAX +static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; // ID for this card + +module_param_array(index, int, NULL, 0444); +MODULE_PARM_DESC(index, "Index value for MARIAN PCI soundcard"); +module_param_array(id, charp, NULL, 0444); +MODULE_PARM_DESC(id, "ID string for MARIAN PCI soundcard"); + +static void snd_marian_card_free(struct snd_card *card) +{ + struct marian_card *marian = card->private_data; + + if (!marian) + return; + + snd_dma_free_pages(&marian->dmabuf); + + if (marian->irq >= 0) + free_irq(marian->irq, (void *)marian); + + if (marian->iobase) + pci_iounmap(marian->pci, marian->iobase); + + if (marian->port) + pci_release_regions(marian->pci); + + pci_disable_device(marian->pci); +} + +static void marian_proc_status_generic(struct marian_card *marian, struct snd_info_buffer *buffer) +{ + snd_iprintf(buffer, "*** Card registers\n"); + snd_iprintf(buffer, "RD 0x064: %08x (SPI bits written)\n", readl(marian->iobase + 0x64)); + snd_iprintf(buffer, "RD 0x068: %08x (SPI bits read)\n", readl(marian->iobase + 0x68)); + snd_iprintf(buffer, "RD 0x070: %08x (SPI bits status)\n", readl(marian->iobase + 0x70)); + snd_iprintf(buffer, "RD 0x088: %08x (Super clock measurement)\n", + readl(marian->iobase + 0x88)); + snd_iprintf(buffer, "RD 0x08C: %08x (HW Pointer)\n", + readl(marian->iobase + SERAPH_RD_HWPOINTER)); + snd_iprintf(buffer, "RD 0x094: %08x (Word clock measurement)\n", + readl(marian->iobase + 0x88)); + snd_iprintf(buffer, "RD 0x0F8: %08x (Extension board)\n", + readl(marian->iobase + 0xF8)); + snd_iprintf(buffer, "RD 0x244: %08x (DMA debug)\n", + readl(marian->iobase + 0x244)); + + snd_iprintf(buffer, "\n*** Card status\n"); + snd_iprintf(buffer, "Firmware build: %08x\n", readl(marian->iobase + 0xFC)); + snd_iprintf(buffer, "Speed mode : %uFS (1..%u)\n", + marian->speedmode, marian->desc->speedmode_max); + snd_iprintf(buffer, "Clock master : %s\n", (marian->clock_source == 1) ? "yes" : "no"); + snd_iprintf(buffer, "DCO frequency: %d.%d Hz\n", marian->dco, marian->dco_millis); + snd_iprintf(buffer, "DCO detune : %d Cent\n", marian->detune); +} + +static void snd_marian_proc_status(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +{ + struct marian_card *marian = entry->private_data; + + if (marian->desc->proc_status) + marian->desc->proc_status(marian, buffer); + else + marian_proc_status_generic(marian, buffer); +} + +/* + * Default port name function, outputs the static string + * port_names of the card descriptor regardless of current + * speed mode and whether input or output ports are requested. + */ +static void marian_proc_ports_generic(struct marian_card *marian, struct snd_info_buffer *buffer, + unsigned int type) +{ + snd_iprintf(buffer, marian->desc->port_names); +} + +static void snd_marian_proc_ports_in(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +{ + struct marian_card *marian = entry->private_data; + + snd_iprintf(buffer, "# generated by MARIAN Seraph driver\n"); + if (marian->desc->proc_ports) + marian->desc->proc_ports(marian, buffer, MARIAN_PORTS_TYPE_INPUT); + else + marian_proc_ports_generic(marian, buffer, MARIAN_PORTS_TYPE_INPUT); +} + +static void snd_marian_proc_ports_out(struct snd_info_entry *entry, struct snd_info_buffer *buffer) +{ + struct marian_card *marian = entry->private_data; + + snd_iprintf(buffer, "# generated by MARIAN Seraph driver\n"); + if (marian->desc->proc_ports) + marian->desc->proc_ports(marian, buffer, MARIAN_PORTS_TYPE_OUTPUT); + else + marian_proc_ports_generic(marian, buffer, MARIAN_PORTS_TYPE_OUTPUT); +} + +static irqreturn_t snd_marian_interrupt(int irq, void *dev_id) +{ + struct marian_card *marian = (struct marian_card *)dev_id; + unsigned int irq_status; + + irq_status = readl(marian->iobase + SERAPH_RD_IRQ_STATUS); + + if (irq_status & 0x00004800) { + if (marian->playback_substream) + snd_pcm_period_elapsed(marian->playback_substream); + + if (marian->capture_substream) + snd_pcm_period_elapsed(marian->capture_substream); + + return IRQ_HANDLED; + } + + return IRQ_NONE; +} + +static int snd_marian_playback_open(struct snd_pcm_substream *substream) +{ + struct marian_card *marian = substream->private_data; + + substream->runtime->hw = marian->desc->info_playback; + + marian->playback_substream = substream; + + snd_pcm_set_sync(substream); + + return 0; +} + +static int snd_marian_capture_open(struct snd_pcm_substream *substream) +{ + struct marian_card *marian = substream->private_data; + + substream->runtime->hw = marian->desc->info_capture; + + marian->capture_substream = substream; + + snd_pcm_set_sync(substream); + + return 0; +} + +static int snd_marian_capture_release(struct snd_pcm_substream *substream) +{ + struct marian_card *marian = snd_pcm_substream_chip(substream); + + marian->capture_substream = NULL; + + return 0; +} + +static int snd_marian_playback_release(struct snd_pcm_substream *substream) +{ + struct marian_card *marian = snd_pcm_substream_chip(substream); + + marian->playback_substream = NULL; + + return 0; +} + +static void marian_generic_set_dco(struct marian_card *marian, unsigned int freq, + unsigned int millis) +{ + u64 val, v2; + s64 detune; + + val = (freq * 1000 + millis) * marian->speedmode; + val <<= 36; + + if (marian->detune != 0) { + /* + * DCO detune active + * this calculation takes a bit of a shortcut + * - should be implemented using a logarithmic scale + */ + detune = marian->detune * 100; + v2 = val; + div_u64(v2, 138564); + detune *= v2; + val += detune; + } + + val = div_u64(val, 80000000); + val = div_u64(val, 1000); + + writel((u32)val, marian->iobase + 0x88); + + marian->dco = freq; + marian->dco_millis = millis; +} + +static void marian_generic_set_speedmode(struct marian_card *marian, unsigned int speedmode) +{ + if (speedmode > marian->desc->speedmode_max) + return; + + switch (speedmode) { + case SPEEDMODE_SLOW: + writel(0x03, marian->iobase + 0x80); + writel(0x00, marian->iobase + 0x8C); // for 48kHz in 1FS mode + marian->speedmode = SPEEDMODE_SLOW; + break; + case SPEEDMODE_FAST: + writel(0x03, marian->iobase + 0x80); + writel(0x01, marian->iobase + 0x8C); // for 96kHz in 2FS mode + marian->speedmode = SPEEDMODE_FAST; + break; + } + + marian_generic_set_dco(marian, marian->dco, marian->dco_millis); +} + +static int snd_marian_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) +{ + struct marian_card *marian = snd_pcm_substream_chip(substream); + unsigned int speedmode; + int buffer_frames; + + buffer_frames = SUBSTREAM_BUF_SIZE / M2_FRAME_SIZE; + + if (params_rate(params) < RATE_SLOW) + speedmode = SPEEDMODE_SLOW; + else if (params_rate(params) < RATE_FAST) + speedmode = SPEEDMODE_FAST; + + if (speedmode > marian->desc->speedmode_max) { + dev_err(marian->card->dev, + "Requested rate (%u Hz) higher than card's maximum\n", + params_rate(params)); + _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE); + return -EBUSY; + } + + spin_lock(&marian->reglock); + if (marian->desc->set_speedmode) + marian->desc->set_speedmode(marian, speedmode); + else + marian_generic_set_speedmode(marian, speedmode); + + marian->detune = 0; + + marian_generic_set_dco(marian, params_rate(params), 0); + spin_unlock(&marian->reglock); + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + snd_pcm_set_runtime_buffer(substream, &marian->playback_buf); + else + snd_pcm_set_runtime_buffer(substream, &marian->capture_buf); + + // apply optional card specific hw constraints + if (marian->desc->hw_constraints_func) + marian->desc->hw_constraints_func(marian, substream, params); + + return 0; +} + +static int snd_marian_prepare(struct snd_pcm_substream *substream) +{ + struct marian_card *marian = snd_pcm_substream_chip(substream); + + if (marian->desc->prepare) + marian->desc->prepare(marian); + + return 0; +} + +static void marian_silence(struct marian_card *marian) +{ + memset(marian->dmabuf.area, 0, marian->dmabuf.bytes); +} + +// atomic by default, no need for locking here +static int snd_marian_trigger(struct snd_pcm_substream *substream, int cmd) +{ + struct marian_card *marian = snd_pcm_substream_chip(substream); + int irq_flags; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + irq_flags = M2_DISABLE_PLAY_IRQ; + if (marian->loopback) + irq_flags |= M2_ENABLE_LOOPBACK; + + marian_silence(marian); + writel(0x3, marian->iobase + SERAPH_WR_DMA_ENABLE); + writel(irq_flags, marian->iobase + SERAPH_WR_IE_ENABLE); + break; + case SNDRV_PCM_TRIGGER_STOP: + irq_flags = M2_DISABLE_PLAY_IRQ | M2_DISABLE_CAPT_IRQ; + writel(irq_flags, marian->iobase + SERAPH_WR_IE_ENABLE); + writel(0x0, marian->iobase + SERAPH_WR_DMA_ENABLE); + marian_silence(marian); + + // unarm channels to inhibit playback from the FPGA's internal buffer + writel(0, marian->iobase + 0x08); + writel(0, marian->iobase + 0x0C); + writel(0, marian->iobase + 0x20); + writel(0, marian->iobase + 0x24); + writel(0, marian->iobase + 0x28); + writel(0, marian->iobase + 0x2C); + writel(0, marian->iobase + 0x30); + writel(0, marian->iobase + 0x34); + writel(0, marian->iobase + 0x38); + writel(0, marian->iobase + 0x3C); + break; + default: + return -EINVAL; + } + + return 0; +} + +static snd_pcm_uframes_t snd_marian_hw_pointer(struct snd_pcm_substream *substream) +{ + struct marian_card *marian = snd_pcm_substream_chip(substream); + + return readl(marian->iobase + SERAPH_RD_HWPOINTER); +} + +static int snd_marian_mmap(struct snd_pcm_substream *substream, struct vm_area_struct *vma) +{ + struct marian_card *marian = snd_pcm_substream_chip(substream); + + if (remap_pfn_range(vma, vma->vm_start, substream->runtime->dma_addr >> PAGE_SHIFT, + vma->vm_end - vma->vm_start, vma->vm_page_prot) < 0) { + dev_err(marian->card->dev, "remap_pfn_range failed\n"); + return -EIO; + } + + return 0; +} + +static const struct snd_pcm_ops snd_marian_playback_ops = { + .open = snd_marian_playback_open, + .close = snd_marian_playback_release, + .hw_params = snd_marian_hw_params, + .prepare = snd_marian_prepare, + .trigger = snd_marian_trigger, + .pointer = snd_marian_hw_pointer, + .mmap = snd_marian_mmap, +}; + +static const struct snd_pcm_ops snd_marian_capture_ops = { + .open = snd_marian_capture_open, + .close = snd_marian_capture_release, + .hw_params = snd_marian_hw_params, + .prepare = snd_marian_prepare, + .trigger = snd_marian_trigger, + .pointer = snd_marian_hw_pointer, + .mmap = snd_marian_mmap, +}; + +static void marian_generic_set_clock_source(struct marian_card *marian, u8 source) +{ + spin_lock(&marian->reglock); + writel(source, marian->iobase + 0x90); + marian->clock_source = source; + spin_unlock(&marian->reglock); +} + +static void marian_generic_init(struct marian_card *marian) +{ + if (!marian->desc->set_speedmode) + marian->desc->set_speedmode = marian_generic_set_speedmode; + + // reset DMA engine + writel(0x00000000, marian->iobase); + + // disable play interrupt + writel(M2_DISABLE_PLAY_IRQ, marian->iobase + SERAPH_WR_IE_ENABLE); + + // init clock mode + marian_generic_set_speedmode(marian, SPEEDMODE_SLOW); + + // init internal clock and set it as clock source + marian_generic_set_clock_source(marian, 1); + + // init SPI clock divider + writel(0x1F, marian->iobase + MARIAN_SPI_CLOCK_DIVIDER); +} + +static void construct_playback_buffer(struct marian_card *marian) +{ + marian->playback_buf = marian->dmabuf; + marian->playback_buf.area += SUBSTREAM_BUF_SIZE; + marian->playback_buf.addr += SUBSTREAM_BUF_SIZE; + marian->playback_buf.bytes = SUBSTREAM_BUF_SIZE; +} + +static void construct_capture_buffer(struct marian_card *marian) +{ + marian->capture_buf = marian->dmabuf; + marian->capture_buf.bytes = SUBSTREAM_BUF_SIZE; +} + +static int snd_marian_create(struct snd_card *card, struct pci_dev *pci, + struct marian_card_descriptor *desc, unsigned int idx) +{ + struct snd_info_entry *entry; + struct marian_card *marian = card->private_data; + int err; + unsigned int len; + + marian->desc = desc; + marian->card = card; + marian->pcm = NULL; + marian->pci = pci; + marian->port = 0; + marian->iobase = NULL; + marian->irq = -1; + marian->idx = idx; + spin_lock_init(&marian->reglock); + spin_lock_init(&marian->spi_lock); + mutex_init(&marian->freq_mutex); + + err = pci_enable_device(pci); + if (err < 0) + return err; + + if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32))) { + dev_err(&pci->dev, "Unable to set DMA mask\n"); + return err; + } + + pci_set_master(pci); + + err = pci_request_regions(pci, "marian"); + if (err < 0) + return err; + + marian->port = pci_resource_start(pci, 0); + len = pci_resource_len(pci, 0); + marian->iobase = pci_iomap(pci, 0, 0); + if (!marian->iobase) { + dev_err(&pci->dev, "unable to grab region 0x%lx-0x%lx\n", + marian->port, marian->port + len - 1); + return -EBUSY; + } + + if (request_irq(pci->irq, snd_marian_interrupt, IRQF_SHARED, "marian", marian)) { + dev_err(&pci->dev, "unable to grab IRQ %d\n", pci->irq); + return -EBUSY; + } + marian->irq = pci->irq; + + card->private_free = snd_marian_card_free; + + strscpy(card->driver, "MARIAN FPGA", sizeof(card->driver)); + strscpy(card->shortname, marian->desc->name, sizeof(card->shortname)); + sprintf(card->longname, "%s PCIe audio at 0x%lx, irq %d", + card->shortname, marian->port, marian->irq); + + snd_card_set_dev(card, &pci->dev); + + err = snd_pcm_new(card, desc->name, 0, 1, 1, &marian->pcm); + if (err < 0) + return err; + marian->pcm->private_data = marian; + snd_pcm_set_ops(marian->pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_marian_playback_ops); + snd_pcm_set_ops(marian->pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_marian_capture_ops); + + len = PAGE_ALIGN(desc->dma_bufsize); + err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_CONTINUOUS, &pci->dev, + desc->dma_bufsize, &marian->dmabuf); + if (err < 0) { + dev_err(card->dev, "Could not allocate %d Bytes (%d)\n", len, err); + + snd_dma_free_pages(&marian->dmabuf); + return err; + } + + writel((u32)marian->dmabuf.addr, + marian->iobase + SERAPH_WR_DMA_ADR); + + // Set 'block' count to buffer_frames/16 to set channel 'buffers' count (16 samples each) + writel(SUBSTREAM_BUF_SIZE / M2_FRAME_SIZE / 16, marian->iobase + SERAPH_WR_DMA_BLOCKS); + + construct_capture_buffer(marian); + construct_playback_buffer(marian); + + if (!snd_card_proc_new(card, "status", &entry)) + snd_info_set_text_ops(entry, marian, snd_marian_proc_status); + if (!snd_card_proc_new(card, "ports.in", &entry)) + snd_info_set_text_ops(entry, marian, snd_marian_proc_ports_in); + if (!snd_card_proc_new(card, "ports.out", &entry)) + snd_info_set_text_ops(entry, marian, snd_marian_proc_ports_out); + + if (marian->desc->init_card) + marian->desc->init_card(marian); + else + marian_generic_init(marian); + + if (marian->desc->create_controls) + marian->desc->create_controls(marian); + + return snd_card_register(card); +} + +/* + * Measure the frequency of a clock source. + * The measurement is triggered and the FPGA's ready + * signal polled (normally takes up to 2ms). The measurement + * has only a certainty of 10-20Hz, this function rounds it up + * to the nearest 10Hz step (in 1FS). + */ +static unsigned int marian_measure_freq(struct marian_card *marian, unsigned int source) +{ + mutex_lock(&marian->freq_mutex); + u32 val; + int tries = 5; + + writel(source & 0x7, marian->iobase + 0xC8); + + while (tries > 0) { + val = readl(marian->iobase + 0x94); + if (val & WCLOCK_NEW_VAL) + break; + + usleep_range(1000, 1200); + tries--; + } + + mutex_unlock(&marian->freq_mutex); + + if (tries > 0) + return (((1280000000 / ((val & 0x3FFFF) + 1)) + 5 * marian->speedmode) + / (10 * marian->speedmode)) * 10 * marian->speedmode; + + return 0; +} + +static int marian_generic_frequency_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 = 27000; + uinfo->value.integer.max = 207000; + uinfo->value.integer.step = 1; + return 0; +} + +static int marian_generic_frequency_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = marian_measure_freq(marian, kcontrol->private_value); + return 0; +} + +static int marian_generic_frequency_create(struct marian_card *marian, char *label, u32 idx) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .private_value = idx, + .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_generic_frequency_info, + .get = marian_generic_frequency_get + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int marian_generic_dco_int_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 1; + if (marian->speedmode == SPEEDMODE_SLOW) { + uinfo->value.integer.min = 32000; + uinfo->value.integer.max = 54000; + } + uinfo->value.integer.step = 1; + return 0; +} + +static int marian_generic_dco_int_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = marian->dco; + + return 0; +} + +static int marian_generic_dco_int_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + spin_lock(&marian->reglock); + marian_generic_set_dco(marian, ucontrol->value.integer.value[0], marian->dco_millis); + spin_unlock(&marian->reglock); + + return 0; +} + +static int marian_generic_dco_int_create(struct marian_card *marian, char *label) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_generic_dco_int_info, + .get = marian_generic_dco_int_get, + .put = marian_generic_dco_int_put + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int marian_generic_dco_millis_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 = 999; + uinfo->value.integer.step = 1; + + return 0; +} + +static int marian_generic_dco_millis_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = marian->dco_millis; + + return 0; +} + +static int marian_generic_dco_millis_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + spin_lock(&marian->reglock); + marian_generic_set_dco(marian, marian->dco, ucontrol->value.integer.value[0]); + spin_unlock(&marian->reglock); + + return 0; +} + +static int marian_generic_dco_millis_create(struct marian_card *marian, char *label) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_generic_dco_millis_info, + .get = marian_generic_dco_millis_get, + .put = marian_generic_dco_millis_put + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int marian_generic_dco_detune_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 = -200; + uinfo->value.integer.max = 200; + uinfo->value.integer.step = 1; + return 0; +} + +static int marian_generic_dco_detune_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = marian->detune; + + return 0; +} + +static int marian_generic_dco_detune_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + spin_lock(&marian->reglock); + marian->detune = ucontrol->value.integer.value[0]; + + marian_generic_set_dco(marian, marian->dco, marian->dco_millis); + spin_unlock(&marian->reglock); + + return 0; +} + +static int marian_generic_dco_detune_create(struct marian_card *marian, char *label) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_generic_dco_detune_info, + .get = marian_generic_dco_detune_get, + .put = marian_generic_dco_detune_put + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int marian_control_pcm_loopback_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; + uinfo->count = 1; + uinfo->value.integer.min = 0; + uinfo->value.integer.max = 1; + + return 0; +} + +static int marian_control_pcm_loopback_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = marian->loopback; + + return 0; +} + +static int marian_control_pcm_loopback_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + marian->loopback = ucontrol->value.integer.value[0]; + + return 0; +} +static int marian_control_pcm_loopback_create(struct marian_card *marian) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = "Loopback", + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, + .info = marian_control_pcm_loopback_info, + .get = marian_control_pcm_loopback_get, + .put = marian_control_pcm_loopback_put, + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static void marian_generic_dco_create(struct marian_card *marian) +{ + marian_generic_dco_int_create(marian, "DCO Freq (Hz)"); + marian_generic_dco_millis_create(marian, "DCO Freq (millis)"); + marian_generic_dco_detune_create(marian, "DCO Detune (cent)"); +} + +static int marian_generic_speedmode_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + static const char * const texts[] = { "1FS", "2FS", "4FS" }; + + uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; + uinfo->count = 1; + switch (marian->desc->speedmode_max) { + case SPEEDMODE_SLOW: + uinfo->value.enumerated.items = 1; + break; + case SPEEDMODE_FAST: + uinfo->value.enumerated.items = 2; + break; + } + if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) + uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; + strscpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item], + sizeof(uinfo->value.enumerated.name)); + return 0; +} + +static int marian_generic_speedmode_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + ucontrol->value.enumerated.item[0] = marian->speedmode - 1; + + return 0; +} + +static int marian_generic_speedmode_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + spin_lock(&marian->reglock); + marian->desc->set_speedmode(marian, ucontrol->value.enumerated.item[0] + 1); + spin_unlock(&marian->reglock); + + return 0; +} + +static int marian_generic_speedmode_create(struct marian_card *marian) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Speed Mode", + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_generic_speedmode_info, + .get = marian_generic_speedmode_get, + .put = marian_generic_speedmode_put, + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int spi_wait_for_ar(struct marian_card *marian) +{ + int tries = 10; + + while (tries > 0) { + if (readl(marian->iobase + 0x70) == SPI_ALL_READY) + break; + udelay(100); + tries--; + } + if (tries == 0) + return -EIO; + return 0; +} + +static int marian_spi_transfer(struct marian_card *marian, uint16_t cs, uint16_t bits_write, + u8 *data_write, uint16_t bits_read, u8 *data_read) +{ + u32 buf = 0; + unsigned int i; + int err = 0; + + spin_lock(&marian->spi_lock); + + if (spi_wait_for_ar(marian) < 0) + writel(0x1234, marian->iobase + 0x70); // Resetting SPI bus + + writel(cs, marian->iobase + 0x60); // chip select register + writel(bits_write, marian->iobase + 0x64); // number of bits to write + writel(bits_read, marian->iobase + 0x68); // number of bits to read + + if (bits_write <= 32) { + if (bits_write <= 8) + buf = data_write[0] << (32 - bits_write); + else if (bits_write <= 16) + buf = data_write[0] << 24 | data_write[1] << (32 - bits_write); + + writel(buf, marian->iobase + 0x6C); // write data left aligned + } + if (bits_read > 0 && bits_read <= 32) { + if (spi_wait_for_ar(marian) < 0) { + dev_dbg(marian->card->dev, + "Bus didn't signal AR\n"); + err = -EIO; + goto unlock_exit; + } + + buf = readl(marian->iobase + MARIAN_SPI_CLOCK_DIVIDER); + + buf <<= 32 - bits_read; + i = 0; + + while (bits_read > 0) { + data_read[i++] = (buf >> 24) & 0xFF; + buf <<= 8; + bits_read -= 8; + } + } + +unlock_exit: + spin_unlock(&marian->spi_lock); + return err; +} + +static u8 marian_m2_spi_read(struct marian_card *marian, u8 adr) +{ + u8 buf_in; + + adr = adr & 0x7F; + + if (marian_spi_transfer(marian, 0x02, 8, &adr, 8, &buf_in) == 0) + return buf_in; + + return 0; +} + +static int marian_m2_spi_write(struct marian_card *marian, u8 adr, u8 val) +{ + u8 buf_out[2]; + + buf_out[0] = 0x80 | adr; + buf_out[1] = val; + + return marian_spi_transfer(marian, 0x02, 16, (u8 *)&buf_out, 0, NULL); +} + +static int marian_m2_sync_state_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +{ + static const char * const texts[] = { "No Signal", "Lock", "Sync" }; + + return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); +} + +static int marian_m2_sync_state_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + u8 v = marian_m2_spi_read(marian, 0x00); + + v = (v >> (kcontrol->private_value * 2)) & 0x3; + if (v == 3) + v--; + + ucontrol->value.enumerated.item[0] = v; + + return 0; +} + +static int marian_m2_sync_state_create(struct marian_card *marian, char *label, u32 idx) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .private_value = idx, + .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_m2_sync_state_info, + .get = marian_m2_sync_state_get + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int marian_m2_channel_mode_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + static const char * const texts[] = { "56ch", "64ch" }; + + return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); +} + +static int marian_m2_input_channel_mode_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + u8 v = marian_m2_spi_read(marian, 0x01); + + v = (v >> (kcontrol->private_value * 2)) & 0x1; + ucontrol->value.enumerated.item[0] = v; + + return 0; +} + +static int marian_m2_input_channel_mode_create(struct marian_card *marian, + char *label, u32 idx) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .private_value = idx, + .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_m2_channel_mode_info, + .get = marian_m2_input_channel_mode_get + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int marian_m2_frame_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) +{ + static const char * const texts[] = { "48kHz", "96kHz" }; + + return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); +} + +static int marian_m2_input_frame_mode_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + u8 v = marian_m2_spi_read(marian, 0x01); + + v = (v >> ((kcontrol->private_value * 2) + 1)) & 0x1; + ucontrol->value.enumerated.item[0] = v; + + return 0; +} + +static int marian_m2_input_frame_mode_create(struct marian_card *marian, char *label, u32 idx) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .private_value = idx, + .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_m2_frame_mode_info, + .get = marian_m2_input_frame_mode_get + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static u8 marian_m2_get_port_mode(struct marian_card *marian, unsigned int port) +{ + struct m2_specific *spec = marian->card_specific; + + if (port) + return (spec->shadow_42 >> M2_PORT2_MODE) & 1; + else + return (spec->shadow_42 >> M2_PORT1_MODE) & 1; +} + +static int marian_m2_output_channel_mode_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + ucontrol->value.enumerated.item[0] = marian_m2_get_port_mode(marian, + kcontrol->private_value); + + return 0; +} + +static void marian_m2_set_port_mode(struct marian_card *marian, unsigned int port, u8 state) +{ + struct m2_specific *spec = (struct m2_specific *)marian->card_specific; + + if (port) + spec->shadow_42 = (spec->shadow_42 & ~(1 << M2_PORT2_MODE)) + | state << M2_PORT2_MODE; + else + spec->shadow_42 = (spec->shadow_42 & ~(1 << M2_PORT1_MODE)) + | state << M2_PORT1_MODE; + + marian_m2_spi_write(marian, 0x42, spec->shadow_42); +} + +static int marian_m2_output_channel_mode_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + spin_lock(&marian->reglock); + marian_m2_set_port_mode(marian, kcontrol->private_value, + ucontrol->value.enumerated.item[0]); + spin_unlock(&marian->reglock); + + return 0; +} + +static int marian_m2_output_channel_mode_create(struct marian_card *marian, + char *label, u32 idx) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .private_value = idx, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_m2_channel_mode_info, + .get = marian_m2_output_channel_mode_get, + .put = marian_m2_output_channel_mode_put + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int marian_m2_output_frame_mode_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + return snd_ctl_boolean_mono_info(kcontrol, uinfo); +} + +static int marian_m2_output_frame_mode_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + struct m2_specific *spec = (struct m2_specific *)marian->card_specific; + + ucontrol->value.enumerated.item[0] = (spec->frame >> kcontrol->private_value) & 1; + + return 0; +} + +static void marian_m2_write_port_frame(struct marian_card *marian) +{ + struct m2_specific *spec = (struct m2_specific *)marian->card_specific; + + spec->shadow_42 = spec->shadow_42 & ~((1 << M2_PORT1_FRAME) | (1 << M2_PORT2_FRAME)); + + if (marian->speedmode == 2) { + // If we are in FS2, set 96kHz mode where enabled + if (spec->frame & 1) + spec->shadow_42 |= 1 << M2_PORT1_FRAME; + if (spec->frame & 2) + spec->shadow_42 |= 1 << M2_PORT2_FRAME; + } + + marian_m2_spi_write(marian, 0x42, spec->shadow_42); +} + +static void marian_m2_set_port_frame(struct marian_card *marian, unsigned int port, u8 state) +{ + struct m2_specific *spec = (struct m2_specific *)marian->card_specific; + + spec->frame = (spec->frame & ~(1 << port)) | (state << port); + + marian_m2_write_port_frame(marian); +} + +static int marian_m2_output_frame_mode_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + spin_lock(&marian->reglock); + marian_m2_set_port_frame(marian, kcontrol->private_value, + ucontrol->value.enumerated.item[0]); + spin_unlock(&marian->reglock); + + return 0; +} + +static int marian_m2_output_frame_mode_create(struct marian_card *marian, char *label, u32 idx) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = label, + .private_value = idx, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_m2_output_frame_mode_info, + .get = marian_m2_output_frame_mode_get, + .put = marian_m2_output_frame_mode_put, + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +static int marian_m2_clock_source_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + static const char * const texts[] = {"Internal", "Sync Bus", + "Input Port 1", "Input Port 2"}; + + return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts); +} + +static int marian_m2_clock_source_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + switch (marian->clock_source) { + case M2_CLOCK_SRC_DCO: + ucontrol->value.enumerated.item[0] = CLOCK_SRC_INTERNAL; + break; + case M2_CLOCK_SRC_SYNCBUS: + ucontrol->value.enumerated.item[0] = CLOCK_SRC_SYNCBUS; + break; + case M2_CLOCK_SRC_MADI1: + ucontrol->value.enumerated.item[0] = CLOCK_SRC_INP1; + break; + case M2_CLOCK_SRC_MADI2: + ucontrol->value.enumerated.item[0] = CLOCK_SRC_INP2; + break; + default: + dev_dbg(marian->card->dev, + "Illegal value for clock_source! (%d)\n", + marian->clock_source); + return -EINVAL; + } + + return 0; +} + +static int marian_m2_clock_source_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct marian_card *marian = snd_kcontrol_chip(kcontrol); + + switch (ucontrol->value.enumerated.item[0]) { + case CLOCK_SRC_INTERNAL: + marian_generic_set_clock_source(marian, M2_CLOCK_SRC_DCO); + break; + case CLOCK_SRC_SYNCBUS: + marian_generic_set_clock_source(marian, M2_CLOCK_SRC_SYNCBUS); + break; + case CLOCK_SRC_INP1: + marian_generic_set_clock_source(marian, M2_CLOCK_SRC_MADI1); + break; + case CLOCK_SRC_INP2: + marian_generic_set_clock_source(marian, M2_CLOCK_SRC_MADI2); + break; + } + + return 0; +} + +static int marian_m2_clock_source_create(struct marian_card *marian) +{ + struct snd_kcontrol_new c = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Clock Source", + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_VOLATILE, + .info = marian_m2_clock_source_info, + .get = marian_m2_clock_source_get, + .put = marian_m2_clock_source_put, + }; + + return snd_ctl_add(marian->card, snd_ctl_new1(&c, marian)); +} + +/* + * Controls: + * + * RO: + * - Input 1 sync state (no signal, lock, sync) + * - Input 1 channel mode (56/64ch) + * - Input 1 frame mode (48/96kHz) + * - Input 1 frequency + * - Input 2 sync state (no signal, lock, sync) + * - Input 2 channel mode (56/64ch) + * - Input 2 frame mode (48/96kHz) + * - Input 2 frequency + * + * RW: + * - Output 1 channel mode (56/64ch) + * - Output 1 frame mode (48/96kHz) + * - Output 2 channel mode (56/64ch) + * - Output 2 frame mode (48/96kHz) + * - Word clock source (Port 1, Port 2, Internal, Sync port, WCK input) + * - Speed mode (1, 2, 4FS) + * - DCO frequency (1 Hertz) + * - DCO frequency (1/1000th) + */ +static void marian_m2_create_controls(struct marian_card *marian) +{ + marian_m2_sync_state_create(marian, "Input 1 Sync", M2_INP1_SYNC_CTL_ID); + marian_m2_sync_state_create(marian, "Input 2 Sync", M2_INP2_SYNC_CTL_ID); + marian_m2_input_channel_mode_create(marian, "Input 1 Channel Mode", + M2_INP1_CM_CTL_ID); + marian_m2_input_channel_mode_create(marian, "Input 2 Channel Mode", + M2_INP2_CM_CTL_ID); + marian_m2_input_frame_mode_create(marian, "Input 1 Frame Mode", + M2_INP1_FM_CTL_ID); + marian_m2_input_frame_mode_create(marian, "Input 2 Frame Mode", + M2_INP2_FM_CTL_ID); + marian_generic_frequency_create(marian, "Input 1 Frequency", + M2_INP1_FREQ_CTL_ID); + marian_generic_frequency_create(marian, "Input 2 Frequency", + M2_INP2_FREQ_CTL_ID); + marian_m2_output_channel_mode_create(marian, "Output 1 Channel Mode", + M2_OUT1_CM_CTL_ID); + marian_m2_output_channel_mode_create(marian, "Output 2 Channel Mode", + M2_OUT2_CM_CTL_ID); + marian_m2_output_frame_mode_create(marian, "Output 1 96kHz Frame", + M2_OUT1_FM_CTL_ID); + marian_m2_output_frame_mode_create(marian, "Output 2 96kHz Frame", + M2_OUT2_FM_CTL_ID); + marian_m2_clock_source_create(marian); + marian_generic_speedmode_create(marian); + marian_generic_dco_create(marian); + marian_control_pcm_loopback_create(marian); +} + +static void marian_m2_set_float(struct marian_card *marian, enum m2_num_mode state) +{ + struct m2_specific *spec = (struct m2_specific *)marian->card_specific; + + spec->shadow_41 = (spec->shadow_41 & ~(1 << M2_INT_FLOAT)) | state << M2_INT_FLOAT; + marian_m2_spi_write(marian, 0x41, spec->shadow_41); +} + +static void marian_m2_set_endianness(struct marian_card *marian, enum m2_endianness_mode state) +{ + struct m2_specific *spec = (struct m2_specific *)marian->card_specific; + + spec->shadow_41 = (spec->shadow_41 & ~(1 << M2_ENDIANNESS)) | state << M2_ENDIANNESS; + marian_m2_spi_write(marian, 0x41, spec->shadow_41); +} + +static void marian_m2_set_speedmode(struct marian_card *marian, unsigned int speedmode) +{ + marian_generic_set_speedmode(marian, speedmode); + marian_m2_write_port_frame(marian); +} + +static int marian_m2_init(struct marian_card *marian) +{ + struct m2_specific *spec; + + marian_generic_init(marian); + spec = kzalloc(sizeof(*spec), GFP_KERNEL); + if (!spec) { + dev_dbg(marian->card->dev, + "Cannot allocate card specific structure\n"); + return -ENOMEM; + } + + spec->shadow_40 = 0x00; + spec->shadow_41 = (1 << M2_TX_ENABLE); + spec->shadow_42 = (1 << M2_PORT1_MODE) | (1 << M2_PORT2_MODE); + + marian_m2_spi_write(marian, 0x40, spec->shadow_40); + marian_m2_spi_write(marian, 0x41, spec->shadow_41); + marian_m2_spi_write(marian, 0x42, spec->shadow_42); + + marian->card_specific = spec; + return 0; +} + +static void marian_m2_free(struct marian_card *marian) +{ + kfree(marian->card_specific); +} + +static void marian_m2_prepare(struct marian_card *marian) +{ + u32 mask = 0xFFFFFFFF; + + spin_lock(&marian->reglock); + writel(mask, marian->iobase + 0x20); + writel(mask, marian->iobase + 0x24); + writel(mask, marian->iobase + 0x28); + writel(mask, marian->iobase + 0x2C); + writel(mask, marian->iobase + 0x30); + writel(mask, marian->iobase + 0x34); + writel(mask, marian->iobase + 0x38); + writel(mask, marian->iobase + 0x3C); + spin_unlock(&marian->reglock); +} + +static void marian_m2_proc_status(struct marian_card *marian, struct snd_info_buffer *buffer) +{ + struct m2_specific *spec = (struct m2_specific *)marian->card_specific; + u8 v1, v2; + + marian_proc_status_generic(marian, buffer); + + snd_iprintf(buffer, "\n*** MADI FPGA registers\n"); + snd_iprintf(buffer, "M2 MADI 00h: %02x\n", marian_m2_spi_read(marian, 0x00)); + snd_iprintf(buffer, "M2 MADI 01h: %02x\n", marian_m2_spi_read(marian, 0x01)); + snd_iprintf(buffer, "M2 MADI 02h: %02x\n", marian_m2_spi_read(marian, 0x02)); + snd_iprintf(buffer, "M2 MADI 40h: %02x\n", spec->shadow_40); + snd_iprintf(buffer, "M2 MADI 41h: %02x\n", spec->shadow_41); + snd_iprintf(buffer, "M2 MADI 42h: %02x\n", spec->shadow_42); + + snd_iprintf(buffer, "\n*** MADI FPGA status\n"); + snd_iprintf(buffer, "MADI FPGA firmware: 0x%02x\n", marian_m2_spi_read(marian, 0x02)); + + snd_iprintf(buffer, "Clock source: "); + switch (marian->clock_source) { + case 1: + snd_iprintf(buffer, "Internal DCO\n"); + break; + case 2: + snd_iprintf(buffer, "Sync bus\n"); + break; + case 4: + snd_iprintf(buffer, "MADI Input 1\n"); + break; + case 5: + snd_iprintf(buffer, "MADI Input 2\n"); + break; + default: + snd_iprintf(buffer, "UNKNOWN\n"); + break; + } + + snd_iprintf(buffer, "Sample format: %s, %s Endian, %s first\n", + (spec->shadow_41 & (1 << M2_INT_FLOAT)) ? "Float" : "Integer", + (spec->shadow_41 & (1 << M2_ENDIANNESS)) ? "Little" : "Big", + (spec->shadow_41 & (1 << M2_BIT_ORDER)) ? "LSB" : "MSB"); + + v1 = marian_m2_spi_read(marian, 0x00); + v2 = marian_m2_spi_read(marian, 0x01); + + snd_iprintf(buffer, "MADI port 1 input: "); + if (!(v1 & 0x03)) + snd_iprintf(buffer, "No signal\n"); + else + snd_iprintf(buffer, "%s, %dch, %dkHz frame, %u Hz\n", + (v1 & 0x02) ? "sync" : "lock", (v2 & 0x01) ? 64 : 56, + (v2 & 0x02) ? 96 : 48, marian_measure_freq(marian, 4)); + + snd_iprintf(buffer, "MADI port 2 input: "); + if (!(v1 & 0x0C)) + snd_iprintf(buffer, "No signal\n"); + else + snd_iprintf(buffer, "%s, %dch, %dkHz frame, %u Hz\n", + (v1 & 0x08) ? "sync" : "lock", + (v2 & 0x04) ? 64 : 56, (v2 & 0x08) ? 96 : 48, + marian_measure_freq(marian, 5)); +} + +static void marian_m2_proc_ports(struct marian_card *marian, + struct snd_info_buffer *buffer, unsigned int type) +{ + int i; + + for (i = 0; i < M2_CHANNELS_COUNT; i++) + snd_iprintf(buffer, "%d=MADI p%dch%02d\n", i + 1, i / 64 + 1, i % 64 + 1); +} + +static void marian_m2_constraints(struct marian_card *marian, struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) +{ + spin_lock(&marian->reglock); + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_FLOAT_BE: + marian_m2_set_float(marian, M2_NUM_MODE_FLOAT); + marian_m2_set_endianness(marian, M2_BE); + break; + case SNDRV_PCM_FORMAT_FLOAT_LE: + marian_m2_set_float(marian, M2_NUM_MODE_FLOAT); + marian_m2_set_endianness(marian, M2_LE); + break; + case SNDRV_PCM_FORMAT_S32_BE: + marian_m2_set_float(marian, M2_NUM_MODE_INT); + marian_m2_set_endianness(marian, M2_BE); + break; + case SNDRV_PCM_FORMAT_S32_LE: + marian_m2_set_float(marian, M2_NUM_MODE_INT); + marian_m2_set_endianness(marian, M2_LE); + break; + } + spin_unlock(&marian->reglock); +} + +static struct marian_card_descriptor descriptor = { + .name = "Seraph M2", + .speedmode_max = 2, + .ch_in = M2_CHANNELS_COUNT, + .ch_out = M2_CHANNELS_COUNT, + .dma_bufsize = 2 * SUBSTREAM_BUF_SIZE, + .hw_constraints_func = marian_m2_constraints, + .create_controls = marian_m2_create_controls, + .init_card = marian_m2_init, + .free_card = marian_m2_free, + .prepare = marian_m2_prepare, + .set_speedmode = marian_m2_set_speedmode, + .proc_status = marian_m2_proc_status, + .proc_ports = marian_m2_proc_ports, + .info_playback = { + .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_NONINTERLEAVED + | SNDRV_PCM_INFO_JOINT_DUPLEX | SNDRV_PCM_INFO_SYNC_START, + .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE + | SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE, + .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_44100 + | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 + | SNDRV_PCM_RATE_96000), + .rate_min = 28000, + .rate_max = RATE_FAST, + .channels_min = M2_CHANNELS_COUNT, + .channels_max = M2_CHANNELS_COUNT, + .buffer_bytes_max = SUBSTREAM_BUF_SIZE, + .period_bytes_min = SUBSTREAM_PERIOD_SIZE, + .period_bytes_max = SUBSTREAM_PERIOD_SIZE, + .periods_min = 2, + .periods_max = 2 + }, + .info_capture = { + .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_NONINTERLEAVED + | SNDRV_PCM_INFO_SYNC_START | SNDRV_PCM_INFO_JOINT_DUPLEX, + .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE + | SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE, + .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_44100 + | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 + | SNDRV_PCM_RATE_96000), + .rate_min = 28000, + .rate_max = RATE_FAST, + .channels_min = M2_CHANNELS_COUNT, + .channels_max = M2_CHANNELS_COUNT, + .buffer_bytes_max = SUBSTREAM_BUF_SIZE, + .period_bytes_min = SUBSTREAM_PERIOD_SIZE, + .period_bytes_max = SUBSTREAM_PERIOD_SIZE, + .periods_min = 2, + .periods_max = 2 + } +}; + +static int snd_marian_m2_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) +{ + static unsigned int dev; + struct snd_card *card; + int err; + + if (dev >= SNDRV_CARDS) + return -ENODEV; + + err = snd_card_new(&pci->dev, index[dev], id[dev], + THIS_MODULE, sizeof(struct marian_card), &card); + if (err < 0) + return err; + + err = snd_marian_create(card, pci, &descriptor, dev); + if (err < 0) { + snd_card_free(card); + return err; + } + + pci_set_drvdata(pci, card); + + dev++; + + return 0; +} + +static void snd_marian_m2_remove(struct pci_dev *pci) +{ + snd_card_free(pci_get_drvdata(pci)); + pci_set_drvdata(pci, NULL); +} + +static struct pci_driver marian_driver = { + .name = "MARIAN", + .id_table = snd_marian_ids, + .probe = snd_marian_m2_probe, + .remove = snd_marian_m2_remove, +}; + +module_pci_driver(marian_driver); + +MODULE_AUTHOR("Florin Faber faberman@linuxproaudio.org"); +MODULE_DESCRIPTION("MARIAN Seraph series"); +MODULE_LICENSE("GPL");