Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[ALSA] ice1724 - Add support of Onkyo SE-90PCI and SE-200PCI

Browse source 
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>
This commit is contained in:
Shin-ya Okada 2007-10-23 15:08:18 +02:00 committed by Jaroslav Kysela
parent 18fe4ac258
commit f31639b8c5
6 changed files with 729 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
Documentation/sound/alsa/ALSA-Configuration.txt
View 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.

2
sound/pci/ice1712/Makefile
View 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

6
sound/pci/ice1712/ice1712.h
View file

@ -400,6 +400,12 @@ struct snd_ice1712 {
struct {
struct ak4114 *ak4114;
} prodigy192;
struct {
struct {
unsigned char ch1, ch2;
} vol[8];
} se;
} spec;
};

3
sound/pci/ice1712/ice1724.c
View 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,
};

700
sound/pci/ice1712/se.c Normal file
View file

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

15
sound/pci/ice1712/se.h Normal file
View file

@ -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 */