git.ipfire.org Git - thirdparty/kernel/stable.git/blob

1 /*

2 * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984,

3 * AD1986A, AD1988

4 *

6 *

7 * This driver is free software; you can redistribute it and/or modify

8 * it under the terms of the GNU General Public License as published by

9 * the Free Software Foundation; either version 2 of the License, or

10 * (at your option) any later version.

11 *

12 * This driver is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

15 * GNU General Public License for more details.

16 *

17 * You should have received a copy of the GNU General Public License

18 * along with this program; if not, write to the Free Software

19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

20 */

22 #include <linux/init.h>

23 #include <linux/slab.h>

24 #include <linux/pci.h>

25 #include <linux/module.h>

27 #include <sound/core.h>

28 #include "hda_codec.h"

29 #include "hda_local.h"

30 #include "hda_auto_parser.h"

31 #include "hda_beep.h"

32 #include "hda_jack.h"

33 #include "hda_generic.h"

36 struct ad198x_spec {

37 struct hda_gen_spec gen;

39 /* for auto parser */

40 int smux_paths[4];

41 unsigned int cur_smux;

42 hda_nid_t eapd_nid;

44 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */

45 };

48 #ifdef CONFIG_SND_HDA_INPUT_BEEP

49 /* additional beep mixers; the actual parameters are overwritten at build */

50 static const struct snd_kcontrol_new ad_beep_mixer[] = {

51 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),

52 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT),

53 { } /* end */

54 };

56 #define set_beep_amp(spec, nid, idx, dir) \

57 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */

58 #else

59 #define set_beep_amp(spec, nid, idx, dir) /* NOP */

60 #endif

62 #ifdef CONFIG_SND_HDA_INPUT_BEEP

63 static int create_beep_ctls(struct hda_codec *codec)

64 {

65 struct ad198x_spec *spec = codec->spec;

66 const struct snd_kcontrol_new *knew;

68 if (!spec->beep_amp)

69 return 0;

71 for (knew = ad_beep_mixer ; knew->name; knew++) {

72 int err;

73 struct snd_kcontrol *kctl;

74 kctl = snd_ctl_new1(knew, codec);

75 if (!kctl)

76 return -ENOMEM;

77 kctl->private_value = spec->beep_amp;

78 err = snd_hda_ctl_add(codec, 0, kctl);

79 if (err < 0)

80 return err;

81 }

82 return 0;

83 }

84 #else

85 #define create_beep_ctls(codec) 0

86 #endif

89 static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,

90 hda_nid_t hp)

91 {

92 if (snd_hda_query_pin_caps(codec, front) & AC_PINCAP_EAPD)

93 snd_hda_codec_write(codec, front, 0, AC_VERB_SET_EAPD_BTLENABLE,

94 !codec->inv_eapd ? 0x00 : 0x02);

95 if (snd_hda_query_pin_caps(codec, hp) & AC_PINCAP_EAPD)

96 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_EAPD_BTLENABLE,

97 !codec->inv_eapd ? 0x00 : 0x02);

98 }

100 static void ad198x_power_eapd(struct hda_codec *codec)

101 {

102 /* We currently only handle front, HP */

103 switch (codec->vendor_id) {

104 case 0x11d41882:

105 case 0x11d4882a:

106 case 0x11d41884:

107 case 0x11d41984:

108 case 0x11d41883:

109 case 0x11d4184a:

110 case 0x11d4194a:

111 case 0x11d4194b:

112 case 0x11d41988:

113 case 0x11d4198b:

114 case 0x11d4989a:

115 case 0x11d4989b:

116 ad198x_power_eapd_write(codec, 0x12, 0x11);

117 break;

118 case 0x11d41981:

119 case 0x11d41983:

120 ad198x_power_eapd_write(codec, 0x05, 0x06);

121 break;

122 case 0x11d41986:

123 ad198x_power_eapd_write(codec, 0x1b, 0x1a);

124 break;

125 }

126 }

127

128 static void ad198x_shutup(struct hda_codec *codec)

129 {

130 snd_hda_shutup_pins(codec);

131 ad198x_power_eapd(codec);

132 }

133

134 #ifdef CONFIG_PM

135 static int ad198x_suspend(struct hda_codec *codec)

136 {

137 ad198x_shutup(codec);

138 return 0;

139 }

140 #endif

141

142 /* follow EAPD via vmaster hook */

143 static void ad_vmaster_eapd_hook(void *private_data, int enabled)

144 {

145 struct hda_codec *codec = private_data;

146 struct ad198x_spec *spec = codec->spec;

147

148 if (!spec->eapd_nid)

149 return;

150 if (codec->inv_eapd)

151 enabled = !enabled;

152 snd_hda_codec_update_cache(codec, spec->eapd_nid, 0,

153 AC_VERB_SET_EAPD_BTLENABLE,

154 enabled ? 0x02 : 0x00);

155 }

156

