es8316ac.c revision 1.1
1 /* $NetBSD: es8316ac.c,v 1.1 2020/01/02 22:06:59 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2020 Jared McNeill <jmcneill (at) invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: es8316ac.c,v 1.1 2020/01/02 22:06:59 jmcneill Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/bus.h> 34 #include <sys/device.h> 35 #include <sys/intr.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/conf.h> 39 #include <sys/bitops.h> 40 41 #include <dev/audio/audio_dai.h> 42 43 #include <dev/i2c/i2cvar.h> 44 45 #include <dev/fdt/fdtvar.h> 46 47 #define ESCODEC_RESET_REG 0x00 48 #define RESET_ALL __BITS(5,0) 49 #define RESET_CSM_ON __BIT(7) 50 #define ESCODEC_CLKMAN1_REG 0x01 51 #define CLKMAN1_MCLK_ON __BIT(6) 52 #define CLKMAN1_BCLK_ON __BIT(5) 53 #define CLKMAN1_CLK_CP_ON __BIT(4) 54 #define CLKMAN1_CLK_DAC_ON __BIT(2) 55 #define CLKMAN1_ANACLK_DAC_ON __BIT(0) 56 #define ESCODEC_ADC_OSR_REG 0x03 57 #define ESCODEC_SD_CLK_REG 0x09 58 #define SD_CLK_MSC __BIT(7) 59 #define SD_CLK_BCLK_INV __BIT(5) 60 #define ESCODEC_SD_ADC_REG 0x0a 61 #define ESCODEC_SD_DAC_REG 0x0b 62 #define SD_FMT_LRP __BIT(5) 63 #define SD_FMT_WL __BITS(4,2) 64 #define SD_FMT_WL_16 3 65 #define SD_FMT_MASK __BITS(1,0) 66 #define SD_FMT_I2S 0 67 #define ESCODEC_VMID_REG 0x0c 68 #define ESCODEC_PDN_REG 0x0d 69 #define ESCODEC_HPSEL_REG 0x13 70 #define ESCODEC_HPMIXRT_REG 0x14 71 #define HPMIXRT_LD2LHPMIX __BIT(7) 72 #define HPMIXRT_RD2RHPMIX __BIT(3) 73 #define ESCODEC_HPMIX_REG 0x15 74 #define HPMIX_LHPMIX_MUTE __BIT(5) 75 #define HPMIX_PDN_LHP_MIX __BIT(4) 76 #define HPMIX_RHPMIX_MUTE __BIT(1) 77 #define HPMIX_PDN_RHP_MIX __BIT(0) 78 #define ESCODEC_HPMIXVOL_REG 0x16 79 #define HPMIXVOL_LHPMIXVOL __BITS(7,4) 80 #define HPMIXVOL_RHPMIXVOL __BITS(3,0) 81 #define ESCODEC_HPOUTEN_REG 0x17 82 #define HPOUTEN_EN_HPL __BIT(6) 83 #define HPOUTEN_HPL_OUTEN __BIT(5) 84 #define HPOUTEN_EN_HPR __BIT(2) 85 #define HPOUTEN_HPR_OUTEN __BIT(1) 86 #define ESCODEC_HPVOL_REG 0x18 87 #define HPVOL_PDN_LICAL __BIT(7) 88 #define HPVOL_HPLVOL __BITS(5,4) 89 #define HPVOL_PDN_RICAL __BIT(3) 90 #define HPVOL_HPRVOL __BITS(1,0) 91 #define ESCODEC_HPPWR_REG 0x19 92 #define HPPWR_PDN_CPHP __BIT(2) 93 #define ESCODEC_CPPWR_REG 0x1a 94 #define CPPWR_PDN_CP __BIT(5) 95 #define ESCODEC_DACPWR_REG 0x2f 96 #define DACPWR_PDN_DAC_L __BIT(4) 97 #define DACPWR_PDN_DAC_R __BIT(0) 98 #define ESCODEC_DACCTL1_REG 0x30 99 #define DACCTL1_MUTE __BIT(5) 100 #define ESCODEC_DACVOL_L_REG 0x33 101 #define DACVOL_L_DACVOLUME __BITS(7,0) 102 #define ESCODEC_DACVOL_R_REG 0x34 103 #define DACVOL_R_DACVOLUME __BITS(7,0) 104 105 static const struct device_compatible_entry compat_data[] = { 106 { "everest,es8316", 1 }, 107 { NULL } 108 }; 109 110 struct escodec_softc { 111 device_t sc_dev; 112 i2c_tag_t sc_i2c; 113 i2c_addr_t sc_addr; 114 int sc_phandle; 115 struct clk *sc_clk; 116 117 struct audio_dai_device sc_dai; 118 audio_dai_tag_t sc_amplifier; 119 120 uint8_t sc_swvol; 121 }; 122 123 static void 124 escodec_lock(struct escodec_softc *sc) 125 { 126 iic_acquire_bus(sc->sc_i2c, 0); 127 } 128 129 static void 130 escodec_unlock(struct escodec_softc *sc) 131 { 132 iic_release_bus(sc->sc_i2c, 0); 133 } 134 135 static uint8_t 136 escodec_read(struct escodec_softc *sc, uint8_t reg) 137 { 138 uint8_t val; 139 140 if (iic_smbus_read_byte(sc->sc_i2c, sc->sc_addr, reg, &val, I2C_F_POLL) != 0) 141 val = 0xff; 142 143 return val; 144 } 145 146 static void 147 escodec_write(struct escodec_softc *sc, uint8_t reg, uint8_t val) 148 { 149 (void)iic_smbus_write_byte(sc->sc_i2c, sc->sc_addr, reg, val, I2C_F_POLL); 150 } 151 152 enum escodec_mixer_ctrl { 153 ESCODEC_OUTPUT_CLASS, 154 ESCODEC_INPUT_CLASS, 155 ESCODEC_OUTPUT_MASTER, 156 ESCODEC_INPUT_DAC, 157 ESCODEC_INPUT_DAC_MUTE, 158 ESCODEC_INPUT_HEADPHONE, 159 ESCODEC_INPUT_MIXEROUT, 160 ESCODEC_INPUT_MIXEROUT_MUTE, 161 162 ESCODEC_MIXER_CTRL_LAST 163 }; 164 165 enum escodec_mixer_type { 166 ESCODEC_MIXER_CLASS, 167 ESCODEC_MIXER_SWVOL, 168 ESCODEC_MIXER_AMPLIFIER, 169 ESCODEC_MIXER_ATTENUATOR, 170 ESCODEC_MIXER_MUTE, 171 }; 172 173 static const struct escodec_mixer { 174 const char * name; 175 int mixer_class; 176 int prev, next; 177 enum escodec_mixer_ctrl ctrl; 178 enum escodec_mixer_type type; 179 u_int reg[2]; 180 uint8_t mask[2]; 181 uint8_t maxval; 182 } escodec_mixers[ESCODEC_MIXER_CTRL_LAST] = { 183 /* 184 * Mixer classes 185 */ 186 [ESCODEC_OUTPUT_CLASS] = { 187 .name = AudioCoutputs, 188 .type = ESCODEC_MIXER_CLASS, 189 }, 190 [ESCODEC_INPUT_CLASS] = { 191 .name = AudioCinputs, 192 .type = ESCODEC_MIXER_CLASS, 193 }, 194 195 /* 196 * Software master volume 197 */ 198 [ESCODEC_OUTPUT_MASTER] = { 199 .name = AudioNmaster, 200 .mixer_class = ESCODEC_OUTPUT_CLASS, 201 .prev = AUDIO_MIXER_LAST, 202 .next = AUDIO_MIXER_LAST, 203 .type = ESCODEC_MIXER_SWVOL, 204 }, 205 206 /* 207 * Stereo DAC 208 */ 209 [ESCODEC_INPUT_DAC] = { 210 .name = AudioNdac, 211 .mixer_class = ESCODEC_INPUT_CLASS, 212 .prev = AUDIO_MIXER_LAST, 213 .next = ESCODEC_INPUT_DAC_MUTE, 214 .type = ESCODEC_MIXER_ATTENUATOR, 215 .reg = { 216 [AUDIO_MIXER_LEVEL_LEFT] = ESCODEC_DACVOL_L_REG, 217 [AUDIO_MIXER_LEVEL_RIGHT] = ESCODEC_DACVOL_R_REG, 218 }, 219 .mask = { 220 [AUDIO_MIXER_LEVEL_LEFT] = DACVOL_L_DACVOLUME, 221 [AUDIO_MIXER_LEVEL_RIGHT] = DACVOL_R_DACVOLUME, 222 }, 223 .maxval = 0xc0, 224 }, 225 [ESCODEC_INPUT_DAC_MUTE] = { 226 .name = AudioNmute, 227 .mixer_class = ESCODEC_INPUT_CLASS, 228 .prev = ESCODEC_INPUT_DAC, 229 .next = AUDIO_MIXER_LAST, 230 .type = ESCODEC_MIXER_MUTE, 231 .reg = { 232 [AUDIO_MIXER_LEVEL_MONO] = ESCODEC_DACCTL1_REG, 233 }, 234 .mask = { 235 [AUDIO_MIXER_LEVEL_MONO] = DACCTL1_MUTE, 236 } 237 }, 238 239 /* 240 * Charge Pump Headphones 241 */ 242 [ESCODEC_INPUT_HEADPHONE] = { 243 .name = AudioNheadphone, 244 .mixer_class = ESCODEC_INPUT_CLASS, 245 .prev = AUDIO_MIXER_LAST, 246 .next = AUDIO_MIXER_LAST, 247 .type = ESCODEC_MIXER_ATTENUATOR, 248 .reg = { 249 [AUDIO_MIXER_LEVEL_LEFT] = ESCODEC_HPVOL_REG, 250 [AUDIO_MIXER_LEVEL_RIGHT] = ESCODEC_HPVOL_REG, 251 }, 252 .mask = { 253 [AUDIO_MIXER_LEVEL_LEFT] = HPVOL_HPLVOL, 254 [AUDIO_MIXER_LEVEL_RIGHT] = HPVOL_HPRVOL, 255 } 256 }, 257 258 /* 259 * Headphone mixer 260 */ 261 [ESCODEC_INPUT_MIXEROUT] = { 262 .name = AudioNmixerout, 263 .mixer_class = ESCODEC_INPUT_CLASS, 264 .prev = AUDIO_MIXER_LAST, 265 .next = ESCODEC_INPUT_MIXEROUT_MUTE, 266 .type = ESCODEC_MIXER_AMPLIFIER, 267 .reg = { 268 [AUDIO_MIXER_LEVEL_LEFT] = ESCODEC_HPMIXVOL_REG, 269 [AUDIO_MIXER_LEVEL_RIGHT] = ESCODEC_HPMIXVOL_REG, 270 }, 271 .mask = { 272 [AUDIO_MIXER_LEVEL_LEFT] = HPMIXVOL_LHPMIXVOL, 273 [AUDIO_MIXER_LEVEL_RIGHT] = HPMIXVOL_RHPMIXVOL 274 }, 275 /* 276 * Datasheet says this field goes up to 0xb, but values 277 * above 0x4 result in noisy output in practice. 278 */ 279 .maxval = 0x4, 280 }, 281 [ESCODEC_INPUT_MIXEROUT_MUTE] = { 282 .name = AudioNmute, 283 .mixer_class = ESCODEC_INPUT_CLASS, 284 .prev = ESCODEC_INPUT_MIXEROUT, 285 .next = AUDIO_MIXER_LAST, 286 .type = ESCODEC_MIXER_MUTE, 287 .reg = { 288 [AUDIO_MIXER_LEVEL_MONO] = ESCODEC_HPMIX_REG, 289 }, 290 .mask = { 291 [AUDIO_MIXER_LEVEL_MONO] = HPMIX_LHPMIX_MUTE | HPMIX_RHPMIX_MUTE, 292 } 293 }, 294 }; 295 296 static void 297 escodec_swvol_codec(audio_filter_arg_t *arg) 298 { 299 struct escodec_softc * const sc = arg->context; 300 const aint_t *src; 301 aint_t *dst; 302 u_int sample_count; 303 u_int i; 304 305 src = arg->src; 306 dst = arg->dst; 307 sample_count = arg->count * arg->srcfmt->channels; 308 for (i = 0; i < sample_count; i++) { 309 aint2_t v = (aint2_t)(*src++); 310 v = v * sc->sc_swvol / 255; 311 *dst++ = (aint_t)v; 312 } 313 } 314 315 static const struct escodec_mixer * 316 escodec_get_mixer(u_int index) 317 { 318 if (index >= ESCODEC_MIXER_CTRL_LAST) 319 return NULL; 320 321 return &escodec_mixers[index]; 322 } 323 324 static int 325 escodec_trigger_output(void *priv, void *start, void *end, int blksize, 326 void (*intr)(void *), void *intarg, const audio_params_t *params) 327 { 328 struct escodec_softc * const sc = priv; 329 uint8_t val; 330 331 escodec_lock(sc); 332 333 /* Enable HP output */ 334 val = HPOUTEN_EN_HPL | HPOUTEN_EN_HPR | 335 HPOUTEN_HPL_OUTEN | HPOUTEN_HPR_OUTEN; 336 escodec_write(sc, ESCODEC_HPOUTEN_REG, val); 337 338 escodec_unlock(sc); 339 340 return 0; 341 } 342 343 static int 344 escodec_halt_output(void *priv) 345 { 346 struct escodec_softc * const sc = priv; 347 348 escodec_lock(sc); 349 350 /* Disable HP output */ 351 escodec_write(sc, ESCODEC_HPOUTEN_REG, 0); 352 353 escodec_unlock(sc); 354 355 return 0; 356 } 357 358 static int 359 escodec_set_format(void *priv, int setmode, 360 const audio_params_t *play, const audio_params_t *rec, 361 audio_filter_reg_t *pfil, audio_filter_reg_t *rfil) 362 { 363 struct escodec_softc * const sc = priv; 364 365 pfil->codec = escodec_swvol_codec; 366 pfil->context = sc; 367 368 return 0; 369 } 370 371 static int 372 escodec_set_port(void *priv, mixer_ctrl_t *mc) 373 { 374 struct escodec_softc * const sc = priv; 375 const struct escodec_mixer *mix; 376 int nvol, shift, ch; 377 uint8_t val; 378 379 if ((mix = escodec_get_mixer(mc->dev)) == NULL) 380 return ENXIO; 381 382 switch (mix->type) { 383 case ESCODEC_MIXER_SWVOL: 384 sc->sc_swvol = mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]; 385 return 0; 386 387 case ESCODEC_MIXER_AMPLIFIER: 388 case ESCODEC_MIXER_ATTENUATOR: 389 escodec_lock(sc); 390 for (ch = 0; ch < 2; ch++) { 391 val = escodec_read(sc, mix->reg[ch]); 392 shift = 8 - fls32(__SHIFTOUT_MASK(mix->mask[ch])); 393 nvol = mc->un.value.level[ch] >> shift; 394 if (mix->type == ESCODEC_MIXER_ATTENUATOR) 395 nvol = __SHIFTOUT_MASK(mix->mask[ch]) - nvol; 396 if (mix->maxval != 0 && nvol > mix->maxval) 397 nvol = mix->maxval; 398 399 val &= ~mix->mask[ch]; 400 val |= __SHIFTIN(nvol, mix->mask[ch]); 401 escodec_write(sc, mix->reg[ch], val); 402 } 403 escodec_unlock(sc); 404 return 0; 405 406 case ESCODEC_MIXER_MUTE: 407 if (mc->un.ord < 0 || mc->un.ord > 1) 408 return EINVAL; 409 escodec_lock(sc); 410 val = escodec_read(sc, mix->reg[0]); 411 if (mc->un.ord) 412 val |= mix->mask[0]; 413 else 414 val &= ~mix->mask[0]; 415 escodec_write(sc, mix->reg[0], val); 416 escodec_unlock(sc); 417 return 0; 418 419 default: 420 return ENXIO; 421 } 422 } 423 424 static int 425 escodec_get_port(void *priv, mixer_ctrl_t *mc) 426 { 427 struct escodec_softc * const sc = priv; 428 const struct escodec_mixer *mix; 429 int nvol, shift, ch; 430 uint8_t val; 431 432 if ((mix = escodec_get_mixer(mc->dev)) == NULL) 433 return ENXIO; 434 435 switch (mix->type) { 436 case ESCODEC_MIXER_SWVOL: 437 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = sc->sc_swvol; 438 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = sc->sc_swvol; 439 return 0; 440 441 case ESCODEC_MIXER_AMPLIFIER: 442 case ESCODEC_MIXER_ATTENUATOR: 443 escodec_lock(sc); 444 for (ch = 0; ch < 2; ch++) { 445 val = escodec_read(sc, mix->reg[ch]); 446 shift = 8 - fls32(__SHIFTOUT_MASK(mix->mask[ch])); 447 nvol = __SHIFTOUT(val, mix->mask[ch]); 448 if (mix->type == ESCODEC_MIXER_ATTENUATOR) 449 nvol = __SHIFTOUT_MASK(mix->mask[ch]) - nvol; 450 nvol <<= shift; 451 mc->un.value.level[ch] = nvol; 452 } 453 escodec_unlock(sc); 454 return 0; 455 456 case ESCODEC_MIXER_MUTE: 457 escodec_lock(sc); 458 val = escodec_read(sc, mix->reg[0]); 459 mc->un.ord = (val & mix->mask[0]) != 0; 460 escodec_unlock(sc); 461 return 0; 462 463 default: 464 return ENXIO; 465 } 466 } 467 468 static int 469 escodec_query_devinfo(void *priv, mixer_devinfo_t *di) 470 { 471 const struct escodec_mixer *mix; 472 473 if ((mix = escodec_get_mixer(di->index)) == NULL) 474 return ENXIO; 475 476 strcpy(di->label.name, mix->name); 477 di->mixer_class = mix->mixer_class; 478 di->next = mix->next; 479 di->prev = mix->prev; 480 481 switch (mix->type) { 482 case ESCODEC_MIXER_CLASS: 483 di->type = AUDIO_MIXER_CLASS; 484 return 0; 485 486 case ESCODEC_MIXER_SWVOL: 487 di->type = AUDIO_MIXER_VALUE; 488 di->un.v.delta = 1; 489 di->un.v.num_channels = 2; 490 strcpy(di->un.v.units.name, AudioNvolume); 491 return 0; 492 493 case ESCODEC_MIXER_AMPLIFIER: 494 case ESCODEC_MIXER_ATTENUATOR: 495 di->type = AUDIO_MIXER_VALUE; 496 di->un.v.delta = 497 256 / (__SHIFTOUT_MASK(mix->mask[0]) + 1); 498 di->un.v.num_channels = 2; 499 strcpy(di->un.v.units.name, AudioNvolume); 500 return 0; 501 502 case ESCODEC_MIXER_MUTE: 503 di->type = AUDIO_MIXER_ENUM; 504 di->un.e.num_mem = 2; 505 strcpy(di->un.e.member[0].label.name, AudioNoff); 506 di->un.e.member[0].ord = 0; 507 strcpy(di->un.e.member[1].label.name, AudioNon); 508 di->un.e.member[1].ord = 1; 509 return 0; 510 511 default: 512 return ENXIO; 513 } 514 } 515 516 static const struct audio_hw_if escodec_hw_if = { 517 .trigger_output = escodec_trigger_output, 518 .halt_output = escodec_halt_output, 519 .set_format = escodec_set_format, 520 .set_port = escodec_set_port, 521 .get_port = escodec_get_port, 522 .query_devinfo = escodec_query_devinfo, 523 }; 524 525 static int 526 escodec_dai_set_sysclk(audio_dai_tag_t dai, u_int rate, int dir) 527 { 528 struct escodec_softc * const sc = audio_dai_private(dai); 529 int error; 530 531 error = clk_set_rate(sc->sc_clk, rate); 532 if (error != 0) 533 return error; 534 535 return 0; 536 } 537 538 static int 539 escodec_dai_set_format(audio_dai_tag_t dai, u_int format) 540 { 541 struct escodec_softc * const sc = audio_dai_private(dai); 542 uint8_t sd_clk, sd_fmt, val; 543 544 const u_int fmt = __SHIFTOUT(format, AUDIO_DAI_FORMAT_MASK); 545 const u_int clk = __SHIFTOUT(format, AUDIO_DAI_CLOCK_MASK); 546 const u_int pol = __SHIFTOUT(format, AUDIO_DAI_POLARITY_MASK); 547 548 if (fmt != AUDIO_DAI_FORMAT_I2S) 549 return EINVAL; 550 551 if (clk != AUDIO_DAI_CLOCK_CBS_CFS) 552 return EINVAL; 553 554 switch (pol) { 555 case AUDIO_DAI_POLARITY_NB_NF: 556 sd_clk = 0; 557 sd_fmt = 0; 558 break; 559 case AUDIO_DAI_POLARITY_NB_IF: 560 sd_clk = 0; 561 sd_fmt = SD_FMT_LRP; 562 break; 563 case AUDIO_DAI_POLARITY_IB_NF: 564 sd_clk = SD_CLK_BCLK_INV; 565 sd_fmt = 0; 566 break; 567 case AUDIO_DAI_POLARITY_IB_IF: 568 sd_clk = SD_CLK_BCLK_INV; 569 sd_fmt = SD_FMT_LRP; 570 break; 571 } 572 573 escodec_lock(sc); 574 575 val = escodec_read(sc, ESCODEC_SD_CLK_REG); 576 val &= ~(SD_CLK_MSC|SD_CLK_BCLK_INV); 577 val |= sd_clk; 578 escodec_write(sc, ESCODEC_SD_CLK_REG, val); 579 580 val = escodec_read(sc, ESCODEC_SD_ADC_REG); 581 val &= ~SD_FMT_MASK; 582 val |= __SHIFTIN(SD_FMT_I2S, SD_FMT_MASK); 583 val &= ~SD_FMT_LRP; 584 val |= sd_fmt; 585 escodec_write(sc, ESCODEC_SD_ADC_REG, val); 586 587 val = escodec_read(sc, ESCODEC_SD_DAC_REG); 588 val &= ~SD_FMT_MASK; 589 val |= __SHIFTIN(SD_FMT_I2S, SD_FMT_MASK); 590 val &= ~SD_FMT_LRP; 591 val |= sd_fmt; 592 escodec_write(sc, ESCODEC_SD_DAC_REG, val); 593 594 val = escodec_read(sc, ESCODEC_CLKMAN1_REG); 595 val |= CLKMAN1_MCLK_ON; 596 val |= CLKMAN1_BCLK_ON; 597 val |= CLKMAN1_CLK_CP_ON; 598 val |= CLKMAN1_CLK_DAC_ON; 599 val |= CLKMAN1_ANACLK_DAC_ON; 600 escodec_write(sc, ESCODEC_CLKMAN1_REG, val); 601 602 escodec_unlock(sc); 603 604 return 0; 605 } 606 607 static int 608 escodec_dai_add_device(audio_dai_tag_t dai, audio_dai_tag_t aux) 609 { 610 struct escodec_softc * const sc = audio_dai_private(dai); 611 612 if (sc->sc_amplifier != NULL) 613 return 0; 614 615 sc->sc_amplifier = aux; 616 617 return 0; 618 } 619 620 static audio_dai_tag_t 621 escodec_dai_get_tag(device_t dev, const void *data, size_t len) 622 { 623 struct escodec_softc * const sc = device_private(dev); 624 625 if (len != 4) 626 return NULL; 627 628 return &sc->sc_dai; 629 } 630 631 static struct fdtbus_dai_controller_func escodec_dai_funcs = { 632 .get_tag = escodec_dai_get_tag 633 }; 634 635 static void 636 escodec_init(struct escodec_softc *sc) 637 { 638 uint8_t val; 639 640 escodec_lock(sc); 641 642 escodec_write(sc, ESCODEC_RESET_REG, RESET_ALL); 643 delay(5000); 644 escodec_write(sc, ESCODEC_RESET_REG, RESET_CSM_ON); 645 delay(30000); 646 647 escodec_write(sc, ESCODEC_VMID_REG, 0xff); 648 escodec_write(sc, ESCODEC_ADC_OSR_REG, 0x32); 649 650 val = escodec_read(sc, ESCODEC_SD_ADC_REG); 651 val &= ~SD_FMT_WL; 652 val |= __SHIFTIN(SD_FMT_WL_16, SD_FMT_WL); 653 escodec_write(sc, ESCODEC_SD_ADC_REG, val); 654 655 val = escodec_read(sc, ESCODEC_SD_DAC_REG); 656 val &= ~SD_FMT_WL; 657 val |= __SHIFTIN(SD_FMT_WL_16, SD_FMT_WL); 658 escodec_write(sc, ESCODEC_SD_DAC_REG, val); 659 660 /* Power up */ 661 escodec_write(sc, ESCODEC_PDN_REG, 0); 662 663 /* Route DAC signal to HP mixer */ 664 val = HPMIXRT_LD2LHPMIX | HPMIXRT_RD2RHPMIX; 665 escodec_write(sc, ESCODEC_HPMIXRT_REG, val); 666 667 /* Power up DAC */ 668 escodec_write(sc, ESCODEC_DACPWR_REG, 0); 669 670 /* Power up HP mixer and unmute */ 671 escodec_write(sc, ESCODEC_HPMIX_REG, 0); 672 673 /* Power up HP output driver */ 674 val = escodec_read(sc, ESCODEC_HPPWR_REG); 675 val &= ~HPPWR_PDN_CPHP; 676 escodec_write(sc, ESCODEC_HPPWR_REG, val); 677 678 /* Power up HP charge pump circuits */ 679 val = escodec_read(sc, ESCODEC_CPPWR_REG); 680 val &= ~CPPWR_PDN_CP; 681 escodec_write(sc, ESCODEC_CPPWR_REG, val); 682 683 /* Set LIN1/RIN1 as inputs for HP mixer */ 684 escodec_write(sc, ESCODEC_HPSEL_REG, 0); 685 686 /* Power up HP output driver calibration */ 687 val = escodec_read(sc, ESCODEC_HPVOL_REG); 688 val &= ~HPVOL_PDN_LICAL; 689 val &= ~HPVOL_PDN_RICAL; 690 escodec_write(sc, ESCODEC_HPVOL_REG, val); 691 692 /* Set headphone mixer to -6dB */ 693 escodec_write(sc, ESCODEC_HPMIXVOL_REG, 0x44); 694 695 /* Set charge pump headphone to -48dB */ 696 escodec_write(sc, ESCODEC_HPVOL_REG, 0x33); 697 698 /* Set DAC to 0dB */ 699 escodec_write(sc, ESCODEC_DACVOL_L_REG, 0); 700 escodec_write(sc, ESCODEC_DACVOL_R_REG, 0); 701 702 escodec_unlock(sc); 703 } 704 705 static int 706 escodec_match(device_t parent, cfdata_t match, void *aux) 707 { 708 struct i2c_attach_args *ia = aux; 709 int match_result; 710 711 if (iic_use_direct_match(ia, match, compat_data, &match_result)) 712 return match_result; 713 714 /* This device is direct-config only */ 715 716 return 0; 717 } 718 719 static void 720 escodec_attach(device_t parent, device_t self, void *aux) 721 { 722 struct escodec_softc * const sc = device_private(self); 723 struct i2c_attach_args * const ia = aux; 724 const int phandle = ia->ia_cookie; 725 726 sc->sc_dev = self; 727 sc->sc_i2c = ia->ia_tag; 728 sc->sc_addr = ia->ia_addr; 729 sc->sc_phandle = ia->ia_cookie; 730 sc->sc_swvol = 0xff; 731 732 sc->sc_clk = fdtbus_clock_get(phandle, "mclk"); 733 if (sc->sc_clk == NULL || clk_enable(sc->sc_clk) != 0) { 734 aprint_error(": couldn't enable mclk\n"); 735 return; 736 } 737 738 aprint_naive("\n"); 739 aprint_normal(": Everest Semi ES8316 Audio CODEC\n"); 740 741 escodec_init(sc); 742 743 sc->sc_dai.dai_set_sysclk = escodec_dai_set_sysclk; 744 sc->sc_dai.dai_set_format = escodec_dai_set_format; 745 sc->sc_dai.dai_add_device = escodec_dai_add_device; 746 sc->sc_dai.dai_hw_if = &escodec_hw_if; 747 sc->sc_dai.dai_dev = self; 748 sc->sc_dai.dai_priv = sc; 749 fdtbus_register_dai_controller(self, phandle, &escodec_dai_funcs); 750 } 751 752 CFATTACH_DECL_NEW(es8316ac, sizeof(struct escodec_softc), 753 escodec_match, escodec_attach, NULL, NULL); 754
Indexes created Sat Oct 18 17:09:52 GMT 2025