[ALSA] ice1724 - Add support of Onkyo SE-90PCI and SE-200PCI
authorShin-ya Okada <sh_okada at d4.dion.ne.jp>
Tue, 23 Oct 2007 13:08:18 +0000 (15:08 +0200)
committerJaroslav Kysela <perex@perex.cz>
Thu, 31 Jan 2008 16:29:09 +0000 (17:29 +0100)
Added the support for Onkyo SE-90PCI and SE-200PCI boards.

Signed-off-by: Shin-ya Okada <sh_okada at d4.dion.ne.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@perex.cz>
Documentation/sound/alsa/ALSA-Configuration.txt
sound/pci/ice1712/Makefile
sound/pci/ice1712/ice1712.h
sound/pci/ice1712/ice1724.c
sound/pci/ice1712/se.c [new file with mode: 0644]
sound/pci/ice1712/se.h [new file with mode: 0644]

index 7b064f2c2a63c363d4881cd13dde951614b5fa10..69ab91c991a6ab047f3ea9c502fc4058cee224d0 100644 (file)
@@ -1157,11 +1157,14 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
                        * Chaintech 9CJS
                        * Chaintech AV-710
                        * Shuttle SN25P
+                       * Onkyo SE-90PCI
+                       * Onkyo SE-200PCI
 
     model       - Use the given board model, one of the following:
                  revo51, revo71, amp2000, prodigy71, prodigy71lt,
                  prodigy192, aureon51, aureon71, universe, ap192,
-                 k8x800, phase22, phase28, ms300, av710
+                 k8x800, phase22, phase28, ms300, av710, se200pci,
+                 se90pci
 
     This module supports multiple cards and autoprobe.
 
index 65ce66adba5ad1251ce1ba68f3b9a53ebac48306..ee86a1de72f8f16b811e0b0e345bdab0c83e9672 100644 (file)
@@ -5,7 +5,7 @@
 
 snd-ice17xx-ak4xxx-objs := ak4xxx.o
 snd-ice1712-objs := ice1712.o delta.o hoontech.o ews.o
-snd-ice1724-objs := ice1724.o amp.o revo.o aureon.o vt1720_mobo.o pontis.o prodigy192.o juli.o phase.o wtm.o
+snd-ice1724-objs := ice1724.o amp.o revo.o aureon.o vt1720_mobo.o pontis.o prodigy192.o juli.o phase.o wtm.o se.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_ICE1712) += snd-ice1712.o snd-ice17xx-ak4xxx.o
index 58640afa54041e49441e8dccf4dd18323f282d02..3c3cac3dc08bfc07011923cf90b5480330213447 100644 (file)
@@ -400,6 +400,12 @@ struct snd_ice1712 {
                struct {
                        struct ak4114 *ak4114;
                } prodigy192;
+               struct {
+                       struct {
+                               unsigned char ch1, ch2;
+                       } vol[8];
+               } se;
+
        } spec;
 
 };
index 0b0bbb0d96b91f8626724b163e68a88838422832..357bdbe21c8fb490da8d67838d3bcf6ce60b419a 100644 (file)
@@ -51,6 +51,7 @@
 #include "juli.h"
 #include "phase.h"
 #include "wtm.h"