157 /*

158 * Automatic parse of I/O pins from the BIOS configuration

159 */

160

161 static int ad198x_auto_build_controls(struct hda_codec *codec)

162 {

163 int err;

164

165 err = snd_hda_gen_build_controls(codec);

166 if (err < 0)

167 return err;

168 err = create_beep_ctls(codec);

169 if (err < 0)

170 return err;

171 return 0;

172 }

173

174 static const struct hda_codec_ops ad198x_auto_patch_ops = {

175 .build_controls = ad198x_auto_build_controls,

176 .build_pcms = snd_hda_gen_build_pcms,

177 .init = snd_hda_gen_init,

178 .free = snd_hda_gen_free,

179 .unsol_event = snd_hda_jack_unsol_event,

180 #ifdef CONFIG_PM

181 .check_power_status = snd_hda_gen_check_power_status,

182 .suspend = ad198x_suspend,

183 #endif

184 .reboot_notify = ad198x_shutup,

185 };

186

187

188 static int ad198x_parse_auto_config(struct hda_codec *codec)

189 {

190 struct ad198x_spec *spec = codec->spec;

191 struct auto_pin_cfg *cfg = &spec->gen.autocfg;

192 int err;

193

194 codec->spdif_status_reset = 1;

195 codec->no_trigger_sense = 1;

196 codec->no_sticky_stream = 1;

197

198 spec->gen.indep_hp = 1;

199

200 err = snd_hda_parse_pin_defcfg(codec, cfg, NULL, 0);

201 if (err < 0)

202 return err;

203 err = snd_hda_gen_parse_auto_config(codec, cfg);

204 if (err < 0)

205 return err;

206

207 codec->patch_ops = ad198x_auto_patch_ops;

208

209 return 0;

210 }

211

212 /*

213 * AD1986A specific

214 */

215

216 static int alloc_ad_spec(struct hda_codec *codec)

217 {

218 struct ad198x_spec *spec;

219

220 spec = kzalloc(sizeof(*spec), GFP_KERNEL);

221 if (!spec)

222 return -ENOMEM;

223 codec->spec = spec;

224 snd_hda_gen_spec_init(&spec->gen);

225 return 0;

226 }

227

228 /*

229 * AD1986A fixup codes

230 */

231

232 /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */

233 static void ad_fixup_inv_jack_detect(struct hda_codec *codec,

234 const struct hda_fixup *fix, int action)

235 {

236 struct ad198x_spec *spec = codec->spec;

237

238 if (action == HDA_FIXUP_ACT_PRE_PROBE) {

239 codec->inv_jack_detect = 1;

240 spec->gen.keep_eapd_on = 1;

241 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook;

242 spec->eapd_nid = 0x1b;

243 }

244 }

245

246 enum {

247 AD1986A_FIXUP_INV_JACK_DETECT,

248 AD1986A_FIXUP_ULTRA,

249 AD1986A_FIXUP_SAMSUNG,

250 AD1986A_FIXUP_3STACK,

251 AD1986A_FIXUP_LAPTOP,

252 AD1986A_FIXUP_LAPTOP_IMIC,

253 };

254

255 static const struct hda_fixup ad1986a_fixups[] = {

256 [AD1986A_FIXUP_INV_JACK_DETECT] = {

257 .type = HDA_FIXUP_FUNC,

258 .v.func = ad_fixup_inv_jack_detect,

259 },

260 [AD1986A_FIXUP_ULTRA] = {

261 .type = HDA_FIXUP_PINS,

262 .v.pins = (const struct hda_pintbl[]) {

263 { 0x1b, 0x90170110 }, /* speaker */

264 { 0x1d, 0x90a7013e }, /* int mic */

265 {}

266 },

267 },

268 [AD1986A_FIXUP_SAMSUNG] = {

269 .type = HDA_FIXUP_PINS,

270 .v.pins = (const struct hda_pintbl[]) {

271 { 0x1b, 0x90170110 }, /* speaker */

272 { 0x1d, 0x90a7013e }, /* int mic */

273 { 0x20, 0x411111f0 }, /* N/A */

274 { 0x24, 0x411111f0 }, /* N/A */

275 {}

276 },

277 },

278 [AD1986A_FIXUP_3STACK] = {

279 .type = HDA_FIXUP_PINS,

280 .v.pins = (const struct hda_pintbl[]) {

281 { 0x1a, 0x02214021 }, /* headphone */

282 { 0x1b, 0x01014011 }, /* front */

283 { 0x1c, 0x01813030 }, /* line-in */

284 { 0x1d, 0x01a19020 }, /* rear mic */

285 { 0x1e, 0x411111f0 }, /* N/A */

286 { 0x1f, 0x02a190f0 }, /* mic */

287 { 0x20, 0x411111f0 }, /* N/A */

288 {}

289 },

290 },

291 [AD1986A_FIXUP_LAPTOP] = {

292 .type = HDA_FIXUP_PINS,

293 .v.pins = (const struct hda_pintbl[]) {

294 { 0x1a, 0x02214021 }, /* headphone */

295 { 0x1b, 0x90170110 }, /* speaker */

296 { 0x1c, 0x411111f0 }, /* N/A */

297 { 0x1d, 0x411111f0 }, /* N/A */

298 { 0x1e, 0x411111f0 }, /* N/A */

299 { 0x1f, 0x02a191f0 }, /* mic */

300 { 0x20, 0x411111f0 }, /* N/A */

301 {}

302 },

303 },

304 [AD1986A_FIXUP_LAPTOP_IMIC] = {

305 .type = HDA_FIXUP_PINS,

306 .v.pins = (const struct hda_pintbl[]) {

307 { 0x1d, 0x90a7013e }, /* int mic */

308 {}

309 },

310 .chained_before = 1,

311 .chain_id = AD1986A_FIXUP_LAPTOP,

312 },

313 };

