wm8750_zaudio.c revision 1.2.4.1
1 /* $NetBSD: wm8750_zaudio.c,v 1.2.4.1 2019/04/21 05:11:22 isaki Exp $ */ 2 /* $OpenBSD: zaurus_audio.c,v 1.8 2005/08/18 13:23:02 robert Exp $ */ 3 4 /* 5 * Copyright (c) 2005 Christopher Pascoe <pascoe (at) openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 /*- 21 * Copyright (C) 2009 NONAKA Kimihiro <nonaka (at) netbsd.org> 22 * All rights reserved. 23 * 24 * Redistribution and use in source and binary forms, with or without 25 * modification, are permitted provided that the following conditions 26 * are met: 27 * 1. Redistributions of source code must retain the above copyright 28 * notice, this list of conditions and the following disclaimer. 29 * 2. Redistributions in binary form must reproduce the above copyright 30 * notice, this list of conditions and the following disclaimer in the 31 * documentation and/or other materials provided with the distribution. 32 * 33 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 34 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 35 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 36 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 37 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 38 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 39 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 40 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 41 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 42 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 43 */ 44 45 /* 46 * TODO: 47 * - powerhooks (currently only works until first suspend) 48 */ 49 50 #include "opt_cputypes.h" 51 #include "opt_zaudio.h" 52 53 #include <sys/cdefs.h> 54 __KERNEL_RCSID(0, "$NetBSD: wm8750_zaudio.c,v 1.2.4.1 2019/04/21 05:11:22 isaki Exp $"); 55 56 #include <sys/param.h> 57 #include <sys/systm.h> 58 #include <sys/callout.h> 59 #include <sys/device.h> 60 #include <sys/kmem.h> 61 #include <sys/kernel.h> 62 #include <sys/audioio.h> 63 #include <sys/mutex.h> 64 #include <sys/intr.h> 65 #include <sys/bus.h> 66 67 #include <dev/audio_if.h> 68 #include <dev/mulaw.h> 69 #include <dev/auconv.h> 70 71 #include <dev/i2c/i2cvar.h> 72 73 #include <arm/xscale/pxa2x0reg.h> 74 #include <arm/xscale/pxa2x0var.h> 75 #include <arm/xscale/pxa2x0_i2c.h> 76 #include <arm/xscale/pxa2x0_i2s.h> 77 #include <arm/xscale/pxa2x0_dmac.h> 78 #include <arm/xscale/pxa2x0_gpio.h> 79 80 #include <zaurus/zaurus/zaurus_var.h> 81 #include <zaurus/dev/zaudiovar.h> 82 #include <zaurus/dev/wm8750reg.h> 83 #include <zaurus/dev/wm8750var.h> 84 #include <zaurus/dev/scoopvar.h> 85 #include <zaurus/dev/ioexpvar.h> 86 87 #define WM8750_ADDRESS 0x1B 88 89 /* GPIO pins */ 90 #define GPIO_HP_IN_C3000 116 91 92 #define WM8750_OP_SPKR 0 93 #define WM8750_OP_HP 1 94 #define WM8750_OP_MIC 2 95 #define WM8750_OP_NUM 3 96 97 #define ZAUDIO_JACK_STATE_OUT 0 98 #define ZAUDIO_JACK_STATE_IN 1 99 #define ZAUDIO_JACK_STATE_INS 2 100 #define ZAUDIO_JACK_STATE_REM 3 101 102 static int wm8750_finalize(device_t); 103 static bool wm8750_suspend(device_t, const pmf_qual_t *); 104 static bool wm8750_resume(device_t, const pmf_qual_t *); 105 static void wm8750_volume_up(device_t); 106 static void wm8750_volume_down(device_t); 107 static void wm8750_volume_toggle(device_t); 108 109 static struct audio_device wm8750_device = { 110 "WM8750", 111 "1.0", 112 "wm" 113 }; 114 115 #define WM8750_FORMAT(enc, prec, ch, chmask) \ 116 { \ 117 .mode = AUMODE_PLAY | AUMODE_RECORD, \ 118 .encoding = (enc), \ 119 .validbits = (prec), \ 120 .precision = (prec), \ 121 .channels = (ch), \ 122 .channel_mask = (chmask), \ 123 .frequency_type = 0, \ 124 .frequency = { 4000, 48000 }, \ 125 } 126 static const struct audio_format wm8750_formats[] = { 127 WM8750_FORMAT(AUDIO_ENCODING_SLINEAR_LE, 16, 2, AUFMT_STEREO), 128 WM8750_FORMAT(AUDIO_ENCODING_SLINEAR_LE, 16, 1, AUFMT_MONAURAL), 129 WM8750_FORMAT(AUDIO_ENCODING_ULINEAR_LE, 8, 2, AUFMT_STEREO), 130 WM8750_FORMAT(AUDIO_ENCODING_ULINEAR_LE, 8, 1, AUFMT_MONAURAL), 131 }; 132 static const int wm8750_nformats = (int)__arraycount(wm8750_formats); 133 134 static void wm8750_init(struct zaudio_softc *); 135 static int wm8750_jack_intr(void *); 136 static void wm8750_jack(void *); 137 static void wm8750_standby(struct zaudio_softc *); 138 static void wm8750_update_volume(struct zaudio_softc *, int); 139 static void wm8750_update_mutes(struct zaudio_softc *, int); 140 static void wm8750_play_setup(struct zaudio_softc *); 141 /*static*/ void wm8750_record_setup(struct zaudio_softc *); 142 static int wm8750_query_encoding(void *, struct audio_encoding *); 143 static int wm8750_set_params(void *, int, int, audio_params_t *, 144 audio_params_t *, stream_filter_list_t *, stream_filter_list_t *); 145 static int wm8750_start_output(void *, void *, int, void (*)(void *), void *); 146 static int wm8750_start_input(void *, void *, int, void (*)(void *), void *); 147 static int wm8750_halt_output(void *); 148 static int wm8750_halt_input(void *); 149 static int wm8750_getdev(void *, struct audio_device *); 150 static int wm8750_set_port(void *, struct mixer_ctrl *); 151 static int wm8750_get_port(void *, struct mixer_ctrl *); 152 static int wm8750_query_devinfo(void *, struct mixer_devinfo *); 153 154 static struct audio_hw_if wm8750_hw_if = { 155 .open = zaudio_open, 156 .close = zaudio_close, 157 .drain = NULL, 158 .query_encoding = wm8750_query_encoding, 159 .set_params = wm8750_set_params, 160 .round_blocksize = zaudio_round_blocksize, 161 .commit_settings = NULL, 162 .init_output = NULL, 163 .init_input = NULL, 164 .start_output = wm8750_start_output, 165 .start_input = wm8750_start_input, 166 .halt_output = wm8750_halt_output, 167 .halt_input = wm8750_halt_input, 168 .speaker_ctl = NULL, 169 .getdev = wm8750_getdev, 170 .setfd = NULL, 171 .set_port = wm8750_set_port, 172 .get_port = wm8750_get_port, 173 .query_devinfo = wm8750_query_devinfo, 174 .allocm = zaudio_allocm, 175 .freem = zaudio_freem, 176 .round_buffersize = zaudio_round_buffersize, 177 .mappage = zaudio_mappage, 178 .get_props = zaudio_get_props, 179 .trigger_output = NULL, 180 .trigger_input = NULL, 181 .dev_ioctl = NULL, 182 .get_locks = zaudio_get_locks, 183 }; 184 185 static const uint16_t playback_regs[][2] = { 186 /* Unmute DAC */ 187 { ADCDACCTL_REG, 0x000 }, 188 189 /* 16 bit audio words */ 190 { AUDINT_REG, AUDINT_SET_FORMAT(2) }, 191 192 /* Enable thermal protection, power */ 193 { ADCTL1_REG, ADCTL1_TSDEN | ADCTL1_SET_VSEL(3) }, 194 195 /* Enable speaker driver, DAC oversampling */ 196 { ADCTL2_REG, ADCTL2_ROUT2INV | ADCTL2_DACOSR }, 197 198 /* Set DAC voltage references */ 199 { PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(1) | PWRMGMT1_VREF }, 200 201 /* Direct DACs to output mixers */ 202 { LOUTMIX1_REG, LOUTMIX1_LD2LO }, 203 { LOUTMIX2_REG, 0x000 }, 204 { ROUTMIX1_REG, 0x000 }, 205 { ROUTMIX2_REG, ROUTMIX2_RD2RO }, 206 207 /* End of list */ 208 { 0xffff, 0xffff } 209 }; 210 211 static const uint16_t record_regs[][2] = { 212 /* Unmute DAC */ 213 { ADCDACCTL_REG, 0x000 }, 214 215 /* 16 bit audio words */ 216 { AUDINT_REG, AUDINT_SET_FORMAT(2) }, 217 218 /* Enable thermal protection, power, left DAC for both channel */ 219 { ADCTL1_REG, ADCTL1_TSDEN | ADCTL1_SET_VSEL(3) 220 | ADCTL1_SET_DATSEL(1) }, 221 222 /* Diffrential input select: LINPUT1-RINPUT1, stereo */ 223 { ADCINPMODE_REG, 0x000 }, 224 225 /* L-R differential, micboost 20dB */ 226 { ADCLSPATH_REG, ADCLSPATH_SET_LINSEL(3) | ADCLSPATH_SET_LMICBOOST(2) }, 227 { ADCRSPATH_REG, ADCRSPATH_SET_RINSEL(3) | ADCRSPATH_SET_RMICBOOST(2) }, 228 229 /* End of list */ 230 { 0xffff, 0xffff } 231 }; 232 233 static __inline int 234 wm8750_write(struct zaudio_softc *sc, int reg, int val) 235 { 236 uint16_t tmp; 237 uint8_t cmd; 238 uint8_t data; 239 240 tmp = (reg << 9) | (val & 0x1ff); 241 cmd = tmp >> 8; 242 data = tmp; 243 return iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, WM8750_ADDRESS, 244 &cmd, 1, &data, 1, 0); 245 } 246 247 int 248 wm8750_match(device_t parent, cfdata_t cf, struct i2c_attach_args *ia) 249 { 250 int match_result; 251 252 if (ZAURUS_ISC860) 253 return 0; 254 255 if (iic_use_direct_match(ia, cf, NULL, &match_result)) 256 return match_result; 257 258 /* indirect config - check typical address */ 259 if (ia->ia_addr == WM8750_ADDRESS) 260 return I2C_MATCH_ADDRESS_ONLY; 261 262 return 0; 263 } 264 265 void 266 wm8750_attach(device_t parent, device_t self, struct i2c_attach_args *ia) 267 { 268 struct zaudio_softc *sc = device_private(self); 269 int error; 270 271 aprint_normal(": I2S, WM8750 Audio\n"); 272 aprint_naive("\n"); 273 274 /* Check for an I2C response from the wm8750 */ 275 iic_acquire_bus(sc->sc_i2c, 0); 276 error = wm8750_write(sc, RESET_REG, 0); 277 iic_release_bus(sc->sc_i2c, 0); 278 if (error) { 279 aprint_error_dev(self, "codec failed to respond\n"); 280 goto fail_i2c; 281 } 282 delay(100); 283 284 /* Allocate memory for volume & mute operations */ 285 sc->sc_volume = kmem_zalloc(sizeof(*sc->sc_volume) * WM8750_OP_NUM, 286 KM_SLEEP); 287 sc->sc_unmute = kmem_zalloc(sizeof(*sc->sc_unmute) * WM8750_OP_NUM, 288 KM_SLEEP); 289 sc->sc_unmute_toggle = kmem_zalloc( 290 sizeof(*sc->sc_unmute_toggle) * WM8750_OP_NUM, KM_SLEEP); 291 292 /* Speaker on, headphones off by default. */ 293 sc->sc_volume[WM8750_OP_SPKR].left = 180; 294 sc->sc_jack = FALSE; 295 UNMUTE(sc, WM8750_OP_SPKR, 1); 296 sc->sc_volume[WM8750_OP_HP].left = 180; 297 sc->sc_volume[WM8750_OP_HP].right = 180; 298 UNMUTE(sc, WM8750_OP_HP, 0); 299 sc->sc_volume[WM8750_OP_MIC].left = 180; 300 UNMUTE(sc, WM8750_OP_MIC, 0); 301 302 /* Configure headphone jack state change handling. */ 303 callout_setfunc(&sc->sc_to, wm8750_jack, sc); 304 pxa2x0_gpio_set_function(GPIO_HP_IN_C3000, GPIO_IN); 305 (void) pxa2x0_gpio_intr_establish(GPIO_HP_IN_C3000, IST_EDGE_BOTH, 306 IPL_BIO, wm8750_jack_intr, sc); 307 308 /* wm8750_init() implicitly depends on ioexp or scoop */ 309 config_finalize_register(self, wm8750_finalize); 310 311 audio_attach_mi(&wm8750_hw_if, sc, self); 312 313 if (!pmf_device_register(self, wm8750_suspend, wm8750_resume)) 314 aprint_error_dev(self, "couldn't establish power handler\n"); 315 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_UP, 316 wm8750_volume_up, true)) 317 aprint_error_dev(self, "couldn't register event handler\n"); 318 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_DOWN, 319 wm8750_volume_down, true)) 320 aprint_error_dev(self, "couldn't register event handler\n"); 321 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_TOGGLE, 322 wm8750_volume_toggle, true)) 323 aprint_error_dev(self, "couldn't register event handler\n"); 324 325 return; 326 327 fail_i2c: 328 pxa2x0_i2s_detach_sub(&sc->sc_i2s); 329 } 330 331 static int 332 wm8750_finalize(device_t dv) 333 { 334 struct zaudio_softc *sc = device_private(dv); 335 336 wm8750_init(sc); 337 return 0; 338 } 339 340 static bool 341 wm8750_suspend(device_t dv, const pmf_qual_t *qual) 342 { 343 struct zaudio_softc *sc = device_private(dv); 344 345 callout_stop(&sc->sc_to); 346 wm8750_standby(sc); 347 348 return true; 349 } 350 351 static bool 352 wm8750_resume(device_t dv, const pmf_qual_t *qual) 353 { 354 struct zaudio_softc *sc = device_private(dv); 355 356 pxa2x0_i2s_init(&sc->sc_i2s); 357 wm8750_init(sc); 358 359 return true; 360 } 361 362 static __inline uint8_t 363 vol_sadd(int vol, int stride) 364 { 365 366 vol += stride; 367 if (vol > 255) 368 return 255; 369 return (uint8_t)vol; 370 } 371 372 #ifndef ZAUDIO_VOLUME_STRIDE 373 #define ZAUDIO_VOLUME_STRIDE 8 374 #endif 375 376 static void 377 wm8750_volume_up(device_t dv) 378 { 379 struct zaudio_softc *sc = device_private(dv); 380 int s; 381 382 s = splbio(); 383 iic_acquire_bus(sc->sc_i2c, 0); 384 385 sc->sc_volume[WM8750_OP_SPKR].left = 386 vol_sadd(sc->sc_volume[WM8750_OP_SPKR].left, ZAUDIO_VOLUME_STRIDE); 387 sc->sc_volume[WM8750_OP_HP].left = 388 vol_sadd(sc->sc_volume[WM8750_OP_HP].left, ZAUDIO_VOLUME_STRIDE); 389 sc->sc_volume[WM8750_OP_HP].right = 390 vol_sadd(sc->sc_volume[WM8750_OP_HP].right, ZAUDIO_VOLUME_STRIDE); 391 392 wm8750_update_volume(sc, WM8750_OP_SPKR); 393 wm8750_update_volume(sc, WM8750_OP_HP); 394 395 iic_release_bus(sc->sc_i2c, 0); 396 splx(s); 397 } 398 399 static __inline uint8_t 400 vol_ssub(int vol, int stride) 401 { 402 403 vol -= stride; 404 if (vol < 0) 405 return 0; 406 return (uint8_t)vol; 407 } 408 409 static void 410 wm8750_volume_down(device_t dv) 411 { 412 struct zaudio_softc *sc = device_private(dv); 413 int s; 414 415 s = splbio(); 416 iic_acquire_bus(sc->sc_i2c, 0); 417 418 sc->sc_volume[WM8750_OP_SPKR].left = 419 vol_ssub(sc->sc_volume[WM8750_OP_SPKR].left, ZAUDIO_VOLUME_STRIDE); 420 sc->sc_volume[WM8750_OP_HP].left = 421 vol_ssub(sc->sc_volume[WM8750_OP_HP].left, ZAUDIO_VOLUME_STRIDE); 422 sc->sc_volume[WM8750_OP_HP].right = 423 vol_ssub(sc->sc_volume[WM8750_OP_HP].right, ZAUDIO_VOLUME_STRIDE); 424 425 wm8750_update_volume(sc, WM8750_OP_SPKR); 426 wm8750_update_volume(sc, WM8750_OP_HP); 427 428 iic_release_bus(sc->sc_i2c, 0); 429 splx(s); 430 } 431 432 static void 433 wm8750_volume_toggle(device_t dv) 434 { 435 struct zaudio_softc *sc = device_private(dv); 436 int s; 437 438 s = splbio(); 439 iic_acquire_bus(sc->sc_i2c, 0); 440 441 if (!sc->sc_unmute[WM8750_OP_SPKR] && !sc->sc_unmute[WM8750_OP_HP]) { 442 sc->sc_unmute[WM8750_OP_SPKR] = 443 sc->sc_unmute_toggle[WM8750_OP_SPKR]; 444 sc->sc_unmute[WM8750_OP_HP] = 445 sc->sc_unmute_toggle[WM8750_OP_HP]; 446 } else { 447 sc->sc_unmute[WM8750_OP_SPKR] = 0; 448 sc->sc_unmute[WM8750_OP_HP] = 0; 449 } 450 wm8750_update_mutes(sc, 1); 451 452 iic_release_bus(sc->sc_i2c, 0); 453 splx(s); 454 } 455 456 static void 457 wm8750_init(struct zaudio_softc *sc) 458 { 459 460 iic_acquire_bus(sc->sc_i2c, 0); 461 462 /* Reset the codec */ 463 wm8750_write(sc, RESET_REG, 0); 464 delay(100); 465 466 /* Switch to standby power only */ 467 wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2)); 468 wm8750_write(sc, PWRMGMT2_REG, 0); 469 470 /* Configure digital interface for I2S */ 471 wm8750_write(sc, AUDINT_REG, AUDINT_SET_FORMAT(2)); 472 473 /* Initialise volume levels */ 474 wm8750_update_volume(sc, WM8750_OP_SPKR); 475 wm8750_update_volume(sc, WM8750_OP_HP); 476 wm8750_update_volume(sc, WM8750_OP_MIC); 477 478 scoop_set_headphone(0); 479 if (ZAURUS_ISC1000) 480 ioexp_set_mic_bias(0); 481 else 482 scoop_set_mic_bias(0); 483 484 iic_release_bus(sc->sc_i2c, 0); 485 486 /* Assume that the jack state has changed. */ 487 wm8750_jack(sc); 488 } 489 490 static int 491 wm8750_jack_intr(void *v) 492 { 493 struct zaudio_softc *sc = v; 494 495 if (!callout_active(&sc->sc_to)) 496 wm8750_jack(sc); 497 498 return 1; 499 } 500 501 static void 502 wm8750_jack(void *v) 503 { 504 struct zaudio_softc *sc = v; 505 506 switch (sc->sc_state) { 507 case ZAUDIO_JACK_STATE_OUT: 508 if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 509 sc->sc_state = ZAUDIO_JACK_STATE_INS; 510 sc->sc_icount = 0; 511 } 512 break; 513 514 case ZAUDIO_JACK_STATE_INS: 515 if (sc->sc_icount++ > 2) { 516 if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 517 sc->sc_state = ZAUDIO_JACK_STATE_IN; 518 sc->sc_jack = TRUE; 519 UNMUTE(sc, WM8750_OP_SPKR, 0); 520 UNMUTE(sc, WM8750_OP_HP, 1); 521 UNMUTE(sc, WM8750_OP_MIC, 1); 522 goto update_mutes; 523 } else 524 sc->sc_state = ZAUDIO_JACK_STATE_OUT; 525 } 526 break; 527 528 case ZAUDIO_JACK_STATE_IN: 529 if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 530 sc->sc_state = ZAUDIO_JACK_STATE_REM; 531 sc->sc_icount = 0; 532 } 533 break; 534 535 case ZAUDIO_JACK_STATE_REM: 536 if (sc->sc_icount++ > 2) { 537 if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 538 sc->sc_state = ZAUDIO_JACK_STATE_OUT; 539 sc->sc_jack = FALSE; 540 UNMUTE(sc, WM8750_OP_SPKR, 1); 541 UNMUTE(sc, WM8750_OP_HP, 0); 542 UNMUTE(sc, WM8750_OP_MIC, 0); 543 goto update_mutes; 544 } else 545 sc->sc_state = ZAUDIO_JACK_STATE_IN; 546 } 547 break; 548 } 549 550 callout_schedule(&sc->sc_to, hz/4); 551 552 return; 553 554 update_mutes: 555 callout_stop(&sc->sc_to); 556 557 if (sc->sc_playing || sc->sc_recording) { 558 iic_acquire_bus(sc->sc_i2c, 0); 559 if (sc->sc_playing) 560 wm8750_update_mutes(sc, 1); 561 if (sc->sc_recording) 562 wm8750_update_mutes(sc, 2); 563 iic_release_bus(sc->sc_i2c, 0); 564 } 565 } 566 567 static void 568 wm8750_standby(struct zaudio_softc *sc) 569 { 570 571 iic_acquire_bus(sc->sc_i2c, 0); 572 573 /* Switch codec to standby power only */ 574 wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2)); 575 wm8750_write(sc, PWRMGMT2_REG, 0); 576 577 scoop_set_headphone(0); 578 if (ZAURUS_ISC1000) 579 ioexp_set_mic_bias(0); 580 else 581 scoop_set_mic_bias(0); 582 583 iic_release_bus(sc->sc_i2c, 0); 584 } 585 586 static void 587 wm8750_update_volume(struct zaudio_softc *sc, int output) 588 { 589 590 switch (output) { 591 case WM8750_OP_SPKR: 592 wm8750_write(sc, LOUT2VOL_REG, LOUT2VOL_LO2VU | LOUT2VOL_LO2ZC | 593 LOUT2VOL_SET_LOUT2VOL(sc->sc_volume[WM8750_OP_SPKR].left >> 1)); 594 wm8750_write(sc, ROUT2VOL_REG, ROUT2VOL_RO2VU | ROUT2VOL_RO2ZC | 595 ROUT2VOL_SET_ROUT2VOL(sc->sc_volume[WM8750_OP_SPKR].left >> 1)); 596 break; 597 598 case WM8750_OP_HP: 599 wm8750_write(sc, LOUT1VOL_REG, LOUT1VOL_LO1VU | LOUT1VOL_LO1ZC | 600 LOUT1VOL_SET_LOUT1VOL(sc->sc_volume[WM8750_OP_HP].left >> 1)); 601 wm8750_write(sc, ROUT1VOL_REG, ROUT1VOL_RO1VU | ROUT1VOL_RO1ZC | 602 ROUT1VOL_SET_ROUT1VOL(sc->sc_volume[WM8750_OP_HP].right >> 1)); 603 break; 604 605 case WM8750_OP_MIC: 606 wm8750_write(sc, LINVOL_REG, LINVOL_LIVU | 607 LINVOL_SET_LINVOL(sc->sc_volume[WM8750_OP_MIC].left >> 2)); 608 wm8750_write(sc, RINVOL_REG, RINVOL_RIVU | 609 RINVOL_SET_RINVOL(sc->sc_volume[WM8750_OP_MIC].left >> 2)); 610 break; 611 } 612 } 613 614 static void 615 wm8750_update_mutes(struct zaudio_softc *sc, int mask) 616 { 617 uint16_t val; 618 619 /* playback */ 620 if (mask & 1) { 621 val = PWRMGMT2_DACL | PWRMGMT2_DACR; 622 if (sc->sc_unmute[WM8750_OP_SPKR]) 623 val |= PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2; 624 if (sc->sc_unmute[WM8750_OP_HP]) 625 val |= PWRMGMT2_LOUT1 | PWRMGMT2_ROUT1; 626 wm8750_write(sc, PWRMGMT2_REG, val); 627 scoop_set_headphone(sc->sc_unmute[WM8750_OP_HP]); 628 } 629 630 /* record */ 631 if (mask & 2) { 632 val = PWRMGMT1_SET_VMIDSEL(1) | PWRMGMT1_VREF; 633 if (sc->sc_unmute[WM8750_OP_MIC]) { 634 val |= PWRMGMT1_AINL | PWRMGMT1_AINR 635 | PWRMGMT1_ADCL | PWRMGMT1_ADCR | PWRMGMT1_MICB; 636 } 637 wm8750_write(sc, PWRMGMT1_REG, val); 638 if (ZAURUS_ISC1000) 639 ioexp_set_mic_bias(sc->sc_unmute[WM8750_OP_MIC]); 640 else 641 scoop_set_mic_bias(sc->sc_unmute[WM8750_OP_MIC]); 642 } 643 } 644 645 static void 646 wm8750_play_setup(struct zaudio_softc *sc) 647 { 648 int i; 649 650 iic_acquire_bus(sc->sc_i2c, 0); 651 652 /* Program the codec with playback settings */ 653 for (i = 0; playback_regs[i][0] != 0xffff; i++) { 654 wm8750_write(sc, playback_regs[i][0], playback_regs[i][1]); 655 } 656 wm8750_update_mutes(sc, 1); 657 658 iic_release_bus(sc->sc_i2c, 0); 659 } 660 661 /*static*/ void 662 wm8750_record_setup(struct zaudio_softc *sc) 663 { 664 int i; 665 666 iic_acquire_bus(sc->sc_i2c, 0); 667 668 /* Program the codec with playback settings */ 669 for (i = 0; record_regs[i][0] != 0xffff; i++) { 670 wm8750_write(sc, record_regs[i][0], record_regs[i][1]); 671 } 672 wm8750_update_mutes(sc, 2); 673 674 iic_release_bus(sc->sc_i2c, 0); 675 } 676 677 static int 678 wm8750_query_encoding(void *hdl, struct audio_encoding *aep) 679 { 680 681 switch (aep->index) { 682 case 0: 683 strlcpy(aep->name, AudioEulinear, sizeof(aep->name)); 684 aep->encoding = AUDIO_ENCODING_ULINEAR; 685 aep->precision = 8; 686 aep->flags = 0; 687 break; 688 689 case 1: 690 strlcpy(aep->name, AudioEmulaw, sizeof(aep->name)); 691 aep->encoding = AUDIO_ENCODING_ULAW; 692 aep->precision = 8; 693 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 694 break; 695 696 case 2: 697 strlcpy(aep->name, AudioEalaw, sizeof(aep->name)); 698 aep->encoding = AUDIO_ENCODING_ALAW; 699 aep->precision = 8; 700 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 701 break; 702 703 case 3: 704 strlcpy(aep->name, AudioEslinear, sizeof(aep->name)); 705 aep->encoding = AUDIO_ENCODING_SLINEAR; 706 aep->precision = 8; 707 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 708 break; 709 710 case 4: 711 strlcpy(aep->name, AudioEslinear_le, sizeof(aep->name)); 712 aep->encoding = AUDIO_ENCODING_SLINEAR_LE; 713 aep->precision = 16; 714 aep->flags = 0; 715 break; 716 717 case 5: 718 strlcpy(aep->name, AudioEulinear_le, sizeof(aep->name)); 719 aep->encoding = AUDIO_ENCODING_ULINEAR_LE; 720 aep->precision = 16; 721 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 722 break; 723 724 case 6: 725 strlcpy(aep->name, AudioEslinear_be, sizeof(aep->name)); 726 aep->encoding = AUDIO_ENCODING_SLINEAR_BE; 727 aep->precision = 16; 728 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 729 break; 730 731 case 7: 732 strlcpy(aep->name, AudioEulinear_be, sizeof(aep->name)); 733 aep->encoding = AUDIO_ENCODING_ULINEAR_BE; 734 aep->precision = 16; 735 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 736 break; 737 738 default: 739 return EINVAL; 740 } 741 742 return 0; 743 } 744 745 static int 746 wm8750_set_params(void *hdl, int setmode, int usemode, audio_params_t *play, 747 audio_params_t *rec, stream_filter_list_t *pfil, stream_filter_list_t *rfil) 748 { 749 struct zaudio_softc *sc = hdl; 750 struct audio_params *p; 751 stream_filter_list_t *fil; 752 int mode, i; 753 754 if (play->sample_rate != rec->sample_rate && 755 usemode == (AUMODE_PLAY | AUMODE_RECORD)) { 756 if (setmode == AUMODE_PLAY) { 757 rec->sample_rate = play->sample_rate; 758 setmode |= AUMODE_RECORD; 759 } else if (setmode == AUMODE_RECORD) { 760 play->sample_rate = rec->sample_rate; 761 setmode |= AUMODE_PLAY; 762 } else 763 return EINVAL; 764 } 765 766 for (mode = AUMODE_RECORD; mode != -1; 767 mode = (mode == AUMODE_RECORD) ? AUMODE_PLAY : -1) { 768 if ((setmode & mode) == 0) 769 continue; 770 771 p = (mode == AUMODE_PLAY) ? play : rec; 772 773 if (p->sample_rate < 4000 || p->sample_rate > 48000 || 774 (p->precision != 8 && p->precision != 16) || 775 (p->channels != 1 && p->channels != 2)) 776 return EINVAL; 777 778 fil = (mode == AUMODE_PLAY) ? pfil : rfil; 779 i = auconv_set_converter(wm8750_formats, wm8750_nformats, 780 mode, p, false, fil); 781 if (i < 0) 782 return EINVAL; 783 } 784 785 if (setmode == AUMODE_RECORD) 786 pxa2x0_i2s_setspeed(&sc->sc_i2s, &rec->sample_rate); 787 else 788 pxa2x0_i2s_setspeed(&sc->sc_i2s, &play->sample_rate); 789 790 return 0; 791 } 792 793 static int 794 wm8750_halt_output(void *hdl) 795 { 796 struct zaudio_softc *sc = hdl; 797 int rv; 798 799 rv = pxa2x0_i2s_halt_output(&sc->sc_i2s); 800 if (!sc->sc_recording) 801 wm8750_standby(sc); 802 sc->sc_playing = 0; 803 804 return rv; 805 } 806 807 static int 808 wm8750_halt_input(void *hdl) 809 { 810 struct zaudio_softc *sc = hdl; 811 int rv; 812 813 rv = pxa2x0_i2s_halt_input(&sc->sc_i2s); 814 if (!sc->sc_playing) 815 wm8750_standby(sc); 816 sc->sc_recording = 0; 817 818 return rv; 819 } 820 821 static int 822 wm8750_getdev(void *hdl, struct audio_device *ret) 823 { 824 825 *ret = wm8750_device; 826 return 0; 827 } 828 829 #define WM8750_SPKR_LVL 0 830 #define WM8750_SPKR_MUTE 1 831 #define WM8750_HP_LVL 2 832 #define WM8750_HP_MUTE 3 833 #define WM8750_MIC_LVL 4 834 #define WM8750_MIC_MUTE 5 835 #define WM8750_RECORD_SOURCE 6 836 #define WM8750_OUTPUT_CLASS 7 837 #define WM8750_INPUT_CLASS 8 838 #define WM8750_RECORD_CLASS 9 839 840 static int 841 wm8750_set_port(void *hdl, struct mixer_ctrl *mc) 842 { 843 struct zaudio_softc *sc = hdl; 844 int error = EINVAL; 845 int s; 846 847 s = splbio(); 848 iic_acquire_bus(sc->sc_i2c, 0); 849 850 switch (mc->dev) { 851 case WM8750_SPKR_LVL: 852 if (mc->type != AUDIO_MIXER_VALUE) 853 break; 854 if (mc->un.value.num_channels == 1) 855 sc->sc_volume[WM8750_OP_SPKR].left = 856 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 857 else 858 break; 859 wm8750_update_volume(sc, WM8750_OP_SPKR); 860 error = 0; 861 break; 862 863 case WM8750_SPKR_MUTE: 864 if (mc->type != AUDIO_MIXER_ENUM) 865 break; 866 UNMUTE(sc, WM8750_OP_SPKR, mc->un.ord ? 1 : 0); 867 wm8750_update_mutes(sc, 1); 868 error = 0; 869 break; 870 871 case WM8750_HP_LVL: 872 if (mc->type != AUDIO_MIXER_VALUE) 873 break; 874 if (mc->un.value.num_channels == 1) { 875 sc->sc_volume[WM8750_OP_HP].left = 876 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 877 sc->sc_volume[WM8750_OP_HP].right = 878 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 879 } else if (mc->un.value.num_channels == 2) { 880 sc->sc_volume[WM8750_OP_HP].left = 881 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]; 882 sc->sc_volume[WM8750_OP_HP].right = 883 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]; 884 } 885 else 886 break; 887 wm8750_update_volume(sc, WM8750_OP_HP); 888 error = 0; 889 break; 890 891 case WM8750_HP_MUTE: 892 if (mc->type != AUDIO_MIXER_ENUM) 893 break; 894 UNMUTE(sc, WM8750_OP_HP, mc->un.ord ? 1 : 0); 895 wm8750_update_mutes(sc, 1); 896 error = 0; 897 break; 898 899 case WM8750_MIC_LVL: 900 if (mc->type != AUDIO_MIXER_VALUE) 901 break; 902 if (mc->un.value.num_channels == 1) 903 sc->sc_volume[WM8750_OP_MIC].left = 904 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 905 else 906 break; 907 wm8750_update_volume(sc, WM8750_OP_MIC); 908 error = 0; 909 break; 910 911 case WM8750_MIC_MUTE: 912 if (mc->type != AUDIO_MIXER_ENUM) 913 break; 914 UNMUTE(sc, WM8750_OP_MIC, mc->un.ord ? 1 : 0); 915 wm8750_update_mutes(sc, 2); 916 error = 0; 917 break; 918 919 case WM8750_RECORD_SOURCE: 920 if (mc->type != AUDIO_MIXER_ENUM) 921 break; 922 if (mc->un.ord != 0) 923 break; 924 /* MIC only */ 925 error = 0; 926 break; 927 } 928 929 iic_release_bus(sc->sc_i2c, 0); 930 splx(s); 931 932 return error; 933 } 934 935 static int 936 wm8750_get_port(void *hdl, struct mixer_ctrl *mc) 937 { 938 struct zaudio_softc *sc = hdl; 939 int error = EINVAL; 940 941 switch (mc->dev) { 942 case WM8750_SPKR_LVL: 943 if (mc->type != AUDIO_MIXER_VALUE) 944 break; 945 if (mc->un.value.num_channels == 1) 946 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 947 sc->sc_volume[WM8750_OP_SPKR].left; 948 else 949 break; 950 error = 0; 951 break; 952 953 case WM8750_SPKR_MUTE: 954 if (mc->type != AUDIO_MIXER_ENUM) 955 break; 956 mc->un.ord = sc->sc_unmute[WM8750_OP_SPKR] ? 1 : 0; 957 error = 0; 958 break; 959 960 case WM8750_HP_LVL: 961 if (mc->type != AUDIO_MIXER_VALUE) 962 break; 963 if (mc->un.value.num_channels == 1) 964 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 965 sc->sc_volume[WM8750_OP_HP].left; 966 else if (mc->un.value.num_channels == 2) { 967 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 968 sc->sc_volume[WM8750_OP_HP].left; 969 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 970 sc->sc_volume[WM8750_OP_HP].right; 971 } 972 else 973 break; 974 error = 0; 975 break; 976 977 case WM8750_HP_MUTE: 978 if (mc->type != AUDIO_MIXER_ENUM) 979 break; 980 mc->un.ord = sc->sc_unmute[WM8750_OP_HP] ? 1 : 0; 981 error = 0; 982 break; 983 984 case WM8750_MIC_LVL: 985 if (mc->type != AUDIO_MIXER_VALUE) 986 break; 987 if (mc->un.value.num_channels == 1) 988 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 989 sc->sc_volume[WM8750_OP_MIC].left; 990 else 991 break; 992 error = 0; 993 break; 994 995 case WM8750_MIC_MUTE: 996 if (mc->type != AUDIO_MIXER_ENUM) 997 break; 998 mc->un.ord = sc->sc_unmute[WM8750_OP_MIC] ? 1 : 0; 999 error = 0; 1000 break; 1001 1002 case WM8750_RECORD_SOURCE: 1003 if (mc->type != AUDIO_MIXER_ENUM) 1004 break; 1005 mc->un.ord = 0; /* MIC only */ 1006 error = 0; 1007 break; 1008 } 1009 1010 return error; 1011 } 1012 1013 /*ARGSUSED*/ 1014 static int 1015 wm8750_query_devinfo(void *hdl, struct mixer_devinfo *di) 1016 { 1017 1018 switch (di->index) { 1019 case WM8750_SPKR_LVL: 1020 di->type = AUDIO_MIXER_VALUE; 1021 di->mixer_class = WM8750_OUTPUT_CLASS; 1022 di->prev = AUDIO_MIXER_LAST; 1023 di->next = WM8750_SPKR_MUTE; 1024 strlcpy(di->label.name, AudioNspeaker, sizeof(di->label.name)); 1025 strlcpy(di->un.v.units.name, AudioNvolume, 1026 sizeof(di->un.v.units.name)); 1027 di->un.v.num_channels = 1; 1028 break; 1029 1030 case WM8750_SPKR_MUTE: 1031 di->type = AUDIO_MIXER_ENUM; 1032 di->mixer_class = WM8750_OUTPUT_CLASS; 1033 di->prev = WM8750_SPKR_LVL; 1034 di->next = AUDIO_MIXER_LAST; 1035 goto mute; 1036 1037 case WM8750_HP_LVL: 1038 di->type = AUDIO_MIXER_VALUE; 1039 di->mixer_class = WM8750_OUTPUT_CLASS; 1040 di->prev = AUDIO_MIXER_LAST; 1041 di->next = WM8750_HP_MUTE; 1042 strlcpy(di->label.name, AudioNheadphone, 1043 sizeof(di->label.name)); 1044 di->un.v.num_channels = 1; 1045 strlcpy(di->un.v.units.name, AudioNvolume, 1046 sizeof(di->un.v.units.name)); 1047 break; 1048 1049 case WM8750_HP_MUTE: 1050 di->type = AUDIO_MIXER_ENUM; 1051 di->mixer_class = WM8750_OUTPUT_CLASS; 1052 di->prev = WM8750_HP_LVL; 1053 di->next = AUDIO_MIXER_LAST; 1054 mute: 1055 strlcpy(di->label.name, AudioNmute, sizeof(di->label.name)); 1056 di->un.e.num_mem = 2; 1057 strlcpy(di->un.e.member[0].label.name, AudioNon, 1058 sizeof(di->un.e.member[0].label.name)); 1059 di->un.e.member[0].ord = 0; 1060 strlcpy(di->un.e.member[1].label.name, AudioNoff, 1061 sizeof(di->un.e.member[1].label.name)); 1062 di->un.e.member[1].ord = 1; 1063 break; 1064 1065 case WM8750_MIC_LVL: 1066 di->type = AUDIO_MIXER_VALUE; 1067 di->mixer_class = WM8750_INPUT_CLASS; 1068 di->prev = AUDIO_MIXER_LAST; 1069 di->next = WM8750_MIC_MUTE; 1070 strlcpy(di->label.name, AudioNmicrophone, 1071 sizeof(di->label.name)); 1072 strlcpy(di->un.v.units.name, AudioNvolume, 1073 sizeof(di->un.v.units.name)); 1074 di->un.v.num_channels = 1; 1075 break; 1076 1077 case WM8750_MIC_MUTE: 1078 di->type = AUDIO_MIXER_ENUM; 1079 di->mixer_class = WM8750_INPUT_CLASS; 1080 di->prev = WM8750_MIC_LVL; 1081 di->next = AUDIO_MIXER_LAST; 1082 goto mute; 1083 1084 case WM8750_RECORD_SOURCE: 1085 di->type = AUDIO_MIXER_ENUM; 1086 di->mixer_class = WM8750_RECORD_CLASS; 1087 di->prev = AUDIO_MIXER_LAST; 1088 di->next = AUDIO_MIXER_LAST; 1089 strlcpy(di->label.name, AudioNsource, sizeof(di->label.name)); 1090 di->un.e.num_mem = 1; 1091 strlcpy(di->un.e.member[0].label.name, AudioNmicrophone, 1092 sizeof(di->un.e.member[0].label.name)); 1093 di->un.e.member[0].ord = 0; 1094 break; 1095 1096 case WM8750_OUTPUT_CLASS: 1097 di->type = AUDIO_MIXER_CLASS; 1098 di->mixer_class = WM8750_OUTPUT_CLASS; 1099 di->prev = AUDIO_MIXER_LAST; 1100 di->next = AUDIO_MIXER_LAST; 1101 strlcpy(di->label.name, AudioCoutputs, sizeof(di->label.name)); 1102 break; 1103 1104 case WM8750_INPUT_CLASS: 1105 di->type = AUDIO_MIXER_CLASS; 1106 di->mixer_class = WM8750_INPUT_CLASS; 1107 di->prev = AUDIO_MIXER_LAST; 1108 di->next = AUDIO_MIXER_LAST; 1109 strlcpy(di->label.name, AudioCinputs, sizeof(di->label.name)); 1110 break; 1111 1112 case WM8750_RECORD_CLASS: 1113 di->type = AUDIO_MIXER_CLASS; 1114 di->mixer_class = WM8750_RECORD_CLASS; 1115 di->prev = AUDIO_MIXER_LAST; 1116 di->next = AUDIO_MIXER_LAST; 1117 strlcpy(di->label.name, AudioCinputs, sizeof(di->label.name)); 1118 break; 1119 1120 default: 1121 return ENXIO; 1122 } 1123 1124 return 0; 1125 } 1126 1127 static int 1128 wm8750_start_output(void *hdl, void *block, int bsize, void (*intr)(void *), 1129 void *intrarg) 1130 { 1131 struct zaudio_softc *sc = hdl; 1132 int rv; 1133 1134 /* Power up codec if we are not already playing. */ 1135 if (!sc->sc_playing) { 1136 sc->sc_playing = 1; 1137 wm8750_play_setup(sc); 1138 } 1139 1140 /* Start DMA via I2S */ 1141 rv = pxa2x0_i2s_start_output(&sc->sc_i2s, block, bsize, intr, intrarg); 1142 if (rv) { 1143 if (!sc->sc_recording) 1144 wm8750_standby(sc); 1145 sc->sc_playing = 0; 1146 } 1147 1148 return rv; 1149 } 1150 1151 static int 1152 wm8750_start_input(void *hdl, void *block, int bsize, void (*intr)(void *), 1153 void *intrarg) 1154 { 1155 struct zaudio_softc *sc = hdl; 1156 int rv; 1157 1158 /* Power up codec if we are not already recording. */ 1159 if (!sc->sc_recording) { 1160 sc->sc_recording = 1; 1161 wm8750_record_setup(sc); 1162 } 1163 1164 /* Start DMA via I2S */ 1165 rv = pxa2x0_i2s_start_input(&sc->sc_i2s, block, bsize, intr, intrarg); 1166 if (rv) { 1167 if (!sc->sc_playing) 1168 wm8750_standby(sc); 1169 sc->sc_recording = 0; 1170 } 1171 return rv; 1172 } 1173
Indexes created Fri Oct 31 11:10:07 GMT 2025