+#include "se.h"
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("VIA ICEnsemble ICE1724/1720 (Envy24HT/PT)");
@@ -65,6 +66,7 @@ MODULE_SUPPORTED_DEVICE("{"
               JULI_DEVICE_DESC
               PHASE_DEVICE_DESC
               WTM_DEVICE_DESC
+              SE_DEVICE_DESC
                "{VIA,VT1720},"
                "{VIA,VT1724},"
                "{ICEnsemble,Generic ICE1724},"
@@ -1933,6 +1935,7 @@ static struct snd_ice1712_card_info *card_tables[] __devinitdata = {
        snd_vt1724_juli_cards,
        snd_vt1724_phase_cards,
        snd_vt1724_wtm_cards,
+       snd_vt1724_se_cards,
        NULL,
 };
 
diff --git a/sound/pci/ice1712/se.c b/sound/pci/ice1712/se.c
new file mode 100644 (file)
index 0000000..ebfe245
--- /dev/null
@@ -0,0 +1,700 @@
+/*
+ *   ALSA driver for ICEnsemble VT1724 (Envy24HT)
+ *
+ *   Lowlevel functions for ONKYO WAVIO SE-90PCI and SE-200PCI
+ *
+ *     Copyright (c) 2007 Shin-ya Okada  sh_okada(at)d4.dion.ne.jp
+ *                                        (at) -> @
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */      
+
+#include <sound/driver.h>
+#include <asm/io.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/tlv.h>
+
+#include "ice1712.h"
+#include "envy24ht.h"
+#include "se.h"
+
+
+/****************************************************************************/
+/*  ONKYO WAVIO SE-200PCI                                                   */
+/****************************************************************************/
+/*
+ *  system configuration ICE_EEP2_SYSCONF=0x4b
+ *    XIN1 49.152MHz
+ *    not have UART
+ *    one stereo ADC and a S/PDIF receiver connected
+ *    four stereo DACs connected
+ *
+ *  AC-Link configuration ICE_EEP2_ACLINK=0x80
+ *    use I2C, not use AC97
+ *
+ *  I2S converters feature ICE_EEP2_I2S=0x78
+ *    I2S codec has no volume/mute control feature
+ *    I2S codec supports 96KHz and 192KHz
+ *    I2S codec 24bits
+ *
+ *  S/PDIF configuration ICE_EEP2_SPDIF=0xc3
+ *    Enable integrated S/PDIF transmitter
+ *    internal S/PDIF out implemented
+ *    S/PDIF is stereo
+ *    External S/PDIF out implemented
+ *
+ *
+ * ** connected chips **
+ *
+ *  WM8740
+ *      A 2ch-DAC of main outputs.
+ *      It setuped as I2S mode by wire, so no way to setup from software.
+ *      The sample-rate are automatically changed. 
+ *          ML/I2S (28pin) --------+
+ *          MC/DM1 (27pin) -- 5V   |
+ *          MD/DM0 (26pin) -- GND  |
+ *          MUTEB  (25pin) -- NC   |
+ *          MODE   (24pin) -- GND  |
+ *          CSBIW  (23pin) --------+
+ *                                 |
+ *          RSTB   (22pin) --R(1K)-+
+ *      Probably it reduce the noise from the control line.
+ *
+ *  WM8766
+ *      A 6ch-DAC for surrounds.
+ *      It's control wire was connected to GPIOxx (3-wire serial interface)
+ *          ML/I2S (11pin) -- GPIO18
+ *          MC/IWL (12pin) -- GPIO17
+ *          MD/DM  (13pin) -- GPIO16
+ *          MUTE   (14pin) -- GPIO01
+ *
+ *  WM8776
+ *     A 2ch-ADC(with 10ch-selector) plus 2ch-DAC.
+ *     It's control wire was connected to SDA/SCLK (2-wire serial interface)
+ *          MODE (16pin) -- R(1K) -- GND
+ *          CE   (17pin) -- R(1K) -- GND  2-wire mode (address=0x34)
+ *          DI   (18pin) -- SDA
+ *          CL   (19pin) -- SCLK
+ *
+ *
+ * ** output pins and device names **
+ *
+ *   7.1ch name -- output connector color -- device (-D option)
+ *
+ *      FRONT 2ch                  -- green  -- plughw:0,0
+ *      CENTER(Lch) SUBWOOFER(Rch) -- black  -- plughw:0,2,0
+ *      SURROUND 2ch               -- orange -- plughw:0,2,1
+ *      SURROUND BACK 2ch          -- white  -- plughw:0,2,2
+ *
+ */
+
+
+/****************************************************************************/
+/*  WM8740 interface                                                        */
+/****************************************************************************/
+
+static void __devinit se200pci_WM8740_init(struct snd_ice1712 *ice)
+{
+       /* nothing to do */
+}
+
+
+static void se200pci_WM8740_set_pro_rate(struct snd_ice1712 *ice,
+                                               unsigned int rate)
+{
+       /* nothing to do */
+}
+
+
+/****************************************************************************/
+/*  WM8766 interface                                                        */
+/****************************************************************************/
+
+static void se200pci_WM8766_write(struct snd_ice1712 *ice,
+                                       unsigned int addr, unsigned int data)
+{
+       unsigned int st;
+       unsigned int bits;
+       int i;
+       const unsigned int DATA  = 0x010000;
+       const unsigned int CLOCK = 0x020000;
+       const unsigned int LOAD  = 0x040000;
+       const unsigned int ALL_MASK = (DATA | CLOCK | LOAD);
+
+       snd_ice1712_save_gpio_status(ice);
+
+       st = ((addr & 0x7f) << 9) | (data & 0x1ff);
+       snd_ice1712_gpio_set_dir(ice, ice->gpio.direction | ALL_MASK);
+       snd_ice1712_gpio_set_mask(ice, ice->gpio.write_mask & ~ALL_MASK);
+       bits = snd_ice1712_gpio_read(ice) & ~ALL_MASK;
+
+       snd_ice1712_gpio_write(ice, bits);
+       for (i = 0; i < 16; i++) {
+               udelay(1);
+               bits &= ~CLOCK;
+               st = (st << 1);
+               if (st & 0x10000)
+                       bits |= DATA;
+               else
+                       bits &= ~DATA;
+
+               snd_ice1712_gpio_write(ice, bits);
+
+               udelay(1);
+               bits |= CLOCK;
+               snd_ice1712_gpio_write(ice, bits);
+       }
+
+       udelay(1);
+       bits |= LOAD;
+       snd_ice1712_gpio_write(ice, bits);
+
+       udelay(1);
+       bits |= (DATA | CLOCK);
+       snd_ice1712_gpio_write(ice, bits);
+
+       snd_ice1712_restore_gpio_status(ice);
+}
+
+static void se200pci_WM8766_set_volume(struct snd_ice1712 *ice, int ch,
+                                       unsigned int vol1, unsigned int vol2)
+{
+       switch (ch) {
+       case 0:
+               se200pci_WM8766_write(ice, 0x000, vol1);
+               se200pci_WM8766_write(ice, 0x001, vol2 | 0x100);
+               break;
+       case 1:
+               se200pci_WM8766_write(ice, 0x004, vol1);
+               se200pci_WM8766_write(ice, 0x005, vol2 | 0x100);
+               break;
+       case 2:
+               se200pci_WM8766_write(ice, 0x006, vol1);
+               se200pci_WM8766_write(ice, 0x007, vol2 | 0x100);
+               break;
+       }
+}
+
+static void __devinit se200pci_WM8766_init(struct snd_ice1712 *ice)
+{
+       se200pci_WM8766_write(ice, 0x1f, 0x000); /* RESET ALL */
+       udelay(10);
+
+       se200pci_WM8766_set_volume(ice, 0, 0, 0); /* volume L=0 R=0 */
+       se200pci_WM8766_set_volume(ice, 1, 0, 0); /* volume L=0 R=0 */
+       se200pci_WM8766_set_volume(ice, 2, 0, 0); /* volume L=0 R=0 */
+
+       se200pci_WM8766_write(ice, 0x03, 0x022); /* serial mode I2S-24bits */
+       se200pci_WM8766_write(ice, 0x0a, 0x080); /* MCLK=256fs */
+       se200pci_WM8766_write(ice, 0x12, 0x000); /* MDP=0 */
+       se200pci_WM8766_write(ice, 0x15, 0x000); /* MDP=0 */
+       se200pci_WM8766_write(ice, 0x09, 0x000); /* demp=off mute=off */
+
+       se200pci_WM8766_write(ice, 0x02, 0x124); /* ch-assign L=L R=R RESET */
+       se200pci_WM8766_write(ice, 0x02, 0x120); /* ch-assign L=L R=R */
+}
+
+static void se200pci_WM8766_set_pro_rate(struct snd_ice1712 *ice,
+                                       unsigned int rate)
+{
+       if (rate > 96000)
+               se200pci_WM8766_write(ice, 0x0a, 0x000); /* MCLK=128fs */
+       else
+               se200pci_WM8766_write(ice, 0x0a, 0x080); /* MCLK=256fs */
+}
+
+
+/****************************************************************************/
+/*  WM8776 interface                                                        */
+/****************************************************************************/
+
+static void se200pci_WM8776_write(struct snd_ice1712 *ice,
+                                       unsigned int addr, unsigned int data)
+{
+       unsigned int val;
+
+       val = (addr << 9) | data;
+       snd_vt1724_write_i2c(ice, 0x34, val >> 8, val & 0xff);
+}
+
+
+static void se200pci_WM8776_set_output_volume(struct snd_ice1712 *ice,
+                                       unsigned int vol1, unsigned int vol2)
+{
+       se200pci_WM8776_write(ice, 0x03, vol1);
+       se200pci_WM8776_write(ice, 0x04, vol2 | 0x100);
+}
+
+static void se200pci_WM8776_set_input_volume(struct snd_ice1712 *ice,
+                                       unsigned int vol1, unsigned int vol2)
+{
+       se200pci_WM8776_write(ice, 0x0e, vol1);
+       se200pci_WM8776_write(ice, 0x0f, vol2 | 0x100);
+}
+
+static const char *se200pci_sel[] = {
+       "LINE-IN", "CD-IN", "MIC-IN", "ALL-MIX", NULL
+};
+
+static void se200pci_WM8776_set_input_selector(struct snd_ice1712 *ice,
+                                              unsigned int sel)
+{
+       static unsigned char vals[] = {
+               /* LINE, CD, MIC, ALL, GND */
+               0x10, 0x04, 0x08, 0x1c, 0x03
+       };
+       if (sel > 4)
+               sel = 4;
+       se200pci_WM8776_write(ice, 0x15, vals[sel]);
+}
+
+static void se200pci_WM8776_set_afl(struct snd_ice1712 *ice, unsigned int afl)
+{
+       /* AFL -- After Fader Listening */
+       if (afl)
+               se200pci_WM8776_write(ice, 0x16, 0x005);
+       else
+               se200pci_WM8776_write(ice, 0x16, 0x001);
+}
+
+static const char *se200pci_agc[] = {
+       "Off", "LimiterMode", "ALCMode", NULL
+};
+
+static void se200pci_WM8776_set_agc(struct snd_ice1712 *ice, unsigned int agc)
+{
+       /* AGC -- Auto Gain Control of the input */
+       switch (agc) {
+       case 0:
+               se200pci_WM8776_write(ice, 0x11, 0x000); /* Off */
+               break;
+       case 1:
+               se200pci_WM8776_write(ice, 0x10, 0x07b);
+               se200pci_WM8776_write(ice, 0x11, 0x100); /* LimiterMode */
+               break;
+       case 2:
+               se200pci_WM8776_write(ice, 0x10, 0x1fb);
+               se200pci_WM8776_write(ice, 0x11, 0x100); /* ALCMode */
+               break;
+       }
+}
+
+static void __devinit se200pci_WM8776_init(struct snd_ice1712 *ice)
+{
+       int i;
+       static unsigned short __devinitdata default_values[] = {
+               0x100, 0x100, 0x100,
+               0x100, 0x100, 0x100,
+               0x000, 0x090, 0x000, 0x000,
+               0x022, 0x022, 0x022,
+               0x008, 0x0cf, 0x0cf, 0x07b, 0x000,
+               0x032, 0x000, 0x0a6, 0x001, 0x001
+       };
+
+       se200pci_WM8776_write(ice, 0x17, 0x000); /* reset all */
+       /* ADC and DAC interface is I2S 24bits mode */
+       /* The sample-rate are automatically changed */
+       udelay(10);
+       /* BUT my board can not do reset all, so I load all by manually. */
+       for (i = 0; i < ARRAY_SIZE(default_values); i++)
+               se200pci_WM8776_write(ice, i, default_values[i]);
+
+       se200pci_WM8776_set_input_selector(ice, 0);
+       se200pci_WM8776_set_afl(ice, 0);
+       se200pci_WM8776_set_agc(ice, 0);
+       se200pci_WM8776_set_input_volume(ice, 0, 0);
+       se200pci_WM8776_set_output_volume(ice, 0, 0);
+
+       /* head phone mute and power down */
+       se200pci_WM8776_write(ice, 0x00, 0);
+       se200pci_WM8776_write(ice, 0x01, 0);
+       se200pci_WM8776_write(ice, 0x02, 0x100);
+       se200pci_WM8776_write(ice, 0x0d, 0x080);
+}
+
+static void se200pci_WM8776_set_pro_rate(struct snd_ice1712 *ice,
+                                               unsigned int rate)
+{
+       /* nothing to do */
+}
+
+
+/****************************************************************************/
+/*  runtime interface                                                       */
+/****************************************************************************/
+
+static void se200pci_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate)
+{
+       se200pci_WM8740_set_pro_rate(ice, rate);
+       se200pci_WM8766_set_pro_rate(ice, rate);
+       se200pci_WM8776_set_pro_rate(ice, rate);
+}
+
+struct se200pci_control {
+       char *name;
+       enum {
+               WM8766,
+               WM8776in,
+               WM8776out,
+               WM8776sel,
+               WM8776agc,
+               WM8776afl
+       } target;
+       enum { VOLUME1, VOLUME2, BOOLEAN, ENUM } type;
+       int ch;
+       const char **member;
+       const char *comment;
+};
+
+static const struct se200pci_control se200pci_cont[] = {
+       {
+               .name = "Front Playback Volume",
+               .target = WM8776out,
+               .type = VOLUME1,
+               .comment = "Front(green)"
+       },
+       {
+               .name = "Side Playback Volume",
+               .target = WM8766,
+               .type = VOLUME1,
+               .ch = 1,
+               .comment = "Surround(orange)"
+       },
+       {
+               .name = "Surround Playback Volume",
+               .target = WM8766,
+               .type = VOLUME1,
+               .ch = 2,
+               .comment = "SurroundBack(white)"
+       },
+       {
+               .name = "CLFE Playback Volume",
+               .target = WM8766,
+               .type = VOLUME1,
+               .ch = 0,
+               .comment = "Center(Lch)&SubWoofer(Rch)(black)"
+       },
+       {
+               .name = "Capture Volume",
+               .target = WM8776in,
+               .type = VOLUME2
+       },
+       {
+               .name = "Capture Select",
+               .target = WM8776sel,
+               .type = ENUM,
+               .member = se200pci_sel
+       },
+       {
+               .name = "AGC Capture Mode",
+               .target = WM8776agc,
+               .type = ENUM,
+               .member = se200pci_agc
+       },
+       {
+               .name = "AFL Bypass Playback Switch",
+               .target = WM8776afl,
+               .type = BOOLEAN
+       }
+};
+
+static int se200pci_cont_info(struct snd_kcontrol *kc,
+                               struct snd_ctl_elem_info *uinfo)
+{
+       struct snd_ice1712 *ice;
+       int n;
+       int c;
+       const char **member;
+
+       ice = snd_kcontrol_chip(kc);
+       n = kc->private_value;
+
+       if (se200pci_cont[n].type == VOLUME1 ||
+           se200pci_cont[n].type == VOLUME2) {
+               uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+               uinfo->count = 2;
+               uinfo->value.integer.min = 0; /* mute */
+               uinfo->value.integer.max = 0xff; /* 0dB */
+
+       } else if (se200pci_cont[n].type == BOOLEAN) {
+               uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+               uinfo->count = 1;
+               uinfo->value.integer.min = 0;
+               uinfo->value.integer.max = 1;
+
+       } else if (se200pci_cont[n].type == ENUM) {
+               uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+               member = se200pci_cont[n].member;
+               if (member == NULL)
+                       return -EINVAL;
+               for (c = 0; member[c]; c++)
+                       ;
+
+               uinfo->count = 1;
+               uinfo->value.enumerated.items = c;
+               if (uinfo->value.enumerated.item >= c)
+                       uinfo->value.enumerated.item = c - 1;
+               strcpy(uinfo->value.enumerated.name,
+                       member[uinfo->value.enumerated.item]);
+       }
+
+       return 0;
+}
+
+static int se200pci_cont_get(struct snd_kcontrol *kc,
+                               struct snd_ctl_elem_value *uc)
+{
+       struct snd_ice1712 *ice;
+       int n;
+
+       ice = snd_kcontrol_chip(kc);
+       n = kc->private_value;
+       if (se200pci_cont[n].type == VOLUME1 ||
+           se200pci_cont[n].type == VOLUME2) {
+               uc->value.integer.value[0] = ice->spec.se.vol[n].ch1;
+               uc->value.integer.value[1] = ice->spec.se.vol[n].ch2;
+
+       } else if (se200pci_cont[n].type == BOOLEAN ||
+                  se200pci_cont[n].type == ENUM)
+               uc->value.integer.value[0] = ice->spec.se.vol[n].ch1;
+
+       return 0;
+}
+
+static int se200pci_cont_put(struct snd_kcontrol *kc,
+                               struct snd_ctl_elem_value *uc)
+{
+       struct snd_ice1712 *ice;
+       int n;
+       unsigned int vol1, vol2;
+       int changed;
+
+       ice = snd_kcontrol_chip(kc);
+       n = kc->private_value;
+
+       changed = 0;
+       vol1 = 0; vol2 = 0;
+       if (se200pci_cont[n].type == VOLUME1 ||
+           se200pci_cont[n].type == VOLUME2) {
+               vol1 = uc->value.integer.value[0];
+               vol2 = uc->value.integer.value[1];
+               if (ice->spec.se.vol[n].ch1 != vol1)
+                       changed = 1;
+               if (ice->spec.se.vol[n].ch2 != vol2)
+                       changed = 1;
+               ice->spec.se.vol[n].ch1 = vol1;
+               ice->spec.se.vol[n].ch2 = vol2;
+
+       } else if (se200pci_cont[n].type == BOOLEAN ||
+                  se200pci_cont[n].type == ENUM) {
+               vol1 = uc->value.integer.value[0];
+               if (ice->spec.se.vol[n].ch1 != vol1)
+                       changed = 1;
+               ice->spec.se.vol[n].ch1 = vol1;
+       }
+
+       switch (se200pci_cont[n].target) {
+       case WM8766:
+               se200pci_WM8766_set_volume(ice,
+                       se200pci_cont[n].ch, vol1, vol2);
+               break;
+
+       case WM8776in:
+               se200pci_WM8776_set_input_volume(ice, vol1, vol2);
+               break;
+
+       case WM8776out:
+               se200pci_WM8776_set_output_volume(ice, vol1, vol2);
+               break;
+
+       case WM8776sel:
+               se200pci_WM8776_set_input_selector(ice, vol1);
+               break;
+
+       case WM8776agc:
+               se200pci_WM8776_set_agc(ice, vol1);
+               break;
+
+       case WM8776afl:
+               se200pci_WM8776_set_afl(ice, vol1);
+               break;
+
+       default:
+               break;
+       }
+
+       return changed;
+}
+
+static const DECLARE_TLV_DB_SCALE(db_scale_gain1, -12750, 50, 1);
+static const DECLARE_TLV_DB_SCALE(db_scale_gain2, -10350, 50, 1);
+
+static int __devinit se200pci_add_controls(struct snd_ice1712 *ice)
+{
+       int i;
+       struct snd_kcontrol_new cont;
+       int err;
+
+       memset(&cont, 0, sizeof(cont));
+       cont.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+       cont.info = se200pci_cont_info;
+       cont.get = se200pci_cont_get;
+       cont.put = se200pci_cont_put;
+       for (i = 0; i < ARRAY_SIZE(se200pci_cont); i++) {
+               cont.private_value = i;
+               cont.name = se200pci_cont[i].name;
+               cont.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
+               cont.tlv.p = NULL;
+               if (se200pci_cont[i].type == VOLUME1 ||
+                   se200pci_cont[i].type == VOLUME2) {
+
+                       cont.access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
+
+                       if (se200pci_cont[i].type == VOLUME1)
+                               cont.tlv.p = db_scale_gain1;
+                       else
+                               cont.tlv.p = db_scale_gain2;
+               }
+               err = snd_ctl_add(ice->card, snd_ctl_new1(&cont, ice));
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+
+/****************************************************************************/
+/*  ONKYO WAVIO SE-90PCI                                                    */
+/****************************************************************************/
+/*
+ *  system configuration ICE_EEP2_SYSCONF=0x4b
+ *  AC-Link configuration ICE_EEP2_ACLINK=0x80
+ *  I2S converters feature ICE_EEP2_I2S=0x78
+ *  S/PDIF configuration ICE_EEP2_SPDIF=0xc3
+ *
+ *  ** connected chip **
+ *
+ *   WM8716
+ *      A 2ch-DAC of main outputs.
+ *      It setuped as I2S mode by wire, so no way to setup from software.
+ *         ML/I2S (28pin) -- +5V
+ *         MC/DM1 (27pin) -- GND
+ *         MC/DM0 (26pin) -- GND
+ *         MUTEB  (25pin) -- open (internal pull-up)
+ *         MODE   (24pin) -- GND
+ *         CSBIWO (23pin) -- +5V
+ *
+ */
+
+ /* Nothing to do for this chip. */
+
+
+/****************************************************************************/
+/*  probe/initialize/setup                                                  */
+/****************************************************************************/
+
+static int __devinit se_init(struct snd_ice1712 *ice)
+{
+       if (ice->eeprom.subvendor == VT1724_SUBDEVICE_SE90PCI) {
+               ice->num_total_dacs = 2;
+               ice->num_total_adcs = 0;
+               ice->vt1720 = 1;
+               return 0;
+
+       } else if (ice->eeprom.subvendor == VT1724_SUBDEVICE_SE200PCI) {
+               ice->num_total_dacs = 8;
+               ice->num_total_adcs = 2;
+               se200pci_WM8740_init(ice);
+               se200pci_WM8766_init(ice);
+               se200pci_WM8776_init(ice);
+               ice->gpio.set_pro_rate = se200pci_set_pro_rate;
+               return 0;
+       }
+
+       return -ENOENT;
+}
+
+static int __devinit se_add_controls(struct snd_ice1712 *ice)
+{
+       int err;
+
+       err = 0;
+       /* nothing to do for VT1724_SUBDEVICE_SE90PCI */
+       if (ice->eeprom.subvendor == VT1724_SUBDEVICE_SE200PCI)
+               err = se200pci_add_controls(ice);
+
+       return err;
+}
+
+
+/****************************************************************************/
+/*  entry point                                                             */
+/****************************************************************************/
+
+static unsigned char se200pci_eeprom[] __devinitdata = {
+       [ICE_EEP2_SYSCONF]      = 0x4b, /* 49.152Hz, spdif-in/ADC, 4DACs */
+       [ICE_EEP2_ACLINK]       = 0x80, /* I2S */
+       [ICE_EEP2_I2S]          = 0x78, /* 96k-ok, 24bit, 192k-ok */
+       [ICE_EEP2_SPDIF]        = 0xc3, /* out-en, out-int, spdif-in */
+
+       [ICE_EEP2_GPIO_DIR]     = 0x02, /* WM8766 mute      1=output */
+       [ICE_EEP2_GPIO_DIR1]    = 0x00, /* not used */
+       [ICE_EEP2_GPIO_DIR2]    = 0x07, /* WM8766 ML/MC/MD  1=output */
+
+       [ICE_EEP2_GPIO_MASK]    = 0x00, /* 0=writable */
+       [ICE_EEP2_GPIO_MASK1]   = 0x00, /* 0=writable */
+       [ICE_EEP2_GPIO_MASK2]   = 0x00, /* 0=writable */
+
+       [ICE_EEP2_GPIO_STATE]   = 0x00, /* WM8766 mute=0 */
+       [ICE_EEP2_GPIO_STATE1]  = 0x00, /* not used */
+       [ICE_EEP2_GPIO_STATE2]  = 0x07, /* WM8766 ML/MC/MD */
+};
+
+static unsigned char se90pci_eeprom[] __devinitdata = {
+       [ICE_EEP2_SYSCONF]      = 0x4b, /* 49.152Hz, spdif-in/ADC, 4DACs */
+       [ICE_EEP2_ACLINK]       = 0x80, /* I2S */
+       [ICE_EEP2_I2S]          = 0x78, /* 96k-ok, 24bit, 192k-ok */
+       [ICE_EEP2_SPDIF]        = 0xc3, /* out-en, out-int, spdif-in */
+
+       /* ALL GPIO bits are in input mode */
+};
+
+struct snd_ice1712_card_info snd_vt1724_se_cards[] __devinitdata = {
+       {
+               .subvendor = VT1724_SUBDEVICE_SE200PCI,
+               .name = "ONKYO SE200PCI",
+               .model = "se200pci",
+               .chip_init = se_init,
+               .build_controls = se_add_controls,
+               .eeprom_size = sizeof(se200pci_eeprom),
+               .eeprom_data = se200pci_eeprom,
+       },
+       {
+               .subvendor = VT1724_SUBDEVICE_SE90PCI,
+               .name = "ONKYO SE90PCI",
+               .model = "se90pci",
+               .chip_init = se_init,
+               .build_controls = se_add_controls,
+               .eeprom_size = sizeof(se90pci_eeprom),
+               .eeprom_data = se90pci_eeprom,
+       },
+       {} /*terminator*/
+};
diff --git a/sound/pci/ice1712/se.h b/sound/pci/ice1712/se.h
new file mode 100644 (file)
index 0000000..0b0a9da
--- /dev/null
@@ -0,0 +1,15 @@
+#ifndef __SOUND_SE_H
+#define __SOUND_SE_H
+
+/* ID */
+#define SE_DEVICE_DESC \
+               "{ONKYO INC,SE-90PCI},"\
+               "{ONKYO INC,SE-200PCI},"
+
+#define VT1724_SUBDEVICE_SE90PCI       0xb161000
+#define VT1724_SUBDEVICE_SE200PCI      0xb160100
+
+/* entry struct */
+extern struct snd_ice1712_card_info snd_vt1724_se_cards[];
+
+#endif /* __SOUND_SE_H */