314

315 static const struct snd_pci_quirk ad1986a_fixup_tbl[] = {

316 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_FIXUP_LAPTOP_IMIC),

317 SND_PCI_QUIRK_MASK(0x1043, 0xff00, 0x8100, "ASUS P5", AD1986A_FIXUP_3STACK),

318 SND_PCI_QUIRK_MASK(0x1043, 0xff00, 0x8200, "ASUS M2", AD1986A_FIXUP_3STACK),

319 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_FIXUP_3STACK),

320 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_FIXUP_LAPTOP),

321 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_FIXUP_SAMSUNG),

322 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_FIXUP_ULTRA),

323 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_FIXUP_INV_JACK_DETECT),

324 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_FIXUP_3STACK),

325 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_FIXUP_3STACK),

326 {}

327 };

328

329 static const struct hda_model_fixup ad1986a_fixup_models[] = {

330 { .id = AD1986A_FIXUP_3STACK, .name = "3stack" },

331 { .id = AD1986A_FIXUP_LAPTOP, .name = "laptop" },

332 { .id = AD1986A_FIXUP_LAPTOP_IMIC, .name = "laptop-imic" },

333 { .id = AD1986A_FIXUP_LAPTOP_IMIC, .name = "laptop-eapd" }, /* alias */

334 {}

335 };

336

337 /*

338 */

339 static int patch_ad1986a(struct hda_codec *codec)

340 {

341 int err;

342 struct ad198x_spec *spec;

343 static hda_nid_t preferred_pairs[] = {

344 0x1a, 0x03,

345 0x1b, 0x03,

346 0x1c, 0x04,

347 0x1d, 0x05,

348 0x1e, 0x03,

349 0

350 };

351

352 err = alloc_ad_spec(codec);

353 if (err < 0)

354 return err;

355 spec = codec->spec;

356

357 /* AD1986A has the inverted EAPD implementation */

358 codec->inv_eapd = 1;

359

360 spec->gen.mixer_nid = 0x07;

361 spec->gen.beep_nid = 0x19;

362 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);

363

364 /* AD1986A has a hardware problem that it can't share a stream

365 * with multiple output pins. The copy of front to surrounds

366 * causes noisy or silent outputs at a certain timing, e.g.

367 * changing the volume.

368 * So, let's disable the shared stream.

369 */

370 spec->gen.multiout.no_share_stream = 1;

371 /* give fixed DAC/pin pairs */

372 spec->gen.preferred_dacs = preferred_pairs;

373

374 /* AD1986A can't manage the dynamic pin on/off smoothly */

375 spec->gen.auto_mute_via_amp = 1;

376

377 snd_hda_pick_fixup(codec, ad1986a_fixup_models, ad1986a_fixup_tbl,

378 ad1986a_fixups);

379 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

380

381 err = ad198x_parse_auto_config(codec);

382 if (err < 0) {

383 snd_hda_gen_free(codec);

384 return err;

385 }

386

387 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

388

389 return 0;

390 }

391

392

393 /*

394 * AD1983 specific

395 */

396

397 /*

398 * SPDIF mux control for AD1983 auto-parser

399 */

400 static int ad1983_auto_smux_enum_info(struct snd_kcontrol *kcontrol,

401 struct snd_ctl_elem_info *uinfo)

402 {

403 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

404 struct ad198x_spec *spec = codec->spec;

405 static const char * const texts2[] = { "PCM", "ADC" };

406 static const char * const texts3[] = { "PCM", "ADC1", "ADC2" };

407 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;

408 int num_conns = snd_hda_get_num_conns(codec, dig_out);

409

410 if (num_conns == 2)

411 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, texts2);

412 else if (num_conns == 3)

413 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);

414 else

415 return -EINVAL;

416 }

417

418 static int ad1983_auto_smux_enum_get(struct snd_kcontrol *kcontrol,

419 struct snd_ctl_elem_value *ucontrol)

