sound/pci/ice1712/se.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
se200pci_WM8740_init
se200pci_WM8740_set_pro_rate
se200pci_WM8766_write
se200pci_WM8766_set_volume
se200pci_WM8766_init
se200pci_WM8766_set_pro_rate
se200pci_WM8776_write
se200pci_WM8776_set_output_volume
se200pci_WM8776_set_input_volume
se200pci_WM8776_set_input_selector
se200pci_WM8776_set_afl
se200pci_WM8776_set_agc
se200pci_WM8776_init
se200pci_WM8776_set_pro_rate
se200pci_set_pro_rate
se200pci_get_enum_count
se200pci_cont_volume_info
se200pci_cont_enum_info
se200pci_cont_volume_get
se200pci_cont_boolean_get
se200pci_cont_enum_get
se200pci_cont_update
se200pci_cont_volume_put
se200pci_cont_boolean_put
se200pci_cont_enum_put
se200pci_add_controls
se_init
se_add_controls
   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 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 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 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 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 };
/* [<][>][^][v][top][bottom][index][help] */
root/sound/pci/ice1712/se.c

DEFINITIONS
