1 /* $NetBSD: zaudio.c,v 1.9 2009/03/13 13:55:18 nonaka 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@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 * TODO: 22 * - powerhooks (currently only works until first suspend) 23 * - record support 24 */ 25 26 #include <sys/cdefs.h> 27 __KERNEL_RCSID(0, "$NetBSD: zaudio.c,v 1.9 2009/03/13 13:55:18 nonaka Exp $"); 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/callout.h> 32 #include <sys/device.h> 33 #include <sys/malloc.h> 34 #include <sys/kernel.h> 35 #include <sys/audioio.h> 36 37 #include <machine/intr.h> 38 #include <machine/bus.h> 39 40 #include <arm/xscale/pxa2x0reg.h> 41 #include <arm/xscale/pxa2x0var.h> 42 #include <arm/xscale/pxa2x0_i2c.h> 43 #include <arm/xscale/pxa2x0_i2s.h> 44 #include <arm/xscale/pxa2x0_dmac.h> 45 #include <arm/xscale/pxa2x0_gpio.h> 46 47 #include <dev/audio_if.h> 48 #include <dev/mulaw.h> 49 #include <dev/auconv.h> 50 51 #include <zaurus/dev/wm8750reg.h> 52 #include <zaurus/dev/scoopvar.h> 53 54 #define WM8750_ADDRESS 0x1B 55 #define SPKR_VOLUME 112 56 57 #define wm8750_write(sc, reg, val) \ 58 pxa2x0_i2c_write_2(&sc->sc_i2c, WM8750_ADDRESS, \ 59 (((reg) << 9) | ((val) & 0x1ff))) 60 61 static int zaudio_match(device_t, cfdata_t, void *); 62 static void zaudio_attach(device_t, device_t, void *); 63 static bool zaudio_suspend(device_t dv PMF_FN_ARGS); 64 static bool zaudio_resume(device_t dv PMF_FN_ARGS); 65 66 #define ZAUDIO_OP_SPKR 0 67 #define ZAUDIO_OP_HP 1 68 69 #define ZAUDIO_JACK_STATE_OUT 0 70 #define ZAUDIO_JACK_STATE_IN 1 71 #define ZAUDIO_JACK_STATE_INS 2 72 #define ZAUDIO_JACK_STATE_REM 3 73 74 /* GPIO pins */ 75 #define GPIO_HP_IN_C3000 116 76 77 struct zaudio_volume { 78 u_int8_t left; 79 u_int8_t right; 80 }; 81 82 struct zaudio_softc { 83 device_t sc_dev; 84 85 /* i2s device softc */ 86 /* NB: pxa2x0_i2s requires this to be the second struct member */ 87 struct pxa2x0_i2s_softc sc_i2s; 88 89 /* i2c device softc */ 90 struct pxa2x0_i2c_softc sc_i2c; 91 92 int sc_playing; 93 94 struct zaudio_volume sc_volume[2]; 95 char sc_unmute[2]; 96 97 int sc_state; 98 int sc_icount; 99 struct callout sc_to; 100 }; 101 102 CFATTACH_DECL_NEW(zaudio, sizeof(struct zaudio_softc), 103 zaudio_match, zaudio_attach, NULL, NULL); 104 105 static struct audio_device wm8750_device = { 106 "WM8750", 107 "1.0", 108 "wm" 109 }; 110 111 #define ZAUDIO_NFORMATS 4 112 static const struct audio_format zaudio_formats[ZAUDIO_NFORMATS] = { 113 {NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 16, 16, 114 2, AUFMT_STEREO, 0, {4000, 48000}}, 115 {NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 16, 16, 116 1, AUFMT_MONAURAL, 0, {4000, 48000}}, 117 {NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_ULINEAR_LE, 8, 8, 118 2, AUFMT_STEREO, 0, {4000, 48000}}, 119 {NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_ULINEAR_LE, 8, 8, 120 1, AUFMT_MONAURAL, 0, {4000, 48000}}, 121 }; 122 123 void zaudio_init(struct zaudio_softc *); 124 static int zaudio_jack_intr(void *); 125 void zaudio_jack(void *); 126 void zaudio_standby(struct zaudio_softc *); 127 void zaudio_update_volume(struct zaudio_softc *, int); 128 void zaudio_update_mutes(struct zaudio_softc *); 129 void zaudio_play_setup(struct zaudio_softc *); 130 static int zaudio_open(void *, int); 131 static void zaudio_close(void *); 132 static int zaudio_query_encoding(void *, struct audio_encoding *); 133 static int zaudio_set_params(void *, int, int, audio_params_t *, 134 audio_params_t *, stream_filter_list_t *, stream_filter_list_t *); 135 static int zaudio_round_blocksize(void *, int, int, const audio_params_t *); 136 static int zaudio_start_output(void *, void *, int, void (*)(void *), void *); 137 static int zaudio_start_input(void *, void *, int, void (*)(void *), void *); 138 static int zaudio_halt_output(void *); 139 static int zaudio_halt_input(void *); 140 static int zaudio_getdev(void *, struct audio_device *); 141 static int zaudio_set_port(void *, struct mixer_ctrl *); 142 static int zaudio_get_port(void *, struct mixer_ctrl *); 143 static int zaudio_query_devinfo(void *, struct mixer_devinfo *); 144 static void *zaudio_allocm(void *, int, size_t, struct malloc_type *, int); 145 static void zaudio_freem(void *, void *, struct malloc_type *); 146 static size_t zaudio_round_buffersize(void *, int, size_t); 147 static paddr_t zaudio_mappage(void *, void *, off_t, int); 148 static int zaudio_get_props(void *); 149 150 struct audio_hw_if wm8750_hw_if = { 151 .open = zaudio_open, 152 .close = zaudio_close, 153 .drain = NULL, 154 .query_encoding = zaudio_query_encoding, 155 .set_params = zaudio_set_params, 156 .round_blocksize = zaudio_round_blocksize, 157 .commit_settings = NULL, 158 .init_output = NULL, 159 .init_input = NULL, 160 .start_output = zaudio_start_output, 161 .start_input = zaudio_start_input, 162 .halt_output = zaudio_halt_output, 163 .halt_input = zaudio_halt_input, 164 .speaker_ctl = NULL, 165 .getdev = zaudio_getdev, 166 .setfd = NULL, 167 .set_port = zaudio_set_port, 168 .get_port = zaudio_get_port, 169 .query_devinfo = zaudio_query_devinfo, 170 .allocm = zaudio_allocm, 171 .freem = zaudio_freem, 172 .round_buffersize = zaudio_round_buffersize, 173 .mappage = zaudio_mappage, 174 .get_props = zaudio_get_props, 175 .trigger_output = NULL, 176 .trigger_input = NULL, 177 .dev_ioctl = NULL, 178 .powerstate = NULL, 179 }; 180 181 static const uint16_t playback_registers[][2] = { 182 /* Unmute DAC */ 183 { ADCDACCTL_REG, 0x000 }, 184 185 /* 16 bit audio words */ 186 { AUDINT_REG, AUDINT_SET_FORMAT(2) }, 187 188 /* Enable thermal protection, power */ 189 { ADCTL1_REG, ADCTL1_TSDEN | ADCTL1_SET_VSEL(3) }, 190 191 /* Enable speaker driver, DAC oversampling */ 192 { ADCTL2_REG, ADCTL2_ROUT2INV | ADCTL2_DACOSR }, 193 194 /* Set DAC voltage references */ 195 { PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(1) | PWRMGMT1_VREF }, 196 197 /* Direct DACs to output mixers */ 198 { LOUTMIX1_REG, LOUTMIX1_LD2LO }, 199 { ROUTMIX2_REG, ROUTMIX2_RD2RO }, 200 201 /* End of list */ 202 { 0xffff, 0xffff } 203 }; 204 205 static int 206 zaudio_match(device_t parent, cfdata_t cf, void *aux) 207 { 208 209 return 1; 210 } 211 212 static void 213 zaudio_attach(device_t parent, device_t self, void *aux) 214 { 215 struct zaudio_softc *sc = device_private(self); 216 struct pxaip_attach_args *pxa = aux; 217 int rv; 218 219 sc->sc_dev = self; 220 221 aprint_normal(": I2C, I2S, WM8750 Audio\n"); 222 aprint_naive("\n"); 223 224 if (!pmf_device_register(sc->sc_dev, zaudio_suspend, zaudio_resume)) 225 aprint_error_dev(sc->sc_dev, 226 "couldn't establish power handler\n"); 227 228 sc->sc_i2s.sc_iot = pxa->pxa_iot; 229 sc->sc_i2s.sc_dmat = pxa->pxa_dmat; 230 sc->sc_i2s.sc_size = PXA2X0_I2S_SIZE; 231 if (pxa2x0_i2s_attach_sub(&sc->sc_i2s)) { 232 aprint_error_dev(sc->sc_dev, "unable to attach I2S\n"); 233 goto fail_i2s; 234 } 235 236 sc->sc_i2c.sc_iot = pxa->pxa_iot; 237 sc->sc_i2c.sc_size = PXA2X0_I2C_SIZE; 238 if (pxa2x0_i2c_attach_sub(&sc->sc_i2c)) { 239 aprint_error_dev(sc->sc_dev, "unable to attach I2C\n"); 240 goto fail_i2c; 241 } 242 243 /* Check for an I2C response from the wm8750 */ 244 pxa2x0_i2c_open(&sc->sc_i2c); 245 rv = wm8750_write(sc, RESET_REG, 0); 246 pxa2x0_i2c_close(&sc->sc_i2c); 247 if (rv) { 248 aprint_error_dev(sc->sc_dev, "codec failed to respond\n"); 249 goto fail_probe; 250 } 251 delay(100); 252 253 /* Speaker on, headphones off by default. */ 254 sc->sc_volume[ZAUDIO_OP_SPKR].left = 240; 255 sc->sc_unmute[ZAUDIO_OP_SPKR] = 1; 256 sc->sc_volume[ZAUDIO_OP_HP].left = 180; 257 sc->sc_volume[ZAUDIO_OP_HP].right = 180; 258 sc->sc_unmute[ZAUDIO_OP_HP] = 0; 259 260 /* Configure headphone jack state change handling. */ 261 callout_init(&sc->sc_to, 0); 262 callout_setfunc(&sc->sc_to, zaudio_jack, sc); 263 pxa2x0_gpio_set_function(GPIO_HP_IN_C3000, GPIO_IN); 264 (void)pxa2x0_gpio_intr_establish(GPIO_HP_IN_C3000, 265 IST_EDGE_BOTH, IPL_BIO, zaudio_jack_intr, sc); 266 267 zaudio_init(sc); 268 269 audio_attach_mi(&wm8750_hw_if, sc, sc->sc_dev); 270 271 return; 272 273 fail_probe: 274 pxa2x0_i2c_detach_sub(&sc->sc_i2c); 275 fail_i2c: 276 pxa2x0_i2s_detach_sub(&sc->sc_i2s); 277 fail_i2s: 278 pmf_device_deregister(self); 279 } 280 281 static bool 282 zaudio_suspend(device_t dv PMF_FN_ARGS) 283 { 284 struct zaudio_softc *sc = device_private(dv); 285 286 callout_stop(&sc->sc_to); 287 zaudio_standby(sc); 288 289 return true; 290 } 291 292 static bool 293 zaudio_resume(device_t dv PMF_FN_ARGS) 294 { 295 struct zaudio_softc *sc = device_private(dv); 296 297 pxa2x0_i2s_init(&sc->sc_i2s); 298 pxa2x0_i2c_init(&sc->sc_i2c); 299 zaudio_init(sc); 300 301 return true; 302 } 303 304 void 305 zaudio_init(struct zaudio_softc *sc) 306 { 307 308 pxa2x0_i2c_open(&sc->sc_i2c); 309 310 /* Reset the codec */ 311 wm8750_write(sc, RESET_REG, 0); 312 delay(100); 313 314 /* Switch to standby power only */ 315 wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2)); 316 wm8750_write(sc, PWRMGMT2_REG, 0); 317 318 /* Configure digital interface for I2S */ 319 wm8750_write(sc, AUDINT_REG, AUDINT_SET_FORMAT(2)); 320 321 /* Initialise volume levels */ 322 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 323 zaudio_update_volume(sc, ZAUDIO_OP_HP); 324 325 pxa2x0_i2c_close(&sc->sc_i2c); 326 327 scoop_set_headphone(0); 328 329 /* Assume that the jack state has changed. */ 330 zaudio_jack(sc); 331 } 332 333 static int 334 zaudio_jack_intr(void *v) 335 { 336 struct zaudio_softc *sc = v; 337 338 if (!callout_active(&sc->sc_to)) 339 zaudio_jack(sc); 340 341 return 1; 342 } 343 344 void 345 zaudio_jack(void *v) 346 { 347 struct zaudio_softc *sc = v; 348 349 switch (sc->sc_state) { 350 case ZAUDIO_JACK_STATE_OUT: 351 if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 352 sc->sc_state = ZAUDIO_JACK_STATE_INS; 353 sc->sc_icount = 0; 354 } 355 break; 356 357 case ZAUDIO_JACK_STATE_INS: 358 if (sc->sc_icount++ > 2) { 359 if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 360 sc->sc_state = ZAUDIO_JACK_STATE_IN; 361 sc->sc_unmute[ZAUDIO_OP_SPKR] = 0; 362 sc->sc_unmute[ZAUDIO_OP_HP] = 1; 363 goto update_mutes; 364 } else 365 sc->sc_state = ZAUDIO_JACK_STATE_OUT; 366 } 367 break; 368 369 case ZAUDIO_JACK_STATE_IN: 370 if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 371 sc->sc_state = ZAUDIO_JACK_STATE_REM; 372 sc->sc_icount = 0; 373 } 374 break; 375 376 case ZAUDIO_JACK_STATE_REM: 377 if (sc->sc_icount++ > 2) { 378 if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 379 sc->sc_state = ZAUDIO_JACK_STATE_OUT; 380 sc->sc_unmute[ZAUDIO_OP_SPKR] = 1; 381 sc->sc_unmute[ZAUDIO_OP_HP] = 0; 382 goto update_mutes; 383 } else 384 sc->sc_state = ZAUDIO_JACK_STATE_IN; 385 } 386 break; 387 } 388 389 callout_schedule(&sc->sc_to, hz/4); 390 391 return; 392 393 update_mutes: 394 callout_stop(&sc->sc_to); 395 396 if (sc->sc_playing) { 397 pxa2x0_i2c_open(&sc->sc_i2c); 398 zaudio_update_mutes(sc); 399 pxa2x0_i2c_close(&sc->sc_i2c); 400 } 401 } 402 403 void 404 zaudio_standby(struct zaudio_softc *sc) 405 { 406 407 pxa2x0_i2c_open(&sc->sc_i2c); 408 409 /* Switch codec to standby power only */ 410 wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2)); 411 wm8750_write(sc, PWRMGMT2_REG, 0); 412 413 pxa2x0_i2c_close(&sc->sc_i2c); 414 415 scoop_set_headphone(0); 416 } 417 418 void 419 zaudio_update_volume(struct zaudio_softc *sc, int output) 420 { 421 422 switch (output) { 423 case ZAUDIO_OP_SPKR: 424 wm8750_write(sc, LOUT2VOL_REG, LOUT2VOL_LO2VU | LOUT2VOL_LO2ZC | 425 LOUT2VOL_SET_LOUT2VOL(sc->sc_volume[ZAUDIO_OP_SPKR 426 ].left >> 1)); 427 wm8750_write(sc, ROUT2VOL_REG, ROUT2VOL_RO2VU | ROUT2VOL_RO2ZC | 428 ROUT2VOL_SET_ROUT2VOL(sc->sc_volume[ZAUDIO_OP_SPKR 429 ].left >> 1)); 430 break; 431 432 case ZAUDIO_OP_HP: 433 wm8750_write(sc, LOUT1VOL_REG, LOUT1VOL_LO1VU | LOUT1VOL_LO1ZC | 434 LOUT1VOL_SET_LOUT1VOL(sc->sc_volume[ZAUDIO_OP_HP 435 ].left >> 1)); 436 wm8750_write(sc, ROUT1VOL_REG, ROUT1VOL_RO1VU | ROUT1VOL_RO1ZC | 437 ROUT1VOL_SET_ROUT1VOL(sc->sc_volume[ZAUDIO_OP_HP 438 ].right >> 1)); 439 break; 440 } 441 } 442 443 void 444 zaudio_update_mutes(struct zaudio_softc *sc) 445 { 446 uint16_t val; 447 448 val = PWRMGMT2_DACL | PWRMGMT2_DACR; 449 450 if (sc->sc_unmute[ZAUDIO_OP_SPKR]) 451 val |= PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2; 452 453 if (sc->sc_unmute[ZAUDIO_OP_HP]) 454 val |= PWRMGMT2_LOUT1 | PWRMGMT2_ROUT1; 455 456 wm8750_write(sc, PWRMGMT2_REG, val); 457 458 scoop_set_headphone(sc->sc_unmute[ZAUDIO_OP_HP]); 459 } 460 461 void 462 zaudio_play_setup(struct zaudio_softc *sc) 463 { 464 int i; 465 466 pxa2x0_i2c_open(&sc->sc_i2c); 467 468 /* Program the codec with playback settings */ 469 for (i = 0; playback_registers[i][0] != 0xffff; i++) { 470 wm8750_write(sc, playback_registers[i][0], 471 playback_registers[i][1]); 472 } 473 zaudio_update_mutes(sc); 474 475 pxa2x0_i2c_close(&sc->sc_i2c); 476 } 477 478 /* 479 * audio operation functions. 480 */ 481 static int 482 zaudio_open(void *hdl, int flags) 483 { 484 struct zaudio_softc *sc = hdl; 485 486 /* Power on the I2S bus and codec */ 487 pxa2x0_i2s_open(&sc->sc_i2s); 488 489 return 0; 490 } 491 492 static void 493 zaudio_close(void *hdl) 494 { 495 struct zaudio_softc *sc = hdl; 496 497 /* Power off the I2S bus and codec */ 498 pxa2x0_i2s_close(&sc->sc_i2s); 499 } 500 501 static int 502 zaudio_query_encoding(void *hdl, struct audio_encoding *aep) 503 { 504 505 switch (aep->index) { 506 case 0: 507 strlcpy(aep->name, AudioEulinear, sizeof(aep->name)); 508 aep->encoding = AUDIO_ENCODING_ULINEAR; 509 aep->precision = 8; 510 aep->flags = 0; 511 break; 512 513 case 1: 514 strlcpy(aep->name, AudioEmulaw, sizeof(aep->name)); 515 aep->encoding = AUDIO_ENCODING_ULAW; 516 aep->precision = 8; 517 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 518 break; 519 520 case 2: 521 strlcpy(aep->name, AudioEalaw, sizeof(aep->name)); 522 aep->encoding = AUDIO_ENCODING_ALAW; 523 aep->precision = 8; 524 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 525 break; 526 527 case 3: 528 strlcpy(aep->name, AudioEslinear, sizeof(aep->name)); 529 aep->encoding = AUDIO_ENCODING_SLINEAR; 530 aep->precision = 8; 531 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 532 break; 533 534 case 4: 535 strlcpy(aep->name, AudioEslinear_le, sizeof(aep->name)); 536 aep->encoding = AUDIO_ENCODING_SLINEAR_LE; 537 aep->precision = 16; 538 aep->flags = 0; 539 break; 540 541 case 5: 542 strlcpy(aep->name, AudioEulinear_le, sizeof(aep->name)); 543 aep->encoding = AUDIO_ENCODING_ULINEAR_LE; 544 aep->precision = 16; 545 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 546 break; 547 548 case 6: 549 strlcpy(aep->name, AudioEslinear_be, sizeof(aep->name)); 550 aep->encoding = AUDIO_ENCODING_SLINEAR_BE; 551 aep->precision = 16; 552 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 553 break; 554 555 case 7: 556 strlcpy(aep->name, AudioEulinear_be, sizeof(aep->name)); 557 aep->encoding = AUDIO_ENCODING_ULINEAR_BE; 558 aep->precision = 16; 559 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 560 break; 561 562 default: 563 return EINVAL; 564 } 565 566 return 0; 567 } 568 569 static int 570 zaudio_set_params(void *hdl, int setmode, int usemode, 571 audio_params_t *play, audio_params_t *rec, 572 stream_filter_list_t *pfil, stream_filter_list_t *rfil) 573 { 574 struct zaudio_softc *sc = hdl; 575 struct audio_params *p; 576 stream_filter_list_t *fil; 577 int mode, i; 578 579 if (play->sample_rate != rec->sample_rate && 580 usemode == (AUMODE_PLAY | AUMODE_RECORD)) { 581 if (setmode == AUMODE_PLAY) { 582 rec->sample_rate = play->sample_rate; 583 setmode |= AUMODE_RECORD; 584 } else if (setmode == AUMODE_RECORD) { 585 play->sample_rate = rec->sample_rate; 586 setmode |= AUMODE_PLAY; 587 } else 588 return EINVAL; 589 } 590 591 for (mode = AUMODE_RECORD; mode != -1; 592 mode = (mode == AUMODE_RECORD) ? AUMODE_PLAY : -1) { 593 if ((setmode & mode) == 0) 594 continue; 595 596 p = (mode == AUMODE_PLAY) ? play : rec; 597 598 if (p->sample_rate < 4000 || p->sample_rate > 48000 || 599 (p->precision != 8 && p->precision != 16) || 600 (p->channels != 1 && p->channels != 2)) 601 return EINVAL; 602 603 fil = (mode == AUMODE_PLAY) ? pfil : rfil; 604 i = auconv_set_converter(zaudio_formats, ZAUDIO_NFORMATS, 605 mode, p, false, fil); 606 if (i < 0) 607 return EINVAL; 608 } 609 610 if (setmode == AUMODE_RECORD) 611 pxa2x0_i2s_setspeed(&sc->sc_i2s, &rec->sample_rate); 612 else 613 pxa2x0_i2s_setspeed(&sc->sc_i2s, &play->sample_rate); 614 615 return 0; 616 } 617 618 static int 619 zaudio_round_blocksize(void *hdl, int bs, int mode, const audio_params_t *param) 620 { 621 struct zaudio_softc *sc = hdl; 622 623 return pxa2x0_i2s_round_blocksize(&sc->sc_i2s, bs, mode, param); 624 } 625 626 627 static int 628 zaudio_halt_output(void *hdl) 629 { 630 struct zaudio_softc *sc = hdl; 631 int rv; 632 633 rv = pxa2x0_i2s_halt_output(&sc->sc_i2s); 634 zaudio_standby(sc); 635 sc->sc_playing = 0; 636 637 return rv; 638 } 639 640 static int 641 zaudio_halt_input(void *hdl) 642 { 643 struct zaudio_softc *sc = hdl; 644 int rv; 645 646 rv = pxa2x0_i2s_halt_input(&sc->sc_i2s); 647 648 return rv; 649 } 650 651 static int 652 zaudio_getdev(void *hdl, struct audio_device *ret) 653 { 654 /* struct zaudio_softc *sc = hdl; */ 655 656 *ret = wm8750_device; 657 return 0; 658 } 659 660 #define ZAUDIO_SPKR_LVL 0 661 #define ZAUDIO_SPKR_MUTE 1 662 #define ZAUDIO_HP_LVL 2 663 #define ZAUDIO_HP_MUTE 3 664 #define ZAUDIO_OUTPUT_CLASS 4 665 666 static int 667 zaudio_set_port(void *hdl, struct mixer_ctrl *mc) 668 { 669 struct zaudio_softc *sc = hdl; 670 int error = EINVAL; 671 int s; 672 673 s = splbio(); 674 pxa2x0_i2c_open(&sc->sc_i2c); 675 676 switch (mc->dev) { 677 case ZAUDIO_SPKR_LVL: 678 if (mc->type != AUDIO_MIXER_VALUE) 679 break; 680 if (mc->un.value.num_channels == 1) 681 sc->sc_volume[ZAUDIO_OP_SPKR].left = 682 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 683 else 684 break; 685 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 686 error = 0; 687 break; 688 689 case ZAUDIO_SPKR_MUTE: 690 if (mc->type != AUDIO_MIXER_ENUM) 691 break; 692 sc->sc_unmute[ZAUDIO_OP_SPKR] = mc->un.ord ? 1 : 0; 693 zaudio_update_mutes(sc); 694 error = 0; 695 break; 696 697 case ZAUDIO_HP_LVL: 698 if (mc->type != AUDIO_MIXER_VALUE) 699 break; 700 if (mc->un.value.num_channels == 1) { 701 sc->sc_volume[ZAUDIO_OP_HP].left = 702 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 703 sc->sc_volume[ZAUDIO_OP_HP].right = 704 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 705 } else if (mc->un.value.num_channels == 2) { 706 sc->sc_volume[ZAUDIO_OP_HP].left = 707 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]; 708 sc->sc_volume[ZAUDIO_OP_HP].right = 709 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]; 710 } 711 else 712 break; 713 zaudio_update_volume(sc, ZAUDIO_OP_HP); 714 error = 0; 715 break; 716 717 case ZAUDIO_HP_MUTE: 718 if (mc->type != AUDIO_MIXER_ENUM) 719 break; 720 sc->sc_unmute[ZAUDIO_OP_HP] = mc->un.ord ? 1 : 0; 721 zaudio_update_mutes(sc); 722 error = 0; 723 break; 724 } 725 726 pxa2x0_i2c_close(&sc->sc_i2c); 727 splx(s); 728 729 return error; 730 } 731 732 static int 733 zaudio_get_port(void *hdl, struct mixer_ctrl *mc) 734 { 735 struct zaudio_softc *sc = hdl; 736 int error = EINVAL; 737 738 switch (mc->dev) { 739 case ZAUDIO_SPKR_LVL: 740 if (mc->type != AUDIO_MIXER_VALUE) 741 break; 742 if (mc->un.value.num_channels == 1) 743 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 744 sc->sc_volume[ZAUDIO_OP_SPKR].left; 745 else 746 break; 747 error = 0; 748 break; 749 750 case ZAUDIO_SPKR_MUTE: 751 if (mc->type != AUDIO_MIXER_ENUM) 752 break; 753 mc->un.ord = sc->sc_unmute[ZAUDIO_OP_SPKR] ? 1 : 0; 754 error = 0; 755 break; 756 757 case ZAUDIO_HP_LVL: 758 if (mc->type != AUDIO_MIXER_VALUE) 759 break; 760 if (mc->un.value.num_channels == 1) 761 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 762 sc->sc_volume[ZAUDIO_OP_HP].left; 763 else if (mc->un.value.num_channels == 2) { 764 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 765 sc->sc_volume[ZAUDIO_OP_HP].left; 766 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 767 sc->sc_volume[ZAUDIO_OP_HP].right; 768 } 769 else 770 break; 771 error = 0; 772 break; 773 774 case ZAUDIO_HP_MUTE: 775 if (mc->type != AUDIO_MIXER_ENUM) 776 break; 777 mc->un.ord = sc->sc_unmute[ZAUDIO_OP_HP] ? 1 : 0; 778 error = 0; 779 break; 780 } 781 782 return error; 783 } 784 785 static int 786 zaudio_query_devinfo(void *hdl, struct mixer_devinfo *di) 787 { 788 /* struct zaudio_softc *sc = hdl; */ 789 790 switch (di->index) { 791 case ZAUDIO_SPKR_LVL: 792 di->type = AUDIO_MIXER_VALUE; 793 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 794 di->prev = AUDIO_MIXER_LAST; 795 di->next = ZAUDIO_SPKR_MUTE; 796 strlcpy(di->label.name, AudioNspeaker, 797 sizeof(di->label.name)); 798 strlcpy(di->un.v.units.name, AudioNvolume, 799 sizeof(di->un.v.units.name)); 800 di->un.v.num_channels = 1; 801 break; 802 803 case ZAUDIO_SPKR_MUTE: 804 di->type = AUDIO_MIXER_ENUM; 805 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 806 di->prev = ZAUDIO_SPKR_LVL; 807 di->next = AUDIO_MIXER_LAST; 808 goto mute; 809 810 case ZAUDIO_HP_LVL: 811 di->type = AUDIO_MIXER_VALUE; 812 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 813 di->prev = AUDIO_MIXER_LAST; 814 di->next = ZAUDIO_HP_MUTE; 815 strlcpy(di->label.name, AudioNheadphone, 816 sizeof(di->label.name)); 817 di->un.v.num_channels = 1; 818 strlcpy(di->un.v.units.name, AudioNvolume, 819 sizeof(di->un.v.units.name)); 820 break; 821 822 case ZAUDIO_HP_MUTE: 823 di->type = AUDIO_MIXER_ENUM; 824 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 825 di->prev = ZAUDIO_HP_LVL; 826 di->next = AUDIO_MIXER_LAST; 827 mute: 828 strlcpy(di->label.name, AudioNmute, sizeof(di->label.name)); 829 di->un.e.num_mem = 2; 830 strlcpy(di->un.e.member[0].label.name, AudioNon, 831 sizeof(di->un.e.member[0].label.name)); 832 di->un.e.member[0].ord = 0; 833 strlcpy(di->un.e.member[1].label.name, AudioNoff, 834 sizeof(di->un.e.member[1].label.name)); 835 di->un.e.member[1].ord = 1; 836 break; 837 838 case ZAUDIO_OUTPUT_CLASS: 839 di->type = AUDIO_MIXER_CLASS; 840 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 841 di->prev = AUDIO_MIXER_LAST; 842 di->next = AUDIO_MIXER_LAST; 843 strlcpy(di->label.name, AudioCoutputs, 844 sizeof(di->label.name)); 845 break; 846 847 default: 848 return ENXIO; 849 } 850 851 return 0; 852 } 853 854 static void * 855 zaudio_allocm(void *hdl, int direction, size_t size, 856 struct malloc_type *type, int flags) 857 { 858 struct zaudio_softc *sc = hdl; 859 860 return pxa2x0_i2s_allocm(&sc->sc_i2s, direction, size, type, flags); 861 } 862 863 static void 864 zaudio_freem(void *hdl, void *ptr, struct malloc_type *type) 865 { 866 struct zaudio_softc *sc = hdl; 867 868 return pxa2x0_i2s_freem(&sc->sc_i2s, ptr, type); 869 } 870 871 static size_t 872 zaudio_round_buffersize(void *hdl, int direction, size_t bufsize) 873 { 874 struct zaudio_softc *sc = hdl; 875 876 return pxa2x0_i2s_round_buffersize(&sc->sc_i2s, direction, bufsize); 877 } 878 879 static paddr_t 880 zaudio_mappage(void *hdl, void *mem, off_t off, int prot) 881 { 882 struct zaudio_softc *sc = hdl; 883 884 return pxa2x0_i2s_mappage(&sc->sc_i2s, mem, off, prot); 885 } 886 887 static int 888 zaudio_get_props(void *hdl) 889 { 890 891 return AUDIO_PROP_MMAP|AUDIO_PROP_INDEPENDENT|AUDIO_PROP_FULLDUPLEX; 892 } 893 894 static int 895 zaudio_start_output(void *hdl, void *block, int bsize, void (*intr)(void *), 896 void *intrarg) 897 { 898 struct zaudio_softc *sc = hdl; 899 int rv; 900 901 /* Power up codec if we are not already playing. */ 902 if (!sc->sc_playing) { 903 sc->sc_playing = 1; 904 zaudio_play_setup(sc); 905 } 906 907 /* Start DMA via I2S */ 908 rv = pxa2x0_i2s_start_output(&sc->sc_i2s, block, bsize, intr, intrarg); 909 if (rv) { 910 zaudio_standby(sc); 911 sc->sc_playing = 0; 912 } 913 return rv; 914 } 915 916 static int 917 zaudio_start_input(void *hdl, void *block, int bsize, void (*intr)(void *), 918 void *intrarg) 919 { 920 921 return ENXIO; 922 } 923