420 {

421 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

422 struct ad198x_spec *spec = codec->spec;

423

424 ucontrol->value.enumerated.item[0] = spec->cur_smux;

425 return 0;

426 }

427

428 static int ad1983_auto_smux_enum_put(struct snd_kcontrol *kcontrol,

429 struct snd_ctl_elem_value *ucontrol)

430 {

431 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

432 struct ad198x_spec *spec = codec->spec;

433 unsigned int val = ucontrol->value.enumerated.item[0];

434 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;

435 int num_conns = snd_hda_get_num_conns(codec, dig_out);

436

437 if (val >= num_conns)

438 return -EINVAL;

439 if (spec->cur_smux == val)

440 return 0;

441 spec->cur_smux = val;

442 snd_hda_codec_write_cache(codec, dig_out, 0,

443 AC_VERB_SET_CONNECT_SEL, val);

444 return 1;

445 }

446

447 static struct snd_kcontrol_new ad1983_auto_smux_mixer = {

448 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,

449 .name = "IEC958 Playback Source",

450 .info = ad1983_auto_smux_enum_info,

451 .get = ad1983_auto_smux_enum_get,

452 .put = ad1983_auto_smux_enum_put,

453 };

454

455 static int ad1983_add_spdif_mux_ctl(struct hda_codec *codec)

456 {

457 struct ad198x_spec *spec = codec->spec;

458 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;

459 int num_conns;

460

461 if (!dig_out)

462 return 0;

463 num_conns = snd_hda_get_num_conns(codec, dig_out);

464 if (num_conns != 2 && num_conns != 3)

465 return 0;

466 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1983_auto_smux_mixer))

467 return -ENOMEM;

468 return 0;

469 }

470

471 static int patch_ad1983(struct hda_codec *codec)

472 {

473 struct ad198x_spec *spec;

474 int err;

475

476 err = alloc_ad_spec(codec);

477 if (err < 0)

478 return err;

479 spec = codec->spec;

480

481 spec->gen.beep_nid = 0x10;

482 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);

483 err = ad198x_parse_auto_config(codec);

484 if (err < 0)

485 goto error;

486 err = ad1983_add_spdif_mux_ctl(codec);

487 if (err < 0)

488 goto error;

489 return 0;

490

491 error:

492 snd_hda_gen_free(codec);

493 return err;

494 }

495

496

497 /*

498 * AD1981 HD specific

499 */

500

501 static void ad1981_fixup_hp_eapd(struct hda_codec *codec,

502 const struct hda_fixup *fix, int action)

503 {

504 struct ad198x_spec *spec = codec->spec;

505

506 if (action == HDA_FIXUP_ACT_PRE_PROBE) {

507 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook;

508 spec->eapd_nid = 0x05;

509 }

510 }

511

512 /* set the upper-limit for mixer amp to 0dB for avoiding the possible

513 * damage by overloading

514 */

515 static void ad1981_fixup_amp_override(struct hda_codec *codec,

516 const struct hda_fixup *fix, int action)

517 {

518 if (action == HDA_FIXUP_ACT_PRE_PROBE)

519 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,

520 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |

521 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |

522 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |

523 (1 << AC_AMPCAP_MUTE_SHIFT));

524 }

525

526 enum {

527 AD1981_FIXUP_AMP_OVERRIDE,

528 AD1981_FIXUP_HP_EAPD,

529 };

530

531 static const struct hda_fixup ad1981_fixups[] = {

532 [AD1981_FIXUP_AMP_OVERRIDE] = {

533 .type = HDA_FIXUP_FUNC,

534 .v.func = ad1981_fixup_amp_override,

535 },

536 [AD1981_FIXUP_HP_EAPD] = {

537 .type = HDA_FIXUP_FUNC,

538 .v.func = ad1981_fixup_hp_eapd,

539 .chained = true,

540 .chain_id = AD1981_FIXUP_AMP_OVERRIDE,

541 },

542 };

543

544 static const struct snd_pci_quirk ad1981_fixup_tbl[] = {

545 SND_PCI_QUIRK_VENDOR(0x1014, "Lenovo", AD1981_FIXUP_AMP_OVERRIDE),

546 SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1981_FIXUP_HP_EAPD),

547 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", AD1981_FIXUP_AMP_OVERRIDE),

548 /* HP nx6320 (reversed SSID, H/W bug) */

549 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_FIXUP_HP_EAPD),

550 {}

551 };

552

553 static int patch_ad1981(struct hda_codec *codec)

554 {

555 struct ad198x_spec *spec;

556 int err;

557

558 err = alloc_ad_spec(codec);

559 if (err < 0)

560 return -ENOMEM;

561 spec = codec->spec;

562

563 spec->gen.mixer_nid = 0x0e;

564 spec->gen.beep_nid = 0x10;

565 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);

566

567 snd_hda_pick_fixup(codec, NULL, ad1981_fixup_tbl, ad1981_fixups);

568 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

569

570 err = ad198x_parse_auto_config(codec);

571 if (err < 0)

