1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * ALSA driver for ICEnsemble VT1724 (Envy24HT) 4 * 5 * Lowlevel functions for ONKYO WAVIO SE-90PCI and SE-200PCI 6 * 7 * Copyright (c) 2007 Shin-ya Okada sh_okada(at)d4.dion.ne.jp 8 * (at) -> @ 9 */ 10 11 #include <linux/delay.h> 12 #include <linux/interrupt.h> 13 #include <linux/init.h> 14 #include <linux/slab.h> 15 #include <sound/core.h> 16 #include <sound/tlv.h> 17 18 #include "ice1712.h" 19 #include "envy24ht.h" 20 #include "se.h" 21 22 struct se_spec { 23 struct { 24 unsigned char ch1, ch2; 25 } vol[8]; 26 }; 27 28 /****************************************************************************/ 29 /* ONKYO WAVIO SE-200PCI */ 30 /****************************************************************************/ 31 /* 32 * system configuration ICE_EEP2_SYSCONF=0x4b 33 * XIN1 49.152MHz 34 * not have UART 35 * one stereo ADC and a S/PDIF receiver connected 36 * four stereo DACs connected 37 * 38 * AC-Link configuration ICE_EEP2_ACLINK=0x80 39 * use I2C, not use AC97 40 * 41 * I2S converters feature ICE_EEP2_I2S=0x78 42 * I2S codec has no volume/mute control feature 43 * I2S codec supports 96KHz and 192KHz 44 * I2S codec 24bits 45 * 46 * S/PDIF configuration ICE_EEP2_SPDIF=0xc3 47 * Enable integrated S/PDIF transmitter 48 * internal S/PDIF out implemented 49 * S/PDIF is stereo 50 * External S/PDIF out implemented 51 * 52 * 53 * ** connected chips ** 54 * 55 * WM8740 56 * A 2ch-DAC of main outputs. 57 * It setuped as I2S mode by wire, so no way to setup from software. 58 * The sample-rate are automatically changed. 59 * ML/I2S (28pin) --------+ 60 * MC/DM1 (27pin) -- 5V | 61 * MD/DM0 (26pin) -- GND | 62 * MUTEB (25pin) -- NC | 63 * MODE (24pin) -- GND | 64 * CSBIW (23pin) --------+ 65 * | 66 * RSTB (22pin) --R(1K)-+ 67 * Probably it reduce the noise from the control line. 68 * 69 * WM8766 70 * A 6ch-DAC for surrounds. 71 * It's control wire was connected to GPIOxx (3-wire serial interface) 72 * ML/I2S (11pin) -- GPIO18 73 * MC/IWL (12pin) -- GPIO17 74 * MD/DM (13pin) -- GPIO16 75 * MUTE (14pin) -- GPIO01 76 * 77 * WM8776 78 * A 2ch-ADC(with 10ch-selector) plus 2ch-DAC. 79 * It's control wire was connected to SDA/SCLK (2-wire serial interface) 80 * MODE (16pin) -- R(1K) -- GND 81 * CE (17pin) -- R(1K) -- GND 2-wire mode (address=0x34) 82 * DI (18pin) -- SDA 83 * CL (19pin) -- SCLK 84 * 85 * 86 * ** output pins and device names ** 87 * 88 * 7.1ch name -- output connector color -- device (-D option) 89 * 90 * FRONT 2ch -- green -- plughw:0,0 91 * CENTER(Lch) SUBWOOFER(Rch) -- black -- plughw:0,2,0 92 * SURROUND 2ch -- orange -- plughw:0,2,1 93 * SURROUND BACK 2ch -- white -- plughw:0,2,2 94 * 95 */ 96 97 98 /****************************************************************************/ 99 /* WM8740 interface */ 100 /****************************************************************************/ 101 102 static void se200pci_WM8740_init(struct snd_ice1712 *ice) 103 { 104 /* nothing to do */ 105 } 106 107 108 static void se200pci_WM8740_set_pro_rate(struct snd_ice1712 *ice, 109 unsigned int rate) 110 { 111 /* nothing to do */ 112 } 113 114 115 /****************************************************************************/ 116 /* WM8766 interface */ 117 /****************************************************************************/ 118 119 static void se200pci_WM8766_write(struct snd_ice1712 *ice, 120 unsigned int addr, unsigned int data) 121 { 122 unsigned int st; 123 unsigned int bits; 124 int i; 125 const unsigned int DATA = 0x010000; 126 const unsigned int CLOCK = 0x020000; 127 const unsigned int LOAD = 0x040000; 128 const unsigned int ALL_MASK = (DATA | CLOCK | LOAD); 129 130 snd_ice1712_save_gpio_status(ice); 131 132 st = ((addr & 0x7f) << 9) | (data & 0x1ff); 133 snd_ice1712_gpio_set_dir(ice, ice->gpio.direction | ALL_MASK); 134 snd_ice1712_gpio_set_mask(ice, ice->gpio.write_mask & ~ALL_MASK); 135 bits = snd_ice1712_gpio_read(ice) & ~ALL_MASK; 136 137 snd_ice1712_gpio_write(ice, bits); 138 for (i = 0; i < 16; i++) { 139 udelay(1); 140 bits &= ~CLOCK; 141 st = (st << 1); 142 if (st & 0x10000) 143 bits |= DATA; 144 else 145 bits &= ~DATA; 146 147 snd_ice1712_gpio_write(ice, bits); 148 149 udelay(1); 150 bits |= CLOCK; 151 snd_ice1712_gpio_write(ice, bits); 152 } 153 154 udelay(1); 155 bits |= LOAD; 156 snd_ice1712_gpio_write(ice, bits); 157 158 udelay(1); 159 bits |= (DATA | CLOCK); 160 snd_ice1712_gpio_write(ice, bits); 161 162 snd_ice1712_restore_gpio_status(ice); 163 } 164 165 static void se200pci_WM8766_set_volume(struct snd_ice1712 *ice, int ch, 166 unsigned int vol1, unsigned int vol2) 167 { 168 switch (ch) { 169 case 0: 170 se200pci_WM8766_write(ice, 0x000, vol1); 171 se200pci_WM8766_write(ice, 0x001, vol2 | 0x100); 172 break; 173 case 1: 174 se200pci_WM8766_write(ice, 0x004, vol1); 175 se200pci_WM8766_write(ice, 0x005, vol2 | 0x100); 176 break; 177 case 2: 178 se200pci_WM8766_write(ice, 0x006, vol1); 179 se200pci_WM8766_write(ice, 0x007, vol2 | 0x100); 180 break; 181 } 182 } 183 184 static void se200pci_WM8766_init(struct snd_ice1712 *ice) 185 { 186 se200pci_WM8766_write(ice, 0x1f, 0x000); /* RESET ALL */ 187 udelay(10); 188 189 se200pci_WM8766_set_volume(ice, 0, 0, 0); /* volume L=0 R=0 */ 190 se200pci_WM8766_set_volume(ice, 1, 0, 0); /* volume L=0 R=0 */ 191 se200pci_WM8766_set_volume(ice, 2, 0, 0); /* volume L=0 R=0 */ 192 193 se200pci_WM8766_write(ice, 0x03, 0x022); /* serial mode I2S-24bits */ 194 se200pci_WM8766_write(ice, 0x0a, 0x080); /* MCLK=256fs */ 195 se200pci_WM8766_write(ice, 0x12, 0x000); /* MDP=0 */ 196 se200pci_WM8766_write(ice, 0x15, 0x000); /* MDP=0 */ 197 se200pci_WM8766_write(ice, 0x09, 0x000); /* demp=off mute=off */ 198 199 se200pci_WM8766_write(ice, 0x02, 0x124); /* ch-assign L=L R=R RESET */ 200 se200pci_WM8766_write(ice, 0x02, 0x120); /* ch-assign L=L R=R */ 201 } 202 203 static void se200pci_WM8766_set_pro_rate(struct snd_ice1712 *ice, 204 unsigned int rate) 205 { 206 if (rate > 96000) 207 se200pci_WM8766_write(ice, 0x0a, 0x000); /* MCLK=128fs */ 208 else 209 se200pci_WM8766_write(ice, 0x0a, 0x080); /* MCLK=256fs */ 210 } 211 212 213 /****************************************************************************/ 214 /* WM8776 interface */ 215 /****************************************************************************/ 216 217 static void se200pci_WM8776_write(struct snd_ice1712 *ice, 218 unsigned int addr, unsigned int data) 219 { 220 unsigned int val; 221 222 val = (addr << 9) | data; 223 snd_vt1724_write_i2c(ice, 0x34, val >> 8, val & 0xff); 224 } 225 226 227 static void se200pci_WM8776_set_output_volume(struct snd_ice1712 *ice, 228 unsigned int vol1, unsigned int vol2) 229 { 230 se200pci_WM8776_write(ice, 0x03, vol1); 231 se200pci_WM8776_write(ice, 0x04, vol2 | 0x100); 232 } 233 234 static void se200pci_WM8776_set_input_volume(struct snd_ice1712 *ice, 235 unsigned int vol1, unsigned int vol2) 236 { 237 se200pci_WM8776_write(ice, 0x0e, vol1); 238 se200pci_WM8776_write(ice, 0x0f, vol2 | 0x100); 239 } 240 241 static const char * const se200pci_sel[] = { 242 "LINE-IN", "CD-IN", "MIC-IN", "ALL-MIX", NULL 243 }; 244 245 static void se200pci_WM8776_set_input_selector(struct snd_ice1712 *ice, 246 unsigned int sel) 247 { 248 static const unsigned char vals[] = { 249 /* LINE, CD, MIC, ALL, GND */ 250 0x10, 0x04, 0x08, 0x1c, 0x03 251 }; 252 if (sel > 4) 253 sel = 4; 254 se200pci_WM8776_write(ice, 0x15, vals[sel]); 255 } 256 257 static void se200pci_WM8776_set_afl(struct snd_ice1712 *ice, unsigned int afl) 258 { 259 /* AFL -- After Fader Listening */ 260 if (afl) 261 se200pci_WM8776_write(ice, 0x16, 0x005); 262 else 263 se200pci_WM8776_write(ice, 0x16, 0x001); 264 } 265 266 static const char * const se200pci_agc[] = { 267 "Off", "LimiterMode", "ALCMode", NULL 268 }; 269 270 static void se200pci_WM8776_set_agc(struct snd_ice1712 *ice, unsigned int agc) 271 { 272 /* AGC -- Auto Gain Control of the input */ 273 switch (agc) { 274 case 0: 275 se200pci_WM8776_write(ice, 0x11, 0x000); /* Off */ 276 break; 277 case 1: 278 se200pci_WM8776_write(ice, 0x10, 0x07b); 279 se200pci_WM8776_write(ice, 0x11, 0x100); /* LimiterMode */ 280 break; 281 case 2: 282 se200pci_WM8776_write(ice, 0x10, 0x1fb); 283 se200pci_WM8776_write(ice, 0x11, 0x100); /* ALCMode */ 284 break; 285 } 286 } 287 288 static void se200pci_WM8776_init(struct snd_ice1712 *ice) 289 { 290 int i; 291 static const unsigned short default_values[] = { 292 0x100, 0x100, 0x100, 293 0x100, 0x100, 0x100, 294 0x000, 0x090, 0x000, 0x000, 295 0x022, 0x022, 0x022, 296 0x008, 0x0cf, 0x0cf, 0x07b, 0x000, 297 0x032, 0x000, 0x0a6, 0x001, 0x001 298 }; 299 300 se200pci_WM8776_write(ice, 0x17, 0x000); /* reset all */ 301 /* ADC and DAC interface is I2S 24bits mode */ 302 /* The sample-rate are automatically changed */ 303 udelay(10); 304 /* BUT my board can not do reset all, so I load all by manually. */ 305 for (i = 0; i < ARRAY_SIZE(default_values); i++) 306 se200pci_WM8776_write(ice, i, default_values[i]); 307 308 se200pci_WM8776_set_input_selector(ice, 0); 309 se200pci_WM8776_set_afl(ice, 0); 310 se200pci_WM8776_set_agc(ice, 0); 311 se200pci_WM8776_set_input_volume(ice, 0, 0); 312 se200pci_WM8776_set_output_volume(ice, 0, 0); 313 314 /* head phone mute and power down */ 315 se200pci_WM8776_write(ice, 0x00, 0); 316 se200pci_WM8776_write(ice, 0x01, 0); 317 se200pci_WM8776_write(ice, 0x02, 0x100); 318 se200pci_WM8776_write(ice, 0x0d, 0x080); 319 } 320 321 static void se200pci_WM8776_set_pro_rate(struct snd_ice1712 *ice, 322 unsigned int rate) 323 { 324 /* nothing to do */ 325 } 326 327 328 /****************************************************************************/ 329 /* runtime interface */ 330 /****************************************************************************/ 331 332 static void se200pci_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate) 333 { 334 se200pci_WM8740_set_pro_rate(ice, rate); 335 se200pci_WM8766_set_pro_rate(ice, rate); 336 se200pci_WM8776_set_pro_rate(ice, rate); 337 } 338 339 struct se200pci_control { 340 const char *name; 341 enum { 342 WM8766, 343 WM8776in, 344 WM8776out, 345 WM8776sel, 346 WM8776agc, 347 WM8776afl 348 } target; 349 enum { VOLUME1, VOLUME2, BOOLEAN, ENUM } type; 350 int ch; 351 const char * const *member; 352 const char *comment; 353 }; 354 355 static const struct se200pci_control se200pci_cont[] = { 356 { 357 .name = "Front Playback Volume", 358 .target = WM8776out, 359 .type = VOLUME1, 360 .comment = "Front(green)" 361 }, 362 { 363 .name = "Side Playback Volume", 364 .target = WM8766, 365 .type = VOLUME1, 366 .ch = 1, 367 .comment = "Surround(orange)" 368 }, 369 { 370 .name = "Surround Playback Volume", 371 .target = WM8766, 372 .type = VOLUME1, 373 .ch = 2, 374 .comment = "SurroundBack(white)" 375 }, 376 { 377 .name = "CLFE Playback Volume", 378 .target = WM8766, 379 .type = VOLUME1, 380 .ch = 0, 381 .comment = "Center(Lch)&SubWoofer(Rch)(black)" 382 }, 383 { 384 .name = "Capture Volume", 385 .target = WM8776in, 386 .type = VOLUME2 387 }, 388 { 389 .name = "Capture Select", 390 .target = WM8776sel, 391 .type = ENUM, 392 .member = se200pci_sel 393 }, 394 { 395 .name = "AGC Capture Mode", 396 .target = WM8776agc, 397 .type = ENUM, 398 .member = se200pci_agc 399 }, 400 { 401 .name = "AFL Bypass Playback Switch", 402 .target = WM8776afl, 403 .type = BOOLEAN 404 } 405 }; 406 407 static int se200pci_get_enum_count(int n) 408 { 409 const char * const *member; 410 int c; 411 412 member = se200pci_cont[n].member; 413 if (!member) 414 return 0; 415 for (c = 0; member[c]; c++) 416 ; 417 return c; 418 } 419 420 static int se200pci_cont_volume_info(struct snd_kcontrol *kc, 421 struct snd_ctl_elem_info *uinfo) 422 { 423 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 424 uinfo->count = 2; 425 uinfo->value.integer.min = 0; /* mute */ 426 uinfo->value.integer.max = 0xff; /* 0dB */ 427 return 0; 428 } 429 430 #define se200pci_cont_boolean_info snd_ctl_boolean_mono_info 431 432 static int se200pci_cont_enum_info(struct snd_kcontrol *kc, 433 struct snd_ctl_elem_info *uinfo) 434 { 435 int n, c; 436 437 n = kc->private_value; 438 c = se200pci_get_enum_count(n); 439 if (!c) 440 return -EINVAL; 441 return snd_ctl_enum_info(uinfo, 1, c, se200pci_cont[n].member); 442 } 443 444 static int se200pci_cont_volume_get(struct snd_kcontrol *kc, 445 struct snd_ctl_elem_value *uc) 446 { 447 struct snd_ice1712 *ice = snd_kcontrol_chip(kc); 448 struct se_spec *spec = ice->spec; 449 int n = kc->private_value; 450 uc->value.integer.value[0] = spec->vol[n].ch1; 451 uc->value.integer.value[1] = spec->vol[n].ch2; 452 return 0; 453 } 454 455 static int se200pci_cont_boolean_get(struct snd_kcontrol *kc, 456 struct snd_ctl_elem_value *uc) 457 { 458 struct snd_ice1712 *ice = snd_kcontrol_chip(kc); 459 struct se_spec *spec = ice->spec; 460 int n = kc->private_value; 461 uc->value.integer.value[0] = spec->vol[n].ch1; 462 return 0; 463 } 464 465 static int se200pci_cont_enum_get(struct snd_kcontrol *kc, 466 struct snd_ctl_elem_value *uc) 467 { 468 struct snd_ice1712 *ice = snd_kcontrol_chip(kc); 469 struct se_spec *spec = ice->spec; 470 int n = kc->private_value; 471 uc->value.enumerated.item[0] = spec->vol[n].ch1; 472 return 0; 473 } 474 475 static void se200pci_cont_update(struct snd_ice1712 *ice, int n) 476 { 477 struct se_spec *spec = ice->spec; 478 switch (se200pci_cont[n].target) { 479 case WM8766: 480 se200pci_WM8766_set_volume(ice, 481 se200pci_cont[n].ch, 482 spec->vol[n].ch1, 483 spec->vol[n].ch2); 484 break; 485 486 case WM8776in: 487 se200pci_WM8776_set_input_volume(ice, 488 spec->vol[n].ch1, 489 spec->vol[n].ch2); 490 break; 491 492 case WM8776out: 493 se200pci_WM8776_set_output_volume(ice, 494 spec->vol[n].ch1, 495 spec->vol[n].ch2); 496 break; 497 498 case WM8776sel: 499 se200pci_WM8776_set_input_selector(ice, 500 spec->vol[n].ch1); 501 break; 502 503 case WM8776agc: 504 se200pci_WM8776_set_agc(ice, spec->vol[n].ch1); 505 break; 506 507 case WM8776afl: 508 se200pci_WM8776_set_afl(ice, spec->vol[n].ch1); 509 break; 510 511 default: 512 break; 513 } 514 } 515 516 static int se200pci_cont_volume_put(struct snd_kcontrol *kc, 517 struct snd_ctl_elem_value *uc) 518 { 519 struct snd_ice1712 *ice = snd_kcontrol_chip(kc); 520 struct se_spec *spec = ice->spec; 521 int n = kc->private_value; 522 unsigned int vol1, vol2; 523 int changed; 524 525 changed = 0; 526 vol1 = uc->value.integer.value[0] & 0xff; 527 vol2 = uc->value.integer.value[1] & 0xff; 528 if (spec->vol[n].ch1 != vol1) { 529 spec->vol[n].ch1 = vol1; 530 changed = 1; 531 } 532 if (spec->vol[n].ch2 != vol2) { 533 spec->vol[n].ch2 = vol2; 534 changed = 1; 535 } 536 if (changed) 537 se200pci_cont_update(ice, n); 538 539 return changed; 540 } 541 542 static int se200pci_cont_boolean_put(struct snd_kcontrol *kc, 543 struct snd_ctl_elem_value *uc) 544 { 545 struct snd_ice1712 *ice = snd_kcontrol_chip(kc); 546 struct se_spec *spec = ice->spec; 547 int n = kc->private_value; 548 unsigned int vol1; 549 550 vol1 = !!uc->value.integer.value[0]; 551 if (spec->vol[n].ch1 != vol1) { 552 spec->vol[n].ch1 = vol1; 553 se200pci_cont_update(ice, n); 554 return 1; 555 } 556 return 0; 557 } 558 559 static int se200pci_cont_enum_put(struct snd_kcontrol *kc, 560 struct snd_ctl_elem_value *uc) 561 { 562 struct snd_ice1712 *ice = snd_kcontrol_chip(kc); 563 struct se_spec *spec = ice->spec; 564 int n = kc->private_value; 565 unsigned int vol1; 566 567 vol1 = uc->value.enumerated.item[0]; 568 if (vol1 >= se200pci_get_enum_count(n)) 569 return -EINVAL; 570 if (spec->vol[n].ch1 != vol1) { 571 spec->vol[n].ch1 = vol1; 572 se200pci_cont_update(ice, n); 573 return 1; 574 } 575 return 0; 576 } 577 578 static const DECLARE_TLV_DB_SCALE(db_scale_gain1, -12750, 50, 1); 579 static const DECLARE_TLV_DB_SCALE(db_scale_gain2, -10350, 50, 1); 580 581 static int se200pci_add_controls(struct snd_ice1712 *ice) 582 { 583 int i; 584 struct snd_kcontrol_new cont; 585 int err; 586 587 memset(&cont, 0, sizeof(cont)); 588 cont.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 589 for (i = 0; i < ARRAY_SIZE(se200pci_cont); i++) { 590 cont.private_value = i; 591 cont.name = se200pci_cont[i].name; 592 cont.access = SNDRV_CTL_ELEM_ACCESS_READWRITE; 593 cont.tlv.p = NULL; 594 switch (se200pci_cont[i].type) { 595 case VOLUME1: 596 case VOLUME2: 597 cont.info = se200pci_cont_volume_info; 598 cont.get = se200pci_cont_volume_get; 599 cont.put = se200pci_cont_volume_put; 600 cont.access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; 601 if (se200pci_cont[i].type == VOLUME1) 602 cont.tlv.p = db_scale_gain1; 603 else 604 cont.tlv.p = db_scale_gain2; 605 break; 606 case BOOLEAN: 607 cont.info = se200pci_cont_boolean_info; 608 cont.get = se200pci_cont_boolean_get; 609 cont.put = se200pci_cont_boolean_put; 610 break; 611 case ENUM: 612 cont.info = se200pci_cont_enum_info; 613 cont.get = se200pci_cont_enum_get; 614 cont.put = se200pci_cont_enum_put; 615 break; 616 default: 617 snd_BUG(); 618 return -EINVAL; 619 } 620 err = snd_ctl_add(ice->card, snd_ctl_new1(&cont, ice)); 621 if (err < 0) 622 return err; 623 } 624 625 return 0; 626 } 627 628 629 /****************************************************************************/ 630 /* ONKYO WAVIO SE-90PCI */ 631 /****************************************************************************/ 632 /* 633 * system configuration ICE_EEP2_SYSCONF=0x4b 634 * AC-Link configuration ICE_EEP2_ACLINK=0x80 635 * I2S converters feature ICE_EEP2_I2S=0x78 636 * S/PDIF configuration ICE_EEP2_SPDIF=0xc3 637 * 638 * ** connected chip ** 639 * 640 * WM8716 641 * A 2ch-DAC of main outputs. 642 * It setuped as I2S mode by wire, so no way to setup from software. 643 * ML/I2S (28pin) -- +5V 644 * MC/DM1 (27pin) -- GND 645 * MC/DM0 (26pin) -- GND 646 * MUTEB (25pin) -- open (internal pull-up) 647 * MODE (24pin) -- GND 648 * CSBIWO (23pin) -- +5V 649 * 650 */ 651 652 /* Nothing to do for this chip. */ 653 654 655 /****************************************************************************/ 656 /* probe/initialize/setup */ 657 /****************************************************************************/ 658 659 static int se_init(struct snd_ice1712 *ice) 660 { 661 struct se_spec *spec; 662 663 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 664 if (!spec) 665 return -ENOMEM; 666 ice->spec = spec; 667 668 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_SE90PCI) { 669 ice->num_total_dacs = 2; 670 ice->num_total_adcs = 0; 671 ice->vt1720 = 1; 672 return 0; 673 674 } else if (ice->eeprom.subvendor == VT1724_SUBDEVICE_SE200PCI) { 675 ice->num_total_dacs = 8; 676 ice->num_total_adcs = 2; 677 se200pci_WM8740_init(ice); 678 se200pci_WM8766_init(ice); 679 se200pci_WM8776_init(ice); 680 ice->gpio.set_pro_rate = se200pci_set_pro_rate; 681 return 0; 682 } 683 684 return -ENOENT; 685 } 686 687 static int se_add_controls(struct snd_ice1712 *ice) 688 { 689 int err; 690 691 err = 0; 692 /* nothing to do for VT1724_SUBDEVICE_SE90PCI */ 693 if (ice->eeprom.subvendor == VT1724_SUBDEVICE_SE200PCI) 694 err = se200pci_add_controls(ice); 695 696 return err; 697 } 698 699 700 /****************************************************************************/ 701 /* entry point */ 702 /****************************************************************************/ 703 704 static const unsigned char se200pci_eeprom[] = { 705 [ICE_EEP2_SYSCONF] = 0x4b, /* 49.152Hz, spdif-in/ADC, 4DACs */ 706 [ICE_EEP2_ACLINK] = 0x80, /* I2S */ 707 [ICE_EEP2_I2S] = 0x78, /* 96k-ok, 24bit, 192k-ok */ 708 [ICE_EEP2_SPDIF] = 0xc3, /* out-en, out-int, spdif-in */ 709 710 [ICE_EEP2_GPIO_DIR] = 0x02, /* WM8766 mute 1=output */ 711 [ICE_EEP2_GPIO_DIR1] = 0x00, /* not used */ 712 [ICE_EEP2_GPIO_DIR2] = 0x07, /* WM8766 ML/MC/MD 1=output */ 713 714 [ICE_EEP2_GPIO_MASK] = 0x00, /* 0=writable */ 715 [ICE_EEP2_GPIO_MASK1] = 0x00, /* 0=writable */ 716 [ICE_EEP2_GPIO_MASK2] = 0x00, /* 0=writable */ 717 718 [ICE_EEP2_GPIO_STATE] = 0x00, /* WM8766 mute=0 */ 719 [ICE_EEP2_GPIO_STATE1] = 0x00, /* not used */ 720 [ICE_EEP2_GPIO_STATE2] = 0x07, /* WM8766 ML/MC/MD */ 721 }; 722 723 static const unsigned char se90pci_eeprom[] = { 724 [ICE_EEP2_SYSCONF] = 0x4b, /* 49.152Hz, spdif-in/ADC, 4DACs */ 725 [ICE_EEP2_ACLINK] = 0x80, /* I2S */ 726 [ICE_EEP2_I2S] = 0x78, /* 96k-ok, 24bit, 192k-ok */ 727 [ICE_EEP2_SPDIF] = 0xc3, /* out-en, out-int, spdif-in */ 728 729 /* ALL GPIO bits are in input mode */ 730 }; 731 732 struct snd_ice1712_card_info snd_vt1724_se_cards[] = { 733 { 734 .subvendor = VT1724_SUBDEVICE_SE200PCI, 735 .name = "ONKYO SE200PCI", 736 .model = "se200pci", 737 .chip_init = se_init, 738 .build_controls = se_add_controls, 739 .eeprom_size = sizeof(se200pci_eeprom), 740 .eeprom_data = se200pci_eeprom, 741 }, 742 { 743 .subvendor = VT1724_SUBDEVICE_SE90PCI, 744 .name = "ONKYO SE90PCI", 745 .model = "se90pci", 746 .chip_init = se_init, 747 .build_controls = se_add_controls, 748 .eeprom_size = sizeof(se90pci_eeprom), 749 .eeprom_data = se90pci_eeprom, 750 }, 751 {} /*terminator*/ 752 }; 753