zaudio.c revision 1.18
1 /* $NetBSD: zaudio.c,v 1.18 2012/01/25 15:58:10 tsutsui 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_zaudio.h" 51 52 #include <sys/cdefs.h> 53 __KERNEL_RCSID(0, "$NetBSD: zaudio.c,v 1.18 2012/01/25 15:58:10 tsutsui Exp $"); 54 55 #include <sys/param.h> 56 #include <sys/systm.h> 57 #include <sys/callout.h> 58 #include <sys/device.h> 59 #include <sys/kmem.h> 60 #include <sys/kernel.h> 61 #include <sys/audioio.h> 62 #include <sys/mutex.h> 63 #include <sys/intr.h> 64 #include <sys/bus.h> 65 66 #include <dev/audio_if.h> 67 #include <dev/mulaw.h> 68 #include <dev/auconv.h> 69 70 #include <dev/i2c/i2cvar.h> 71 72 #include <arm/xscale/pxa2x0reg.h> 73 #include <arm/xscale/pxa2x0var.h> 74 #include <arm/xscale/pxa2x0_i2c.h> 75 #include <arm/xscale/pxa2x0_i2s.h> 76 #include <arm/xscale/pxa2x0_dmac.h> 77 #include <arm/xscale/pxa2x0_gpio.h> 78 79 #include <zaurus/zaurus/zaurus_var.h> 80 #include <zaurus/dev/wm8750reg.h> 81 #include <zaurus/dev/scoopvar.h> 82 #include <zaurus/dev/ioexpvar.h> 83 84 #define WM8750_ADDRESS 0x1B 85 86 /* GPIO pins */ 87 #define GPIO_HP_IN_C3000 116 88 89 #define ZAUDIO_OP_SPKR 0 90 #define ZAUDIO_OP_HP 1 91 #define ZAUDIO_OP_MIC 2 92 #define ZAUDIO_OP_NUM 3 93 94 #define ZAUDIO_JACK_STATE_OUT 0 95 #define ZAUDIO_JACK_STATE_IN 1 96 #define ZAUDIO_JACK_STATE_INS 2 97 #define ZAUDIO_JACK_STATE_REM 3 98 99 struct zaudio_volume { 100 uint8_t left; 101 uint8_t right; 102 }; 103 104 struct zaudio_softc { 105 device_t sc_dev; 106 kmutex_t sc_lock; 107 kmutex_t sc_intr_lock; 108 109 /* i2s device softc */ 110 /* NB: pxa2x0_i2s requires this to be the second struct member */ 111 struct pxa2x0_i2s_softc sc_i2s; 112 113 i2c_tag_t sc_i2c; 114 115 int sc_playing; 116 int sc_recording; 117 118 struct zaudio_volume sc_volume[ZAUDIO_OP_NUM]; 119 uint8_t sc_unmute[ZAUDIO_OP_NUM]; 120 uint8_t sc_unmute_toggle[ZAUDIO_OP_NUM]; 121 122 int sc_state; 123 int sc_icount; 124 struct callout sc_to; 125 }; 126 127 #define UNMUTE(sc,op,val) sc->sc_unmute[op] = sc->sc_unmute_toggle[op] = val 128 129 static int zaudio_match(device_t, cfdata_t, void *); 130 static void zaudio_attach(device_t, device_t, void *); 131 132 CFATTACH_DECL_NEW(zaudio, sizeof(struct zaudio_softc), 133 zaudio_match, zaudio_attach, NULL, NULL); 134 135 static int zaudio_finalize(device_t); 136 static bool zaudio_suspend(device_t, const pmf_qual_t *); 137 static bool zaudio_resume(device_t, const pmf_qual_t *); 138 static void zaudio_volume_up(device_t); 139 static void zaudio_volume_down(device_t); 140 static void zaudio_volume_toggle(device_t); 141 142 static struct audio_device wm8750_device = { 143 "WM8750", 144 "1.0", 145 "wm" 146 }; 147 148 static const struct audio_format zaudio_formats[] = { 149 { 150 .driver_data = NULL, 151 .mode = AUMODE_PLAY | AUMODE_RECORD, 152 .encoding = AUDIO_ENCODING_SLINEAR_LE, 153 .validbits = 16, 154 .precision = 16, 155 .channels = 2, 156 .channel_mask = AUFMT_STEREO, 157 .frequency_type = 0, 158 .frequency = { 4000, 48000 } 159 }, 160 { 161 .driver_data = NULL, 162 .mode = AUMODE_PLAY | AUMODE_RECORD, 163 .encoding = AUDIO_ENCODING_SLINEAR_LE, 164 .validbits = 16, 165 .precision = 16, 166 .channels = 1, 167 .channel_mask = AUFMT_MONAURAL, 168 .frequency_type = 0, 169 .frequency = { 4000, 48000 } 170 }, 171 { 172 .driver_data = NULL, 173 .mode = AUMODE_PLAY | AUMODE_RECORD, 174 .encoding = AUDIO_ENCODING_ULINEAR_LE, 175 .validbits = 8, 176 .precision = 8, 177 .channels = 2, 178 .channel_mask = AUFMT_STEREO, 179 .frequency_type = 0, 180 .frequency = { 4000, 48000 } 181 }, 182 { 183 .driver_data = NULL, 184 .mode = AUMODE_PLAY | AUMODE_RECORD, 185 .encoding = AUDIO_ENCODING_ULINEAR_LE, 186 .validbits = 8, 187 .precision = 8, 188 .channels = 1, 189 .channel_mask = AUFMT_MONAURAL, 190 .frequency_type = 0, 191 .frequency = { 4000, 48000 } 192 }, 193 }; 194 static const int zaudio_nformats = (int)__arraycount(zaudio_formats); 195 196 static void zaudio_init(struct zaudio_softc *); 197 static int zaudio_jack_intr(void *); 198 static void zaudio_jack(void *); 199 static void zaudio_standby(struct zaudio_softc *); 200 static void zaudio_update_volume(struct zaudio_softc *, int); 201 static void zaudio_update_mutes(struct zaudio_softc *, int); 202 static void zaudio_play_setup(struct zaudio_softc *); 203 /*static*/ void zaudio_record_setup(struct zaudio_softc *); 204 static int zaudio_open(void *, int); 205 static void zaudio_close(void *); 206 static int zaudio_query_encoding(void *, struct audio_encoding *); 207 static int zaudio_set_params(void *, int, int, audio_params_t *, 208 audio_params_t *, stream_filter_list_t *, stream_filter_list_t *); 209 static int zaudio_round_blocksize(void *, int, int, const audio_params_t *); 210 static int zaudio_start_output(void *, void *, int, void (*)(void *), void *); 211 static int zaudio_start_input(void *, void *, int, void (*)(void *), void *); 212 static int zaudio_halt_output(void *); 213 static int zaudio_halt_input(void *); 214 static int zaudio_getdev(void *, struct audio_device *); 215 static int zaudio_set_port(void *, struct mixer_ctrl *); 216 static int zaudio_get_port(void *, struct mixer_ctrl *); 217 static int zaudio_query_devinfo(void *, struct mixer_devinfo *); 218 static void *zaudio_allocm(void *, int, size_t); 219 static void zaudio_freem(void *, void *, size_t); 220 static size_t zaudio_round_buffersize(void *, int, size_t); 221 static paddr_t zaudio_mappage(void *, void *, off_t, int); 222 static int zaudio_get_props(void *); 223 static void zaudio_get_locks(void *, kmutex_t **, kmutex_t **); 224 225 struct audio_hw_if wm8750_hw_if = { 226 .open = zaudio_open, 227 .close = zaudio_close, 228 .drain = NULL, 229 .query_encoding = zaudio_query_encoding, 230 .set_params = zaudio_set_params, 231 .round_blocksize = zaudio_round_blocksize, 232 .commit_settings = NULL, 233 .init_output = NULL, 234 .init_input = NULL, 235 .start_output = zaudio_start_output, 236 .start_input = zaudio_start_input, 237 .halt_output = zaudio_halt_output, 238 .halt_input = zaudio_halt_input, 239 .speaker_ctl = NULL, 240 .getdev = zaudio_getdev, 241 .setfd = NULL, 242 .set_port = zaudio_set_port, 243 .get_port = zaudio_get_port, 244 .query_devinfo = zaudio_query_devinfo, 245 .allocm = zaudio_allocm, 246 .freem = zaudio_freem, 247 .round_buffersize = zaudio_round_buffersize, 248 .mappage = zaudio_mappage, 249 .get_props = zaudio_get_props, 250 .trigger_output = NULL, 251 .trigger_input = NULL, 252 .dev_ioctl = NULL, 253 .get_locks = zaudio_get_locks, 254 }; 255 256 static const uint16_t playback_regs[][2] = { 257 /* Unmute DAC */ 258 { ADCDACCTL_REG, 0x000 }, 259 260 /* 16 bit audio words */ 261 { AUDINT_REG, AUDINT_SET_FORMAT(2) }, 262 263 /* Enable thermal protection, power */ 264 { ADCTL1_REG, ADCTL1_TSDEN | ADCTL1_SET_VSEL(3) }, 265 266 /* Enable speaker driver, DAC oversampling */ 267 { ADCTL2_REG, ADCTL2_ROUT2INV | ADCTL2_DACOSR }, 268 269 /* Set DAC voltage references */ 270 { PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(1) | PWRMGMT1_VREF }, 271 272 /* Direct DACs to output mixers */ 273 { LOUTMIX1_REG, LOUTMIX1_LD2LO }, 274 { LOUTMIX2_REG, 0x000 }, 275 { ROUTMIX1_REG, 0x000 }, 276 { ROUTMIX2_REG, ROUTMIX2_RD2RO }, 277 278 /* End of list */ 279 { 0xffff, 0xffff } 280 }; 281 282 static const uint16_t record_regs[][2] = { 283 /* Unmute DAC */ 284 { ADCDACCTL_REG, 0x000 }, 285 286 /* 16 bit audio words */ 287 { AUDINT_REG, AUDINT_SET_FORMAT(2) }, 288 289 /* Enable thermal protection, power, left DAC for both channel */ 290 { ADCTL1_REG, ADCTL1_TSDEN | ADCTL1_SET_VSEL(3) 291 | ADCTL1_SET_DATSEL(1) }, 292 293 /* Diffrential input select: LINPUT1-RINPUT1, stereo */ 294 { ADCINPMODE_REG, 0x000 }, 295 296 /* L-R differential, micboost 20dB */ 297 { ADCLSPATH_REG, ADCLSPATH_SET_LINSEL(3) | ADCLSPATH_SET_LMICBOOST(2) }, 298 { ADCRSPATH_REG, ADCRSPATH_SET_RINSEL(3) | ADCRSPATH_SET_RMICBOOST(2) }, 299 300 /* End of list */ 301 { 0xffff, 0xffff } 302 }; 303 304 static __inline int 305 wm8750_write(struct zaudio_softc *sc, int reg, int val) 306 { 307 uint16_t tmp; 308 uint8_t cmd; 309 uint8_t data; 310 311 tmp = (reg << 9) | (val & 0x1ff); 312 cmd = tmp >> 8; 313 data = tmp; 314 return iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, WM8750_ADDRESS, 315 &cmd, 1, &data, 1, 0); 316 } 317 318 static int 319 zaudio_match(device_t parent, cfdata_t cf, void *aux) 320 { 321 struct i2c_attach_args *ia = aux; 322 323 if (ia->ia_name) { 324 /* direct config - check name */ 325 if (strcmp(ia->ia_name, "zaudio") == 0) 326 return 1; 327 } else { 328 /* indirect config - check typical address */ 329 if (ia->ia_addr == WM8750_ADDRESS) 330 return 1; 331 } 332 return 0; 333 } 334 335 static void 336 zaudio_attach(device_t parent, device_t self, void *aux) 337 { 338 struct zaudio_softc *sc = device_private(self); 339 struct i2c_attach_args *ia = aux; 340 int error; 341 342 sc->sc_dev = self; 343 sc->sc_i2c = ia->ia_tag; 344 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); 345 mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED); 346 347 aprint_normal(": I2S, WM8750 Audio\n"); 348 aprint_naive("\n"); 349 350 sc->sc_i2s.sc_iot = &pxa2x0_bs_tag; 351 sc->sc_i2s.sc_dmat = &pxa2x0_bus_dma_tag; 352 sc->sc_i2s.sc_size = PXA2X0_I2S_SIZE; 353 sc->sc_i2s.sc_intr_lock = &sc->sc_intr_lock; 354 if (pxa2x0_i2s_attach_sub(&sc->sc_i2s)) { 355 aprint_error_dev(self, "unable to attach I2S\n"); 356 goto fail_i2s; 357 } 358 359 /* Check for an I2C response from the wm8750 */ 360 iic_acquire_bus(sc->sc_i2c, 0); 361 error = wm8750_write(sc, RESET_REG, 0); 362 iic_release_bus(sc->sc_i2c, 0); 363 if (error) { 364 aprint_error_dev(self, "codec failed to respond\n"); 365 goto fail_i2c; 366 } 367 delay(100); 368 369 /* Speaker on, headphones off by default. */ 370 sc->sc_volume[ZAUDIO_OP_SPKR].left = 180; 371 UNMUTE(sc, ZAUDIO_OP_SPKR, 1); 372 sc->sc_volume[ZAUDIO_OP_HP].left = 180; 373 sc->sc_volume[ZAUDIO_OP_HP].right = 180; 374 UNMUTE(sc, ZAUDIO_OP_HP, 0); 375 sc->sc_volume[ZAUDIO_OP_MIC].left = 180; 376 UNMUTE(sc, ZAUDIO_OP_MIC, 0); 377 378 /* Configure headphone jack state change handling. */ 379 callout_init(&sc->sc_to, 0); 380 callout_setfunc(&sc->sc_to, zaudio_jack, sc); 381 pxa2x0_gpio_set_function(GPIO_HP_IN_C3000, GPIO_IN); 382 (void) pxa2x0_gpio_intr_establish(GPIO_HP_IN_C3000, IST_EDGE_BOTH, 383 IPL_BIO, zaudio_jack_intr, sc); 384 385 /* zaudio_init() implicitly depends on ioexp or scoop */ 386 config_finalize_register(self, zaudio_finalize); 387 388 audio_attach_mi(&wm8750_hw_if, sc, self); 389 390 if (!pmf_device_register(self, zaudio_suspend, zaudio_resume)) 391 aprint_error_dev(self, "couldn't establish power handler\n"); 392 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_UP, 393 zaudio_volume_up, true)) 394 aprint_error_dev(self, "couldn't register event handler\n"); 395 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_DOWN, 396 zaudio_volume_down, true)) 397 aprint_error_dev(self, "couldn't register event handler\n"); 398 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_TOGGLE, 399 zaudio_volume_toggle, true)) 400 aprint_error_dev(self, "couldn't register event handler\n"); 401 402 return; 403 404 fail_i2c: 405 pxa2x0_i2s_detach_sub(&sc->sc_i2s); 406 fail_i2s: 407 pmf_device_deregister(self); 408 } 409 410 static int 411 zaudio_finalize(device_t dv) 412 { 413 struct zaudio_softc *sc = device_private(dv); 414 415 zaudio_init(sc); 416 return 0; 417 } 418 419 static bool 420 zaudio_suspend(device_t dv, const pmf_qual_t *qual) 421 { 422 struct zaudio_softc *sc = device_private(dv); 423 424 callout_stop(&sc->sc_to); 425 zaudio_standby(sc); 426 427 return true; 428 } 429 430 static bool 431 zaudio_resume(device_t dv, const pmf_qual_t *qual) 432 { 433 struct zaudio_softc *sc = device_private(dv); 434 435 pxa2x0_i2s_init(&sc->sc_i2s); 436 zaudio_init(sc); 437 438 return true; 439 } 440 441 static __inline uint8_t 442 vol_sadd(int vol, int stride) 443 { 444 445 vol += stride; 446 if (vol > 255) 447 return 255; 448 return (uint8_t)vol; 449 } 450 451 #ifndef ZAUDIO_VOLUME_STRIDE 452 #define ZAUDIO_VOLUME_STRIDE 8 453 #endif 454 455 static void 456 zaudio_volume_up(device_t dv) 457 { 458 struct zaudio_softc *sc = device_private(dv); 459 int s; 460 461 s = splbio(); 462 iic_acquire_bus(sc->sc_i2c, 0); 463 464 sc->sc_volume[ZAUDIO_OP_SPKR].left = 465 vol_sadd(sc->sc_volume[ZAUDIO_OP_SPKR].left, ZAUDIO_VOLUME_STRIDE); 466 sc->sc_volume[ZAUDIO_OP_HP].left = 467 vol_sadd(sc->sc_volume[ZAUDIO_OP_HP].left, ZAUDIO_VOLUME_STRIDE); 468 sc->sc_volume[ZAUDIO_OP_HP].right = 469 vol_sadd(sc->sc_volume[ZAUDIO_OP_HP].right, ZAUDIO_VOLUME_STRIDE); 470 471 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 472 zaudio_update_volume(sc, ZAUDIO_OP_HP); 473 474 iic_release_bus(sc->sc_i2c, 0); 475 splx(s); 476 } 477 478 static __inline uint8_t 479 vol_ssub(int vol, int stride) 480 { 481 482 vol -= stride; 483 if (vol < 0) 484 return 0; 485 return (uint8_t)vol; 486 } 487 488 static void 489 zaudio_volume_down(device_t dv) 490 { 491 struct zaudio_softc *sc = device_private(dv); 492 int s; 493 494 s = splbio(); 495 iic_acquire_bus(sc->sc_i2c, 0); 496 497 sc->sc_volume[ZAUDIO_OP_SPKR].left = 498 vol_ssub(sc->sc_volume[ZAUDIO_OP_SPKR].left, ZAUDIO_VOLUME_STRIDE); 499 sc->sc_volume[ZAUDIO_OP_HP].left = 500 vol_ssub(sc->sc_volume[ZAUDIO_OP_HP].left, ZAUDIO_VOLUME_STRIDE); 501 sc->sc_volume[ZAUDIO_OP_HP].right = 502 vol_ssub(sc->sc_volume[ZAUDIO_OP_HP].right, ZAUDIO_VOLUME_STRIDE); 503 504 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 505 zaudio_update_volume(sc, ZAUDIO_OP_HP); 506 507 iic_release_bus(sc->sc_i2c, 0); 508 splx(s); 509 } 510 511 static void 512 zaudio_volume_toggle(device_t dv) 513 { 514 struct zaudio_softc *sc = device_private(dv); 515 int s; 516 517 s = splbio(); 518 iic_acquire_bus(sc->sc_i2c, 0); 519 520 if (!sc->sc_unmute[ZAUDIO_OP_SPKR] && !sc->sc_unmute[ZAUDIO_OP_HP]) { 521 sc->sc_unmute[ZAUDIO_OP_SPKR] = 522 sc->sc_unmute_toggle[ZAUDIO_OP_SPKR]; 523 sc->sc_unmute[ZAUDIO_OP_HP] = 524 sc->sc_unmute_toggle[ZAUDIO_OP_HP]; 525 } else { 526 sc->sc_unmute[ZAUDIO_OP_SPKR] = 0; 527 sc->sc_unmute[ZAUDIO_OP_HP] = 0; 528 } 529 zaudio_update_mutes(sc, 1); 530 531 iic_release_bus(sc->sc_i2c, 0); 532 splx(s); 533 } 534 535 static void 536 zaudio_init(struct zaudio_softc *sc) 537 { 538 539 iic_acquire_bus(sc->sc_i2c, 0); 540 541 /* Reset the codec */ 542 wm8750_write(sc, RESET_REG, 0); 543 delay(100); 544 545 /* Switch to standby power only */ 546 wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2)); 547 wm8750_write(sc, PWRMGMT2_REG, 0); 548 549 /* Configure digital interface for I2S */ 550 wm8750_write(sc, AUDINT_REG, AUDINT_SET_FORMAT(2)); 551 552 /* Initialise volume levels */ 553 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 554 zaudio_update_volume(sc, ZAUDIO_OP_HP); 555 zaudio_update_volume(sc, ZAUDIO_OP_MIC); 556 557 scoop_set_headphone(0); 558 if (ZAURUS_ISC1000) 559 ioexp_set_mic_bias(0); 560 else 561 scoop_set_mic_bias(0); 562 563 iic_release_bus(sc->sc_i2c, 0); 564 565 /* Assume that the jack state has changed. */ 566 zaudio_jack(sc); 567 } 568 569 static int 570 zaudio_jack_intr(void *v) 571 { 572 struct zaudio_softc *sc = v; 573 574 if (!callout_active(&sc->sc_to)) 575 zaudio_jack(sc); 576 577 return 1; 578 } 579 580 static void 581 zaudio_jack(void *v) 582 { 583 struct zaudio_softc *sc = v; 584 585 switch (sc->sc_state) { 586 case ZAUDIO_JACK_STATE_OUT: 587 if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 588 sc->sc_state = ZAUDIO_JACK_STATE_INS; 589 sc->sc_icount = 0; 590 } 591 break; 592 593 case ZAUDIO_JACK_STATE_INS: 594 if (sc->sc_icount++ > 2) { 595 if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 596 sc->sc_state = ZAUDIO_JACK_STATE_IN; 597 UNMUTE(sc, ZAUDIO_OP_SPKR, 0); 598 UNMUTE(sc, ZAUDIO_OP_HP, 1); 599 UNMUTE(sc, ZAUDIO_OP_MIC, 1); 600 goto update_mutes; 601 } else 602 sc->sc_state = ZAUDIO_JACK_STATE_OUT; 603 } 604 break; 605 606 case ZAUDIO_JACK_STATE_IN: 607 if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 608 sc->sc_state = ZAUDIO_JACK_STATE_REM; 609 sc->sc_icount = 0; 610 } 611 break; 612 613 case ZAUDIO_JACK_STATE_REM: 614 if (sc->sc_icount++ > 2) { 615 if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 616 sc->sc_state = ZAUDIO_JACK_STATE_OUT; 617 UNMUTE(sc, ZAUDIO_OP_SPKR, 1); 618 UNMUTE(sc, ZAUDIO_OP_HP, 0); 619 UNMUTE(sc, ZAUDIO_OP_MIC, 0); 620 goto update_mutes; 621 } else 622 sc->sc_state = ZAUDIO_JACK_STATE_IN; 623 } 624 break; 625 } 626 627 callout_schedule(&sc->sc_to, hz/4); 628 629 return; 630 631 update_mutes: 632 callout_stop(&sc->sc_to); 633 634 if (sc->sc_playing || sc->sc_recording) { 635 iic_acquire_bus(sc->sc_i2c, 0); 636 if (sc->sc_playing) 637 zaudio_update_mutes(sc, 1); 638 if (sc->sc_recording) 639 zaudio_update_mutes(sc, 2); 640 iic_release_bus(sc->sc_i2c, 0); 641 } 642 } 643 644 static void 645 zaudio_standby(struct zaudio_softc *sc) 646 { 647 648 iic_acquire_bus(sc->sc_i2c, 0); 649 650 /* Switch codec to standby power only */ 651 wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2)); 652 wm8750_write(sc, PWRMGMT2_REG, 0); 653 654 scoop_set_headphone(0); 655 if (ZAURUS_ISC1000) 656 ioexp_set_mic_bias(0); 657 else 658 scoop_set_mic_bias(0); 659 660 iic_release_bus(sc->sc_i2c, 0); 661 } 662 663 static void 664 zaudio_update_volume(struct zaudio_softc *sc, int output) 665 { 666 667 switch (output) { 668 case ZAUDIO_OP_SPKR: 669 wm8750_write(sc, LOUT2VOL_REG, LOUT2VOL_LO2VU | LOUT2VOL_LO2ZC | 670 LOUT2VOL_SET_LOUT2VOL(sc->sc_volume[ZAUDIO_OP_SPKR].left >> 1)); 671 wm8750_write(sc, ROUT2VOL_REG, ROUT2VOL_RO2VU | ROUT2VOL_RO2ZC | 672 ROUT2VOL_SET_ROUT2VOL(sc->sc_volume[ZAUDIO_OP_SPKR].left >> 1)); 673 break; 674 675 case ZAUDIO_OP_HP: 676 wm8750_write(sc, LOUT1VOL_REG, LOUT1VOL_LO1VU | LOUT1VOL_LO1ZC | 677 LOUT1VOL_SET_LOUT1VOL(sc->sc_volume[ZAUDIO_OP_HP].left >> 1)); 678 wm8750_write(sc, ROUT1VOL_REG, ROUT1VOL_RO1VU | ROUT1VOL_RO1ZC | 679 ROUT1VOL_SET_ROUT1VOL(sc->sc_volume[ZAUDIO_OP_HP].right >> 1)); 680 break; 681 682 case ZAUDIO_OP_MIC: 683 wm8750_write(sc, LINVOL_REG, LINVOL_LIVU | 684 LINVOL_SET_LINVOL(sc->sc_volume[ZAUDIO_OP_MIC].left >> 2)); 685 wm8750_write(sc, RINVOL_REG, RINVOL_RIVU | 686 RINVOL_SET_RINVOL(sc->sc_volume[ZAUDIO_OP_MIC].left >> 2)); 687 break; 688 } 689 } 690 691 static void 692 zaudio_update_mutes(struct zaudio_softc *sc, int mask) 693 { 694 uint16_t val; 695 696 /* playback */ 697 if (mask & 1) { 698 val = PWRMGMT2_DACL | PWRMGMT2_DACR; 699 if (sc->sc_unmute[ZAUDIO_OP_SPKR]) 700 val |= PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2; 701 if (sc->sc_unmute[ZAUDIO_OP_HP]) 702 val |= PWRMGMT2_LOUT1 | PWRMGMT2_ROUT1; 703 wm8750_write(sc, PWRMGMT2_REG, val); 704 scoop_set_headphone(sc->sc_unmute[ZAUDIO_OP_HP]); 705 } 706 707 /* record */ 708 if (mask & 2) { 709 val = PWRMGMT1_SET_VMIDSEL(1) | PWRMGMT1_VREF; 710 if (sc->sc_unmute[ZAUDIO_OP_MIC]) { 711 val |= PWRMGMT1_AINL | PWRMGMT1_AINR 712 | PWRMGMT1_ADCL | PWRMGMT1_ADCR | PWRMGMT1_MICB; 713 } 714 wm8750_write(sc, PWRMGMT1_REG, val); 715 if (ZAURUS_ISC1000) 716 ioexp_set_mic_bias(sc->sc_unmute[ZAUDIO_OP_MIC]); 717 else 718 scoop_set_mic_bias(sc->sc_unmute[ZAUDIO_OP_MIC]); 719 } 720 } 721 722 static void 723 zaudio_play_setup(struct zaudio_softc *sc) 724 { 725 int i; 726 727 iic_acquire_bus(sc->sc_i2c, 0); 728 729 /* Program the codec with playback settings */ 730 for (i = 0; playback_regs[i][0] != 0xffff; i++) { 731 wm8750_write(sc, playback_regs[i][0], playback_regs[i][1]); 732 } 733 zaudio_update_mutes(sc, 1); 734 735 iic_release_bus(sc->sc_i2c, 0); 736 } 737 738 /*static*/ void 739 zaudio_record_setup(struct zaudio_softc *sc) 740 { 741 int i; 742 743 iic_acquire_bus(sc->sc_i2c, 0); 744 745 /* Program the codec with playback settings */ 746 for (i = 0; record_regs[i][0] != 0xffff; i++) { 747 wm8750_write(sc, record_regs[i][0], record_regs[i][1]); 748 } 749 zaudio_update_mutes(sc, 2); 750 751 iic_release_bus(sc->sc_i2c, 0); 752 } 753 754 /* 755 * audio operation functions. 756 */ 757 static int 758 zaudio_open(void *hdl, int flags) 759 { 760 struct zaudio_softc *sc = hdl; 761 762 /* Power on the I2S bus and codec */ 763 pxa2x0_i2s_open(&sc->sc_i2s); 764 765 return 0; 766 } 767 768 static void 769 zaudio_close(void *hdl) 770 { 771 struct zaudio_softc *sc = hdl; 772 773 /* Power off the I2S bus and codec */ 774 pxa2x0_i2s_close(&sc->sc_i2s); 775 } 776 777 static int 778 zaudio_query_encoding(void *hdl, struct audio_encoding *aep) 779 { 780 781 switch (aep->index) { 782 case 0: 783 strlcpy(aep->name, AudioEulinear, sizeof(aep->name)); 784 aep->encoding = AUDIO_ENCODING_ULINEAR; 785 aep->precision = 8; 786 aep->flags = 0; 787 break; 788 789 case 1: 790 strlcpy(aep->name, AudioEmulaw, sizeof(aep->name)); 791 aep->encoding = AUDIO_ENCODING_ULAW; 792 aep->precision = 8; 793 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 794 break; 795 796 case 2: 797 strlcpy(aep->name, AudioEalaw, sizeof(aep->name)); 798 aep->encoding = AUDIO_ENCODING_ALAW; 799 aep->precision = 8; 800 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 801 break; 802 803 case 3: 804 strlcpy(aep->name, AudioEslinear, sizeof(aep->name)); 805 aep->encoding = AUDIO_ENCODING_SLINEAR; 806 aep->precision = 8; 807 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 808 break; 809 810 case 4: 811 strlcpy(aep->name, AudioEslinear_le, sizeof(aep->name)); 812 aep->encoding = AUDIO_ENCODING_SLINEAR_LE; 813 aep->precision = 16; 814 aep->flags = 0; 815 break; 816 817 case 5: 818 strlcpy(aep->name, AudioEulinear_le, sizeof(aep->name)); 819 aep->encoding = AUDIO_ENCODING_ULINEAR_LE; 820 aep->precision = 16; 821 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 822 break; 823 824 case 6: 825 strlcpy(aep->name, AudioEslinear_be, sizeof(aep->name)); 826 aep->encoding = AUDIO_ENCODING_SLINEAR_BE; 827 aep->precision = 16; 828 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 829 break; 830 831 case 7: 832 strlcpy(aep->name, AudioEulinear_be, sizeof(aep->name)); 833 aep->encoding = AUDIO_ENCODING_ULINEAR_BE; 834 aep->precision = 16; 835 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 836 break; 837 838 default: 839 return EINVAL; 840 } 841 842 return 0; 843 } 844 845 static int 846 zaudio_set_params(void *hdl, int setmode, int usemode, audio_params_t *play, 847 audio_params_t *rec, stream_filter_list_t *pfil, stream_filter_list_t *rfil) 848 { 849 struct zaudio_softc *sc = hdl; 850 struct audio_params *p; 851 stream_filter_list_t *fil; 852 int mode, i; 853 854 if (play->sample_rate != rec->sample_rate && 855 usemode == (AUMODE_PLAY | AUMODE_RECORD)) { 856 if (setmode == AUMODE_PLAY) { 857 rec->sample_rate = play->sample_rate; 858 setmode |= AUMODE_RECORD; 859 } else if (setmode == AUMODE_RECORD) { 860 play->sample_rate = rec->sample_rate; 861 setmode |= AUMODE_PLAY; 862 } else 863 return EINVAL; 864 } 865 866 for (mode = AUMODE_RECORD; mode != -1; 867 mode = (mode == AUMODE_RECORD) ? AUMODE_PLAY : -1) { 868 if ((setmode & mode) == 0) 869 continue; 870 871 p = (mode == AUMODE_PLAY) ? play : rec; 872 873 if (p->sample_rate < 4000 || p->sample_rate > 48000 || 874 (p->precision != 8 && p->precision != 16) || 875 (p->channels != 1 && p->channels != 2)) 876 return EINVAL; 877 878 fil = (mode == AUMODE_PLAY) ? pfil : rfil; 879 i = auconv_set_converter(zaudio_formats, zaudio_nformats, 880 mode, p, false, fil); 881 if (i < 0) 882 return EINVAL; 883 } 884 885 if (setmode == AUMODE_RECORD) 886 pxa2x0_i2s_setspeed(&sc->sc_i2s, &rec->sample_rate); 887 else 888 pxa2x0_i2s_setspeed(&sc->sc_i2s, &play->sample_rate); 889 890 return 0; 891 } 892 893 static int 894 zaudio_round_blocksize(void *hdl, int bs, int mode, const audio_params_t *param) 895 { 896 struct zaudio_softc *sc = hdl; 897 898 return pxa2x0_i2s_round_blocksize(&sc->sc_i2s, bs, mode, param); 899 } 900 901 static int 902 zaudio_halt_output(void *hdl) 903 { 904 struct zaudio_softc *sc = hdl; 905 int rv; 906 907 rv = pxa2x0_i2s_halt_output(&sc->sc_i2s); 908 if (!sc->sc_recording) 909 zaudio_standby(sc); 910 sc->sc_playing = 0; 911 912 return rv; 913 } 914 915 static int 916 zaudio_halt_input(void *hdl) 917 { 918 struct zaudio_softc *sc = hdl; 919 int rv; 920 921 rv = pxa2x0_i2s_halt_input(&sc->sc_i2s); 922 if (!sc->sc_playing) 923 zaudio_standby(sc); 924 sc->sc_recording = 0; 925 926 return rv; 927 } 928 929 static int 930 zaudio_getdev(void *hdl, struct audio_device *ret) 931 { 932 933 *ret = wm8750_device; 934 return 0; 935 } 936 937 #define ZAUDIO_SPKR_LVL 0 938 #define ZAUDIO_SPKR_MUTE 1 939 #define ZAUDIO_HP_LVL 2 940 #define ZAUDIO_HP_MUTE 3 941 #define ZAUDIO_MIC_LVL 4 942 #define ZAUDIO_MIC_MUTE 5 943 #define ZAUDIO_RECORD_SOURCE 6 944 #define ZAUDIO_OUTPUT_CLASS 7 945 #define ZAUDIO_INPUT_CLASS 8 946 #define ZAUDIO_RECORD_CLASS 9 947 948 static int 949 zaudio_set_port(void *hdl, struct mixer_ctrl *mc) 950 { 951 struct zaudio_softc *sc = hdl; 952 int error = EINVAL; 953 int s; 954 955 s = splbio(); 956 iic_acquire_bus(sc->sc_i2c, 0); 957 958 switch (mc->dev) { 959 case ZAUDIO_SPKR_LVL: 960 if (mc->type != AUDIO_MIXER_VALUE) 961 break; 962 if (mc->un.value.num_channels == 1) 963 sc->sc_volume[ZAUDIO_OP_SPKR].left = 964 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 965 else 966 break; 967 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 968 error = 0; 969 break; 970 971 case ZAUDIO_SPKR_MUTE: 972 if (mc->type != AUDIO_MIXER_ENUM) 973 break; 974 UNMUTE(sc, ZAUDIO_OP_SPKR, mc->un.ord ? 1 : 0); 975 zaudio_update_mutes(sc, 1); 976 error = 0; 977 break; 978 979 case ZAUDIO_HP_LVL: 980 if (mc->type != AUDIO_MIXER_VALUE) 981 break; 982 if (mc->un.value.num_channels == 1) { 983 sc->sc_volume[ZAUDIO_OP_HP].left = 984 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 985 sc->sc_volume[ZAUDIO_OP_HP].right = 986 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 987 } else if (mc->un.value.num_channels == 2) { 988 sc->sc_volume[ZAUDIO_OP_HP].left = 989 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]; 990 sc->sc_volume[ZAUDIO_OP_HP].right = 991 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]; 992 } 993 else 994 break; 995 zaudio_update_volume(sc, ZAUDIO_OP_HP); 996 error = 0; 997 break; 998 999 case ZAUDIO_HP_MUTE: 1000 if (mc->type != AUDIO_MIXER_ENUM) 1001 break; 1002 UNMUTE(sc, ZAUDIO_OP_HP, mc->un.ord ? 1 : 0); 1003 zaudio_update_mutes(sc, 1); 1004 error = 0; 1005 break; 1006 1007 case ZAUDIO_MIC_LVL: 1008 if (mc->type != AUDIO_MIXER_VALUE) 1009 break; 1010 if (mc->un.value.num_channels == 1) 1011 sc->sc_volume[ZAUDIO_OP_MIC].left = 1012 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 1013 else 1014 break; 1015 zaudio_update_volume(sc, ZAUDIO_OP_MIC); 1016 error = 0; 1017 break; 1018 1019 case ZAUDIO_MIC_MUTE: 1020 if (mc->type != AUDIO_MIXER_ENUM) 1021 break; 1022 UNMUTE(sc, ZAUDIO_OP_MIC, mc->un.ord ? 1 : 0); 1023 zaudio_update_mutes(sc, 2); 1024 error = 0; 1025 break; 1026 1027 case ZAUDIO_RECORD_SOURCE: 1028 if (mc->type != AUDIO_MIXER_ENUM) 1029 break; 1030 if (mc->un.ord != 0) 1031 break; 1032 /* MIC only */ 1033 error = 0; 1034 break; 1035 } 1036 1037 iic_release_bus(sc->sc_i2c, 0); 1038 splx(s); 1039 1040 return error; 1041 } 1042 1043 static int 1044 zaudio_get_port(void *hdl, struct mixer_ctrl *mc) 1045 { 1046 struct zaudio_softc *sc = hdl; 1047 int error = EINVAL; 1048 1049 switch (mc->dev) { 1050 case ZAUDIO_SPKR_LVL: 1051 if (mc->type != AUDIO_MIXER_VALUE) 1052 break; 1053 if (mc->un.value.num_channels == 1) 1054 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 1055 sc->sc_volume[ZAUDIO_OP_SPKR].left; 1056 else 1057 break; 1058 error = 0; 1059 break; 1060 1061 case ZAUDIO_SPKR_MUTE: 1062 if (mc->type != AUDIO_MIXER_ENUM) 1063 break; 1064 mc->un.ord = sc->sc_unmute[ZAUDIO_OP_SPKR] ? 1 : 0; 1065 error = 0; 1066 break; 1067 1068 case ZAUDIO_HP_LVL: 1069 if (mc->type != AUDIO_MIXER_VALUE) 1070 break; 1071 if (mc->un.value.num_channels == 1) 1072 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 1073 sc->sc_volume[ZAUDIO_OP_HP].left; 1074 else if (mc->un.value.num_channels == 2) { 1075 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 1076 sc->sc_volume[ZAUDIO_OP_HP].left; 1077 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 1078 sc->sc_volume[ZAUDIO_OP_HP].right; 1079 } 1080 else 1081 break; 1082 error = 0; 1083 break; 1084 1085 case ZAUDIO_HP_MUTE: 1086 if (mc->type != AUDIO_MIXER_ENUM) 1087 break; 1088 mc->un.ord = sc->sc_unmute[ZAUDIO_OP_HP] ? 1 : 0; 1089 error = 0; 1090 break; 1091 1092 case ZAUDIO_MIC_LVL: 1093 if (mc->type != AUDIO_MIXER_VALUE) 1094 break; 1095 if (mc->un.value.num_channels == 1) 1096 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 1097 sc->sc_volume[ZAUDIO_OP_MIC].left; 1098 else 1099 break; 1100 error = 0; 1101 break; 1102 1103 case ZAUDIO_MIC_MUTE: 1104 if (mc->type != AUDIO_MIXER_ENUM) 1105 break; 1106 mc->un.ord = sc->sc_unmute[ZAUDIO_OP_MIC] ? 1 : 0; 1107 error = 0; 1108 break; 1109 1110 case ZAUDIO_RECORD_SOURCE: 1111 if (mc->type != AUDIO_MIXER_ENUM) 1112 break; 1113 mc->un.ord = 0; /* MIC only */ 1114 error = 0; 1115 break; 1116 } 1117 1118 return error; 1119 } 1120 1121 /*ARGSUSED*/ 1122 static int 1123 zaudio_query_devinfo(void *hdl, struct mixer_devinfo *di) 1124 { 1125 1126 switch (di->index) { 1127 case ZAUDIO_SPKR_LVL: 1128 di->type = AUDIO_MIXER_VALUE; 1129 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1130 di->prev = AUDIO_MIXER_LAST; 1131 di->next = ZAUDIO_SPKR_MUTE; 1132 strlcpy(di->label.name, AudioNspeaker, sizeof(di->label.name)); 1133 strlcpy(di->un.v.units.name, AudioNvolume, 1134 sizeof(di->un.v.units.name)); 1135 di->un.v.num_channels = 1; 1136 break; 1137 1138 case ZAUDIO_SPKR_MUTE: 1139 di->type = AUDIO_MIXER_ENUM; 1140 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1141 di->prev = ZAUDIO_SPKR_LVL; 1142 di->next = AUDIO_MIXER_LAST; 1143 goto mute; 1144 1145 case ZAUDIO_HP_LVL: 1146 di->type = AUDIO_MIXER_VALUE; 1147 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1148 di->prev = AUDIO_MIXER_LAST; 1149 di->next = ZAUDIO_HP_MUTE; 1150 strlcpy(di->label.name, AudioNheadphone, 1151 sizeof(di->label.name)); 1152 di->un.v.num_channels = 1; 1153 strlcpy(di->un.v.units.name, AudioNvolume, 1154 sizeof(di->un.v.units.name)); 1155 break; 1156 1157 case ZAUDIO_HP_MUTE: 1158 di->type = AUDIO_MIXER_ENUM; 1159 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1160 di->prev = ZAUDIO_HP_LVL; 1161 di->next = AUDIO_MIXER_LAST; 1162 mute: 1163 strlcpy(di->label.name, AudioNmute, sizeof(di->label.name)); 1164 di->un.e.num_mem = 2; 1165 strlcpy(di->un.e.member[0].label.name, AudioNon, 1166 sizeof(di->un.e.member[0].label.name)); 1167 di->un.e.member[0].ord = 0; 1168 strlcpy(di->un.e.member[1].label.name, AudioNoff, 1169 sizeof(di->un.e.member[1].label.name)); 1170 di->un.e.member[1].ord = 1; 1171 break; 1172 1173 case ZAUDIO_MIC_LVL: 1174 di->type = AUDIO_MIXER_VALUE; 1175 di->mixer_class = ZAUDIO_INPUT_CLASS; 1176 di->prev = AUDIO_MIXER_LAST; 1177 di->next = ZAUDIO_MIC_MUTE; 1178 strlcpy(di->label.name, AudioNmicrophone, 1179 sizeof(di->label.name)); 1180 strlcpy(di->un.v.units.name, AudioNvolume, 1181 sizeof(di->un.v.units.name)); 1182 di->un.v.num_channels = 1; 1183 break; 1184 1185 case ZAUDIO_MIC_MUTE: 1186 di->type = AUDIO_MIXER_ENUM; 1187 di->mixer_class = ZAUDIO_INPUT_CLASS; 1188 di->prev = ZAUDIO_MIC_LVL; 1189 di->next = AUDIO_MIXER_LAST; 1190 goto mute; 1191 1192 case ZAUDIO_RECORD_SOURCE: 1193 di->type = AUDIO_MIXER_ENUM; 1194 di->mixer_class = ZAUDIO_RECORD_CLASS; 1195 di->prev = AUDIO_MIXER_LAST; 1196 di->next = AUDIO_MIXER_LAST; 1197 strlcpy(di->label.name, AudioNsource, sizeof(di->label.name)); 1198 di->un.e.num_mem = 1; 1199 strlcpy(di->un.e.member[0].label.name, AudioNmicrophone, 1200 sizeof(di->un.e.member[0].label.name)); 1201 di->un.e.member[0].ord = 0; 1202 break; 1203 1204 case ZAUDIO_OUTPUT_CLASS: 1205 di->type = AUDIO_MIXER_CLASS; 1206 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1207 di->prev = AUDIO_MIXER_LAST; 1208 di->next = AUDIO_MIXER_LAST; 1209 strlcpy(di->label.name, AudioCoutputs, sizeof(di->label.name)); 1210 break; 1211 1212 case ZAUDIO_INPUT_CLASS: 1213 di->type = AUDIO_MIXER_CLASS; 1214 di->mixer_class = ZAUDIO_INPUT_CLASS; 1215 di->prev = AUDIO_MIXER_LAST; 1216 di->next = AUDIO_MIXER_LAST; 1217 strlcpy(di->label.name, AudioCinputs, sizeof(di->label.name)); 1218 break; 1219 1220 case ZAUDIO_RECORD_CLASS: 1221 di->type = AUDIO_MIXER_CLASS; 1222 di->mixer_class = ZAUDIO_RECORD_CLASS; 1223 di->prev = AUDIO_MIXER_LAST; 1224 di->next = AUDIO_MIXER_LAST; 1225 strlcpy(di->label.name, AudioCinputs, sizeof(di->label.name)); 1226 break; 1227 1228 default: 1229 return ENXIO; 1230 } 1231 1232 return 0; 1233 } 1234 1235 static void * 1236 zaudio_allocm(void *hdl, int direction, size_t size) 1237 { 1238 struct zaudio_softc *sc = hdl; 1239 1240 return pxa2x0_i2s_allocm(&sc->sc_i2s, direction, size); 1241 } 1242 1243 static void 1244 zaudio_freem(void *hdl, void *ptr, size_t size) 1245 { 1246 struct zaudio_softc *sc = hdl; 1247 1248 return pxa2x0_i2s_freem(&sc->sc_i2s, ptr, size); 1249 } 1250 1251 static size_t 1252 zaudio_round_buffersize(void *hdl, int direction, size_t bufsize) 1253 { 1254 struct zaudio_softc *sc = hdl; 1255 1256 return pxa2x0_i2s_round_buffersize(&sc->sc_i2s, direction, bufsize); 1257 } 1258 1259 static paddr_t 1260 zaudio_mappage(void *hdl, void *mem, off_t off, int prot) 1261 { 1262 struct zaudio_softc *sc = hdl; 1263 1264 return pxa2x0_i2s_mappage(&sc->sc_i2s, mem, off, prot); 1265 } 1266 1267 static int 1268 zaudio_get_props(void *hdl) 1269 { 1270 1271 return AUDIO_PROP_MMAP|AUDIO_PROP_INDEPENDENT; 1272 } 1273 1274 static int 1275 zaudio_start_output(void *hdl, void *block, int bsize, void (*intr)(void *), 1276 void *intrarg) 1277 { 1278 struct zaudio_softc *sc = hdl; 1279 int rv; 1280 1281 /* Power up codec if we are not already playing. */ 1282 if (!sc->sc_playing) { 1283 sc->sc_playing = 1; 1284 zaudio_play_setup(sc); 1285 } 1286 1287 /* Start DMA via I2S */ 1288 rv = pxa2x0_i2s_start_output(&sc->sc_i2s, block, bsize, intr, intrarg); 1289 if (rv) { 1290 if (!sc->sc_recording) 1291 zaudio_standby(sc); 1292 sc->sc_playing = 0; 1293 } 1294 1295 return rv; 1296 } 1297 1298 static int 1299 zaudio_start_input(void *hdl, void *block, int bsize, void (*intr)(void *), 1300 void *intrarg) 1301 { 1302 struct zaudio_softc *sc = hdl; 1303 int rv; 1304 1305 /* Power up codec if we are not already recording. */ 1306 if (!sc->sc_recording) { 1307 sc->sc_recording = 1; 1308 zaudio_record_setup(sc); 1309 } 1310 1311 /* Start DMA via I2S */ 1312 rv = pxa2x0_i2s_start_input(&sc->sc_i2s, block, bsize, intr, intrarg); 1313 if (rv) { 1314 if (!sc->sc_playing) 1315 zaudio_standby(sc); 1316 sc->sc_recording = 0; 1317 } 1318 return rv; 1319 } 1320 1321 static void 1322 zaudio_get_locks(void *hdl, kmutex_t **intr, kmutex_t **thread) 1323 { 1324 struct zaudio_softc *sc = hdl; 1325 1326 *intr = &sc->sc_intr_lock; 1327 *thread = &sc->sc_lock; 1328 } 1329
Indexes created Wed Oct 22 13:09:56 GMT 2025