572 goto error;

573 err = ad1983_add_spdif_mux_ctl(codec);

574 if (err < 0)

575 goto error;

576

577 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

578

579 return 0;

580

581 error:

582 snd_hda_gen_free(codec);

583 return err;

584 }

585

586

587 /*

588 * AD1988

589 *

590 * Output pins and routes

591 *

592 * Pin Mix Sel DAC (*)

593 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06

594 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06

595 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a

596 * port-D 0x12 (mute/hp) <- 0x29 <- 04

597 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a

598 * port-F 0x16 (mute) <- 0x2a <- 06

599 * port-G 0x24 (mute) <- 0x27 <- 05

600 * port-H 0x25 (mute) <- 0x28 <- 0a

601 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06

602 *

603 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah

604 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.

605 *

606 * Input pins and routes

607 *

608 * pin boost mix input # / adc input #

609 * port-A 0x11 -> 0x38 -> mix 2, ADC 0

610 * port-B 0x14 -> 0x39 -> mix 0, ADC 1

611 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2

612 * port-D 0x12 -> 0x3d -> mix 3, ADC 8

613 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4

614 * port-F 0x16 -> 0x3b -> mix 5, ADC 3

615 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6

616 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7

617 *

618 *

619 * DAC assignment

620 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03

621 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03

622 *

623 * Inputs of Analog Mix (0x20)

624 * 0:Port-B (front mic)

625 * 1:Port-C/G/H (line-in)

626 * 2:Port-A

627 * 3:Port-D (line-in/2)

628 * 4:Port-E/G/H (mic-in)

629 * 5:Port-F (mic2-in)

630 * 6:CD

631 * 7:Beep

632 *

633 * ADC selection

634 * 0:Port-A

635 * 1:Port-B (front mic-in)

636 * 2:Port-C (line-in)

637 * 3:Port-F (mic2-in)

638 * 4:Port-E (mic-in)

639 * 5:CD

640 * 6:Port-G

641 * 7:Port-H

642 * 8:Port-D (line-in/2)

643 * 9:Mix

644 *

645 * Proposed pin assignments by the datasheet

646 *

647 * 6-stack

648 * Port-A front headphone

649 * B front mic-in

650 * C rear line-in

651 * D rear front-out

652 * E rear mic-in

653 * F rear surround

654 * G rear CLFE

655 * H rear side

656 *

657 * 3-stack

658 * Port-A front headphone

659 * B front mic

660 * C rear line-in/surround

661 * D rear front-out

662 * E rear mic-in/CLFE

663 *

664 * laptop

665 * Port-A headphone

666 * B mic-in

667 * C docking station

668 * D internal speaker (with EAPD)

669 * E/F quad mic array

670 */

671

672 #ifdef ENABLE_AD_STATIC_QUIRKS

673 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,

674 struct snd_ctl_elem_info *uinfo)

675 {

676 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

677 struct ad198x_spec *spec = codec->spec;

678 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,

679 spec->num_channel_mode);

680 }

681

682 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,

683 struct snd_ctl_elem_value *ucontrol)

684 {

685 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

686 struct ad198x_spec *spec = codec->spec;

687 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,

688 spec->num_channel_mode, spec->multiout.max_channels);

689 }

690

691 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,

692 struct snd_ctl_elem_value *ucontrol)

693 {

694 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

695 struct ad198x_spec *spec = codec->spec;

696 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,

697 spec->num_channel_mode,

698 &spec->multiout.max_channels);

699 if (err >= 0 && spec->need_dac_fix)

700 spec->multiout.num_dacs = spec->multiout.max_channels / 2;

701 return err;

702 }

703 #endif /* ENABLE_AD_STATIC_QUIRKS */

704

705 static int ad1988_auto_smux_enum_info(struct snd_kcontrol *kcontrol,

706 struct snd_ctl_elem_info *uinfo)

707 {

708 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

709 static const char * const texts[] = {

710 "PCM", "ADC1", "ADC2", "ADC3",

711 };

712 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;

713 if (num_conns > 4)

714 num_conns = 4;

715 return snd_hda_enum_helper_info(kcontrol, uinfo, num_conns, texts);

716 }

717

718 static int ad1988_auto_smux_enum_get(struct snd_kcontrol *kcontrol,

719 struct snd_ctl_elem_value *ucontrol)

720 {

721 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

722 struct ad198x_spec *spec = codec->spec;

723

724 ucontrol->value.enumerated.item[0] = spec->cur_smux;

725 return 0;

726 }

727

728 static int ad1988_auto_smux_enum_put(struct snd_kcontrol *kcontrol,

729 struct snd_ctl_elem_value *ucontrol)

730 {

731 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);

732 struct ad198x_spec *spec = codec->spec;

733 unsigned int val = ucontrol->value.enumerated.item[0];

734 struct nid_path *path;

735 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;

736

737 if (val >= num_conns)

738 return -EINVAL;

