1 /* 2 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 3 * Universal interface for Audio Codec '97 4 * 5 * For more details look to AC '97 component specification revision 2.2 6 * by Intel Corporation (http://developer.intel.com) and to datasheets 7 * for specific codecs. 8 * 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 23 * 24 */ 25 26 #include "ac97_local.h" 27 #include "ac97_patch.h" 28 29 /* 30 * Chip specific initialization 31 */ 32 33 static int patch_build_controls(struct snd_ac97 * ac97, const struct snd_kcontrol_new *controls, int count) 34 { 35 int idx, err; 36 37 for (idx = 0; idx < count; idx++) 38 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&controls[idx], ac97))) < 0) 39 return err; 40 return 0; 41 } 42 43 /* replace with a new TLV */ 44 static void reset_tlv(struct snd_ac97 *ac97, const char *name, 45 const unsigned int *tlv) 46 { 47 struct snd_ctl_elem_id sid; 48 struct snd_kcontrol *kctl; 49 memset(&sid, 0, sizeof(sid)); 50 strcpy(sid.name, name); 51 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 52 kctl = snd_ctl_find_id(ac97->bus->card, &sid); 53 if (kctl && kctl->tlv.p) 54 kctl->tlv.p = tlv; 55 } 56 57 /* set to the page, update bits and restore the page */ 58 static int ac97_update_bits_page(struct snd_ac97 *ac97, unsigned short reg, unsigned short mask, unsigned short value, unsigned short page) 59 { 60 unsigned short page_save; 61 int ret; 62 63 mutex_lock(&ac97->page_mutex); 64 page_save = snd_ac97_read(ac97, AC97_INT_PAGING) & AC97_PAGE_MASK; 65 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page); 66 ret = snd_ac97_update_bits(ac97, reg, mask, value); 67 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save); 68 mutex_unlock(&ac97->page_mutex); /* unlock paging */ 69 return ret; 70 } 71 72 /* 73 * shared line-in/mic controls 74 */ 75 static int ac97_enum_text_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo, 76 const char **texts, unsigned int nums) 77 { 78 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 79 uinfo->count = 1; 80 uinfo->value.enumerated.items = nums; 81 if (uinfo->value.enumerated.item > nums - 1) 82 uinfo->value.enumerated.item = nums - 1; 83 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 84 return 0; 85 } 86 87 static int ac97_surround_jack_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 88 { 89 static const char *texts[] = { "Shared", "Independent" }; 90 return ac97_enum_text_info(kcontrol, uinfo, texts, 2); 91 } 92 93 static int ac97_surround_jack_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 94 { 95 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 96 97 ucontrol->value.enumerated.item[0] = ac97->indep_surround; 98 return 0; 99 } 100 101 static int ac97_surround_jack_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 102 { 103 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 104 unsigned char indep = !!ucontrol->value.enumerated.item[0]; 105 106 if (indep != ac97->indep_surround) { 107 ac97->indep_surround = indep; 108 if (ac97->build_ops->update_jacks) 109 ac97->build_ops->update_jacks(ac97); 110 return 1; 111 } 112 return 0; 113 } 114 115 static int ac97_channel_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 116 { 117 static const char *texts[] = { "2ch", "4ch", "6ch" }; 118 if (kcontrol->private_value) 119 return ac97_enum_text_info(kcontrol, uinfo, texts, 2); /* 4ch only */ 120 return ac97_enum_text_info(kcontrol, uinfo, texts, 3); 121 } 122 123 static int ac97_channel_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 124 { 125 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 126 127 ucontrol->value.enumerated.item[0] = ac97->channel_mode; 128 return 0; 129 } 130 131 static int ac97_channel_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 132 { 133 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 134 unsigned char mode = ucontrol->value.enumerated.item[0]; 135 136 if (kcontrol->private_value) { 137 if (mode >= 2) 138 return -EINVAL; 139 } else { 140 if (mode >= 3) 141 return -EINVAL; 142 } 143 144 if (mode != ac97->channel_mode) { 145 ac97->channel_mode = mode; 146 if (ac97->build_ops->update_jacks) 147 ac97->build_ops->update_jacks(ac97); 148 return 1; 149 } 150 return 0; 151 } 152 153 #define AC97_SURROUND_JACK_MODE_CTL \ 154 { \ 155 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 156 .name = "Surround Jack Mode", \ 157 .info = ac97_surround_jack_mode_info, \ 158 .get = ac97_surround_jack_mode_get, \ 159 .put = ac97_surround_jack_mode_put, \ 160 } 161 #define AC97_CHANNEL_MODE_CTL \ 162 { \ 163 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 164 .name = "Channel Mode", \ 165 .info = ac97_channel_mode_info, \ 166 .get = ac97_channel_mode_get, \ 167 .put = ac97_channel_mode_put, \ 168 } 169 #define AC97_CHANNEL_MODE_4CH_CTL \ 170 { \ 171 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 172 .name = "Channel Mode", \ 173 .info = ac97_channel_mode_info, \ 174 .get = ac97_channel_mode_get, \ 175 .put = ac97_channel_mode_put, \ 176 .private_value = 1, \ 177 } 178 179 static inline int is_surround_on(struct snd_ac97 *ac97) 180 { 181 return ac97->channel_mode >= 1; 182 } 183 184 static inline int is_clfe_on(struct snd_ac97 *ac97) 185 { 186 return ac97->channel_mode >= 2; 187 } 188 189 /* system has shared jacks with surround out enabled */ 190 static inline int is_shared_surrout(struct snd_ac97 *ac97) 191 { 192 return !ac97->indep_surround && is_surround_on(ac97); 193 } 194 195 /* system has shared jacks with center/lfe out enabled */ 196 static inline int is_shared_clfeout(struct snd_ac97 *ac97) 197 { 198 return !ac97->indep_surround && is_clfe_on(ac97); 199 } 200 201 /* system has shared jacks with line in enabled */ 202 static inline int is_shared_linein(struct snd_ac97 *ac97) 203 { 204 return !ac97->indep_surround && !is_surround_on(ac97); 205 } 206 207 /* system has shared jacks with mic in enabled */ 208 static inline int is_shared_micin(struct snd_ac97 *ac97) 209 { 210 return !ac97->indep_surround && !is_clfe_on(ac97); 211 } 212 213 214 /* The following snd_ac97_ymf753_... items added by David Shust (dshust@shustring.com) */ 215 /* Modified for YMF743 by Keita Maehara <maehara@debian.org> */ 216 217 /* It is possible to indicate to the Yamaha YMF7x3 the type of 218 speakers being used. */ 219 220 static int snd_ac97_ymf7x3_info_speaker(struct snd_kcontrol *kcontrol, 221 struct snd_ctl_elem_info *uinfo) 222 { 223 static char *texts[3] = { 224 "Standard", "Small", "Smaller" 225 }; 226 227 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 228 uinfo->count = 1; 229 uinfo->value.enumerated.items = 3; 230 if (uinfo->value.enumerated.item > 2) 231 uinfo->value.enumerated.item = 2; 232 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 233 return 0; 234 } 235 236 static int snd_ac97_ymf7x3_get_speaker(struct snd_kcontrol *kcontrol, 237 struct snd_ctl_elem_value *ucontrol) 238 { 239 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 240 unsigned short val; 241 242 val = ac97->regs[AC97_YMF7X3_3D_MODE_SEL]; 243 val = (val >> 10) & 3; 244 if (val > 0) /* 0 = invalid */ 245 val--; 246 ucontrol->value.enumerated.item[0] = val; 247 return 0; 248 } 249 250 static int snd_ac97_ymf7x3_put_speaker(struct snd_kcontrol *kcontrol, 251 struct snd_ctl_elem_value *ucontrol) 252 { 253 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 254 unsigned short val; 255 256 if (ucontrol->value.enumerated.item[0] > 2) 257 return -EINVAL; 258 val = (ucontrol->value.enumerated.item[0] + 1) << 10; 259 return snd_ac97_update(ac97, AC97_YMF7X3_3D_MODE_SEL, val); 260 } 261 262 static const struct snd_kcontrol_new snd_ac97_ymf7x3_controls_speaker = 263 { 264 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 265 .name = "3D Control - Speaker", 266 .info = snd_ac97_ymf7x3_info_speaker, 267 .get = snd_ac97_ymf7x3_get_speaker, 268 .put = snd_ac97_ymf7x3_put_speaker, 269 }; 270 271 /* It is possible to indicate to the Yamaha YMF7x3 the source to 272 direct to the S/PDIF output. */ 273 static int snd_ac97_ymf7x3_spdif_source_info(struct snd_kcontrol *kcontrol, 274 struct snd_ctl_elem_info *uinfo) 275 { 276 static char *texts[2] = { "AC-Link", "A/D Converter" }; 277 278 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 279 uinfo->count = 1; 280 uinfo->value.enumerated.items = 2; 281 if (uinfo->value.enumerated.item > 1) 282 uinfo->value.enumerated.item = 1; 283 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 284 return 0; 285 } 286 287 static int snd_ac97_ymf7x3_spdif_source_get(struct snd_kcontrol *kcontrol, 288 struct snd_ctl_elem_value *ucontrol) 289 { 290 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 291 unsigned short val; 292 293 val = ac97->regs[AC97_YMF7X3_DIT_CTRL]; 294 ucontrol->value.enumerated.item[0] = (val >> 1) & 1; 295 return 0; 296 } 297 298 static int snd_ac97_ymf7x3_spdif_source_put(struct snd_kcontrol *kcontrol, 299 struct snd_ctl_elem_value *ucontrol) 300 { 301 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 302 unsigned short val; 303 304 if (ucontrol->value.enumerated.item[0] > 1) 305 return -EINVAL; 306 val = ucontrol->value.enumerated.item[0] << 1; 307 return snd_ac97_update_bits(ac97, AC97_YMF7X3_DIT_CTRL, 0x0002, val); 308 } 309 310 static int patch_yamaha_ymf7x3_3d(struct snd_ac97 *ac97) 311 { 312 struct snd_kcontrol *kctl; 313 int err; 314 315 kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97); 316 err = snd_ctl_add(ac97->bus->card, kctl); 317 if (err < 0) 318 return err; 319 strcpy(kctl->id.name, "3D Control - Wide"); 320 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 9, 7, 0); 321 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000); 322 err = snd_ctl_add(ac97->bus->card, 323 snd_ac97_cnew(&snd_ac97_ymf7x3_controls_speaker, 324 ac97)); 325 if (err < 0) 326 return err; 327 snd_ac97_write_cache(ac97, AC97_YMF7X3_3D_MODE_SEL, 0x0c00); 328 return 0; 329 } 330 331 static const struct snd_kcontrol_new snd_ac97_yamaha_ymf743_controls_spdif[3] = 332 { 333 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH), 334 AC97_YMF7X3_DIT_CTRL, 0, 1, 0), 335 { 336 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 337 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, NONE) "Source", 338 .info = snd_ac97_ymf7x3_spdif_source_info, 339 .get = snd_ac97_ymf7x3_spdif_source_get, 340 .put = snd_ac97_ymf7x3_spdif_source_put, 341 }, 342 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("", NONE, NONE) "Mute", 343 AC97_YMF7X3_DIT_CTRL, 2, 1, 1) 344 }; 345 346 static int patch_yamaha_ymf743_build_spdif(struct snd_ac97 *ac97) 347 { 348 int err; 349 350 err = patch_build_controls(ac97, &snd_ac97_controls_spdif[0], 3); 351 if (err < 0) 352 return err; 353 err = patch_build_controls(ac97, 354 snd_ac97_yamaha_ymf743_controls_spdif, 3); 355 if (err < 0) 356 return err; 357 /* set default PCM S/PDIF params */ 358 /* PCM audio,no copyright,no preemphasis,PCM coder,original */ 359 snd_ac97_write_cache(ac97, AC97_YMF7X3_DIT_CTRL, 0xa201); 360 return 0; 361 } 362 363 static struct snd_ac97_build_ops patch_yamaha_ymf743_ops = { 364 .build_spdif = patch_yamaha_ymf743_build_spdif, 365 .build_3d = patch_yamaha_ymf7x3_3d, 366 }; 367 368 static int patch_yamaha_ymf743(struct snd_ac97 *ac97) 369 { 370 ac97->build_ops = &patch_yamaha_ymf743_ops; 371 ac97->caps |= AC97_BC_BASS_TREBLE; 372 ac97->caps |= 0x04 << 10; /* Yamaha 3D enhancement */ 373 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */ 374 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */ 375 return 0; 376 } 377 378 /* The AC'97 spec states that the S/PDIF signal is to be output at pin 48. 379 The YMF753 will output the S/PDIF signal to pin 43, 47 (EAPD), or 48. 380 By default, no output pin is selected, and the S/PDIF signal is not output. 381 There is also a bit to mute S/PDIF output in a vendor-specific register. */ 382 static int snd_ac97_ymf753_spdif_output_pin_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 383 { 384 static char *texts[3] = { "Disabled", "Pin 43", "Pin 48" }; 385 386 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 387 uinfo->count = 1; 388 uinfo->value.enumerated.items = 3; 389 if (uinfo->value.enumerated.item > 2) 390 uinfo->value.enumerated.item = 2; 391 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 392 return 0; 393 } 394 395 static int snd_ac97_ymf753_spdif_output_pin_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 396 { 397 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 398 unsigned short val; 399 400 val = ac97->regs[AC97_YMF7X3_DIT_CTRL]; 401 ucontrol->value.enumerated.item[0] = (val & 0x0008) ? 2 : (val & 0x0020) ? 1 : 0; 402 return 0; 403 } 404 405 static int snd_ac97_ymf753_spdif_output_pin_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 406 { 407 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 408 unsigned short val; 409 410 if (ucontrol->value.enumerated.item[0] > 2) 411 return -EINVAL; 412 val = (ucontrol->value.enumerated.item[0] == 2) ? 0x0008 : 413 (ucontrol->value.enumerated.item[0] == 1) ? 0x0020 : 0; 414 return snd_ac97_update_bits(ac97, AC97_YMF7X3_DIT_CTRL, 0x0028, val); 415 /* The following can be used to direct S/PDIF output to pin 47 (EAPD). 416 snd_ac97_write_cache(ac97, 0x62, snd_ac97_read(ac97, 0x62) | 0x0008); */ 417 } 418 419 static const struct snd_kcontrol_new snd_ac97_ymf753_controls_spdif[3] = { 420 { 421 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 422 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 423 .info = snd_ac97_ymf7x3_spdif_source_info, 424 .get = snd_ac97_ymf7x3_spdif_source_get, 425 .put = snd_ac97_ymf7x3_spdif_source_put, 426 }, 427 { 428 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 429 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Output Pin", 430 .info = snd_ac97_ymf753_spdif_output_pin_info, 431 .get = snd_ac97_ymf753_spdif_output_pin_get, 432 .put = snd_ac97_ymf753_spdif_output_pin_put, 433 }, 434 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("", NONE, NONE) "Mute", 435 AC97_YMF7X3_DIT_CTRL, 2, 1, 1) 436 }; 437 438 static int patch_yamaha_ymf753_post_spdif(struct snd_ac97 * ac97) 439 { 440 int err; 441 442 if ((err = patch_build_controls(ac97, snd_ac97_ymf753_controls_spdif, ARRAY_SIZE(snd_ac97_ymf753_controls_spdif))) < 0) 443 return err; 444 return 0; 445 } 446 447 static struct snd_ac97_build_ops patch_yamaha_ymf753_ops = { 448 .build_3d = patch_yamaha_ymf7x3_3d, 449 .build_post_spdif = patch_yamaha_ymf753_post_spdif 450 }; 451 452 static int patch_yamaha_ymf753(struct snd_ac97 * ac97) 453 { 454 /* Patch for Yamaha YMF753, Copyright (c) by David Shust, dshust@shustring.com. 455 This chip has nonstandard and extended behaviour with regard to its S/PDIF output. 456 The AC'97 spec states that the S/PDIF signal is to be output at pin 48. 457 The YMF753 will ouput the S/PDIF signal to pin 43, 47 (EAPD), or 48. 458 By default, no output pin is selected, and the S/PDIF signal is not output. 459 There is also a bit to mute S/PDIF output in a vendor-specific register. 460 */ 461 ac97->build_ops = &patch_yamaha_ymf753_ops; 462 ac97->caps |= AC97_BC_BASS_TREBLE; 463 ac97->caps |= 0x04 << 10; /* Yamaha 3D enhancement */ 464 return 0; 465 } 466 467 /* 468 * May 2, 2003 Liam Girdwood <liam.girdwood@wolfsonmicro.com> 469 * removed broken wolfson00 patch. 470 * added support for WM9705,WM9708,WM9709,WM9710,WM9711,WM9712 and WM9717. 471 */ 472 473 static const struct snd_kcontrol_new wm97xx_snd_ac97_controls[] = { 474 AC97_DOUBLE("Front Playback Volume", AC97_WM97XX_FMIXER_VOL, 8, 0, 31, 1), 475 AC97_SINGLE("Front Playback Switch", AC97_WM97XX_FMIXER_VOL, 15, 1, 1), 476 }; 477 478 static int patch_wolfson_wm9703_specific(struct snd_ac97 * ac97) 479 { 480 /* This is known to work for the ViewSonic ViewPad 1000 481 * Randolph Bentson <bentson@holmsjoen.com> 482 * WM9703/9707/9708/9717 483 */ 484 int err, i; 485 486 for (i = 0; i < ARRAY_SIZE(wm97xx_snd_ac97_controls); i++) { 487 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm97xx_snd_ac97_controls[i], ac97))) < 0) 488 return err; 489 } 490 snd_ac97_write_cache(ac97, AC97_WM97XX_FMIXER_VOL, 0x0808); 491 return 0; 492 } 493 494 static struct snd_ac97_build_ops patch_wolfson_wm9703_ops = { 495 .build_specific = patch_wolfson_wm9703_specific, 496 }; 497 498 static int patch_wolfson03(struct snd_ac97 * ac97) 499 { 500 ac97->build_ops = &patch_wolfson_wm9703_ops; 501 return 0; 502 } 503 504 static const struct snd_kcontrol_new wm9704_snd_ac97_controls[] = { 505 AC97_DOUBLE("Front Playback Volume", AC97_WM97XX_FMIXER_VOL, 8, 0, 31, 1), 506 AC97_SINGLE("Front Playback Switch", AC97_WM97XX_FMIXER_VOL, 15, 1, 1), 507 AC97_DOUBLE("Rear Playback Volume", AC97_WM9704_RMIXER_VOL, 8, 0, 31, 1), 508 AC97_SINGLE("Rear Playback Switch", AC97_WM9704_RMIXER_VOL, 15, 1, 1), 509 AC97_DOUBLE("Rear DAC Volume", AC97_WM9704_RPCM_VOL, 8, 0, 31, 1), 510 AC97_DOUBLE("Surround Volume", AC97_SURROUND_MASTER, 8, 0, 31, 1), 511 }; 512 513 static int patch_wolfson_wm9704_specific(struct snd_ac97 * ac97) 514 { 515 int err, i; 516 for (i = 0; i < ARRAY_SIZE(wm9704_snd_ac97_controls); i++) { 517 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm9704_snd_ac97_controls[i], ac97))) < 0) 518 return err; 519 } 520 /* patch for DVD noise */ 521 snd_ac97_write_cache(ac97, AC97_WM9704_TEST, 0x0200); 522 return 0; 523 } 524 525 static struct snd_ac97_build_ops patch_wolfson_wm9704_ops = { 526 .build_specific = patch_wolfson_wm9704_specific, 527 }; 528 529 static int patch_wolfson04(struct snd_ac97 * ac97) 530 { 531 /* WM9704M/9704Q */ 532 ac97->build_ops = &patch_wolfson_wm9704_ops; 533 return 0; 534 } 535 536 static int patch_wolfson_wm9705_specific(struct snd_ac97 * ac97) 537 { 538 int err, i; 539 for (i = 0; i < ARRAY_SIZE(wm97xx_snd_ac97_controls); i++) { 540 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm97xx_snd_ac97_controls[i], ac97))) < 0) 541 return err; 542 } 543 snd_ac97_write_cache(ac97, 0x72, 0x0808); 544 return 0; 545 } 546 547 static struct snd_ac97_build_ops patch_wolfson_wm9705_ops = { 548 .build_specific = patch_wolfson_wm9705_specific, 549 }; 550 551 static int patch_wolfson05(struct snd_ac97 * ac97) 552 { 553 /* WM9705, WM9710 */ 554 ac97->build_ops = &patch_wolfson_wm9705_ops; 555 #ifdef CONFIG_TOUCHSCREEN_WM9705 556 /* WM9705 touchscreen uses AUX and VIDEO for touch */ 557 ac97->flags |= AC97_HAS_NO_VIDEO | AC97_HAS_NO_AUX; 558 #endif 559 return 0; 560 } 561 562 static const char* wm9711_alc_select[] = {"None", "Left", "Right", "Stereo"}; 563 static const char* wm9711_alc_mix[] = {"Stereo", "Right", "Left", "None"}; 564 static const char* wm9711_out3_src[] = {"Left", "VREF", "Left + Right", "Mono"}; 565 static const char* wm9711_out3_lrsrc[] = {"Master Mix", "Headphone Mix"}; 566 static const char* wm9711_rec_adc[] = {"Stereo", "Left", "Right", "Mute"}; 567 static const char* wm9711_base[] = {"Linear Control", "Adaptive Boost"}; 568 static const char* wm9711_rec_gain[] = {"+1.5dB Steps", "+0.75dB Steps"}; 569 static const char* wm9711_mic[] = {"Mic 1", "Differential", "Mic 2", "Stereo"}; 570 static const char* wm9711_rec_sel[] = 571 {"Mic 1", "NC", "NC", "Master Mix", "Line", "Headphone Mix", "Phone Mix", "Phone"}; 572 static const char* wm9711_ng_type[] = {"Constant Gain", "Mute"}; 573 574 static const struct ac97_enum wm9711_enum[] = { 575 AC97_ENUM_SINGLE(AC97_PCI_SVID, 14, 4, wm9711_alc_select), 576 AC97_ENUM_SINGLE(AC97_VIDEO, 10, 4, wm9711_alc_mix), 577 AC97_ENUM_SINGLE(AC97_AUX, 9, 4, wm9711_out3_src), 578 AC97_ENUM_SINGLE(AC97_AUX, 8, 2, wm9711_out3_lrsrc), 579 AC97_ENUM_SINGLE(AC97_REC_SEL, 12, 4, wm9711_rec_adc), 580 AC97_ENUM_SINGLE(AC97_MASTER_TONE, 15, 2, wm9711_base), 581 AC97_ENUM_DOUBLE(AC97_REC_GAIN, 14, 6, 2, wm9711_rec_gain), 582 AC97_ENUM_SINGLE(AC97_MIC, 5, 4, wm9711_mic), 583 AC97_ENUM_DOUBLE(AC97_REC_SEL, 8, 0, 8, wm9711_rec_sel), 584 AC97_ENUM_SINGLE(AC97_PCI_SVID, 5, 2, wm9711_ng_type), 585 }; 586 587 static const struct snd_kcontrol_new wm9711_snd_ac97_controls[] = { 588 AC97_SINGLE("ALC Target Volume", AC97_CODEC_CLASS_REV, 12, 15, 0), 589 AC97_SINGLE("ALC Hold Time", AC97_CODEC_CLASS_REV, 8, 15, 0), 590 AC97_SINGLE("ALC Decay Time", AC97_CODEC_CLASS_REV, 4, 15, 0), 591 AC97_SINGLE("ALC Attack Time", AC97_CODEC_CLASS_REV, 0, 15, 0), 592 AC97_ENUM("ALC Function", wm9711_enum[0]), 593 AC97_SINGLE("ALC Max Volume", AC97_PCI_SVID, 11, 7, 1), 594 AC97_SINGLE("ALC ZC Timeout", AC97_PCI_SVID, 9, 3, 1), 595 AC97_SINGLE("ALC ZC Switch", AC97_PCI_SVID, 8, 1, 0), 596 AC97_SINGLE("ALC NG Switch", AC97_PCI_SVID, 7, 1, 0), 597 AC97_ENUM("ALC NG Type", wm9711_enum[9]), 598 AC97_SINGLE("ALC NG Threshold", AC97_PCI_SVID, 0, 31, 1), 599 600 AC97_SINGLE("Side Tone Switch", AC97_VIDEO, 15, 1, 1), 601 AC97_SINGLE("Side Tone Volume", AC97_VIDEO, 12, 7, 1), 602 AC97_ENUM("ALC Headphone Mux", wm9711_enum[1]), 603 AC97_SINGLE("ALC Headphone Volume", AC97_VIDEO, 7, 7, 1), 604 605 AC97_SINGLE("Out3 Switch", AC97_AUX, 15, 1, 1), 606 AC97_SINGLE("Out3 ZC Switch", AC97_AUX, 7, 1, 0), 607 AC97_ENUM("Out3 Mux", wm9711_enum[2]), 608 AC97_ENUM("Out3 LR Mux", wm9711_enum[3]), 609 AC97_SINGLE("Out3 Volume", AC97_AUX, 0, 31, 1), 610 611 AC97_SINGLE("Beep to Headphone Switch", AC97_PC_BEEP, 15, 1, 1), 612 AC97_SINGLE("Beep to Headphone Volume", AC97_PC_BEEP, 12, 7, 1), 613 AC97_SINGLE("Beep to Side Tone Switch", AC97_PC_BEEP, 11, 1, 1), 614 AC97_SINGLE("Beep to Side Tone Volume", AC97_PC_BEEP, 8, 7, 1), 615 AC97_SINGLE("Beep to Phone Switch", AC97_PC_BEEP, 7, 1, 1), 616 AC97_SINGLE("Beep to Phone Volume", AC97_PC_BEEP, 4, 7, 1), 617 618 AC97_SINGLE("Aux to Headphone Switch", AC97_CD, 15, 1, 1), 619 AC97_SINGLE("Aux to Headphone Volume", AC97_CD, 12, 7, 1), 620 AC97_SINGLE("Aux to Side Tone Switch", AC97_CD, 11, 1, 1), 621 AC97_SINGLE("Aux to Side Tone Volume", AC97_CD, 8, 7, 1), 622 AC97_SINGLE("Aux to Phone Switch", AC97_CD, 7, 1, 1), 623 AC97_SINGLE("Aux to Phone Volume", AC97_CD, 4, 7, 1), 624 625 AC97_SINGLE("Phone to Headphone Switch", AC97_PHONE, 15, 1, 1), 626 AC97_SINGLE("Phone to Master Switch", AC97_PHONE, 14, 1, 1), 627 628 AC97_SINGLE("Line to Headphone Switch", AC97_LINE, 15, 1, 1), 629 AC97_SINGLE("Line to Master Switch", AC97_LINE, 14, 1, 1), 630 AC97_SINGLE("Line to Phone Switch", AC97_LINE, 13, 1, 1), 631 632 AC97_SINGLE("PCM Playback to Headphone Switch", AC97_PCM, 15, 1, 1), 633 AC97_SINGLE("PCM Playback to Master Switch", AC97_PCM, 14, 1, 1), 634 AC97_SINGLE("PCM Playback to Phone Switch", AC97_PCM, 13, 1, 1), 635 636 AC97_SINGLE("Capture 20dB Boost Switch", AC97_REC_SEL, 14, 1, 0), 637 AC97_ENUM("Capture to Phone Mux", wm9711_enum[4]), 638 AC97_SINGLE("Capture to Phone 20dB Boost Switch", AC97_REC_SEL, 11, 1, 1), 639 AC97_ENUM("Capture Select", wm9711_enum[8]), 640 641 AC97_SINGLE("3D Upper Cut-off Switch", AC97_3D_CONTROL, 5, 1, 1), 642 AC97_SINGLE("3D Lower Cut-off Switch", AC97_3D_CONTROL, 4, 1, 1), 643 644 AC97_ENUM("Bass Control", wm9711_enum[5]), 645 AC97_SINGLE("Bass Cut-off Switch", AC97_MASTER_TONE, 12, 1, 1), 646 AC97_SINGLE("Tone Cut-off Switch", AC97_MASTER_TONE, 4, 1, 1), 647 AC97_SINGLE("Playback Attenuate (-6dB) Switch", AC97_MASTER_TONE, 6, 1, 0), 648 649 AC97_SINGLE("ADC Switch", AC97_REC_GAIN, 15, 1, 1), 650 AC97_ENUM("Capture Volume Steps", wm9711_enum[6]), 651 AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 63, 1), 652 AC97_SINGLE("Capture ZC Switch", AC97_REC_GAIN, 7, 1, 0), 653 654 AC97_SINGLE("Mic 1 to Phone Switch", AC97_MIC, 14, 1, 1), 655 AC97_SINGLE("Mic 2 to Phone Switch", AC97_MIC, 13, 1, 1), 656 AC97_ENUM("Mic Select Source", wm9711_enum[7]), 657 AC97_SINGLE("Mic 1 Volume", AC97_MIC, 8, 31, 1), 658 AC97_SINGLE("Mic 2 Volume", AC97_MIC, 0, 31, 1), 659 AC97_SINGLE("Mic 20dB Boost Switch", AC97_MIC, 7, 1, 0), 660 661 AC97_SINGLE("Master ZC Switch", AC97_MASTER, 7, 1, 0), 662 AC97_SINGLE("Headphone ZC Switch", AC97_HEADPHONE, 7, 1, 0), 663 AC97_SINGLE("Mono ZC Switch", AC97_MASTER_MONO, 7, 1, 0), 664 }; 665 666 static int patch_wolfson_wm9711_specific(struct snd_ac97 * ac97) 667 { 668 int err, i; 669 670 for (i = 0; i < ARRAY_SIZE(wm9711_snd_ac97_controls); i++) { 671 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm9711_snd_ac97_controls[i], ac97))) < 0) 672 return err; 673 } 674 snd_ac97_write_cache(ac97, AC97_CODEC_CLASS_REV, 0x0808); 675 snd_ac97_write_cache(ac97, AC97_PCI_SVID, 0x0808); 676 snd_ac97_write_cache(ac97, AC97_VIDEO, 0x0808); 677 snd_ac97_write_cache(ac97, AC97_AUX, 0x0808); 678 snd_ac97_write_cache(ac97, AC97_PC_BEEP, 0x0808); 679 snd_ac97_write_cache(ac97, AC97_CD, 0x0000); 680 return 0; 681 } 682 683 static struct snd_ac97_build_ops patch_wolfson_wm9711_ops = { 684 .build_specific = patch_wolfson_wm9711_specific, 685 }; 686 687 static int patch_wolfson11(struct snd_ac97 * ac97) 688 { 689 /* WM9711, WM9712 */ 690 ac97->build_ops = &patch_wolfson_wm9711_ops; 691 692 ac97->flags |= AC97_HAS_NO_REC_GAIN | AC97_STEREO_MUTES | AC97_HAS_NO_MIC | 693 AC97_HAS_NO_PC_BEEP | AC97_HAS_NO_VIDEO | AC97_HAS_NO_CD; 694 695 return 0; 696 } 697 698 static const char* wm9713_mic_mixer[] = {"Stereo", "Mic 1", "Mic 2", "Mute"}; 699 static const char* wm9713_rec_mux[] = {"Stereo", "Left", "Right", "Mute"}; 700 static const char* wm9713_rec_src[] = 701 {"Mic 1", "Mic 2", "Line", "Mono In", "Headphone Mix", "Master Mix", 702 "Mono Mix", "Zh"}; 703 static const char* wm9713_rec_gain[] = {"+1.5dB Steps", "+0.75dB Steps"}; 704 static const char* wm9713_alc_select[] = {"None", "Left", "Right", "Stereo"}; 705 static const char* wm9713_mono_pga[] = {"Vmid", "Zh", "Mono Mix", "Inv 1"}; 706 static const char* wm9713_spk_pga[] = 707 {"Vmid", "Zh", "Headphone Mix", "Master Mix", "Inv", "NC", "NC", "NC"}; 708 static const char* wm9713_hp_pga[] = {"Vmid", "Zh", "Headphone Mix", "NC"}; 709 static const char* wm9713_out3_pga[] = {"Vmid", "Zh", "Inv 1", "NC"}; 710 static const char* wm9713_out4_pga[] = {"Vmid", "Zh", "Inv 2", "NC"}; 711 static const char* wm9713_dac_inv[] = 712 {"Off", "Mono Mix", "Master Mix", "Headphone Mix L", "Headphone Mix R", 713 "Headphone Mix Mono", "NC", "Vmid"}; 714 static const char* wm9713_base[] = {"Linear Control", "Adaptive Boost"}; 715 static const char* wm9713_ng_type[] = {"Constant Gain", "Mute"}; 716 717 static const struct ac97_enum wm9713_enum[] = { 718 AC97_ENUM_SINGLE(AC97_LINE, 3, 4, wm9713_mic_mixer), 719 AC97_ENUM_SINGLE(AC97_VIDEO, 14, 4, wm9713_rec_mux), 720 AC97_ENUM_SINGLE(AC97_VIDEO, 9, 4, wm9713_rec_mux), 721 AC97_ENUM_DOUBLE(AC97_VIDEO, 3, 0, 8, wm9713_rec_src), 722 AC97_ENUM_DOUBLE(AC97_CD, 14, 6, 2, wm9713_rec_gain), 723 AC97_ENUM_SINGLE(AC97_PCI_SVID, 14, 4, wm9713_alc_select), 724 AC97_ENUM_SINGLE(AC97_REC_GAIN, 14, 4, wm9713_mono_pga), 725 AC97_ENUM_DOUBLE(AC97_REC_GAIN, 11, 8, 8, wm9713_spk_pga), 726 AC97_ENUM_DOUBLE(AC97_REC_GAIN, 6, 4, 4, wm9713_hp_pga), 727 AC97_ENUM_SINGLE(AC97_REC_GAIN, 2, 4, wm9713_out3_pga), 728 AC97_ENUM_SINGLE(AC97_REC_GAIN, 0, 4, wm9713_out4_pga), 729 AC97_ENUM_DOUBLE(AC97_REC_GAIN_MIC, 13, 10, 8, wm9713_dac_inv), 730 AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 15, 2, wm9713_base), 731 AC97_ENUM_SINGLE(AC97_PCI_SVID, 5, 2, wm9713_ng_type), 732 }; 733 734 static const struct snd_kcontrol_new wm13_snd_ac97_controls[] = { 735 AC97_DOUBLE("Line In Volume", AC97_PC_BEEP, 8, 0, 31, 1), 736 AC97_SINGLE("Line In to Headphone Switch", AC97_PC_BEEP, 15, 1, 1), 737 AC97_SINGLE("Line In to Master Switch", AC97_PC_BEEP, 14, 1, 1), 738 AC97_SINGLE("Line In to Mono Switch", AC97_PC_BEEP, 13, 1, 1), 739 740 AC97_DOUBLE("PCM Playback Volume", AC97_PHONE, 8, 0, 31, 1), 741 AC97_SINGLE("PCM Playback to Headphone Switch", AC97_PHONE, 15, 1, 1), 742 AC97_SINGLE("PCM Playback to Master Switch", AC97_PHONE, 14, 1, 1), 743 AC97_SINGLE("PCM Playback to Mono Switch", AC97_PHONE, 13, 1, 1), 744 745 AC97_SINGLE("Mic 1 Volume", AC97_MIC, 8, 31, 1), 746 AC97_SINGLE("Mic 2 Volume", AC97_MIC, 0, 31, 1), 747 AC97_SINGLE("Mic 1 to Mono Switch", AC97_LINE, 7, 1, 1), 748 AC97_SINGLE("Mic 2 to Mono Switch", AC97_LINE, 6, 1, 1), 749 AC97_SINGLE("Mic Boost (+20dB) Switch", AC97_LINE, 5, 1, 0), 750 AC97_ENUM("Mic to Headphone Mux", wm9713_enum[0]), 751 AC97_SINGLE("Mic Headphone Mixer Volume", AC97_LINE, 0, 7, 1), 752 753 AC97_SINGLE("Capture Switch", AC97_CD, 15, 1, 1), 754 AC97_ENUM("Capture Volume Steps", wm9713_enum[4]), 755 AC97_DOUBLE("Capture Volume", AC97_CD, 8, 0, 15, 0), 756 AC97_SINGLE("Capture ZC Switch", AC97_CD, 7, 1, 0), 757 758 AC97_ENUM("Capture to Headphone Mux", wm9713_enum[1]), 759 AC97_SINGLE("Capture to Headphone Volume", AC97_VIDEO, 11, 7, 1), 760 AC97_ENUM("Capture to Mono Mux", wm9713_enum[2]), 761 AC97_SINGLE("Capture to Mono Boost (+20dB) Switch", AC97_VIDEO, 8, 1, 0), 762 AC97_SINGLE("Capture ADC Boost (+20dB) Switch", AC97_VIDEO, 6, 1, 0), 763 AC97_ENUM("Capture Select", wm9713_enum[3]), 764 765 AC97_SINGLE("ALC Target Volume", AC97_CODEC_CLASS_REV, 12, 15, 0), 766 AC97_SINGLE("ALC Hold Time", AC97_CODEC_CLASS_REV, 8, 15, 0), 767 AC97_SINGLE("ALC Decay Time ", AC97_CODEC_CLASS_REV, 4, 15, 0), 768 AC97_SINGLE("ALC Attack Time", AC97_CODEC_CLASS_REV, 0, 15, 0), 769 AC97_ENUM("ALC Function", wm9713_enum[5]), 770 AC97_SINGLE("ALC Max Volume", AC97_PCI_SVID, 11, 7, 0), 771 AC97_SINGLE("ALC ZC Timeout", AC97_PCI_SVID, 9, 3, 0), 772 AC97_SINGLE("ALC ZC Switch", AC97_PCI_SVID, 8, 1, 0), 773 AC97_SINGLE("ALC NG Switch", AC97_PCI_SVID, 7, 1, 0), 774 AC97_ENUM("ALC NG Type", wm9713_enum[13]), 775 AC97_SINGLE("ALC NG Threshold", AC97_PCI_SVID, 0, 31, 0), 776 777 AC97_DOUBLE("Master ZC Switch", AC97_MASTER, 14, 6, 1, 0), 778 AC97_DOUBLE("Headphone ZC Switch", AC97_HEADPHONE, 14, 6, 1, 0), 779 AC97_DOUBLE("Out3/4 ZC Switch", AC97_MASTER_MONO, 14, 6, 1, 0), 780 AC97_SINGLE("Master Right Switch", AC97_MASTER, 7, 1, 1), 781 AC97_SINGLE("Headphone Right Switch", AC97_HEADPHONE, 7, 1, 1), 782 AC97_SINGLE("Out3/4 Right Switch", AC97_MASTER_MONO, 7, 1, 1), 783 784 AC97_SINGLE("Mono In to Headphone Switch", AC97_MASTER_TONE, 15, 1, 1), 785 AC97_SINGLE("Mono In to Master Switch", AC97_MASTER_TONE, 14, 1, 1), 786 AC97_SINGLE("Mono In Volume", AC97_MASTER_TONE, 8, 31, 1), 787 AC97_SINGLE("Mono Switch", AC97_MASTER_TONE, 7, 1, 1), 788 AC97_SINGLE("Mono ZC Switch", AC97_MASTER_TONE, 6, 1, 0), 789 AC97_SINGLE("Mono Volume", AC97_MASTER_TONE, 0, 31, 1), 790 791 AC97_SINGLE("PC Beep to Headphone Switch", AC97_AUX, 15, 1, 1), 792 AC97_SINGLE("PC Beep to Headphone Volume", AC97_AUX, 12, 7, 1), 793 AC97_SINGLE("PC Beep to Master Switch", AC97_AUX, 11, 1, 1), 794 AC97_SINGLE("PC Beep to Master Volume", AC97_AUX, 8, 7, 1), 795 AC97_SINGLE("PC Beep to Mono Switch", AC97_AUX, 7, 1, 1), 796 AC97_SINGLE("PC Beep to Mono Volume", AC97_AUX, 4, 7, 1), 797 798 AC97_SINGLE("Voice to Headphone Switch", AC97_PCM, 15, 1, 1), 799 AC97_SINGLE("Voice to Headphone Volume", AC97_PCM, 12, 7, 1), 800 AC97_SINGLE("Voice to Master Switch", AC97_PCM, 11, 1, 1), 801 AC97_SINGLE("Voice to Master Volume", AC97_PCM, 8, 7, 1), 802 AC97_SINGLE("Voice to Mono Switch", AC97_PCM, 7, 1, 1), 803 AC97_SINGLE("Voice to Mono Volume", AC97_PCM, 4, 7, 1), 804 805 AC97_SINGLE("Aux to Headphone Switch", AC97_REC_SEL, 15, 1, 1), 806 AC97_SINGLE("Aux to Headphone Volume", AC97_REC_SEL, 12, 7, 1), 807 AC97_SINGLE("Aux to Master Switch", AC97_REC_SEL, 11, 1, 1), 808 AC97_SINGLE("Aux to Master Volume", AC97_REC_SEL, 8, 7, 1), 809 AC97_SINGLE("Aux to Mono Switch", AC97_REC_SEL, 7, 1, 1), 810 AC97_SINGLE("Aux to Mono Volume", AC97_REC_SEL, 4, 7, 1), 811 812 AC97_ENUM("Mono Input Mux", wm9713_enum[6]), 813 AC97_ENUM("Master Input Mux", wm9713_enum[7]), 814 AC97_ENUM("Headphone Input Mux", wm9713_enum[8]), 815 AC97_ENUM("Out 3 Input Mux", wm9713_enum[9]), 816 AC97_ENUM("Out 4 Input Mux", wm9713_enum[10]), 817 818 AC97_ENUM("Bass Control", wm9713_enum[12]), 819 AC97_SINGLE("Bass Cut-off Switch", AC97_GENERAL_PURPOSE, 12, 1, 1), 820 AC97_SINGLE("Tone Cut-off Switch", AC97_GENERAL_PURPOSE, 4, 1, 1), 821 AC97_SINGLE("Playback Attenuate (-6dB) Switch", AC97_GENERAL_PURPOSE, 6, 1, 0), 822 AC97_SINGLE("Bass Volume", AC97_GENERAL_PURPOSE, 8, 15, 1), 823 AC97_SINGLE("Tone Volume", AC97_GENERAL_PURPOSE, 0, 15, 1), 824 }; 825 826 static const struct snd_kcontrol_new wm13_snd_ac97_controls_3d[] = { 827 AC97_ENUM("Inv Input Mux", wm9713_enum[11]), 828 AC97_SINGLE("3D Upper Cut-off Switch", AC97_REC_GAIN_MIC, 5, 1, 0), 829 AC97_SINGLE("3D Lower Cut-off Switch", AC97_REC_GAIN_MIC, 4, 1, 0), 830 AC97_SINGLE("3D Depth", AC97_REC_GAIN_MIC, 0, 15, 1), 831 }; 832 833 static int patch_wolfson_wm9713_3d (struct snd_ac97 * ac97) 834 { 835 int err, i; 836 837 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls_3d); i++) { 838 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls_3d[i], ac97))) < 0) 839 return err; 840 } 841 return 0; 842 } 843 844 static int patch_wolfson_wm9713_specific(struct snd_ac97 * ac97) 845 { 846 int err, i; 847 848 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls); i++) { 849 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls[i], ac97))) < 0) 850 return err; 851 } 852 snd_ac97_write_cache(ac97, AC97_PC_BEEP, 0x0808); 853 snd_ac97_write_cache(ac97, AC97_PHONE, 0x0808); 854 snd_ac97_write_cache(ac97, AC97_MIC, 0x0808); 855 snd_ac97_write_cache(ac97, AC97_LINE, 0x00da); 856 snd_ac97_write_cache(ac97, AC97_CD, 0x0808); 857 snd_ac97_write_cache(ac97, AC97_VIDEO, 0xd612); 858 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x1ba0); 859 return 0; 860 } 861 862 #ifdef CONFIG_PM 863 static void patch_wolfson_wm9713_suspend (struct snd_ac97 * ac97) 864 { 865 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xfeff); 866 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0xffff); 867 } 868 869 static void patch_wolfson_wm9713_resume (struct snd_ac97 * ac97) 870 { 871 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xda00); 872 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0x3810); 873 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0x0); 874 } 875 #endif 876 877 static struct snd_ac97_build_ops patch_wolfson_wm9713_ops = { 878 .build_specific = patch_wolfson_wm9713_specific, 879 .build_3d = patch_wolfson_wm9713_3d, 880 #ifdef CONFIG_PM 881 .suspend = patch_wolfson_wm9713_suspend, 882 .resume = patch_wolfson_wm9713_resume 883 #endif 884 }; 885 886 static int patch_wolfson13(struct snd_ac97 * ac97) 887 { 888 /* WM9713, WM9714 */ 889 ac97->build_ops = &patch_wolfson_wm9713_ops; 890 891 ac97->flags |= AC97_HAS_NO_REC_GAIN | AC97_STEREO_MUTES | AC97_HAS_NO_PHONE | 892 AC97_HAS_NO_PC_BEEP | AC97_HAS_NO_VIDEO | AC97_HAS_NO_CD | AC97_HAS_NO_TONE | 893 AC97_HAS_NO_STD_PCM; 894 ac97->scaps &= ~AC97_SCAP_MODEM; 895 896 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xda00); 897 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0x3810); 898 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0x0); 899 900 return 0; 901 } 902 903 /* 904 * Tritech codec 905 */ 906 static int patch_tritech_tr28028(struct snd_ac97 * ac97) 907 { 908 snd_ac97_write_cache(ac97, 0x26, 0x0300); 909 snd_ac97_write_cache(ac97, 0x26, 0x0000); 910 snd_ac97_write_cache(ac97, AC97_SURROUND_MASTER, 0x0000); 911 snd_ac97_write_cache(ac97, AC97_SPDIF, 0x0000); 912 return 0; 913 } 914 915 /* 916 * Sigmatel STAC97xx codecs 917 */ 918 static int patch_sigmatel_stac9700_3d(struct snd_ac97 * ac97) 919 { 920 struct snd_kcontrol *kctl; 921 int err; 922 923 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0) 924 return err; 925 strcpy(kctl->id.name, "3D Control Sigmatel - Depth"); 926 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 2, 3, 0); 927 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000); 928 return 0; 929 } 930 931 static int patch_sigmatel_stac9708_3d(struct snd_ac97 * ac97) 932 { 933 struct snd_kcontrol *kctl; 934 int err; 935 936 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0) 937 return err; 938 strcpy(kctl->id.name, "3D Control Sigmatel - Depth"); 939 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 0, 3, 0); 940 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0) 941 return err; 942 strcpy(kctl->id.name, "3D Control Sigmatel - Rear Depth"); 943 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 2, 3, 0); 944 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000); 945 return 0; 946 } 947 948 static const struct snd_kcontrol_new snd_ac97_sigmatel_4speaker = 949 AC97_SINGLE("Sigmatel 4-Speaker Stereo Playback Switch", AC97_SIGMATEL_DAC2INVERT, 2, 1, 0); 950 951 static const struct snd_kcontrol_new snd_ac97_sigmatel_phaseinvert = 952 AC97_SINGLE("Sigmatel Surround Phase Inversion Playback Switch", AC97_SIGMATEL_DAC2INVERT, 3, 1, 0); 953 954 static const struct snd_kcontrol_new snd_ac97_sigmatel_controls[] = { 955 AC97_SINGLE("Sigmatel DAC 6dB Attenuate", AC97_SIGMATEL_ANALOG, 1, 1, 0), 956 AC97_SINGLE("Sigmatel ADC 6dB Attenuate", AC97_SIGMATEL_ANALOG, 0, 1, 0) 957 }; 958 959 static int patch_sigmatel_stac97xx_specific(struct snd_ac97 * ac97) 960 { 961 int err; 962 963 snd_ac97_write_cache(ac97, AC97_SIGMATEL_ANALOG, snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG) & ~0x0003); 964 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_ANALOG, 1)) 965 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_controls[0], 1)) < 0) 966 return err; 967 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_ANALOG, 0)) 968 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_controls[1], 1)) < 0) 969 return err; 970 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_DAC2INVERT, 2)) 971 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_4speaker, 1)) < 0) 972 return err; 973 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_DAC2INVERT, 3)) 974 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_phaseinvert, 1)) < 0) 975 return err; 976 return 0; 977 } 978 979 static struct snd_ac97_build_ops patch_sigmatel_stac9700_ops = { 980 .build_3d = patch_sigmatel_stac9700_3d, 981 .build_specific = patch_sigmatel_stac97xx_specific 982 }; 983 984 static int patch_sigmatel_stac9700(struct snd_ac97 * ac97) 985 { 986 ac97->build_ops = &patch_sigmatel_stac9700_ops; 987 return 0; 988 } 989 990 static int snd_ac97_stac9708_put_bias(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 991 { 992 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 993 int err; 994 995 mutex_lock(&ac97->page_mutex); 996 snd_ac97_write(ac97, AC97_SIGMATEL_BIAS1, 0xabba); 997 err = snd_ac97_update_bits(ac97, AC97_SIGMATEL_BIAS2, 0x0010, 998 (ucontrol->value.integer.value[0] & 1) << 4); 999 snd_ac97_write(ac97, AC97_SIGMATEL_BIAS1, 0); 1000 mutex_unlock(&ac97->page_mutex); 1001 return err; 1002 } 1003 1004 static const struct snd_kcontrol_new snd_ac97_stac9708_bias_control = { 1005 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1006 .name = "Sigmatel Output Bias Switch", 1007 .info = snd_ac97_info_volsw, 1008 .get = snd_ac97_get_volsw, 1009 .put = snd_ac97_stac9708_put_bias, 1010 .private_value = AC97_SINGLE_VALUE(AC97_SIGMATEL_BIAS2, 4, 1, 0), 1011 }; 1012 1013 static int patch_sigmatel_stac9708_specific(struct snd_ac97 *ac97) 1014 { 1015 int err; 1016 1017 /* the register bit is writable, but the function is not implemented: */ 1018 snd_ac97_remove_ctl(ac97, "PCM Out Path & Mute", NULL); 1019 1020 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Sigmatel Surround Playback"); 1021 if ((err = patch_build_controls(ac97, &snd_ac97_stac9708_bias_control, 1)) < 0) 1022 return err; 1023 return patch_sigmatel_stac97xx_specific(ac97); 1024 } 1025 1026 static struct snd_ac97_build_ops patch_sigmatel_stac9708_ops = { 1027 .build_3d = patch_sigmatel_stac9708_3d, 1028 .build_specific = patch_sigmatel_stac9708_specific 1029 }; 1030 1031 static int patch_sigmatel_stac9708(struct snd_ac97 * ac97) 1032 { 1033 unsigned int codec72, codec6c; 1034 1035 ac97->build_ops = &patch_sigmatel_stac9708_ops; 1036 ac97->caps |= 0x10; /* HP (sigmatel surround) support */ 1037 1038 codec72 = snd_ac97_read(ac97, AC97_SIGMATEL_BIAS2) & 0x8000; 1039 codec6c = snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG); 1040 1041 if ((codec72==0) && (codec6c==0)) { 1042 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba); 1043 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x1000); 1044 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba); 1045 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0007); 1046 } else if ((codec72==0x8000) && (codec6c==0)) { 1047 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba); 1048 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x1001); 1049 snd_ac97_write_cache(ac97, AC97_SIGMATEL_DAC2INVERT, 0x0008); 1050 } else if ((codec72==0x8000) && (codec6c==0x0080)) { 1051 /* nothing */ 1052 } 1053 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000); 1054 return 0; 1055 } 1056 1057 static int patch_sigmatel_stac9721(struct snd_ac97 * ac97) 1058 { 1059 ac97->build_ops = &patch_sigmatel_stac9700_ops; 1060 if (snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG) == 0) { 1061 // patch for SigmaTel 1062 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba); 1063 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x4000); 1064 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba); 1065 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002); 1066 } 1067 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000); 1068 return 0; 1069 } 1070 1071 static int patch_sigmatel_stac9744(struct snd_ac97 * ac97) 1072 { 1073 // patch for SigmaTel 1074 ac97->build_ops = &patch_sigmatel_stac9700_ops; 1075 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba); 1076 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x0000); /* is this correct? --jk */ 1077 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba); 1078 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002); 1079 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000); 1080 return 0; 1081 } 1082 1083 static int patch_sigmatel_stac9756(struct snd_ac97 * ac97) 1084 { 1085 // patch for SigmaTel 1086 ac97->build_ops = &patch_sigmatel_stac9700_ops; 1087 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba); 1088 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x0000); /* is this correct? --jk */ 1089 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba); 1090 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002); 1091 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000); 1092 return 0; 1093 } 1094 1095 static int snd_ac97_stac9758_output_jack_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1096 { 1097 static char *texts[5] = { "Input/Disabled", "Front Output", 1098 "Rear Output", "Center/LFE Output", "Mixer Output" }; 1099 1100 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1101 uinfo->count = 1; 1102 uinfo->value.enumerated.items = 5; 1103 if (uinfo->value.enumerated.item > 4) 1104 uinfo->value.enumerated.item = 4; 1105 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1106 return 0; 1107 } 1108 1109 static int snd_ac97_stac9758_output_jack_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1110 { 1111 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1112 int shift = kcontrol->private_value; 1113 unsigned short val; 1114 1115 val = ac97->regs[AC97_SIGMATEL_OUTSEL] >> shift; 1116 if (!(val & 4)) 1117 ucontrol->value.enumerated.item[0] = 0; 1118 else 1119 ucontrol->value.enumerated.item[0] = 1 + (val & 3); 1120 return 0; 1121 } 1122 1123 static int snd_ac97_stac9758_output_jack_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1124 { 1125 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1126 int shift = kcontrol->private_value; 1127 unsigned short val; 1128 1129 if (ucontrol->value.enumerated.item[0] > 4) 1130 return -EINVAL; 1131 if (ucontrol->value.enumerated.item[0] == 0) 1132 val = 0; 1133 else 1134 val = 4 | (ucontrol->value.enumerated.item[0] - 1); 1135 return ac97_update_bits_page(ac97, AC97_SIGMATEL_OUTSEL, 1136 7 << shift, val << shift, 0); 1137 } 1138 1139 static int snd_ac97_stac9758_input_jack_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1140 { 1141 static char *texts[7] = { "Mic2 Jack", "Mic1 Jack", "Line In Jack", 1142 "Front Jack", "Rear Jack", "Center/LFE Jack", "Mute" }; 1143 1144 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1145 uinfo->count = 1; 1146 uinfo->value.enumerated.items = 7; 1147 if (uinfo->value.enumerated.item > 6) 1148 uinfo->value.enumerated.item = 6; 1149 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1150 return 0; 1151 } 1152 1153 static int snd_ac97_stac9758_input_jack_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1154 { 1155 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1156 int shift = kcontrol->private_value; 1157 unsigned short val; 1158 1159 val = ac97->regs[AC97_SIGMATEL_INSEL]; 1160 ucontrol->value.enumerated.item[0] = (val >> shift) & 7; 1161 return 0; 1162 } 1163 1164 static int snd_ac97_stac9758_input_jack_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1165 { 1166 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1167 int shift = kcontrol->private_value; 1168 1169 return ac97_update_bits_page(ac97, AC97_SIGMATEL_INSEL, 7 << shift, 1170 ucontrol->value.enumerated.item[0] << shift, 0); 1171 } 1172 1173 static int snd_ac97_stac9758_phonesel_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1174 { 1175 static char *texts[3] = { "None", "Front Jack", "Rear Jack" }; 1176 1177 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1178 uinfo->count = 1; 1179 uinfo->value.enumerated.items = 3; 1180 if (uinfo->value.enumerated.item > 2) 1181 uinfo->value.enumerated.item = 2; 1182 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1183 return 0; 1184 } 1185 1186 static int snd_ac97_stac9758_phonesel_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1187 { 1188 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1189 1190 ucontrol->value.enumerated.item[0] = ac97->regs[AC97_SIGMATEL_IOMISC] & 3; 1191 return 0; 1192 } 1193 1194 static int snd_ac97_stac9758_phonesel_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1195 { 1196 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1197 1198 return ac97_update_bits_page(ac97, AC97_SIGMATEL_IOMISC, 3, 1199 ucontrol->value.enumerated.item[0], 0); 1200 } 1201 1202 #define STAC9758_OUTPUT_JACK(xname, shift) \ 1203 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ 1204 .info = snd_ac97_stac9758_output_jack_info, \ 1205 .get = snd_ac97_stac9758_output_jack_get, \ 1206 .put = snd_ac97_stac9758_output_jack_put, \ 1207 .private_value = shift } 1208 #define STAC9758_INPUT_JACK(xname, shift) \ 1209 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ 1210 .info = snd_ac97_stac9758_input_jack_info, \ 1211 .get = snd_ac97_stac9758_input_jack_get, \ 1212 .put = snd_ac97_stac9758_input_jack_put, \ 1213 .private_value = shift } 1214 static const struct snd_kcontrol_new snd_ac97_sigmatel_stac9758_controls[] = { 1215 STAC9758_OUTPUT_JACK("Mic1 Jack", 1), 1216 STAC9758_OUTPUT_JACK("LineIn Jack", 4), 1217 STAC9758_OUTPUT_JACK("Front Jack", 7), 1218 STAC9758_OUTPUT_JACK("Rear Jack", 10), 1219 STAC9758_OUTPUT_JACK("Center/LFE Jack", 13), 1220 STAC9758_INPUT_JACK("Mic Input Source", 0), 1221 STAC9758_INPUT_JACK("Line Input Source", 8), 1222 { 1223 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1224 .name = "Headphone Amp", 1225 .info = snd_ac97_stac9758_phonesel_info, 1226 .get = snd_ac97_stac9758_phonesel_get, 1227 .put = snd_ac97_stac9758_phonesel_put 1228 }, 1229 AC97_SINGLE("Exchange Center/LFE", AC97_SIGMATEL_IOMISC, 4, 1, 0), 1230 AC97_SINGLE("Headphone +3dB Boost", AC97_SIGMATEL_IOMISC, 8, 1, 0) 1231 }; 1232 1233 static int patch_sigmatel_stac9758_specific(struct snd_ac97 *ac97) 1234 { 1235 int err; 1236 1237 err = patch_sigmatel_stac97xx_specific(ac97); 1238 if (err < 0) 1239 return err; 1240 err = patch_build_controls(ac97, snd_ac97_sigmatel_stac9758_controls, 1241 ARRAY_SIZE(snd_ac97_sigmatel_stac9758_controls)); 1242 if (err < 0) 1243 return err; 1244 /* DAC-A direct */ 1245 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Front Playback"); 1246 /* DAC-A to Mix = PCM */ 1247 /* DAC-B direct = Surround */ 1248 /* DAC-B to Mix */ 1249 snd_ac97_rename_vol_ctl(ac97, "Video Playback", "Surround Mix Playback"); 1250 /* DAC-C direct = Center/LFE */ 1251 1252 return 0; 1253 } 1254 1255 static struct snd_ac97_build_ops patch_sigmatel_stac9758_ops = { 1256 .build_3d = patch_sigmatel_stac9700_3d, 1257 .build_specific = patch_sigmatel_stac9758_specific 1258 }; 1259 1260 static int patch_sigmatel_stac9758(struct snd_ac97 * ac97) 1261 { 1262 static unsigned short regs[4] = { 1263 AC97_SIGMATEL_OUTSEL, 1264 AC97_SIGMATEL_IOMISC, 1265 AC97_SIGMATEL_INSEL, 1266 AC97_SIGMATEL_VARIOUS 1267 }; 1268 static unsigned short def_regs[4] = { 1269 /* OUTSEL */ 0xd794, /* CL:CL, SR:SR, LO:MX, LI:DS, MI:DS */ 1270 /* IOMISC */ 0x2001, 1271 /* INSEL */ 0x0201, /* LI:LI, MI:M1 */ 1272 /* VARIOUS */ 0x0040 1273 }; 1274 static unsigned short m675_regs[4] = { 1275 /* OUTSEL */ 0xfc70, /* CL:MX, SR:MX, LO:DS, LI:MX, MI:DS */ 1276 /* IOMISC */ 0x2102, /* HP amp on */ 1277 /* INSEL */ 0x0203, /* LI:LI, MI:FR */ 1278 /* VARIOUS */ 0x0041 /* stereo mic */ 1279 }; 1280 unsigned short *pregs = def_regs; 1281 int i; 1282 1283 /* Gateway M675 notebook */ 1284 if (ac97->pci && 1285 ac97->subsystem_vendor == 0x107b && 1286 ac97->subsystem_device == 0x0601) 1287 pregs = m675_regs; 1288 1289 // patch for SigmaTel 1290 ac97->build_ops = &patch_sigmatel_stac9758_ops; 1291 /* FIXME: assume only page 0 for writing cache */ 1292 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR); 1293 for (i = 0; i < 4; i++) 1294 snd_ac97_write_cache(ac97, regs[i], pregs[i]); 1295 1296 ac97->flags |= AC97_STEREO_MUTES; 1297 return 0; 1298 } 1299 1300 /* 1301 * Cirrus Logic CS42xx codecs 1302 */ 1303 static const struct snd_kcontrol_new snd_ac97_cirrus_controls_spdif[2] = { 1304 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), AC97_CSR_SPDIF, 15, 1, 0), 1305 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA", AC97_CSR_ACMODE, 0, 3, 0) 1306 }; 1307 1308 static int patch_cirrus_build_spdif(struct snd_ac97 * ac97) 1309 { 1310 int err; 1311 1312 /* con mask, pro mask, default */ 1313 if ((err = patch_build_controls(ac97, &snd_ac97_controls_spdif[0], 3)) < 0) 1314 return err; 1315 /* switch, spsa */ 1316 if ((err = patch_build_controls(ac97, &snd_ac97_cirrus_controls_spdif[0], 1)) < 0) 1317 return err; 1318 switch (ac97->id & AC97_ID_CS_MASK) { 1319 case AC97_ID_CS4205: 1320 if ((err = patch_build_controls(ac97, &snd_ac97_cirrus_controls_spdif[1], 1)) < 0) 1321 return err; 1322 break; 1323 } 1324 /* set default PCM S/PDIF params */ 1325 /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */ 1326 snd_ac97_write_cache(ac97, AC97_CSR_SPDIF, 0x0a20); 1327 return 0; 1328 } 1329 1330 static struct snd_ac97_build_ops patch_cirrus_ops = { 1331 .build_spdif = patch_cirrus_build_spdif 1332 }; 1333 1334 static int patch_cirrus_spdif(struct snd_ac97 * ac97) 1335 { 1336 /* Basically, the cs4201/cs4205/cs4297a has non-standard sp/dif registers. 1337 WHY CAN'T ANYONE FOLLOW THE BLOODY SPEC? *sigh* 1338 - sp/dif EA ID is not set, but sp/dif is always present. 1339 - enable/disable is spdif register bit 15. 1340 - sp/dif control register is 0x68. differs from AC97: 1341 - valid is bit 14 (vs 15) 1342 - no DRS 1343 - only 44.1/48k [00 = 48, 01=44,1] (AC97 is 00=44.1, 10=48) 1344 - sp/dif ssource select is in 0x5e bits 0,1. 1345 */ 1346 1347 ac97->build_ops = &patch_cirrus_ops; 1348 ac97->flags |= AC97_CS_SPDIF; 1349 ac97->rates[AC97_RATES_SPDIF] &= ~SNDRV_PCM_RATE_32000; 1350 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */ 1351 snd_ac97_write_cache(ac97, AC97_CSR_ACMODE, 0x0080); 1352 return 0; 1353 } 1354 1355 static int patch_cirrus_cs4299(struct snd_ac97 * ac97) 1356 { 1357 /* force the detection of PC Beep */ 1358 ac97->flags |= AC97_HAS_PC_BEEP; 1359 1360 return patch_cirrus_spdif(ac97); 1361 } 1362 1363 /* 1364 * Conexant codecs 1365 */ 1366 static const struct snd_kcontrol_new snd_ac97_conexant_controls_spdif[1] = { 1367 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), AC97_CXR_AUDIO_MISC, 3, 1, 0), 1368 }; 1369 1370 static int patch_conexant_build_spdif(struct snd_ac97 * ac97) 1371 { 1372 int err; 1373 1374 /* con mask, pro mask, default */ 1375 if ((err = patch_build_controls(ac97, &snd_ac97_controls_spdif[0], 3)) < 0) 1376 return err; 1377 /* switch */ 1378 if ((err = patch_build_controls(ac97, &snd_ac97_conexant_controls_spdif[0], 1)) < 0) 1379 return err; 1380 /* set default PCM S/PDIF params */ 1381 /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */ 1382 snd_ac97_write_cache(ac97, AC97_CXR_AUDIO_MISC, 1383 snd_ac97_read(ac97, AC97_CXR_AUDIO_MISC) & ~(AC97_CXR_SPDIFEN|AC97_CXR_COPYRGT|AC97_CXR_SPDIF_MASK)); 1384 return 0; 1385 } 1386 1387 static struct snd_ac97_build_ops patch_conexant_ops = { 1388 .build_spdif = patch_conexant_build_spdif 1389 }; 1390 1391 static int patch_conexant(struct snd_ac97 * ac97) 1392 { 1393 ac97->build_ops = &patch_conexant_ops; 1394 ac97->flags |= AC97_CX_SPDIF; 1395 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */ 1396 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */ 1397 return 0; 1398 } 1399 1400 static int patch_cx20551(struct snd_ac97 *ac97) 1401 { 1402 snd_ac97_update_bits(ac97, 0x5c, 0x01, 0x01); 1403 return 0; 1404 } 1405 1406 /* 1407 * Analog Device AD18xx, AD19xx codecs 1408 */ 1409 #ifdef CONFIG_PM 1410 static void ad18xx_resume(struct snd_ac97 *ac97) 1411 { 1412 static unsigned short setup_regs[] = { 1413 AC97_AD_MISC, AC97_AD_SERIAL_CFG, AC97_AD_JACK_SPDIF, 1414 }; 1415 int i, codec; 1416 1417 for (i = 0; i < (int)ARRAY_SIZE(setup_regs); i++) { 1418 unsigned short reg = setup_regs[i]; 1419 if (test_bit(reg, ac97->reg_accessed)) { 1420 snd_ac97_write(ac97, reg, ac97->regs[reg]); 1421 snd_ac97_read(ac97, reg); 1422 } 1423 } 1424 1425 if (! (ac97->flags & AC97_AD_MULTI)) 1426 /* normal restore */ 1427 snd_ac97_restore_status(ac97); 1428 else { 1429 /* restore the AD18xx codec configurations */ 1430 for (codec = 0; codec < 3; codec++) { 1431 if (! ac97->spec.ad18xx.id[codec]) 1432 continue; 1433 /* select single codec */ 1434 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 1435 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]); 1436 ac97->bus->ops->write(ac97, AC97_AD_CODEC_CFG, ac97->spec.ad18xx.codec_cfg[codec]); 1437 } 1438 /* select all codecs */ 1439 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000); 1440 1441 /* restore status */ 1442 for (i = 2; i < 0x7c ; i += 2) { 1443 if (i == AC97_POWERDOWN || i == AC97_EXTENDED_ID) 1444 continue; 1445 if (test_bit(i, ac97->reg_accessed)) { 1446 /* handle multi codecs for AD18xx */ 1447 if (i == AC97_PCM) { 1448 for (codec = 0; codec < 3; codec++) { 1449 if (! ac97->spec.ad18xx.id[codec]) 1450 continue; 1451 /* select single codec */ 1452 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 1453 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]); 1454 /* update PCM bits */ 1455 ac97->bus->ops->write(ac97, AC97_PCM, ac97->spec.ad18xx.pcmreg[codec]); 1456 } 1457 /* select all codecs */ 1458 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000); 1459 continue; 1460 } else if (i == AC97_AD_TEST || 1461 i == AC97_AD_CODEC_CFG || 1462 i == AC97_AD_SERIAL_CFG) 1463 continue; /* ignore */ 1464 } 1465 snd_ac97_write(ac97, i, ac97->regs[i]); 1466 snd_ac97_read(ac97, i); 1467 } 1468 } 1469 1470 snd_ac97_restore_iec958(ac97); 1471 } 1472 1473 static void ad1888_resume(struct snd_ac97 *ac97) 1474 { 1475 ad18xx_resume(ac97); 1476 snd_ac97_write_cache(ac97, AC97_CODEC_CLASS_REV, 0x8080); 1477 } 1478 1479 #endif 1480 1481 static const struct snd_ac97_res_table ad1819_restbl[] = { 1482 { AC97_PHONE, 0x9f1f }, 1483 { AC97_MIC, 0x9f1f }, 1484 { AC97_LINE, 0x9f1f }, 1485 { AC97_CD, 0x9f1f }, 1486 { AC97_VIDEO, 0x9f1f }, 1487 { AC97_AUX, 0x9f1f }, 1488 { AC97_PCM, 0x9f1f }, 1489 { } /* terminator */ 1490 }; 1491 1492 static int patch_ad1819(struct snd_ac97 * ac97) 1493 { 1494 unsigned short scfg; 1495 1496 // patch for Analog Devices 1497 scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG); 1498 snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x7000); /* select all codecs */ 1499 ac97->res_table = ad1819_restbl; 1500 return 0; 1501 } 1502 1503 static unsigned short patch_ad1881_unchained(struct snd_ac97 * ac97, int idx, unsigned short mask) 1504 { 1505 unsigned short val; 1506 1507 // test for unchained codec 1508 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, mask); 1509 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0000); /* ID0C, ID1C, SDIE = off */ 1510 val = snd_ac97_read(ac97, AC97_VENDOR_ID2); 1511 if ((val & 0xff40) != 0x5340) 1512 return 0; 1513 ac97->spec.ad18xx.unchained[idx] = mask; 1514 ac97->spec.ad18xx.id[idx] = val; 1515 ac97->spec.ad18xx.codec_cfg[idx] = 0x0000; 1516 return mask; 1517 } 1518 1519 static int patch_ad1881_chained1(struct snd_ac97 * ac97, int idx, unsigned short codec_bits) 1520 { 1521 static int cfg_bits[3] = { 1<<12, 1<<14, 1<<13 }; 1522 unsigned short val; 1523 1524 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, cfg_bits[idx]); 1525 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0004); // SDIE 1526 val = snd_ac97_read(ac97, AC97_VENDOR_ID2); 1527 if ((val & 0xff40) != 0x5340) 1528 return 0; 1529 if (codec_bits) 1530 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, codec_bits); 1531 ac97->spec.ad18xx.chained[idx] = cfg_bits[idx]; 1532 ac97->spec.ad18xx.id[idx] = val; 1533 ac97->spec.ad18xx.codec_cfg[idx] = codec_bits ? codec_bits : 0x0004; 1534 return 1; 1535 } 1536 1537 static void patch_ad1881_chained(struct snd_ac97 * ac97, int unchained_idx, int cidx1, int cidx2) 1538 { 1539 // already detected? 1540 if (ac97->spec.ad18xx.unchained[cidx1] || ac97->spec.ad18xx.chained[cidx1]) 1541 cidx1 = -1; 1542 if (ac97->spec.ad18xx.unchained[cidx2] || ac97->spec.ad18xx.chained[cidx2]) 1543 cidx2 = -1; 1544 if (cidx1 < 0 && cidx2 < 0) 1545 return; 1546 // test for chained codecs 1547 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 1548 ac97->spec.ad18xx.unchained[unchained_idx]); 1549 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0002); // ID1C 1550 ac97->spec.ad18xx.codec_cfg[unchained_idx] = 0x0002; 1551 if (cidx1 >= 0) { 1552 if (cidx2 < 0) 1553 patch_ad1881_chained1(ac97, cidx1, 0); 1554 else if (patch_ad1881_chained1(ac97, cidx1, 0x0006)) // SDIE | ID1C 1555 patch_ad1881_chained1(ac97, cidx2, 0); 1556 else if (patch_ad1881_chained1(ac97, cidx2, 0x0006)) // SDIE | ID1C 1557 patch_ad1881_chained1(ac97, cidx1, 0); 1558 } else if (cidx2 >= 0) { 1559 patch_ad1881_chained1(ac97, cidx2, 0); 1560 } 1561 } 1562 1563 static struct snd_ac97_build_ops patch_ad1881_build_ops = { 1564 #ifdef CONFIG_PM 1565 .resume = ad18xx_resume 1566 #endif 1567 }; 1568 1569 static int patch_ad1881(struct snd_ac97 * ac97) 1570 { 1571 static const char cfg_idxs[3][2] = { 1572 {2, 1}, 1573 {0, 2}, 1574 {0, 1} 1575 }; 1576 1577 // patch for Analog Devices 1578 unsigned short codecs[3]; 1579 unsigned short val; 1580 int idx, num; 1581 1582 val = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG); 1583 snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, val); 1584 codecs[0] = patch_ad1881_unchained(ac97, 0, (1<<12)); 1585 codecs[1] = patch_ad1881_unchained(ac97, 1, (1<<14)); 1586 codecs[2] = patch_ad1881_unchained(ac97, 2, (1<<13)); 1587 1588 if (! (codecs[0] || codecs[1] || codecs[2])) 1589 goto __end; 1590 1591 for (idx = 0; idx < 3; idx++) 1592 if (ac97->spec.ad18xx.unchained[idx]) 1593 patch_ad1881_chained(ac97, idx, cfg_idxs[idx][0], cfg_idxs[idx][1]); 1594 1595 if (ac97->spec.ad18xx.id[1]) { 1596 ac97->flags |= AC97_AD_MULTI; 1597 ac97->scaps |= AC97_SCAP_SURROUND_DAC; 1598 } 1599 if (ac97->spec.ad18xx.id[2]) { 1600 ac97->flags |= AC97_AD_MULTI; 1601 ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC; 1602 } 1603 1604 __end: 1605 /* select all codecs */ 1606 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000); 1607 /* check if only one codec is present */ 1608 for (idx = num = 0; idx < 3; idx++) 1609 if (ac97->spec.ad18xx.id[idx]) 1610 num++; 1611 if (num == 1) { 1612 /* ok, deselect all ID bits */ 1613 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0000); 1614 ac97->spec.ad18xx.codec_cfg[0] = 1615 ac97->spec.ad18xx.codec_cfg[1] = 1616 ac97->spec.ad18xx.codec_cfg[2] = 0x0000; 1617 } 1618 /* required for AD1886/AD1885 combination */ 1619 ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID); 1620 if (ac97->spec.ad18xx.id[0]) { 1621 ac97->id &= 0xffff0000; 1622 ac97->id |= ac97->spec.ad18xx.id[0]; 1623 } 1624 ac97->build_ops = &patch_ad1881_build_ops; 1625 return 0; 1626 } 1627 1628 static const struct snd_kcontrol_new snd_ac97_controls_ad1885[] = { 1629 AC97_SINGLE("Digital Mono Direct", AC97_AD_MISC, 11, 1, 0), 1630 /* AC97_SINGLE("Digital Audio Mode", AC97_AD_MISC, 12, 1, 0), */ /* seems problematic */ 1631 AC97_SINGLE("Low Power Mixer", AC97_AD_MISC, 14, 1, 0), 1632 AC97_SINGLE("Zero Fill DAC", AC97_AD_MISC, 15, 1, 0), 1633 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 9, 1, 1), /* inverted */ 1634 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 8, 1, 1), /* inverted */ 1635 }; 1636 1637 static const DECLARE_TLV_DB_SCALE(db_scale_6bit_6db_max, -8850, 150, 0); 1638 1639 static int patch_ad1885_specific(struct snd_ac97 * ac97) 1640 { 1641 int err; 1642 1643 if ((err = patch_build_controls(ac97, snd_ac97_controls_ad1885, ARRAY_SIZE(snd_ac97_controls_ad1885))) < 0) 1644 return err; 1645 reset_tlv(ac97, "Headphone Playback Volume", 1646 db_scale_6bit_6db_max); 1647 return 0; 1648 } 1649 1650 static struct snd_ac97_build_ops patch_ad1885_build_ops = { 1651 .build_specific = &patch_ad1885_specific, 1652 #ifdef CONFIG_PM 1653 .resume = ad18xx_resume 1654 #endif 1655 }; 1656 1657 static int patch_ad1885(struct snd_ac97 * ac97) 1658 { 1659 patch_ad1881(ac97); 1660 /* This is required to deal with the Intel D815EEAL2 */ 1661 /* i.e. Line out is actually headphone out from codec */ 1662 1663 /* set default */ 1664 snd_ac97_write_cache(ac97, AC97_AD_MISC, 0x0404); 1665 1666 ac97->build_ops = &patch_ad1885_build_ops; 1667 return 0; 1668 } 1669 1670 static int patch_ad1886_specific(struct snd_ac97 * ac97) 1671 { 1672 reset_tlv(ac97, "Headphone Playback Volume", 1673 db_scale_6bit_6db_max); 1674 return 0; 1675 } 1676 1677 static struct snd_ac97_build_ops patch_ad1886_build_ops = { 1678 .build_specific = &patch_ad1886_specific, 1679 #ifdef CONFIG_PM 1680 .resume = ad18xx_resume 1681 #endif 1682 }; 1683 1684 static int patch_ad1886(struct snd_ac97 * ac97) 1685 { 1686 patch_ad1881(ac97); 1687 /* Presario700 workaround */ 1688 /* for Jack Sense/SPDIF Register misetting causing */ 1689 snd_ac97_write_cache(ac97, AC97_AD_JACK_SPDIF, 0x0010); 1690 ac97->build_ops = &patch_ad1886_build_ops; 1691 return 0; 1692 } 1693 1694 /* MISC bits (AD1888/AD1980/AD1985 register 0x76) */ 1695 #define AC97_AD198X_MBC 0x0003 /* mic boost */ 1696 #define AC97_AD198X_MBC_20 0x0000 /* +20dB */ 1697 #define AC97_AD198X_MBC_10 0x0001 /* +10dB */ 1698 #define AC97_AD198X_MBC_30 0x0002 /* +30dB */ 1699 #define AC97_AD198X_VREFD 0x0004 /* VREF high-Z */ 1700 #define AC97_AD198X_VREFH 0x0008 /* 0=2.25V, 1=3.7V */ 1701 #define AC97_AD198X_VREF_0 0x000c /* 0V (AD1985 only) */ 1702 #define AC97_AD198X_VREF_MASK (AC97_AD198X_VREFH | AC97_AD198X_VREFD) 1703 #define AC97_AD198X_VREF_SHIFT 2 1704 #define AC97_AD198X_SRU 0x0010 /* sample rate unlock */ 1705 #define AC97_AD198X_LOSEL 0x0020 /* LINE_OUT amplifiers input select */ 1706 #define AC97_AD198X_2MIC 0x0040 /* 2-channel mic select */ 1707 #define AC97_AD198X_SPRD 0x0080 /* SPREAD enable */ 1708 #define AC97_AD198X_DMIX0 0x0100 /* downmix mode: */ 1709 /* 0 = 6-to-4, 1 = 6-to-2 downmix */ 1710 #define AC97_AD198X_DMIX1 0x0200 /* downmix mode: 1 = enabled */ 1711 #define AC97_AD198X_HPSEL 0x0400 /* headphone amplifier input select */ 1712 #define AC97_AD198X_CLDIS 0x0800 /* center/lfe disable */ 1713 #define AC97_AD198X_LODIS 0x1000 /* LINE_OUT disable */ 1714 #define AC97_AD198X_MSPLT 0x2000 /* mute split */ 1715 #define AC97_AD198X_AC97NC 0x4000 /* AC97 no compatible mode */ 1716 #define AC97_AD198X_DACZ 0x8000 /* DAC zero-fill mode */ 1717 1718 /* MISC 1 bits (AD1986 register 0x76) */ 1719 #define AC97_AD1986_MBC 0x0003 /* mic boost */ 1720 #define AC97_AD1986_MBC_20 0x0000 /* +20dB */ 1721 #define AC97_AD1986_MBC_10 0x0001 /* +10dB */ 1722 #define AC97_AD1986_MBC_30 0x0002 /* +30dB */ 1723 #define AC97_AD1986_LISEL0 0x0004 /* LINE_IN select bit 0 */ 1724 #define AC97_AD1986_LISEL1 0x0008 /* LINE_IN select bit 1 */ 1725 #define AC97_AD1986_LISEL_MASK (AC97_AD1986_LISEL1 | AC97_AD1986_LISEL0) 1726 #define AC97_AD1986_LISEL_LI 0x0000 /* LINE_IN pins as LINE_IN source */ 1727 #define AC97_AD1986_LISEL_SURR 0x0004 /* SURROUND pins as LINE_IN source */ 1728 #define AC97_AD1986_LISEL_MIC 0x0008 /* MIC_1/2 pins as LINE_IN source */ 1729 #define AC97_AD1986_SRU 0x0010 /* sample rate unlock */ 1730 #define AC97_AD1986_SOSEL 0x0020 /* SURROUND_OUT amplifiers input sel */ 1731 #define AC97_AD1986_2MIC 0x0040 /* 2-channel mic select */ 1732 #define AC97_AD1986_SPRD 0x0080 /* SPREAD enable */ 1733 #define AC97_AD1986_DMIX0 0x0100 /* downmix mode: */ 1734 /* 0 = 6-to-4, 1 = 6-to-2 downmix */ 1735 #define AC97_AD1986_DMIX1 0x0200 /* downmix mode: 1 = enabled */ 1736 #define AC97_AD1986_CLDIS 0x0800 /* center/lfe disable */ 1737 #define AC97_AD1986_SODIS 0x1000 /* SURROUND_OUT disable */ 1738 #define AC97_AD1986_MSPLT 0x2000 /* mute split (read only 1) */ 1739 #define AC97_AD1986_AC97NC 0x4000 /* AC97 no compatible mode (r/o 1) */ 1740 #define AC97_AD1986_DACZ 0x8000 /* DAC zero-fill mode */ 1741 1742 /* MISC 2 bits (AD1986 register 0x70) */ 1743 #define AC97_AD_MISC2 0x70 /* Misc Control Bits 2 (AD1986) */ 1744 1745 #define AC97_AD1986_CVREF0 0x0004 /* C/LFE VREF_OUT 2.25V */ 1746 #define AC97_AD1986_CVREF1 0x0008 /* C/LFE VREF_OUT 0V */ 1747 #define AC97_AD1986_CVREF2 0x0010 /* C/LFE VREF_OUT 3.7V */ 1748 #define AC97_AD1986_CVREF_MASK \ 1749 (AC97_AD1986_CVREF2 | AC97_AD1986_CVREF1 | AC97_AD1986_CVREF0) 1750 #define AC97_AD1986_JSMAP 0x0020 /* Jack Sense Mapping 1 = alternate */ 1751 #define AC97_AD1986_MMDIS 0x0080 /* Mono Mute Disable */ 1752 #define AC97_AD1986_MVREF0 0x0400 /* MIC VREF_OUT 2.25V */ 1753 #define AC97_AD1986_MVREF1 0x0800 /* MIC VREF_OUT 0V */ 1754 #define AC97_AD1986_MVREF2 0x1000 /* MIC VREF_OUT 3.7V */ 1755 #define AC97_AD1986_MVREF_MASK \ 1756 (AC97_AD1986_MVREF2 | AC97_AD1986_MVREF1 | AC97_AD1986_MVREF0) 1757 1758 /* MISC 3 bits (AD1986 register 0x7a) */ 1759 #define AC97_AD_MISC3 0x7a /* Misc Control Bits 3 (AD1986) */ 1760 1761 #define AC97_AD1986_MMIX 0x0004 /* Mic Mix, left/right */ 1762 #define AC97_AD1986_GPO 0x0008 /* General Purpose Out */ 1763 #define AC97_AD1986_LOHPEN 0x0010 /* LINE_OUT headphone drive */ 1764 #define AC97_AD1986_LVREF0 0x0100 /* LINE_OUT VREF_OUT 2.25V */ 1765 #define AC97_AD1986_LVREF1 0x0200 /* LINE_OUT VREF_OUT 0V */ 1766 #define AC97_AD1986_LVREF2 0x0400 /* LINE_OUT VREF_OUT 3.7V */ 1767 #define AC97_AD1986_LVREF_MASK \ 1768 (AC97_AD1986_LVREF2 | AC97_AD1986_LVREF1 | AC97_AD1986_LVREF0) 1769 #define AC97_AD1986_JSINVA 0x0800 /* Jack Sense Invert SENSE_A */ 1770 #define AC97_AD1986_LOSEL 0x1000 /* LINE_OUT amplifiers input select */ 1771 #define AC97_AD1986_HPSEL0 0x2000 /* Headphone amplifiers */ 1772 /* input select Surround DACs */ 1773 #define AC97_AD1986_HPSEL1 0x4000 /* Headphone amplifiers input */ 1774 /* select C/LFE DACs */ 1775 #define AC97_AD1986_JSINVB 0x8000 /* Jack Sense Invert SENSE_B */ 1776 1777 /* Serial Config bits (AD1986 register 0x74) (incomplete) */ 1778 #define AC97_AD1986_OMS0 0x0100 /* Optional Mic Selector bit 0 */ 1779 #define AC97_AD1986_OMS1 0x0200 /* Optional Mic Selector bit 1 */ 1780 #define AC97_AD1986_OMS2 0x0400 /* Optional Mic Selector bit 2 */ 1781 #define AC97_AD1986_OMS_MASK \ 1782 (AC97_AD1986_OMS2 | AC97_AD1986_OMS1 | AC97_AD1986_OMS0) 1783 #define AC97_AD1986_OMS_M 0x0000 /* MIC_1/2 pins are MIC sources */ 1784 #define AC97_AD1986_OMS_L 0x0100 /* LINE_IN pins are MIC sources */ 1785 #define AC97_AD1986_OMS_C 0x0200 /* Center/LFE pins are MCI sources */ 1786 #define AC97_AD1986_OMS_MC 0x0400 /* Mix of MIC and C/LFE pins */ 1787 /* are MIC sources */ 1788 #define AC97_AD1986_OMS_ML 0x0500 /* MIX of MIC and LINE_IN pins */ 1789 /* are MIC sources */ 1790 #define AC97_AD1986_OMS_LC 0x0600 /* MIX of LINE_IN and C/LFE pins */ 1791 /* are MIC sources */ 1792 #define AC97_AD1986_OMS_MLC 0x0700 /* MIX of MIC, LINE_IN, C/LFE pins */ 1793 /* are MIC sources */ 1794 1795 1796 static int snd_ac97_ad198x_spdif_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1797 { 1798 static char *texts[2] = { "AC-Link", "A/D Converter" }; 1799 1800 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1801 uinfo->count = 1; 1802 uinfo->value.enumerated.items = 2; 1803 if (uinfo->value.enumerated.item > 1) 1804 uinfo->value.enumerated.item = 1; 1805 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1806 return 0; 1807 } 1808 1809 static int snd_ac97_ad198x_spdif_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1810 { 1811 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1812 unsigned short val; 1813 1814 val = ac97->regs[AC97_AD_SERIAL_CFG]; 1815 ucontrol->value.enumerated.item[0] = (val >> 2) & 1; 1816 return 0; 1817 } 1818 1819 static int snd_ac97_ad198x_spdif_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1820 { 1821 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1822 unsigned short val; 1823 1824 if (ucontrol->value.enumerated.item[0] > 1) 1825 return -EINVAL; 1826 val = ucontrol->value.enumerated.item[0] << 2; 1827 return snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x0004, val); 1828 } 1829 1830 static const struct snd_kcontrol_new snd_ac97_ad198x_spdif_source = { 1831 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1832 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 1833 .info = snd_ac97_ad198x_spdif_source_info, 1834 .get = snd_ac97_ad198x_spdif_source_get, 1835 .put = snd_ac97_ad198x_spdif_source_put, 1836 }; 1837 1838 static int patch_ad198x_post_spdif(struct snd_ac97 * ac97) 1839 { 1840 return patch_build_controls(ac97, &snd_ac97_ad198x_spdif_source, 1); 1841 } 1842 1843 static const struct snd_kcontrol_new snd_ac97_ad1981x_jack_sense[] = { 1844 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 11, 1, 0), 1845 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0), 1846 }; 1847 1848 /* black list to avoid HP/Line jack-sense controls 1849 * (SS vendor << 16 | device) 1850 */ 1851 static unsigned int ad1981_jacks_blacklist[] = { 1852 0x10140523, /* Thinkpad R40 */ 1853 0x10140534, /* Thinkpad X31 */ 1854 0x10140537, /* Thinkpad T41p */ 1855 0x10140554, /* Thinkpad T42p/R50p */ 1856 0x10140567, /* Thinkpad T43p 2668-G7U */ 1857 0x10140581, /* Thinkpad X41-2527 */ 1858 0x104380b0, /* Asus A7V8X-MX */ 1859 0x11790241, /* Toshiba Satellite A-15 S127 */ 1860 0x144dc01a, /* Samsung NP-X20C004/SEG */ 1861 0 /* end */ 1862 }; 1863 1864 static int check_list(struct snd_ac97 *ac97, const unsigned int *list) 1865 { 1866 u32 subid = ((u32)ac97->subsystem_vendor << 16) | ac97->subsystem_device; 1867 for (; *list; list++) 1868 if (*list == subid) 1869 return 1; 1870 return 0; 1871 } 1872 1873 static int patch_ad1981a_specific(struct snd_ac97 * ac97) 1874 { 1875 if (check_list(ac97, ad1981_jacks_blacklist)) 1876 return 0; 1877 return patch_build_controls(ac97, snd_ac97_ad1981x_jack_sense, 1878 ARRAY_SIZE(snd_ac97_ad1981x_jack_sense)); 1879 } 1880 1881 static struct snd_ac97_build_ops patch_ad1981a_build_ops = { 1882 .build_post_spdif = patch_ad198x_post_spdif, 1883 .build_specific = patch_ad1981a_specific, 1884 #ifdef CONFIG_PM 1885 .resume = ad18xx_resume 1886 #endif 1887 }; 1888 1889 /* white list to enable HP jack-sense bits 1890 * (SS vendor << 16 | device) 1891 */ 1892 static unsigned int ad1981_jacks_whitelist[] = { 1893 0x0e11005a, /* HP nc4000/4010 */ 1894 0x103c0890, /* HP nc6000 */ 1895 0x103c0938, /* HP nc4220 */ 1896 0x103c099c, /* HP nx6110 */ 1897 0x103c0944, /* HP nc6220 */ 1898 0x103c0934, /* HP nc8220 */ 1899 0x103c006d, /* HP nx9105 */ 1900 0x17340088, /* FSC Scenic-W */ 1901 0 /* end */ 1902 }; 1903 1904 static void check_ad1981_hp_jack_sense(struct snd_ac97 *ac97) 1905 { 1906 if (check_list(ac97, ad1981_jacks_whitelist)) 1907 /* enable headphone jack sense */ 1908 snd_ac97_update_bits(ac97, AC97_AD_JACK_SPDIF, 1<<11, 1<<11); 1909 } 1910 1911 static int patch_ad1981a(struct snd_ac97 *ac97) 1912 { 1913 patch_ad1881(ac97); 1914 ac97->build_ops = &patch_ad1981a_build_ops; 1915 snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD198X_MSPLT, AC97_AD198X_MSPLT); 1916 ac97->flags |= AC97_STEREO_MUTES; 1917 check_ad1981_hp_jack_sense(ac97); 1918 return 0; 1919 } 1920 1921 static const struct snd_kcontrol_new snd_ac97_ad198x_2cmic = 1922 AC97_SINGLE("Stereo Mic", AC97_AD_MISC, 6, 1, 0); 1923 1924 static int patch_ad1981b_specific(struct snd_ac97 *ac97) 1925 { 1926 int err; 1927 1928 if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0) 1929 return err; 1930 if (check_list(ac97, ad1981_jacks_blacklist)) 1931 return 0; 1932 return patch_build_controls(ac97, snd_ac97_ad1981x_jack_sense, 1933 ARRAY_SIZE(snd_ac97_ad1981x_jack_sense)); 1934 } 1935 1936 static struct snd_ac97_build_ops patch_ad1981b_build_ops = { 1937 .build_post_spdif = patch_ad198x_post_spdif, 1938 .build_specific = patch_ad1981b_specific, 1939 #ifdef CONFIG_PM 1940 .resume = ad18xx_resume 1941 #endif 1942 }; 1943 1944 static int patch_ad1981b(struct snd_ac97 *ac97) 1945 { 1946 patch_ad1881(ac97); 1947 ac97->build_ops = &patch_ad1981b_build_ops; 1948 snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD198X_MSPLT, AC97_AD198X_MSPLT); 1949 ac97->flags |= AC97_STEREO_MUTES; 1950 check_ad1981_hp_jack_sense(ac97); 1951 return 0; 1952 } 1953 1954 #define snd_ac97_ad1888_lohpsel_info snd_ctl_boolean_mono_info 1955 1956 static int snd_ac97_ad1888_lohpsel_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1957 { 1958 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1959 unsigned short val; 1960 1961 val = ac97->regs[AC97_AD_MISC]; 1962 ucontrol->value.integer.value[0] = !(val & AC97_AD198X_LOSEL); 1963 return 0; 1964 } 1965 1966 static int snd_ac97_ad1888_lohpsel_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1967 { 1968 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1969 unsigned short val; 1970 1971 val = !ucontrol->value.integer.value[0] 1972 ? (AC97_AD198X_LOSEL | AC97_AD198X_HPSEL) : 0; 1973 return snd_ac97_update_bits(ac97, AC97_AD_MISC, 1974 AC97_AD198X_LOSEL | AC97_AD198X_HPSEL, val); 1975 } 1976 1977 static int snd_ac97_ad1888_downmix_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1978 { 1979 static char *texts[3] = {"Off", "6 -> 4", "6 -> 2"}; 1980 1981 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1982 uinfo->count = 1; 1983 uinfo->value.enumerated.items = 3; 1984 if (uinfo->value.enumerated.item > 2) 1985 uinfo->value.enumerated.item = 2; 1986 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1987 return 0; 1988 } 1989 1990 static int snd_ac97_ad1888_downmix_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1991 { 1992 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 1993 unsigned short val; 1994 1995 val = ac97->regs[AC97_AD_MISC]; 1996 if (!(val & AC97_AD198X_DMIX1)) 1997 ucontrol->value.enumerated.item[0] = 0; 1998 else 1999 ucontrol->value.enumerated.item[0] = 1 + ((val >> 8) & 1); 2000 return 0; 2001 } 2002 2003 static int snd_ac97_ad1888_downmix_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2004 { 2005 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2006 unsigned short val; 2007 2008 if (ucontrol->value.enumerated.item[0] > 2) 2009 return -EINVAL; 2010 if (ucontrol->value.enumerated.item[0] == 0) 2011 val = 0; 2012 else 2013 val = AC97_AD198X_DMIX1 | 2014 ((ucontrol->value.enumerated.item[0] - 1) << 8); 2015 return snd_ac97_update_bits(ac97, AC97_AD_MISC, 2016 AC97_AD198X_DMIX0 | AC97_AD198X_DMIX1, val); 2017 } 2018 2019 static void ad1888_update_jacks(struct snd_ac97 *ac97) 2020 { 2021 unsigned short val = 0; 2022 /* clear LODIS if shared jack is to be used for Surround out */ 2023 if (is_shared_linein(ac97)) 2024 val |= (1 << 12); 2025 /* clear CLDIS if shared jack is to be used for C/LFE out */ 2026 if (is_shared_micin(ac97)) 2027 val |= (1 << 11); 2028 /* shared Line-In */ 2029 snd_ac97_update_bits(ac97, AC97_AD_MISC, (1 << 11) | (1 << 12), val); 2030 } 2031 2032 static const struct snd_kcontrol_new snd_ac97_ad1888_controls[] = { 2033 { 2034 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2035 .name = "Exchange Front/Surround", 2036 .info = snd_ac97_ad1888_lohpsel_info, 2037 .get = snd_ac97_ad1888_lohpsel_get, 2038 .put = snd_ac97_ad1888_lohpsel_put 2039 }, 2040 AC97_SINGLE("V_REFOUT Enable", AC97_AD_MISC, 2, 1, 1), 2041 AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2, 12, 1, 1), 2042 AC97_SINGLE("Spread Front to Surround and Center/LFE", AC97_AD_MISC, 7, 1, 0), 2043 { 2044 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2045 .name = "Downmix", 2046 .info = snd_ac97_ad1888_downmix_info, 2047 .get = snd_ac97_ad1888_downmix_get, 2048 .put = snd_ac97_ad1888_downmix_put 2049 }, 2050 AC97_SURROUND_JACK_MODE_CTL, 2051 AC97_CHANNEL_MODE_CTL, 2052 2053 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 10, 1, 0), 2054 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0), 2055 }; 2056 2057 static int patch_ad1888_specific(struct snd_ac97 *ac97) 2058 { 2059 /* rename 0x04 as "Master" and 0x02 as "Master Surround" */ 2060 snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Master Surround Playback"); 2061 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback"); 2062 return patch_build_controls(ac97, snd_ac97_ad1888_controls, ARRAY_SIZE(snd_ac97_ad1888_controls)); 2063 } 2064 2065 static struct snd_ac97_build_ops patch_ad1888_build_ops = { 2066 .build_post_spdif = patch_ad198x_post_spdif, 2067 .build_specific = patch_ad1888_specific, 2068 #ifdef CONFIG_PM 2069 .resume = ad1888_resume, 2070 #endif 2071 .update_jacks = ad1888_update_jacks, 2072 }; 2073 2074 static int patch_ad1888(struct snd_ac97 * ac97) 2075 { 2076 unsigned short misc; 2077 2078 patch_ad1881(ac97); 2079 ac97->build_ops = &patch_ad1888_build_ops; 2080 /* Switch FRONT/SURROUND LINE-OUT/HP-OUT default connection */ 2081 /* it seems that most vendors connect line-out connector to headphone out of AC'97 */ 2082 /* AD-compatible mode */ 2083 /* Stereo mutes enabled */ 2084 misc = snd_ac97_read(ac97, AC97_AD_MISC); 2085 snd_ac97_write_cache(ac97, AC97_AD_MISC, misc | 2086 AC97_AD198X_LOSEL | 2087 AC97_AD198X_HPSEL | 2088 AC97_AD198X_MSPLT | 2089 AC97_AD198X_AC97NC); 2090 ac97->flags |= AC97_STEREO_MUTES; 2091 return 0; 2092 } 2093 2094 static int patch_ad1980_specific(struct snd_ac97 *ac97) 2095 { 2096 int err; 2097 2098 if ((err = patch_ad1888_specific(ac97)) < 0) 2099 return err; 2100 return patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1); 2101 } 2102 2103 static struct snd_ac97_build_ops patch_ad1980_build_ops = { 2104 .build_post_spdif = patch_ad198x_post_spdif, 2105 .build_specific = patch_ad1980_specific, 2106 #ifdef CONFIG_PM 2107 .resume = ad18xx_resume, 2108 #endif 2109 .update_jacks = ad1888_update_jacks, 2110 }; 2111 2112 static int patch_ad1980(struct snd_ac97 * ac97) 2113 { 2114 patch_ad1888(ac97); 2115 ac97->build_ops = &patch_ad1980_build_ops; 2116 return 0; 2117 } 2118 2119 static int snd_ac97_ad1985_vrefout_info(struct snd_kcontrol *kcontrol, 2120 struct snd_ctl_elem_info *uinfo) 2121 { 2122 static char *texts[4] = {"High-Z", "3.7 V", "2.25 V", "0 V"}; 2123 2124 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2125 uinfo->count = 1; 2126 uinfo->value.enumerated.items = 4; 2127 if (uinfo->value.enumerated.item > 3) 2128 uinfo->value.enumerated.item = 3; 2129 strcpy(uinfo->value.enumerated.name, 2130 texts[uinfo->value.enumerated.item]); 2131 return 0; 2132 } 2133 2134 static int snd_ac97_ad1985_vrefout_get(struct snd_kcontrol *kcontrol, 2135 struct snd_ctl_elem_value *ucontrol) 2136 { 2137 static const int reg2ctrl[4] = {2, 0, 1, 3}; 2138 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2139 unsigned short val; 2140 val = (ac97->regs[AC97_AD_MISC] & AC97_AD198X_VREF_MASK) 2141 >> AC97_AD198X_VREF_SHIFT; 2142 ucontrol->value.enumerated.item[0] = reg2ctrl[val]; 2143 return 0; 2144 } 2145 2146 static int snd_ac97_ad1985_vrefout_put(struct snd_kcontrol *kcontrol, 2147 struct snd_ctl_elem_value *ucontrol) 2148 { 2149 static const int ctrl2reg[4] = {1, 2, 0, 3}; 2150 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2151 unsigned short val; 2152 2153 if (ucontrol->value.enumerated.item[0] > 3) 2154 return -EINVAL; 2155 val = ctrl2reg[ucontrol->value.enumerated.item[0]] 2156 << AC97_AD198X_VREF_SHIFT; 2157 return snd_ac97_update_bits(ac97, AC97_AD_MISC, 2158 AC97_AD198X_VREF_MASK, val); 2159 } 2160 2161 static const struct snd_kcontrol_new snd_ac97_ad1985_controls[] = { 2162 AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0), 2163 { 2164 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2165 .name = "Exchange Front/Surround", 2166 .info = snd_ac97_ad1888_lohpsel_info, 2167 .get = snd_ac97_ad1888_lohpsel_get, 2168 .put = snd_ac97_ad1888_lohpsel_put 2169 }, 2170 AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2, 12, 1, 1), 2171 AC97_SINGLE("Spread Front to Surround and Center/LFE", 2172 AC97_AD_MISC, 7, 1, 0), 2173 { 2174 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2175 .name = "Downmix", 2176 .info = snd_ac97_ad1888_downmix_info, 2177 .get = snd_ac97_ad1888_downmix_get, 2178 .put = snd_ac97_ad1888_downmix_put 2179 }, 2180 { 2181 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2182 .name = "V_REFOUT", 2183 .info = snd_ac97_ad1985_vrefout_info, 2184 .get = snd_ac97_ad1985_vrefout_get, 2185 .put = snd_ac97_ad1985_vrefout_put 2186 }, 2187 AC97_SURROUND_JACK_MODE_CTL, 2188 AC97_CHANNEL_MODE_CTL, 2189 2190 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 10, 1, 0), 2191 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0), 2192 }; 2193 2194 static void ad1985_update_jacks(struct snd_ac97 *ac97) 2195 { 2196 ad1888_update_jacks(ac97); 2197 /* clear OMS if shared jack is to be used for C/LFE out */ 2198 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 1 << 9, 2199 is_shared_micin(ac97) ? 1 << 9 : 0); 2200 } 2201 2202 static int patch_ad1985_specific(struct snd_ac97 *ac97) 2203 { 2204 int err; 2205 2206 /* rename 0x04 as "Master" and 0x02 as "Master Surround" */ 2207 snd_ac97_rename_vol_ctl(ac97, "Master Playback", 2208 "Master Surround Playback"); 2209 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback"); 2210 2211 if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0) 2212 return err; 2213 2214 return patch_build_controls(ac97, snd_ac97_ad1985_controls, 2215 ARRAY_SIZE(snd_ac97_ad1985_controls)); 2216 } 2217 2218 static struct snd_ac97_build_ops patch_ad1985_build_ops = { 2219 .build_post_spdif = patch_ad198x_post_spdif, 2220 .build_specific = patch_ad1985_specific, 2221 #ifdef CONFIG_PM 2222 .resume = ad18xx_resume, 2223 #endif 2224 .update_jacks = ad1985_update_jacks, 2225 }; 2226 2227 static int patch_ad1985(struct snd_ac97 * ac97) 2228 { 2229 unsigned short misc; 2230 2231 patch_ad1881(ac97); 2232 ac97->build_ops = &patch_ad1985_build_ops; 2233 misc = snd_ac97_read(ac97, AC97_AD_MISC); 2234 /* switch front/surround line-out/hp-out */ 2235 /* AD-compatible mode */ 2236 /* Stereo mutes enabled */ 2237 snd_ac97_write_cache(ac97, AC97_AD_MISC, misc | 2238 AC97_AD198X_LOSEL | 2239 AC97_AD198X_HPSEL | 2240 AC97_AD198X_MSPLT | 2241 AC97_AD198X_AC97NC); 2242 ac97->flags |= AC97_STEREO_MUTES; 2243 2244 /* update current jack configuration */ 2245 ad1985_update_jacks(ac97); 2246 2247 /* on AD1985 rev. 3, AC'97 revision bits are zero */ 2248 ac97->ext_id = (ac97->ext_id & ~AC97_EI_REV_MASK) | AC97_EI_REV_23; 2249 return 0; 2250 } 2251 2252 #define snd_ac97_ad1986_bool_info snd_ctl_boolean_mono_info 2253 2254 static int snd_ac97_ad1986_lososel_get(struct snd_kcontrol *kcontrol, 2255 struct snd_ctl_elem_value *ucontrol) 2256 { 2257 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2258 unsigned short val; 2259 2260 val = ac97->regs[AC97_AD_MISC3]; 2261 ucontrol->value.integer.value[0] = (val & AC97_AD1986_LOSEL) != 0; 2262 return 0; 2263 } 2264 2265 static int snd_ac97_ad1986_lososel_put(struct snd_kcontrol *kcontrol, 2266 struct snd_ctl_elem_value *ucontrol) 2267 { 2268 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2269 int ret0; 2270 int ret1; 2271 int sprd = (ac97->regs[AC97_AD_MISC] & AC97_AD1986_SPRD) != 0; 2272 2273 ret0 = snd_ac97_update_bits(ac97, AC97_AD_MISC3, AC97_AD1986_LOSEL, 2274 ucontrol->value.integer.value[0] != 0 2275 ? AC97_AD1986_LOSEL : 0); 2276 if (ret0 < 0) 2277 return ret0; 2278 2279 /* SOSEL is set to values of "Spread" or "Exchange F/S" controls */ 2280 ret1 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SOSEL, 2281 (ucontrol->value.integer.value[0] != 0 2282 || sprd) 2283 ? AC97_AD1986_SOSEL : 0); 2284 if (ret1 < 0) 2285 return ret1; 2286 2287 return (ret0 > 0 || ret1 > 0) ? 1 : 0; 2288 } 2289 2290 static int snd_ac97_ad1986_spread_get(struct snd_kcontrol *kcontrol, 2291 struct snd_ctl_elem_value *ucontrol) 2292 { 2293 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2294 unsigned short val; 2295 2296 val = ac97->regs[AC97_AD_MISC]; 2297 ucontrol->value.integer.value[0] = (val & AC97_AD1986_SPRD) != 0; 2298 return 0; 2299 } 2300 2301 static int snd_ac97_ad1986_spread_put(struct snd_kcontrol *kcontrol, 2302 struct snd_ctl_elem_value *ucontrol) 2303 { 2304 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2305 int ret0; 2306 int ret1; 2307 int sprd = (ac97->regs[AC97_AD_MISC3] & AC97_AD1986_LOSEL) != 0; 2308 2309 ret0 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SPRD, 2310 ucontrol->value.integer.value[0] != 0 2311 ? AC97_AD1986_SPRD : 0); 2312 if (ret0 < 0) 2313 return ret0; 2314 2315 /* SOSEL is set to values of "Spread" or "Exchange F/S" controls */ 2316 ret1 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SOSEL, 2317 (ucontrol->value.integer.value[0] != 0 2318 || sprd) 2319 ? AC97_AD1986_SOSEL : 0); 2320 if (ret1 < 0) 2321 return ret1; 2322 2323 return (ret0 > 0 || ret1 > 0) ? 1 : 0; 2324 } 2325 2326 static int snd_ac97_ad1986_miclisel_get(struct snd_kcontrol *kcontrol, 2327 struct snd_ctl_elem_value *ucontrol) 2328 { 2329 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2330 2331 ucontrol->value.integer.value[0] = ac97->spec.ad18xx.swap_mic_linein; 2332 return 0; 2333 } 2334 2335 static int snd_ac97_ad1986_miclisel_put(struct snd_kcontrol *kcontrol, 2336 struct snd_ctl_elem_value *ucontrol) 2337 { 2338 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2339 unsigned char swap = ucontrol->value.integer.value[0] != 0; 2340 2341 if (swap != ac97->spec.ad18xx.swap_mic_linein) { 2342 ac97->spec.ad18xx.swap_mic_linein = swap; 2343 if (ac97->build_ops->update_jacks) 2344 ac97->build_ops->update_jacks(ac97); 2345 return 1; 2346 } 2347 return 0; 2348 } 2349 2350 static int snd_ac97_ad1986_vrefout_get(struct snd_kcontrol *kcontrol, 2351 struct snd_ctl_elem_value *ucontrol) 2352 { 2353 /* Use MIC_1/2 V_REFOUT as the "get" value */ 2354 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2355 unsigned short val; 2356 unsigned short reg = ac97->regs[AC97_AD_MISC2]; 2357 if ((reg & AC97_AD1986_MVREF0) != 0) 2358 val = 2; 2359 else if ((reg & AC97_AD1986_MVREF1) != 0) 2360 val = 3; 2361 else if ((reg & AC97_AD1986_MVREF2) != 0) 2362 val = 1; 2363 else 2364 val = 0; 2365 ucontrol->value.enumerated.item[0] = val; 2366 return 0; 2367 } 2368 2369 static int snd_ac97_ad1986_vrefout_put(struct snd_kcontrol *kcontrol, 2370 struct snd_ctl_elem_value *ucontrol) 2371 { 2372 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2373 unsigned short cval; 2374 unsigned short lval; 2375 unsigned short mval; 2376 int cret; 2377 int lret; 2378 int mret; 2379 2380 switch (ucontrol->value.enumerated.item[0]) 2381 { 2382 case 0: /* High-Z */ 2383 cval = 0; 2384 lval = 0; 2385 mval = 0; 2386 break; 2387 case 1: /* 3.7 V */ 2388 cval = AC97_AD1986_CVREF2; 2389 lval = AC97_AD1986_LVREF2; 2390 mval = AC97_AD1986_MVREF2; 2391 break; 2392 case 2: /* 2.25 V */ 2393 cval = AC97_AD1986_CVREF0; 2394 lval = AC97_AD1986_LVREF0; 2395 mval = AC97_AD1986_MVREF0; 2396 break; 2397 case 3: /* 0 V */ 2398 cval = AC97_AD1986_CVREF1; 2399 lval = AC97_AD1986_LVREF1; 2400 mval = AC97_AD1986_MVREF1; 2401 break; 2402 default: 2403 return -EINVAL; 2404 } 2405 2406 cret = snd_ac97_update_bits(ac97, AC97_AD_MISC2, 2407 AC97_AD1986_CVREF_MASK, cval); 2408 if (cret < 0) 2409 return cret; 2410 lret = snd_ac97_update_bits(ac97, AC97_AD_MISC3, 2411 AC97_AD1986_LVREF_MASK, lval); 2412 if (lret < 0) 2413 return lret; 2414 mret = snd_ac97_update_bits(ac97, AC97_AD_MISC2, 2415 AC97_AD1986_MVREF_MASK, mval); 2416 if (mret < 0) 2417 return mret; 2418 2419 return (cret > 0 || lret > 0 || mret > 0) ? 1 : 0; 2420 } 2421 2422 static const struct snd_kcontrol_new snd_ac97_ad1986_controls[] = { 2423 AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0), 2424 { 2425 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2426 .name = "Exchange Front/Surround", 2427 .info = snd_ac97_ad1986_bool_info, 2428 .get = snd_ac97_ad1986_lososel_get, 2429 .put = snd_ac97_ad1986_lososel_put 2430 }, 2431 { 2432 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2433 .name = "Exchange Mic/Line In", 2434 .info = snd_ac97_ad1986_bool_info, 2435 .get = snd_ac97_ad1986_miclisel_get, 2436 .put = snd_ac97_ad1986_miclisel_put 2437 }, 2438 { 2439 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2440 .name = "Spread Front to Surround and Center/LFE", 2441 .info = snd_ac97_ad1986_bool_info, 2442 .get = snd_ac97_ad1986_spread_get, 2443 .put = snd_ac97_ad1986_spread_put 2444 }, 2445 { 2446 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2447 .name = "Downmix", 2448 .info = snd_ac97_ad1888_downmix_info, 2449 .get = snd_ac97_ad1888_downmix_get, 2450 .put = snd_ac97_ad1888_downmix_put 2451 }, 2452 { 2453 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2454 .name = "V_REFOUT", 2455 .info = snd_ac97_ad1985_vrefout_info, 2456 .get = snd_ac97_ad1986_vrefout_get, 2457 .put = snd_ac97_ad1986_vrefout_put 2458 }, 2459 AC97_SURROUND_JACK_MODE_CTL, 2460 AC97_CHANNEL_MODE_CTL, 2461 2462 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 10, 1, 0), 2463 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0) 2464 }; 2465 2466 static void ad1986_update_jacks(struct snd_ac97 *ac97) 2467 { 2468 unsigned short misc_val = 0; 2469 unsigned short ser_val; 2470 2471 /* disable SURROUND and CENTER/LFE if not surround mode */ 2472 if (!is_surround_on(ac97)) 2473 misc_val |= AC97_AD1986_SODIS; 2474 if (!is_clfe_on(ac97)) 2475 misc_val |= AC97_AD1986_CLDIS; 2476 2477 /* select line input (default=LINE_IN, SURROUND or MIC_1/2) */ 2478 if (is_shared_linein(ac97)) 2479 misc_val |= AC97_AD1986_LISEL_SURR; 2480 else if (ac97->spec.ad18xx.swap_mic_linein != 0) 2481 misc_val |= AC97_AD1986_LISEL_MIC; 2482 snd_ac97_update_bits(ac97, AC97_AD_MISC, 2483 AC97_AD1986_SODIS | AC97_AD1986_CLDIS | 2484 AC97_AD1986_LISEL_MASK, 2485 misc_val); 2486 2487 /* select microphone input (MIC_1/2, Center/LFE or LINE_IN) */ 2488 if (is_shared_micin(ac97)) 2489 ser_val = AC97_AD1986_OMS_C; 2490 else if (ac97->spec.ad18xx.swap_mic_linein != 0) 2491 ser_val = AC97_AD1986_OMS_L; 2492 else 2493 ser_val = AC97_AD1986_OMS_M; 2494 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 2495 AC97_AD1986_OMS_MASK, 2496 ser_val); 2497 } 2498 2499 static int patch_ad1986_specific(struct snd_ac97 *ac97) 2500 { 2501 int err; 2502 2503 if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0) 2504 return err; 2505 2506 return patch_build_controls(ac97, snd_ac97_ad1986_controls, 2507 ARRAY_SIZE(snd_ac97_ad1985_controls)); 2508 } 2509 2510 static struct snd_ac97_build_ops patch_ad1986_build_ops = { 2511 .build_post_spdif = patch_ad198x_post_spdif, 2512 .build_specific = patch_ad1986_specific, 2513 #ifdef CONFIG_PM 2514 .resume = ad18xx_resume, 2515 #endif 2516 .update_jacks = ad1986_update_jacks, 2517 }; 2518 2519 static int patch_ad1986(struct snd_ac97 * ac97) 2520 { 2521 patch_ad1881(ac97); 2522 ac97->build_ops = &patch_ad1986_build_ops; 2523 ac97->flags |= AC97_STEREO_MUTES; 2524 2525 /* update current jack configuration */ 2526 ad1986_update_jacks(ac97); 2527 2528 return 0; 2529 } 2530 2531 2532 /* 2533 * realtek ALC65x/850 codecs 2534 */ 2535 static void alc650_update_jacks(struct snd_ac97 *ac97) 2536 { 2537 int shared; 2538 2539 /* shared Line-In / Surround Out */ 2540 shared = is_shared_surrout(ac97); 2541 snd_ac97_update_bits(ac97, AC97_ALC650_MULTICH, 1 << 9, 2542 shared ? (1 << 9) : 0); 2543 /* update shared Mic In / Center/LFE Out */ 2544 shared = is_shared_clfeout(ac97); 2545 /* disable/enable vref */ 2546 snd_ac97_update_bits(ac97, AC97_ALC650_CLOCK, 1 << 12, 2547 shared ? (1 << 12) : 0); 2548 /* turn on/off center-on-mic */ 2549 snd_ac97_update_bits(ac97, AC97_ALC650_MULTICH, 1 << 10, 2550 shared ? (1 << 10) : 0); 2551 /* GPIO0 high for mic */ 2552 snd_ac97_update_bits(ac97, AC97_ALC650_GPIO_STATUS, 0x100, 2553 shared ? 0 : 0x100); 2554 } 2555 2556 static const struct snd_kcontrol_new snd_ac97_controls_alc650[] = { 2557 AC97_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0), 2558 AC97_SINGLE("Surround Down Mix", AC97_ALC650_MULTICH, 1, 1, 0), 2559 AC97_SINGLE("Center/LFE Down Mix", AC97_ALC650_MULTICH, 2, 1, 0), 2560 AC97_SINGLE("Exchange Center/LFE", AC97_ALC650_MULTICH, 3, 1, 0), 2561 /* 4: Analog Input To Surround */ 2562 /* 5: Analog Input To Center/LFE */ 2563 /* 6: Independent Master Volume Right */ 2564 /* 7: Independent Master Volume Left */ 2565 /* 8: reserved */ 2566 /* 9: Line-In/Surround share */ 2567 /* 10: Mic/CLFE share */ 2568 /* 11-13: in IEC958 controls */ 2569 AC97_SINGLE("Swap Surround Slot", AC97_ALC650_MULTICH, 14, 1, 0), 2570 #if 0 /* always set in patch_alc650 */ 2571 AC97_SINGLE("IEC958 Input Clock Enable", AC97_ALC650_CLOCK, 0, 1, 0), 2572 AC97_SINGLE("IEC958 Input Pin Enable", AC97_ALC650_CLOCK, 1, 1, 0), 2573 AC97_SINGLE("Surround DAC Switch", AC97_ALC650_SURR_DAC_VOL, 15, 1, 1), 2574 AC97_DOUBLE("Surround DAC Volume", AC97_ALC650_SURR_DAC_VOL, 8, 0, 31, 1), 2575 AC97_SINGLE("Center/LFE DAC Switch", AC97_ALC650_LFE_DAC_VOL, 15, 1, 1), 2576 AC97_DOUBLE("Center/LFE DAC Volume", AC97_ALC650_LFE_DAC_VOL, 8, 0, 31, 1), 2577 #endif 2578 AC97_SURROUND_JACK_MODE_CTL, 2579 AC97_CHANNEL_MODE_CTL, 2580 }; 2581 2582 static const struct snd_kcontrol_new snd_ac97_spdif_controls_alc650[] = { 2583 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_ALC650_MULTICH, 11, 1, 0), 2584 AC97_SINGLE("Analog to IEC958 Output", AC97_ALC650_MULTICH, 12, 1, 0), 2585 /* disable this controls since it doesn't work as expected */ 2586 /* AC97_SINGLE("IEC958 Input Monitor", AC97_ALC650_MULTICH, 13, 1, 0), */ 2587 }; 2588 2589 static const DECLARE_TLV_DB_SCALE(db_scale_5bit_3db_max, -4350, 150, 0); 2590 2591 static int patch_alc650_specific(struct snd_ac97 * ac97) 2592 { 2593 int err; 2594 2595 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc650, ARRAY_SIZE(snd_ac97_controls_alc650))) < 0) 2596 return err; 2597 if (ac97->ext_id & AC97_EI_SPDIF) { 2598 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc650, ARRAY_SIZE(snd_ac97_spdif_controls_alc650))) < 0) 2599 return err; 2600 } 2601 if (ac97->id != AC97_ID_ALC650F) 2602 reset_tlv(ac97, "Master Playback Volume", 2603 db_scale_5bit_3db_max); 2604 return 0; 2605 } 2606 2607 static struct snd_ac97_build_ops patch_alc650_ops = { 2608 .build_specific = patch_alc650_specific, 2609 .update_jacks = alc650_update_jacks 2610 }; 2611 2612 static int patch_alc650(struct snd_ac97 * ac97) 2613 { 2614 unsigned short val; 2615 2616 ac97->build_ops = &patch_alc650_ops; 2617 2618 /* determine the revision */ 2619 val = snd_ac97_read(ac97, AC97_ALC650_REVISION) & 0x3f; 2620 if (val < 3) 2621 ac97->id = 0x414c4720; /* Old version */ 2622 else if (val < 0x10) 2623 ac97->id = 0x414c4721; /* D version */ 2624 else if (val < 0x20) 2625 ac97->id = 0x414c4722; /* E version */ 2626 else if (val < 0x30) 2627 ac97->id = 0x414c4723; /* F version */ 2628 2629 /* revision E or F */ 2630 /* FIXME: what about revision D ? */ 2631 ac97->spec.dev_flags = (ac97->id == 0x414c4722 || 2632 ac97->id == 0x414c4723); 2633 2634 /* enable AC97_ALC650_GPIO_SETUP, AC97_ALC650_CLOCK for R/W */ 2635 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_STATUS, 2636 snd_ac97_read(ac97, AC97_ALC650_GPIO_STATUS) | 0x8000); 2637 2638 /* Enable SPDIF-IN only on Rev.E and above */ 2639 val = snd_ac97_read(ac97, AC97_ALC650_CLOCK); 2640 /* SPDIF IN with pin 47 */ 2641 if (ac97->spec.dev_flags && 2642 /* ASUS A6KM requires EAPD */ 2643 ! (ac97->subsystem_vendor == 0x1043 && 2644 ac97->subsystem_device == 0x1103)) 2645 val |= 0x03; /* enable */ 2646 else 2647 val &= ~0x03; /* disable */ 2648 snd_ac97_write_cache(ac97, AC97_ALC650_CLOCK, val); 2649 2650 /* set default: slot 3,4,7,8,6,9 2651 spdif-in monitor off, analog-spdif off, spdif-in off 2652 center on mic off, surround on line-in off 2653 downmix off, duplicate front off 2654 */ 2655 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 0); 2656 2657 /* set GPIO0 for mic bias */ 2658 /* GPIO0 pin output, no interrupt, high */ 2659 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_SETUP, 2660 snd_ac97_read(ac97, AC97_ALC650_GPIO_SETUP) | 0x01); 2661 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_STATUS, 2662 (snd_ac97_read(ac97, AC97_ALC650_GPIO_STATUS) | 0x100) & ~0x10); 2663 2664 /* full DAC volume */ 2665 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808); 2666 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808); 2667 return 0; 2668 } 2669 2670 static void alc655_update_jacks(struct snd_ac97 *ac97) 2671 { 2672 int shared; 2673 2674 /* shared Line-In / Surround Out */ 2675 shared = is_shared_surrout(ac97); 2676 ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 1 << 9, 2677 shared ? (1 << 9) : 0, 0); 2678 /* update shared Mic In / Center/LFE Out */ 2679 shared = is_shared_clfeout(ac97); 2680 /* misc control; vrefout disable */ 2681 snd_ac97_update_bits(ac97, AC97_ALC650_CLOCK, 1 << 12, 2682 shared ? (1 << 12) : 0); 2683 ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 1 << 10, 2684 shared ? (1 << 10) : 0, 0); 2685 } 2686 2687 static const struct snd_kcontrol_new snd_ac97_controls_alc655[] = { 2688 AC97_PAGE_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0, 0), 2689 AC97_SURROUND_JACK_MODE_CTL, 2690 AC97_CHANNEL_MODE_CTL, 2691 }; 2692 2693 static int alc655_iec958_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 2694 { 2695 static char *texts_655[3] = { "PCM", "Analog In", "IEC958 In" }; 2696 static char *texts_658[4] = { "PCM", "Analog1 In", "Analog2 In", "IEC958 In" }; 2697 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2698 2699 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2700 uinfo->count = 1; 2701 uinfo->value.enumerated.items = ac97->spec.dev_flags ? 4 : 3; 2702 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) 2703 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; 2704 strcpy(uinfo->value.enumerated.name, 2705 ac97->spec.dev_flags ? 2706 texts_658[uinfo->value.enumerated.item] : 2707 texts_655[uinfo->value.enumerated.item]); 2708 return 0; 2709 } 2710 2711 static int alc655_iec958_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2712 { 2713 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2714 unsigned short val; 2715 2716 val = ac97->regs[AC97_ALC650_MULTICH]; 2717 val = (val >> 12) & 3; 2718 if (ac97->spec.dev_flags && val == 3) 2719 val = 0; 2720 ucontrol->value.enumerated.item[0] = val; 2721 return 0; 2722 } 2723 2724 static int alc655_iec958_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2725 { 2726 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2727 2728 return ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 3 << 12, 2729 (unsigned short)ucontrol->value.enumerated.item[0] << 12, 2730 0); 2731 } 2732 2733 static const struct snd_kcontrol_new snd_ac97_spdif_controls_alc655[] = { 2734 AC97_PAGE_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_ALC650_MULTICH, 11, 1, 0, 0), 2735 /* disable this controls since it doesn't work as expected */ 2736 /* AC97_PAGE_SINGLE("IEC958 Input Monitor", AC97_ALC650_MULTICH, 14, 1, 0, 0), */ 2737 { 2738 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2739 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 2740 .info = alc655_iec958_route_info, 2741 .get = alc655_iec958_route_get, 2742 .put = alc655_iec958_route_put, 2743 }, 2744 }; 2745 2746 static int patch_alc655_specific(struct snd_ac97 * ac97) 2747 { 2748 int err; 2749 2750 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc655, ARRAY_SIZE(snd_ac97_controls_alc655))) < 0) 2751 return err; 2752 if (ac97->ext_id & AC97_EI_SPDIF) { 2753 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc655, ARRAY_SIZE(snd_ac97_spdif_controls_alc655))) < 0) 2754 return err; 2755 } 2756 return 0; 2757 } 2758 2759 static struct snd_ac97_build_ops patch_alc655_ops = { 2760 .build_specific = patch_alc655_specific, 2761 .update_jacks = alc655_update_jacks 2762 }; 2763 2764 static int patch_alc655(struct snd_ac97 * ac97) 2765 { 2766 unsigned int val; 2767 2768 if (ac97->id == AC97_ID_ALC658) { 2769 ac97->spec.dev_flags = 1; /* ALC658 */ 2770 if ((snd_ac97_read(ac97, AC97_ALC650_REVISION) & 0x3f) == 2) { 2771 ac97->id = AC97_ID_ALC658D; 2772 ac97->spec.dev_flags = 2; 2773 } 2774 } 2775 2776 ac97->build_ops = &patch_alc655_ops; 2777 2778 /* assume only page 0 for writing cache */ 2779 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR); 2780 2781 /* adjust default values */ 2782 val = snd_ac97_read(ac97, 0x7a); /* misc control */ 2783 if (ac97->spec.dev_flags) /* ALC658 */ 2784 val &= ~(1 << 1); /* Pin 47 is spdif input pin */ 2785 else { /* ALC655 */ 2786 if (ac97->subsystem_vendor == 0x1462 && 2787 (ac97->subsystem_device == 0x0131 || /* MSI S270 laptop */ 2788 ac97->subsystem_device == 0x0161 || /* LG K1 Express */ 2789 ac97->subsystem_device == 0x0351 || /* MSI L725 laptop */ 2790 ac97->subsystem_device == 0x0471 || /* MSI L720 laptop */ 2791 ac97->subsystem_device == 0x0061)) /* MSI S250 laptop */ 2792 val &= ~(1 << 1); /* Pin 47 is EAPD (for internal speaker) */ 2793 else 2794 val |= (1 << 1); /* Pin 47 is spdif input pin */ 2795 } 2796 val &= ~(1 << 12); /* vref enable */ 2797 snd_ac97_write_cache(ac97, 0x7a, val); 2798 /* set default: spdif-in enabled, 2799 spdif-in monitor off, spdif-in PCM off 2800 center on mic off, surround on line-in off 2801 duplicate front off 2802 */ 2803 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 1<<15); 2804 2805 /* full DAC volume */ 2806 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808); 2807 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808); 2808 2809 /* update undocumented bit... */ 2810 if (ac97->id == AC97_ID_ALC658D) 2811 snd_ac97_update_bits(ac97, 0x74, 0x0800, 0x0800); 2812 2813 return 0; 2814 } 2815 2816 2817 #define AC97_ALC850_JACK_SELECT 0x76 2818 #define AC97_ALC850_MISC1 0x7a 2819 2820 static void alc850_update_jacks(struct snd_ac97 *ac97) 2821 { 2822 int shared; 2823 2824 /* shared Line-In / Surround Out */ 2825 shared = is_shared_surrout(ac97); 2826 /* SURR 1kOhm (bit4), Amp (bit5) */ 2827 snd_ac97_update_bits(ac97, AC97_ALC850_MISC1, (1<<4)|(1<<5), 2828 shared ? (1<<5) : (1<<4)); 2829 /* LINE-IN = 0, SURROUND = 2 */ 2830 snd_ac97_update_bits(ac97, AC97_ALC850_JACK_SELECT, 7 << 12, 2831 shared ? (2<<12) : (0<<12)); 2832 /* update shared Mic In / Center/LFE Out */ 2833 shared = is_shared_clfeout(ac97); 2834 /* Vref disable (bit12), 1kOhm (bit13) */ 2835 snd_ac97_update_bits(ac97, AC97_ALC850_MISC1, (1<<12)|(1<<13), 2836 shared ? (1<<12) : (1<<13)); 2837 /* MIC-IN = 1, CENTER-LFE = 5 */ 2838 snd_ac97_update_bits(ac97, AC97_ALC850_JACK_SELECT, 7 << 4, 2839 shared ? (5<<4) : (1<<4)); 2840 } 2841 2842 static const struct snd_kcontrol_new snd_ac97_controls_alc850[] = { 2843 AC97_PAGE_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0, 0), 2844 AC97_SINGLE("Mic Front Input Switch", AC97_ALC850_JACK_SELECT, 15, 1, 1), 2845 AC97_SURROUND_JACK_MODE_CTL, 2846 AC97_CHANNEL_MODE_CTL, 2847 }; 2848 2849 static int patch_alc850_specific(struct snd_ac97 *ac97) 2850 { 2851 int err; 2852 2853 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc850, ARRAY_SIZE(snd_ac97_controls_alc850))) < 0) 2854 return err; 2855 if (ac97->ext_id & AC97_EI_SPDIF) { 2856 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc655, ARRAY_SIZE(snd_ac97_spdif_controls_alc655))) < 0) 2857 return err; 2858 } 2859 return 0; 2860 } 2861 2862 static struct snd_ac97_build_ops patch_alc850_ops = { 2863 .build_specific = patch_alc850_specific, 2864 .update_jacks = alc850_update_jacks 2865 }; 2866 2867 static int patch_alc850(struct snd_ac97 *ac97) 2868 { 2869 ac97->build_ops = &patch_alc850_ops; 2870 2871 ac97->spec.dev_flags = 0; /* for IEC958 playback route - ALC655 compatible */ 2872 2873 /* assume only page 0 for writing cache */ 2874 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR); 2875 2876 /* adjust default values */ 2877 /* set default: spdif-in enabled, 2878 spdif-in monitor off, spdif-in PCM off 2879 center on mic off, surround on line-in off 2880 duplicate front off 2881 */ 2882 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 1<<15); 2883 /* SURR_OUT: on, Surr 1kOhm: on, Surr Amp: off, Front 1kOhm: off 2884 * Front Amp: on, Vref: enable, Center 1kOhm: on, Mix: on 2885 */ 2886 snd_ac97_write_cache(ac97, 0x7a, (1<<1)|(1<<4)|(0<<5)|(1<<6)| 2887 (1<<7)|(0<<12)|(1<<13)|(0<<14)); 2888 /* detection UIO2,3: all path floating, UIO3: MIC, Vref2: disable, 2889 * UIO1: FRONT, Vref3: disable, UIO3: LINE, Front-Mic: mute 2890 */ 2891 snd_ac97_write_cache(ac97, 0x76, (0<<0)|(0<<2)|(1<<4)|(1<<7)|(2<<8)| 2892 (1<<11)|(0<<12)|(1<<15)); 2893 2894 /* full DAC volume */ 2895 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808); 2896 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808); 2897 return 0; 2898 } 2899 2900 2901 /* 2902 * C-Media CM97xx codecs 2903 */ 2904 static void cm9738_update_jacks(struct snd_ac97 *ac97) 2905 { 2906 /* shared Line-In / Surround Out */ 2907 snd_ac97_update_bits(ac97, AC97_CM9738_VENDOR_CTRL, 1 << 10, 2908 is_shared_surrout(ac97) ? (1 << 10) : 0); 2909 } 2910 2911 static const struct snd_kcontrol_new snd_ac97_cm9738_controls[] = { 2912 AC97_SINGLE("Duplicate Front", AC97_CM9738_VENDOR_CTRL, 13, 1, 0), 2913 AC97_SURROUND_JACK_MODE_CTL, 2914 AC97_CHANNEL_MODE_4CH_CTL, 2915 }; 2916 2917 static int patch_cm9738_specific(struct snd_ac97 * ac97) 2918 { 2919 return patch_build_controls(ac97, snd_ac97_cm9738_controls, ARRAY_SIZE(snd_ac97_cm9738_controls)); 2920 } 2921 2922 static struct snd_ac97_build_ops patch_cm9738_ops = { 2923 .build_specific = patch_cm9738_specific, 2924 .update_jacks = cm9738_update_jacks 2925 }; 2926 2927 static int patch_cm9738(struct snd_ac97 * ac97) 2928 { 2929 ac97->build_ops = &patch_cm9738_ops; 2930 /* FIXME: can anyone confirm below? */ 2931 /* CM9738 has no PCM volume although the register reacts */ 2932 ac97->flags |= AC97_HAS_NO_PCM_VOL; 2933 snd_ac97_write_cache(ac97, AC97_PCM, 0x8000); 2934 2935 return 0; 2936 } 2937 2938 static int snd_ac97_cmedia_spdif_playback_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 2939 { 2940 static char *texts[] = { "Analog", "Digital" }; 2941 2942 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2943 uinfo->count = 1; 2944 uinfo->value.enumerated.items = 2; 2945 if (uinfo->value.enumerated.item > 1) 2946 uinfo->value.enumerated.item = 1; 2947 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 2948 return 0; 2949 } 2950 2951 static int snd_ac97_cmedia_spdif_playback_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2952 { 2953 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2954 unsigned short val; 2955 2956 val = ac97->regs[AC97_CM9739_SPDIF_CTRL]; 2957 ucontrol->value.enumerated.item[0] = (val >> 1) & 0x01; 2958 return 0; 2959 } 2960 2961 static int snd_ac97_cmedia_spdif_playback_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2962 { 2963 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 2964 2965 return snd_ac97_update_bits(ac97, AC97_CM9739_SPDIF_CTRL, 2966 0x01 << 1, 2967 (ucontrol->value.enumerated.item[0] & 0x01) << 1); 2968 } 2969 2970 static const struct snd_kcontrol_new snd_ac97_cm9739_controls_spdif[] = { 2971 /* BIT 0: SPDI_EN - always true */ 2972 { /* BIT 1: SPDIFS */ 2973 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2974 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 2975 .info = snd_ac97_cmedia_spdif_playback_source_info, 2976 .get = snd_ac97_cmedia_spdif_playback_source_get, 2977 .put = snd_ac97_cmedia_spdif_playback_source_put, 2978 }, 2979 /* BIT 2: IG_SPIV */ 2980 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Valid Switch", AC97_CM9739_SPDIF_CTRL, 2, 1, 0), 2981 /* BIT 3: SPI2F */ 2982 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Monitor", AC97_CM9739_SPDIF_CTRL, 3, 1, 0), 2983 /* BIT 4: SPI2SDI */ 2984 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_CM9739_SPDIF_CTRL, 4, 1, 0), 2985 /* BIT 8: SPD32 - 32bit SPDIF - not supported yet */ 2986 }; 2987 2988 static void cm9739_update_jacks(struct snd_ac97 *ac97) 2989 { 2990 /* shared Line-In / Surround Out */ 2991 snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 1 << 10, 2992 is_shared_surrout(ac97) ? (1 << 10) : 0); 2993 /* shared Mic In / Center/LFE Out **/ 2994 snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 0x3000, 2995 is_shared_clfeout(ac97) ? 0x1000 : 0x2000); 2996 } 2997 2998 static const struct snd_kcontrol_new snd_ac97_cm9739_controls[] = { 2999 AC97_SURROUND_JACK_MODE_CTL, 3000 AC97_CHANNEL_MODE_CTL, 3001 }; 3002 3003 static int patch_cm9739_specific(struct snd_ac97 * ac97) 3004 { 3005 return patch_build_controls(ac97, snd_ac97_cm9739_controls, ARRAY_SIZE(snd_ac97_cm9739_controls)); 3006 } 3007 3008 static int patch_cm9739_post_spdif(struct snd_ac97 * ac97) 3009 { 3010 return patch_build_controls(ac97, snd_ac97_cm9739_controls_spdif, ARRAY_SIZE(snd_ac97_cm9739_controls_spdif)); 3011 } 3012 3013 static struct snd_ac97_build_ops patch_cm9739_ops = { 3014 .build_specific = patch_cm9739_specific, 3015 .build_post_spdif = patch_cm9739_post_spdif, 3016 .update_jacks = cm9739_update_jacks 3017 }; 3018 3019 static int patch_cm9739(struct snd_ac97 * ac97) 3020 { 3021 unsigned short val; 3022 3023 ac97->build_ops = &patch_cm9739_ops; 3024 3025 /* CM9739/A has no Master and PCM volume although the register reacts */ 3026 ac97->flags |= AC97_HAS_NO_MASTER_VOL | AC97_HAS_NO_PCM_VOL; 3027 snd_ac97_write_cache(ac97, AC97_MASTER, 0x8000); 3028 snd_ac97_write_cache(ac97, AC97_PCM, 0x8000); 3029 3030 /* check spdif */ 3031 val = snd_ac97_read(ac97, AC97_EXTENDED_STATUS); 3032 if (val & AC97_EA_SPCV) { 3033 /* enable spdif in */ 3034 snd_ac97_write_cache(ac97, AC97_CM9739_SPDIF_CTRL, 3035 snd_ac97_read(ac97, AC97_CM9739_SPDIF_CTRL) | 0x01); 3036 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */ 3037 } else { 3038 ac97->ext_id &= ~AC97_EI_SPDIF; /* disable extended-id */ 3039 ac97->rates[AC97_RATES_SPDIF] = 0; 3040 } 3041 3042 /* set-up multi channel */ 3043 /* bit 14: 0 = SPDIF, 1 = EAPD */ 3044 /* bit 13: enable internal vref output for mic */ 3045 /* bit 12: disable center/lfe (swithable) */ 3046 /* bit 10: disable surround/line (switchable) */ 3047 /* bit 9: mix 2 surround off */ 3048 /* bit 4: undocumented; 0 mutes the CM9739A, which defaults to 1 */ 3049 /* bit 3: undocumented; surround? */ 3050 /* bit 0: dB */ 3051 val = snd_ac97_read(ac97, AC97_CM9739_MULTI_CHAN) & (1 << 4); 3052 val |= (1 << 3); 3053 val |= (1 << 13); 3054 if (! (ac97->ext_id & AC97_EI_SPDIF)) 3055 val |= (1 << 14); 3056 snd_ac97_write_cache(ac97, AC97_CM9739_MULTI_CHAN, val); 3057 3058 /* FIXME: set up GPIO */ 3059 snd_ac97_write_cache(ac97, 0x70, 0x0100); 3060 snd_ac97_write_cache(ac97, 0x72, 0x0020); 3061 /* Special exception for ASUS W1000/CMI9739. It does not have an SPDIF in. */ 3062 if (ac97->pci && 3063 ac97->subsystem_vendor == 0x1043 && 3064 ac97->subsystem_device == 0x1843) { 3065 snd_ac97_write_cache(ac97, AC97_CM9739_SPDIF_CTRL, 3066 snd_ac97_read(ac97, AC97_CM9739_SPDIF_CTRL) & ~0x01); 3067 snd_ac97_write_cache(ac97, AC97_CM9739_MULTI_CHAN, 3068 snd_ac97_read(ac97, AC97_CM9739_MULTI_CHAN) | (1 << 14)); 3069 } 3070 3071 return 0; 3072 } 3073 3074 #define AC97_CM9761_MULTI_CHAN 0x64 3075 #define AC97_CM9761_FUNC 0x66 3076 #define AC97_CM9761_SPDIF_CTRL 0x6c 3077 3078 static void cm9761_update_jacks(struct snd_ac97 *ac97) 3079 { 3080 /* FIXME: check the bits for each model 3081 * model 83 is confirmed to work 3082 */ 3083 static unsigned short surr_on[3][2] = { 3084 { 0x0008, 0x0000 }, /* 9761-78 & 82 */ 3085 { 0x0000, 0x0008 }, /* 9761-82 rev.B */ 3086 { 0x0000, 0x0008 }, /* 9761-83 */ 3087 }; 3088 static unsigned short clfe_on[3][2] = { 3089 { 0x0000, 0x1000 }, /* 9761-78 & 82 */ 3090 { 0x1000, 0x0000 }, /* 9761-82 rev.B */ 3091 { 0x0000, 0x1000 }, /* 9761-83 */ 3092 }; 3093 static unsigned short surr_shared[3][2] = { 3094 { 0x0000, 0x0400 }, /* 9761-78 & 82 */ 3095 { 0x0000, 0x0400 }, /* 9761-82 rev.B */ 3096 { 0x0000, 0x0400 }, /* 9761-83 */ 3097 }; 3098 static unsigned short clfe_shared[3][2] = { 3099 { 0x2000, 0x0880 }, /* 9761-78 & 82 */ 3100 { 0x0000, 0x2880 }, /* 9761-82 rev.B */ 3101 { 0x2000, 0x0800 }, /* 9761-83 */ 3102 }; 3103 unsigned short val = 0; 3104 3105 val |= surr_on[ac97->spec.dev_flags][is_surround_on(ac97)]; 3106 val |= clfe_on[ac97->spec.dev_flags][is_clfe_on(ac97)]; 3107 val |= surr_shared[ac97->spec.dev_flags][is_shared_surrout(ac97)]; 3108 val |= clfe_shared[ac97->spec.dev_flags][is_shared_clfeout(ac97)]; 3109 3110 snd_ac97_update_bits(ac97, AC97_CM9761_MULTI_CHAN, 0x3c88, val); 3111 } 3112 3113 static const struct snd_kcontrol_new snd_ac97_cm9761_controls[] = { 3114 AC97_SURROUND_JACK_MODE_CTL, 3115 AC97_CHANNEL_MODE_CTL, 3116 }; 3117 3118 static int cm9761_spdif_out_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 3119 { 3120 static char *texts[] = { "AC-Link", "ADC", "SPDIF-In" }; 3121 3122 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3123 uinfo->count = 1; 3124 uinfo->value.enumerated.items = 3; 3125 if (uinfo->value.enumerated.item > 2) 3126 uinfo->value.enumerated.item = 2; 3127 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 3128 return 0; 3129 } 3130 3131 static int cm9761_spdif_out_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 3132 { 3133 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 3134 3135 if (ac97->regs[AC97_CM9761_FUNC] & 0x1) 3136 ucontrol->value.enumerated.item[0] = 2; /* SPDIF-loopback */ 3137 else if (ac97->regs[AC97_CM9761_SPDIF_CTRL] & 0x2) 3138 ucontrol->value.enumerated.item[0] = 1; /* ADC loopback */ 3139 else 3140 ucontrol->value.enumerated.item[0] = 0; /* AC-link */ 3141 return 0; 3142 } 3143 3144 static int cm9761_spdif_out_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 3145 { 3146 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol); 3147 3148 if (ucontrol->value.enumerated.item[0] == 2) 3149 return snd_ac97_update_bits(ac97, AC97_CM9761_FUNC, 0x1, 0x1); 3150 snd_ac97_update_bits(ac97, AC97_CM9761_FUNC, 0x1, 0); 3151 return snd_ac97_update_bits(ac97, AC97_CM9761_SPDIF_CTRL, 0x2, 3152 ucontrol->value.enumerated.item[0] == 1 ? 0x2 : 0); 3153 } 3154 3155 static const char *cm9761_dac_clock[] = { "AC-Link", "SPDIF-In", "Both" }; 3156 static const struct ac97_enum cm9761_dac_clock_enum = 3157 AC97_ENUM_SINGLE(AC97_CM9761_SPDIF_CTRL, 9, 3, cm9761_dac_clock); 3158 3159 static const struct snd_kcontrol_new snd_ac97_cm9761_controls_spdif[] = { 3160 { /* BIT 1: SPDIFS */ 3161 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3162 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 3163 .info = cm9761_spdif_out_source_info, 3164 .get = cm9761_spdif_out_source_get, 3165 .put = cm9761_spdif_out_source_put, 3166 }, 3167 /* BIT 2: IG_SPIV */ 3168 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Valid Switch", AC97_CM9761_SPDIF_CTRL, 2, 1, 0), 3169 /* BIT 3: SPI2F */ 3170 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Monitor", AC97_CM9761_SPDIF_CTRL, 3, 1, 0), 3171 /* BIT 4: SPI2SDI */ 3172 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_CM9761_SPDIF_CTRL, 4, 1, 0), 3173 /* BIT 9-10: DAC_CTL */ 3174 AC97_ENUM("DAC Clock Source", cm9761_dac_clock_enum), 3175 }; 3176 3177 static int patch_cm9761_post_spdif(struct snd_ac97 * ac97) 3178 { 3179 return patch_build_controls(ac97, snd_ac97_cm9761_controls_spdif, ARRAY_SIZE(snd_ac97_cm9761_controls_spdif)); 3180 } 3181 3182 static int patch_cm9761_specific(struct snd_ac97 * ac97) 3183 { 3184 return patch_build_controls(ac97, snd_ac97_cm9761_controls, ARRAY_SIZE(snd_ac97_cm9761_controls)); 3185 } 3186 3187 static struct snd_ac97_build_ops patch_cm9761_ops = { 3188 .build_specific = patch_cm9761_specific, 3189 .build_post_spdif = patch_cm9761_post_spdif, 3190 .update_jacks = cm9761_update_jacks 3191 }; 3192 3193 static int patch_cm9761(struct snd_ac97 *ac97) 3194 { 3195 unsigned short val; 3196 3197 /* CM9761 has no PCM volume although the register reacts */ 3198 /* Master volume seems to have _some_ influence on the analog 3199 * input sounds 3200 */ 3201 ac97->flags |= /*AC97_HAS_NO_MASTER_VOL |*/ AC97_HAS_NO_PCM_VOL; 3202 snd_ac97_write_cache(ac97, AC97_MASTER, 0x8808); 3203 snd_ac97_write_cache(ac97, AC97_PCM, 0x8808); 3204 3205 ac97->spec.dev_flags = 0; /* 1 = model 82 revision B, 2 = model 83 */ 3206 if (ac97->id == AC97_ID_CM9761_82) { 3207 unsigned short tmp; 3208 /* check page 1, reg 0x60 */ 3209 val = snd_ac97_read(ac97, AC97_INT_PAGING); 3210 snd_ac97_write_cache(ac97, AC97_INT_PAGING, (val & ~0x0f) | 0x01); 3211 tmp = snd_ac97_read(ac97, 0x60); 3212 ac97->spec.dev_flags = tmp & 1; /* revision B? */ 3213 snd_ac97_write_cache(ac97, AC97_INT_PAGING, val); 3214 } else if (ac97->id == AC97_ID_CM9761_83) 3215 ac97->spec.dev_flags = 2; 3216 3217 ac97->build_ops = &patch_cm9761_ops; 3218 3219 /* enable spdif */ 3220 /* force the SPDIF bit in ext_id - codec doesn't set this bit! */ 3221 ac97->ext_id |= AC97_EI_SPDIF; 3222 /* to be sure: we overwrite the ext status bits */ 3223 snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, 0x05c0); 3224 /* Don't set 0x0200 here. This results in the silent analog output */ 3225 snd_ac97_write_cache(ac97, AC97_CM9761_SPDIF_CTRL, 0x0001); /* enable spdif-in */ 3226 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */ 3227 3228 /* set-up multi channel */ 3229 /* bit 15: pc master beep off 3230 * bit 14: pin47 = EAPD/SPDIF 3231 * bit 13: vref ctl [= cm9739] 3232 * bit 12: CLFE control (reverted on rev B) 3233 * bit 11: Mic/center share (reverted on rev B) 3234 * bit 10: suddound/line share 3235 * bit 9: Analog-in mix -> surround 3236 * bit 8: Analog-in mix -> CLFE 3237 * bit 7: Mic/LFE share (mic/center/lfe) 3238 * bit 5: vref select (9761A) 3239 * bit 4: front control 3240 * bit 3: surround control (revereted with rev B) 3241 * bit 2: front mic 3242 * bit 1: stereo mic 3243 * bit 0: mic boost level (0=20dB, 1=30dB) 3244 */ 3245 3246 #if 0 3247 if (ac97->spec.dev_flags) 3248 val = 0x0214; 3249 else 3250 val = 0x321c; 3251 #endif 3252 val = snd_ac97_read(ac97, AC97_CM9761_MULTI_CHAN); 3253 val |= (1 << 4); /* front on */ 3254 snd_ac97_write_cache(ac97, AC97_CM9761_MULTI_CHAN, val); 3255 3256 /* FIXME: set up GPIO */ 3257 snd_ac97_write_cache(ac97, 0x70, 0x0100); 3258 snd_ac97_write_cache(ac97, 0x72, 0x0020); 3259 3260 return 0; 3261 } 3262 3263 #define AC97_CM9780_SIDE 0x60 3264 #define AC97_CM9780_JACK 0x62 3265 #define AC97_CM9780_MIXER 0x64 3266 #define AC97_CM9780_MULTI_CHAN 0x66 3267 #define AC97_CM9780_SPDIF 0x6c 3268 3269 static const char *cm9780_ch_select[] = { "Front", "Side", "Center/LFE", "Rear" }; 3270 static const struct ac97_enum cm9780_ch_select_enum = 3271 AC97_ENUM_SINGLE(AC97_CM9780_MULTI_CHAN, 6, 4, cm9780_ch_select); 3272 static const struct snd_kcontrol_new cm9780_controls[] = { 3273 AC97_DOUBLE("Side Playback Switch", AC97_CM9780_SIDE, 15, 7, 1, 1), 3274 AC97_DOUBLE("Side Playback Volume", AC97_CM9780_SIDE, 8, 0, 31, 0), 3275 AC97_ENUM("Side Playback Route", cm9780_ch_select_enum), 3276 }; 3277 3278 static int patch_cm9780_specific(struct snd_ac97 *ac97) 3279 { 3280 return patch_build_controls(ac97, cm9780_controls, ARRAY_SIZE(cm9780_controls)); 3281 } 3282 3283 static struct snd_ac97_build_ops patch_cm9780_ops = { 3284 .build_specific = patch_cm9780_specific, 3285 .build_post_spdif = patch_cm9761_post_spdif /* identical with CM9761 */ 3286 }; 3287 3288 static int patch_cm9780(struct snd_ac97 *ac97) 3289 { 3290 unsigned short val; 3291 3292 ac97->build_ops = &patch_cm9780_ops; 3293 3294 /* enable spdif */ 3295 if (ac97->ext_id & AC97_EI_SPDIF) { 3296 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */ 3297 val = snd_ac97_read(ac97, AC97_CM9780_SPDIF); 3298 val |= 0x1; /* SPDI_EN */ 3299 snd_ac97_write_cache(ac97, AC97_CM9780_SPDIF, val); 3300 } 3301 3302 return 0; 3303 } 3304 3305 /* 3306 * VIA VT1616 codec 3307 */ 3308 static const struct snd_kcontrol_new snd_ac97_controls_vt1616[] = { 3309 AC97_SINGLE("DC Offset removal", 0x5a, 10, 1, 0), 3310 AC97_SINGLE("Alternate Level to Surround Out", 0x5a, 15, 1, 0), 3311 AC97_SINGLE("Downmix LFE and Center to Front", 0x5a, 12, 1, 0), 3312 AC97_SINGLE("Downmix Surround to Front", 0x5a, 11, 1, 0), 3313 }; 3314 3315 static int patch_vt1616_specific(struct snd_ac97 * ac97) 3316 { 3317 int err; 3318 3319 if (snd_ac97_try_bit(ac97, 0x5a, 9)) 3320 if ((err = patch_build_controls(ac97, &snd_ac97_controls_vt1616[0], 1)) < 0) 3321 return err; 3322 if ((err = patch_build_controls(ac97, &snd_ac97_controls_vt1616[1], ARRAY_SIZE(snd_ac97_controls_vt1616) - 1)) < 0) 3323 return err; 3324 return 0; 3325 } 3326 3327 static struct snd_ac97_build_ops patch_vt1616_ops = { 3328 .build_specific = patch_vt1616_specific 3329 }; 3330 3331 static int patch_vt1616(struct snd_ac97 * ac97) 3332 { 3333 ac97->build_ops = &patch_vt1616_ops; 3334 return 0; 3335 } 3336 3337 /* 3338 * VT1617A codec 3339 */ 3340 3341 /* 3342 * unfortunately, the vt1617a stashes the twiddlers required for 3343 * nooding the i/o jacks on 2 different regs. * thameans that we cant 3344 * use the easy way provided by AC97_ENUM_DOUBLE() we have to write 3345 * are own funcs. 3346 * 3347 * NB: this is absolutely and utterly different from the vt1618. dunno 3348 * about the 1616. 3349 */ 3350 3351 /* copied from ac97_surround_jack_mode_info() */ 3352 static int snd_ac97_vt1617a_smart51_info(struct snd_kcontrol *kcontrol, 3353 struct snd_ctl_elem_info *uinfo) 3354 { 3355 /* ordering in this list reflects vt1617a docs for Reg 20 and 3356 * 7a and Table 6 that lays out the matrix NB WRT Table6: SM51 3357 * is SM51EN *AND* it's Bit14, not Bit15 so the table is very 3358 * counter-intuitive */ 3359 3360 static const char* texts[] = { "LineIn Mic1", "LineIn Mic1 Mic3", 3361 "Surr LFE/C Mic3", "LineIn LFE/C Mic3", 3362 "LineIn Mic2", "LineIn Mic2 Mic1", 3363 "Surr LFE Mic1", "Surr LFE Mic1 Mic2"}; 3364 return ac97_enum_text_info(kcontrol, uinfo, texts, 8); 3365 } 3366 3367 static int snd_ac97_vt1617a_smart51_get(struct snd_kcontrol *kcontrol, 3368 struct snd_ctl_elem_value *ucontrol) 3369 { 3370 ushort usSM51, usMS; 3371 3372 struct snd_ac97 *pac97; 3373 3374 pac97 = snd_kcontrol_chip(kcontrol); /* grab codec handle */ 3375 3376 /* grab our desirec bits, then mash them together in a manner 3377 * consistent with Table 6 on page 17 in the 1617a docs */ 3378 3379 usSM51 = snd_ac97_read(pac97, 0x7a) >> 14; 3380 usMS = snd_ac97_read(pac97, 0x20) >> 8; 3381 3382 ucontrol->value.enumerated.item[0] = (usSM51 << 1) + usMS; 3383 3384 return 0; 3385 } 3386 3387 static int snd_ac97_vt1617a_smart51_put(struct snd_kcontrol *kcontrol, 3388 struct snd_ctl_elem_value *ucontrol) 3389 { 3390 ushort usSM51, usMS, usReg; 3391 3392 struct snd_ac97 *pac97; 3393 3394 pac97 = snd_kcontrol_chip(kcontrol); /* grab codec handle */ 3395 3396 usSM51 = ucontrol->value.enumerated.item[0] >> 1; 3397 usMS = ucontrol->value.enumerated.item[0] & 1; 3398 3399 /* push our values into the register - consider that things will be left 3400 * in a funky state if the write fails */ 3401 3402 usReg = snd_ac97_read(pac97, 0x7a); 3403 snd_ac97_write_cache(pac97, 0x7a, (usReg & 0x3FFF) + (usSM51 << 14)); 3404 usReg = snd_ac97_read(pac97, 0x20); 3405 snd_ac97_write_cache(pac97, 0x20, (usReg & 0xFEFF) + (usMS << 8)); 3406 3407 return 0; 3408 } 3409 3410 static const struct snd_kcontrol_new snd_ac97_controls_vt1617a[] = { 3411 3412 AC97_SINGLE("Center/LFE Exchange", 0x5a, 8, 1, 0), 3413 /* 3414 * These are used to enable/disable surround sound on motherboards 3415 * that have 3 bidirectional analog jacks 3416 */ 3417 { 3418 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3419 .name = "Smart 5.1 Select", 3420 .info = snd_ac97_vt1617a_smart51_info, 3421 .get = snd_ac97_vt1617a_smart51_get, 3422 .put = snd_ac97_vt1617a_smart51_put, 3423 }, 3424 }; 3425 3426 int patch_vt1617a(struct snd_ac97 * ac97) 3427 { 3428 int err = 0; 3429 3430 /* we choose to not fail out at this point, but we tell the 3431 caller when we return */ 3432 3433 err = patch_build_controls(ac97, &snd_ac97_controls_vt1617a[0], 3434 ARRAY_SIZE(snd_ac97_controls_vt1617a)); 3435 3436 /* bring analog power consumption to normal by turning off the 3437 * headphone amplifier, like WinXP driver for EPIA SP 3438 */ 3439 snd_ac97_write_cache(ac97, 0x5c, 0x20); 3440 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */ 3441 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000; 3442 ac97->build_ops = &patch_vt1616_ops; 3443 3444 return err; 3445 } 3446 3447 /* 3448 */ 3449 static void it2646_update_jacks(struct snd_ac97 *ac97) 3450 { 3451 /* shared Line-In / Surround Out */ 3452 snd_ac97_update_bits(ac97, 0x76, 1 << 9, 3453 is_shared_surrout(ac97) ? (1<<9) : 0); 3454 /* shared Mic / Center/LFE Out */ 3455 snd_ac97_update_bits(ac97, 0x76, 1 << 10, 3456 is_shared_clfeout(ac97) ? (1<<10) : 0); 3457 } 3458 3459 static const struct snd_kcontrol_new snd_ac97_controls_it2646[] = { 3460 AC97_SURROUND_JACK_MODE_CTL, 3461 AC97_CHANNEL_MODE_CTL, 3462 }; 3463 3464 static const struct snd_kcontrol_new snd_ac97_spdif_controls_it2646[] = { 3465 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 0x76, 11, 1, 0), 3466 AC97_SINGLE("Analog to IEC958 Output", 0x76, 12, 1, 0), 3467 AC97_SINGLE("IEC958 Input Monitor", 0x76, 13, 1, 0), 3468 }; 3469 3470 static int patch_it2646_specific(struct snd_ac97 * ac97) 3471 { 3472 int err; 3473 if ((err = patch_build_controls(ac97, snd_ac97_controls_it2646, ARRAY_SIZE(snd_ac97_controls_it2646))) < 0) 3474 return err; 3475 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_it2646, ARRAY_SIZE(snd_ac97_spdif_controls_it2646))) < 0) 3476 return err; 3477 return 0; 3478 } 3479 3480 static struct snd_ac97_build_ops patch_it2646_ops = { 3481 .build_specific = patch_it2646_specific, 3482 .update_jacks = it2646_update_jacks 3483 }; 3484 3485 static int patch_it2646(struct snd_ac97 * ac97) 3486 { 3487 ac97->build_ops = &patch_it2646_ops; 3488 /* full DAC volume */ 3489 snd_ac97_write_cache(ac97, 0x5E, 0x0808); 3490 snd_ac97_write_cache(ac97, 0x7A, 0x0808); 3491 return 0; 3492 } 3493 3494 /* 3495 * Si3036 codec 3496 */ 3497 3498 #define AC97_SI3036_CHIP_ID 0x5a 3499 #define AC97_SI3036_LINE_CFG 0x5c 3500 3501 static const struct snd_kcontrol_new snd_ac97_controls_si3036[] = { 3502 AC97_DOUBLE("Modem Speaker Volume", 0x5c, 14, 12, 3, 1) 3503 }; 3504 3505 static int patch_si3036_specific(struct snd_ac97 * ac97) 3506 { 3507 int idx, err; 3508 for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_si3036); idx++) 3509 if ((err = snd_ctl_add(ac97->bus->card, snd_ctl_new1(&snd_ac97_controls_si3036[idx], ac97))) < 0) 3510 return err; 3511 return 0; 3512 } 3513 3514 static struct snd_ac97_build_ops patch_si3036_ops = { 3515 .build_specific = patch_si3036_specific, 3516 }; 3517 3518 static int mpatch_si3036(struct snd_ac97 * ac97) 3519 { 3520 ac97->build_ops = &patch_si3036_ops; 3521 snd_ac97_write_cache(ac97, 0x5c, 0xf210 ); 3522 snd_ac97_write_cache(ac97, 0x68, 0); 3523 return 0; 3524 } 3525 3526 /* 3527 * LM 4550 Codec 3528 * 3529 * We use a static resolution table since LM4550 codec cannot be 3530 * properly autoprobed to determine the resolution via 3531 * check_volume_resolution(). 3532 */ 3533 3534 static struct snd_ac97_res_table lm4550_restbl[] = { 3535 { AC97_MASTER, 0x1f1f }, 3536 { AC97_HEADPHONE, 0x1f1f }, 3537 { AC97_MASTER_MONO, 0x001f }, 3538 { AC97_PC_BEEP, 0x001f }, /* LSB is ignored */ 3539 { AC97_PHONE, 0x001f }, 3540 { AC97_MIC, 0x001f }, 3541 { AC97_LINE, 0x1f1f }, 3542 { AC97_CD, 0x1f1f }, 3543 { AC97_VIDEO, 0x1f1f }, 3544 { AC97_AUX, 0x1f1f }, 3545 { AC97_PCM, 0x1f1f }, 3546 { AC97_REC_GAIN, 0x0f0f }, 3547 { } /* terminator */ 3548 }; 3549 3550 static int patch_lm4550(struct snd_ac97 *ac97) 3551 { 3552 ac97->res_table = lm4550_restbl; 3553 return 0; 3554 } 3555 3556 /* 3557 * UCB1400 codec (http://www.semiconductors.philips.com/acrobat_download/datasheets/UCB1400-02.pdf) 3558 */ 3559 static const struct snd_kcontrol_new snd_ac97_controls_ucb1400[] = { 3560 /* enable/disable headphone driver which allows direct connection to 3561 stereo headphone without the use of external DC blocking 3562 capacitors */ 3563 AC97_SINGLE("Headphone Driver", 0x6a, 6, 1, 0), 3564 /* Filter used to compensate the DC offset is added in the ADC to remove idle 3565 tones from the audio band. */ 3566 AC97_SINGLE("DC Filter", 0x6a, 4, 1, 0), 3567 /* Control smart-low-power mode feature. Allows automatic power down 3568 of unused blocks in the ADC analog front end and the PLL. */ 3569 AC97_SINGLE("Smart Low Power Mode", 0x6c, 4, 3, 0), 3570 }; 3571 3572 static int patch_ucb1400_specific(struct snd_ac97 * ac97) 3573 { 3574 int idx, err; 3575 for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_ucb1400); idx++) 3576 if ((err = snd_ctl_add(ac97->bus->card, snd_ctl_new1(&snd_ac97_controls_ucb1400[idx], ac97))) < 0) 3577 return err; 3578 return 0; 3579 } 3580 3581 static struct snd_ac97_build_ops patch_ucb1400_ops = { 3582 .build_specific = patch_ucb1400_specific, 3583 }; 3584 3585 static int patch_ucb1400(struct snd_ac97 * ac97) 3586 { 3587 ac97->build_ops = &patch_ucb1400_ops; 3588 /* enable headphone driver and smart low power mode by default */ 3589 snd_ac97_write(ac97, 0x6a, 0x0050); 3590 snd_ac97_write(ac97, 0x6c, 0x0030); 3591 return 0; 3592 } 3593