739 if (spec->cur_smux == val)

740 return 0;

741

742 mutex_lock(&codec->control_mutex);

743 codec->cached_write = 1;

744 path = snd_hda_get_path_from_idx(codec,

745 spec->smux_paths[spec->cur_smux]);

746 if (path)

747 snd_hda_activate_path(codec, path, false, true);

748 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[val]);

749 if (path)

750 snd_hda_activate_path(codec, path, true, true);

751 spec->cur_smux = val;

752 codec->cached_write = 0;

753 mutex_unlock(&codec->control_mutex);

754 snd_hda_codec_flush_cache(codec); /* flush the updates */

755 return 1;

756 }

757

758 static struct snd_kcontrol_new ad1988_auto_smux_mixer = {

759 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,

760 .name = "IEC958 Playback Source",

761 .info = ad1988_auto_smux_enum_info,

762 .get = ad1988_auto_smux_enum_get,

763 .put = ad1988_auto_smux_enum_put,

764 };

765

766 static int ad1988_auto_init(struct hda_codec *codec)

767 {

768 struct ad198x_spec *spec = codec->spec;

769 int i, err;

770

771 err = snd_hda_gen_init(codec);

772 if (err < 0)

773 return err;

774 if (!spec->gen.autocfg.dig_outs)

775 return 0;

776

777 for (i = 0; i < 4; i++) {

778 struct nid_path *path;

779 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[i]);

780 if (path)

781 snd_hda_activate_path(codec, path, path->active, false);

782 }

783

784 return 0;

785 }

786

787 static int ad1988_add_spdif_mux_ctl(struct hda_codec *codec)

788 {

789 struct ad198x_spec *spec = codec->spec;

790 int i, num_conns;

791 /* we create four static faked paths, since AD codecs have odd

792 * widget connections regarding the SPDIF out source

793 */

794 static struct nid_path fake_paths[4] = {

795 {

796 .depth = 3,

797 .path = { 0x02, 0x1d, 0x1b },

798 .idx = { 0, 0, 0 },

799 .multi = { 0, 0, 0 },

800 },

801 {

802 .depth = 4,

803 .path = { 0x08, 0x0b, 0x1d, 0x1b },

804 .idx = { 0, 0, 1, 0 },

805 .multi = { 0, 1, 0, 0 },

806 },

807 {

808 .depth = 4,

809 .path = { 0x09, 0x0b, 0x1d, 0x1b },

810 .idx = { 0, 1, 1, 0 },

811 .multi = { 0, 1, 0, 0 },

812 },

813 {

814 .depth = 4,

815 .path = { 0x0f, 0x0b, 0x1d, 0x1b },

816 .idx = { 0, 2, 1, 0 },

817 .multi = { 0, 1, 0, 0 },

818 },

819 };

820

821 /* SPDIF source mux appears to be present only on AD1988A */

822 if (!spec->gen.autocfg.dig_outs ||

823 get_wcaps_type(get_wcaps(codec, 0x1d)) != AC_WID_AUD_MIX)

824 return 0;

825

826 num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;

827 if (num_conns != 3 && num_conns != 4)

828 return 0;

829

830 for (i = 0; i < num_conns; i++) {

831 struct nid_path *path = snd_array_new(&spec->gen.paths);

832 if (!path)

833 return -ENOMEM;

834 *path = fake_paths[i];

835 if (!i)

836 path->active = 1;

837 spec->smux_paths[i] = snd_hda_get_path_idx(codec, path);

838 }

839

840 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1988_auto_smux_mixer))

841 return -ENOMEM;

842

843 codec->patch_ops.init = ad1988_auto_init;

844

845 return 0;

846 }

847

848 /*

849 */

850

851 enum {

852 AD1988_FIXUP_6STACK_DIG,

853 };

854

855 static const struct hda_fixup ad1988_fixups[] = {

856 [AD1988_FIXUP_6STACK_DIG] = {

857 .type = HDA_FIXUP_PINS,

858 .v.pins = (const struct hda_pintbl[]) {

859 { 0x11, 0x02214130 }, /* front-hp */

860 { 0x12, 0x01014010 }, /* line-out */

861 { 0x14, 0x02a19122 }, /* front-mic */

862 { 0x15, 0x01813021 }, /* line-in */

863 { 0x16, 0x01011012 }, /* line-out */

864 { 0x17, 0x01a19020 }, /* mic */

865 { 0x1b, 0x0145f1f0 }, /* SPDIF */

866 { 0x24, 0x01016011 }, /* line-out */

867 { 0x25, 0x01012013 }, /* line-out */

868 { }

869 }

870 },

871 };

872

873 static const struct hda_model_fixup ad1988_fixup_models[] = {

874 { .id = AD1988_FIXUP_6STACK_DIG, .name = "6stack-dig" },

875 {}

876 };

877

878 static int patch_ad1988(struct hda_codec *codec)

879 {

880 struct ad198x_spec *spec;

881 int err;

882

883 err = alloc_ad_spec(codec);

884 if (err < 0)

885 return err;

886 spec = codec->spec;

887

888 spec->gen.mixer_nid = 0x20;

889 spec->gen.mixer_merge_nid = 0x21;

890 spec->gen.beep_nid = 0x10;

891 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);

892

893 snd_hda_pick_fixup(codec, ad1988_fixup_models, NULL, ad1988_fixups);

894 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

895

896 err = ad198x_parse_auto_config(codec);

897 if (err < 0)

898 goto error;

899 err = ad1988_add_spdif_mux_ctl(codec);

900 if (err < 0)

901 goto error;

902

903 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

904

905 return 0;

906

907 error:

908 snd_hda_gen_free(codec);

909 return err;

910 }

911

912

913 /*

914 * AD1884 / AD1984

915 *

916 * port-B - front line/mic-in

917 * port-E - aux in/out

918 * port-F - aux in/out

919 * port-C - rear line/mic-in

920 * port-D - rear line/hp-out

921 * port-A - front line/hp-out

922 *

923 * AD1984 = AD1884 + two digital mic-ins

924 *

925 * AD1883 / AD1884A / AD1984A / AD1984B

926 *

927 * port-B (0x14) - front mic-in

928 * port-E (0x1c) - rear mic-in

929 * port-F (0x16) - CD / ext out

930 * port-C (0x15) - rear line-in

931 * port-D (0x12) - rear line-out

932 * port-A (0x11) - front hp-out

933 *

934 * AD1984A = AD1884A + digital-mic

935 * AD1883 = equivalent with AD1984A

936 * AD1984B = AD1984A + extra SPDIF-out

937 */

938

939 /* set the upper-limit for mixer amp to 0dB for avoiding the possible

940 * damage by overloading

941 */

942 static void ad1884_fixup_amp_override(struct hda_codec *codec,

943 const struct hda_fixup *fix, int action)

944 {

945 if (action == HDA_FIXUP_ACT_PRE_PROBE)

946 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,

947 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |

948 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |

949 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |

950 (1 << AC_AMPCAP_MUTE_SHIFT));

951 }

952

953 /* toggle GPIO1 according to the mute state */

954 static void ad1884_vmaster_hp_gpio_hook(void *private_data, int enabled)

955 {

956 struct hda_codec *codec = private_data;

957 struct ad198x_spec *spec = codec->spec;

958

959 if (spec->eapd_nid)

960 ad_vmaster_eapd_hook(private_data, enabled);

961 snd_hda_codec_update_cache(codec, 0x01, 0,

962 AC_VERB_SET_GPIO_DATA,

963 enabled ? 0x00 : 0x02);

964 }

965

966 static void ad1884_fixup_hp_eapd(struct hda_codec *codec,

967 const struct hda_fixup *fix, int action)

968 {

969 struct ad198x_spec *spec = codec->spec;

970 static const struct hda_verb gpio_init_verbs[] = {

971 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},

972 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},

973 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},

974 {},

975 };

976

977 switch (action) {

978 case HDA_FIXUP_ACT_PRE_PROBE:

979 spec->gen.vmaster_mute.hook = ad1884_vmaster_hp_gpio_hook;

980 spec->gen.own_eapd_ctl = 1;

981 snd_hda_sequence_write_cache(codec, gpio_init_verbs);

982 break;

983 case HDA_FIXUP_ACT_PROBE:

984 if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)

985 spec->eapd_nid = spec->gen.autocfg.line_out_pins[0];

986 else

987 spec->eapd_nid = spec->gen.autocfg.speaker_pins[0];

988 break;

989 }

990 }

991

992 static void ad1884_fixup_thinkpad(struct hda_codec *codec,

993 const struct hda_fixup *fix, int action)

994 {

995 struct ad198x_spec *spec = codec->spec;

996

997 if (action == HDA_FIXUP_ACT_PRE_PROBE) {

998 spec->gen.keep_eapd_on = 1;

999 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook;

1000 spec->eapd_nid = 0x12;

1001 }

1002 }

1003

1004 /* set magic COEFs for dmic */

1005 static const struct hda_verb ad1884_dmic_init_verbs[] = {

1006 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},

1007 {0x01, AC_VERB_SET_PROC_COEF, 0x08},

1008 {}

1009 };

1010

1011 enum {

1012 AD1884_FIXUP_AMP_OVERRIDE,

1013 AD1884_FIXUP_HP_EAPD,

1014 AD1884_FIXUP_DMIC_COEF,

1015 AD1884_FIXUP_THINKPAD,

1016 AD1884_FIXUP_HP_TOUCHSMART,

1017 };

1018

1019 static const struct hda_fixup ad1884_fixups[] = {

1020 [AD1884_FIXUP_AMP_OVERRIDE] = {

1021 .type = HDA_FIXUP_FUNC,

1022 .v.func = ad1884_fixup_amp_override,

1023 },

1024 [AD1884_FIXUP_HP_EAPD] = {

1025 .type = HDA_FIXUP_FUNC,

1026 .v.func = ad1884_fixup_hp_eapd,

1027 .chained = true,

1028 .chain_id = AD1884_FIXUP_AMP_OVERRIDE,

1029 },

1030 [AD1884_FIXUP_DMIC_COEF] = {

1031 .type = HDA_FIXUP_VERBS,

1032 .v.verbs = ad1884_dmic_init_verbs,

1033 },

1034 [AD1884_FIXUP_THINKPAD] = {

1035 .type = HDA_FIXUP_FUNC,

1036 .v.func = ad1884_fixup_thinkpad,

1037 .chained = true,

1038 .chain_id = AD1884_FIXUP_DMIC_COEF,

1039 },

1040 [AD1884_FIXUP_HP_TOUCHSMART] = {

1041 .type = HDA_FIXUP_VERBS,

1042 .v.verbs = ad1884_dmic_init_verbs,

1043 .chained = true,

1044 .chain_id = AD1884_FIXUP_HP_EAPD,

1045 },

1046 };

1047

1048 static const struct snd_pci_quirk ad1884_fixup_tbl[] = {

1049 SND_PCI_QUIRK(0x103c, 0x2a82, "HP Touchsmart", AD1884_FIXUP_HP_TOUCHSMART),

1050 SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1884_FIXUP_HP_EAPD),

1051 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1884_FIXUP_THINKPAD),

1052 {}

1053 };

1054

1055

1056 static int patch_ad1884(struct hda_codec *codec)

1057 {

1058 struct ad198x_spec *spec;

1059 int err;

1060

1061 err = alloc_ad_spec(codec);

1062 if (err < 0)

1063 return err;

1064 spec = codec->spec;

1065

1066 spec->gen.mixer_nid = 0x20;

1067 spec->gen.beep_nid = 0x10;

1068 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);

1069

1070 snd_hda_pick_fixup(codec, NULL, ad1884_fixup_tbl, ad1884_fixups);

1071 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

1072

1073 err = ad198x_parse_auto_config(codec);

1074 if (err < 0)

1075 goto error;

1076 err = ad1983_add_spdif_mux_ctl(codec);

1077 if (err < 0)

1078 goto error;

1079

1080 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

1081

1082 return 0;

1083

1084 error:

1085 snd_hda_gen_free(codec);

1086 return err;

1087 }

1088

1089 /*

1090 * AD1882 / AD1882A

1091 *

1092 * port-A - front hp-out

1093 * port-B - front mic-in

1094 * port-C - rear line-in, shared surr-out (3stack)

1095 * port-D - rear line-out

1096 * port-E - rear mic-in, shared clfe-out (3stack)

1097 * port-F - rear surr-out (6stack)

1098 * port-G - rear clfe-out (6stack)

1099 */

1100

1101 static int patch_ad1882(struct hda_codec *codec)

1102 {

1103 struct ad198x_spec *spec;

1104 int err;

1105

1106 err = alloc_ad_spec(codec);

1107 if (err < 0)

1108 return err;

1109 spec = codec->spec;

1110

1111 spec->gen.mixer_nid = 0x20;

1112 spec->gen.mixer_merge_nid = 0x21;

1113 spec->gen.beep_nid = 0x10;

1114 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);

1115 err = ad198x_parse_auto_config(codec);

1116 if (err < 0)

1117 goto error;

1118 err = ad1988_add_spdif_mux_ctl(codec);

1119 if (err < 0)

1120 goto error;

1121 return 0;

1122

1123 error:

1124 snd_hda_gen_free(codec);

1125 return err;

1126 }

1127

1128

1129 /*

1130 * patch entries

1131 */

1132 static const struct hda_codec_preset snd_hda_preset_analog[] = {

1133 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884 },

1134 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },

1135 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884 },

1136 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },

1137 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884 },

1138 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884 },

1139 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },

1140 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },

1141 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1884 },

1142 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },

1143 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },

1144 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },

1145 { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 },

1146 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 },

1147 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 },

1148 {} /* terminator */

1149 };

1150

1151 MODULE_ALIAS("snd-hda-codec-id:11d4*");

1152

1153 MODULE_LICENSE("GPL");

1154 MODULE_DESCRIPTION("Analog Devices HD-audio codec");

1155

1156 static struct hda_codec_preset_list analog_list = {

1157 .preset = snd_hda_preset_analog,

1158 .owner = THIS_MODULE,

1159 };

1160

1161 static int __init patch_analog_init(void)

1162 {

1163 return snd_hda_add_codec_preset(&analog_list);

1164 }

1165

1166 static void __exit patch_analog_exit(void)

1167 {

1168 snd_hda_delete_codec_preset(&analog_list);

1169 }

1170

1171 module_init(patch_analog_init)

1172 module_exit(patch_analog_exit)