zaudio.c revision 1.16
1 /* $NetBSD: zaudio.c,v 1.16 2011/11/23 23:07:30 jmcneill 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 REGENTS AND CONTRIBUTORS ``AS IS'' AND 34 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 35 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 36 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 37 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 38 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 39 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 40 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 41 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 42 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 43 * SUCH DAMAGE. 44 */ 45 46 /* 47 * TODO: 48 * - powerhooks (currently only works until first suspend) 49 */ 50 51 #include "opt_zaudio.h" 52 53 #include <sys/cdefs.h> 54 __KERNEL_RCSID(0, "$NetBSD: zaudio.c,v 1.16 2011/11/23 23:07:30 jmcneill 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/wm8750reg.h> 82 #include <zaurus/dev/scoopvar.h> 83 #include <zaurus/dev/ioexpvar.h> 84 85 #define WM8750_ADDRESS 0x1B 86 87 /* GPIO pins */ 88 #define GPIO_HP_IN_C3000 116 89 90 #define ZAUDIO_OP_SPKR 0 91 #define ZAUDIO_OP_HP 1 92 #define ZAUDIO_OP_MIC 2 93 #define ZAUDIO_OP_NUM 3 94 95 #define ZAUDIO_JACK_STATE_OUT 0 96 #define ZAUDIO_JACK_STATE_IN 1 97 #define ZAUDIO_JACK_STATE_INS 2 98 #define ZAUDIO_JACK_STATE_REM 3 99 100 struct zaudio_volume { 101 uint8_t left; 102 uint8_t right; 103 }; 104 105 struct zaudio_softc { 106 device_t sc_dev; 107 kmutex_t sc_lock; 108 kmutex_t sc_intr_lock; 109 110 /* i2s device softc */ 111 /* NB: pxa2x0_i2s requires this to be the second struct member */ 112 struct pxa2x0_i2s_softc sc_i2s; 113 114 i2c_tag_t sc_i2c; 115 116 int sc_playing; 117 int sc_recording; 118 119 struct zaudio_volume sc_volume[ZAUDIO_OP_NUM]; 120 uint8_t sc_unmute[ZAUDIO_OP_NUM]; 121 uint8_t sc_unmute_toggle[ZAUDIO_OP_NUM]; 122 123 int sc_state; 124 int sc_icount; 125 struct callout sc_to; 126 }; 127 128 #define UNMUTE(sc,op,val) sc->sc_unmute[op] = sc->sc_unmute_toggle[op] = val 129 130 static int zaudio_match(device_t, cfdata_t, void *); 131 static void zaudio_attach(device_t, device_t, void *); 132 133 CFATTACH_DECL_NEW(zaudio, sizeof(struct zaudio_softc), 134 zaudio_match, zaudio_attach, NULL, NULL); 135 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(sc); 386 387 audio_attach_mi(&wm8750_hw_if, sc, self); 388 389 if (!pmf_device_register(self, zaudio_suspend, zaudio_resume)) 390 aprint_error_dev(self, "couldn't establish power handler\n"); 391 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_UP, 392 zaudio_volume_up, true)) 393 aprint_error_dev(self, "couldn't register event handler\n"); 394 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_DOWN, 395 zaudio_volume_down, true)) 396 aprint_error_dev(self, "couldn't register event handler\n"); 397 if (!pmf_event_register(self, PMFE_AUDIO_VOLUME_TOGGLE, 398 zaudio_volume_toggle, true)) 399 aprint_error_dev(self, "couldn't register event handler\n"); 400 401 return; 402 403 fail_i2c: 404 pxa2x0_i2s_detach_sub(&sc->sc_i2s); 405 fail_i2s: 406 pmf_device_deregister(self); 407 } 408 409 static bool 410 zaudio_suspend(device_t dv, const pmf_qual_t *qual) 411 { 412 struct zaudio_softc *sc = device_private(dv); 413 414 callout_stop(&sc->sc_to); 415 zaudio_standby(sc); 416 417 return true; 418 } 419 420 static bool 421 zaudio_resume(device_t dv, const pmf_qual_t *qual) 422 { 423 struct zaudio_softc *sc = device_private(dv); 424 425 pxa2x0_i2s_init(&sc->sc_i2s); 426 zaudio_init(sc); 427 428 return true; 429 } 430 431 static __inline uint8_t 432 vol_sadd(int vol, int stride) 433 { 434 435 vol += stride; 436 if (vol > 255) 437 return 255; 438 return (uint8_t)vol; 439 } 440 441 #ifndef ZAUDIO_VOLUME_STRIDE 442 #define ZAUDIO_VOLUME_STRIDE 8 443 #endif 444 445 static void 446 zaudio_volume_up(device_t dv) 447 { 448 struct zaudio_softc *sc = device_private(dv); 449 int s; 450 451 s = splbio(); 452 iic_acquire_bus(sc->sc_i2c, 0); 453 454 sc->sc_volume[ZAUDIO_OP_SPKR].left = 455 vol_sadd(sc->sc_volume[ZAUDIO_OP_SPKR].left, ZAUDIO_VOLUME_STRIDE); 456 sc->sc_volume[ZAUDIO_OP_HP].left = 457 vol_sadd(sc->sc_volume[ZAUDIO_OP_HP].left, ZAUDIO_VOLUME_STRIDE); 458 sc->sc_volume[ZAUDIO_OP_HP].right = 459 vol_sadd(sc->sc_volume[ZAUDIO_OP_HP].right, ZAUDIO_VOLUME_STRIDE); 460 461 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 462 zaudio_update_volume(sc, ZAUDIO_OP_HP); 463 464 iic_release_bus(sc->sc_i2c, 0); 465 splx(s); 466 } 467 468 static __inline uint8_t 469 vol_ssub(int vol, int stride) 470 { 471 472 vol -= stride; 473 if (vol < 0) 474 return 0; 475 return (uint8_t)vol; 476 } 477 478 static void 479 zaudio_volume_down(device_t dv) 480 { 481 struct zaudio_softc *sc = device_private(dv); 482 int s; 483 484 s = splbio(); 485 iic_acquire_bus(sc->sc_i2c, 0); 486 487 sc->sc_volume[ZAUDIO_OP_SPKR].left = 488 vol_ssub(sc->sc_volume[ZAUDIO_OP_SPKR].left, ZAUDIO_VOLUME_STRIDE); 489 sc->sc_volume[ZAUDIO_OP_HP].left = 490 vol_ssub(sc->sc_volume[ZAUDIO_OP_HP].left, ZAUDIO_VOLUME_STRIDE); 491 sc->sc_volume[ZAUDIO_OP_HP].right = 492 vol_ssub(sc->sc_volume[ZAUDIO_OP_HP].right, ZAUDIO_VOLUME_STRIDE); 493 494 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 495 zaudio_update_volume(sc, ZAUDIO_OP_HP); 496 497 iic_release_bus(sc->sc_i2c, 0); 498 splx(s); 499 } 500 501 static void 502 zaudio_volume_toggle(device_t dv) 503 { 504 struct zaudio_softc *sc = device_private(dv); 505 int s; 506 507 s = splbio(); 508 iic_acquire_bus(sc->sc_i2c, 0); 509 510 if (!sc->sc_unmute[ZAUDIO_OP_SPKR] && !sc->sc_unmute[ZAUDIO_OP_HP]) { 511 sc->sc_unmute[ZAUDIO_OP_SPKR] = 512 sc->sc_unmute_toggle[ZAUDIO_OP_SPKR]; 513 sc->sc_unmute[ZAUDIO_OP_HP] = 514 sc->sc_unmute_toggle[ZAUDIO_OP_HP]; 515 } else { 516 sc->sc_unmute[ZAUDIO_OP_SPKR] = 0; 517 sc->sc_unmute[ZAUDIO_OP_HP] = 0; 518 } 519 zaudio_update_mutes(sc, 1); 520 521 iic_release_bus(sc->sc_i2c, 0); 522 splx(s); 523 } 524 525 static void 526 zaudio_init(struct zaudio_softc *sc) 527 { 528 529 iic_acquire_bus(sc->sc_i2c, 0); 530 531 /* Reset the codec */ 532 wm8750_write(sc, RESET_REG, 0); 533 delay(100); 534 535 /* Switch to standby power only */ 536 wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2)); 537 wm8750_write(sc, PWRMGMT2_REG, 0); 538 539 /* Configure digital interface for I2S */ 540 wm8750_write(sc, AUDINT_REG, AUDINT_SET_FORMAT(2)); 541 542 /* Initialise volume levels */ 543 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 544 zaudio_update_volume(sc, ZAUDIO_OP_HP); 545 zaudio_update_volume(sc, ZAUDIO_OP_MIC); 546 547 scoop_set_headphone(0); 548 if (ZAURUS_ISC1000) 549 ioexp_set_mic_bias(0); 550 else 551 scoop_set_mic_bias(0); 552 553 iic_release_bus(sc->sc_i2c, 0); 554 555 /* Assume that the jack state has changed. */ 556 zaudio_jack(sc); 557 } 558 559 static int 560 zaudio_jack_intr(void *v) 561 { 562 struct zaudio_softc *sc = v; 563 564 if (!callout_active(&sc->sc_to)) 565 zaudio_jack(sc); 566 567 return 1; 568 } 569 570 static void 571 zaudio_jack(void *v) 572 { 573 struct zaudio_softc *sc = v; 574 575 switch (sc->sc_state) { 576 case ZAUDIO_JACK_STATE_OUT: 577 if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 578 sc->sc_state = ZAUDIO_JACK_STATE_INS; 579 sc->sc_icount = 0; 580 } 581 break; 582 583 case ZAUDIO_JACK_STATE_INS: 584 if (sc->sc_icount++ > 2) { 585 if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 586 sc->sc_state = ZAUDIO_JACK_STATE_IN; 587 UNMUTE(sc, ZAUDIO_OP_SPKR, 0); 588 UNMUTE(sc, ZAUDIO_OP_HP, 1); 589 UNMUTE(sc, ZAUDIO_OP_MIC, 1); 590 goto update_mutes; 591 } else 592 sc->sc_state = ZAUDIO_JACK_STATE_OUT; 593 } 594 break; 595 596 case ZAUDIO_JACK_STATE_IN: 597 if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 598 sc->sc_state = ZAUDIO_JACK_STATE_REM; 599 sc->sc_icount = 0; 600 } 601 break; 602 603 case ZAUDIO_JACK_STATE_REM: 604 if (sc->sc_icount++ > 2) { 605 if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) { 606 sc->sc_state = ZAUDIO_JACK_STATE_OUT; 607 UNMUTE(sc, ZAUDIO_OP_SPKR, 1); 608 UNMUTE(sc, ZAUDIO_OP_HP, 0); 609 UNMUTE(sc, ZAUDIO_OP_MIC, 0); 610 goto update_mutes; 611 } else 612 sc->sc_state = ZAUDIO_JACK_STATE_IN; 613 } 614 break; 615 } 616 617 callout_schedule(&sc->sc_to, hz/4); 618 619 return; 620 621 update_mutes: 622 callout_stop(&sc->sc_to); 623 624 if (sc->sc_playing || sc->sc_recording) { 625 iic_acquire_bus(sc->sc_i2c, 0); 626 if (sc->sc_playing) 627 zaudio_update_mutes(sc, 1); 628 if (sc->sc_recording) 629 zaudio_update_mutes(sc, 2); 630 iic_release_bus(sc->sc_i2c, 0); 631 } 632 } 633 634 static void 635 zaudio_standby(struct zaudio_softc *sc) 636 { 637 638 iic_acquire_bus(sc->sc_i2c, 0); 639 640 /* Switch codec to standby power only */ 641 wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2)); 642 wm8750_write(sc, PWRMGMT2_REG, 0); 643 644 scoop_set_headphone(0); 645 if (ZAURUS_ISC1000) 646 ioexp_set_mic_bias(0); 647 else 648 scoop_set_mic_bias(0); 649 650 iic_release_bus(sc->sc_i2c, 0); 651 } 652 653 static void 654 zaudio_update_volume(struct zaudio_softc *sc, int output) 655 { 656 657 switch (output) { 658 case ZAUDIO_OP_SPKR: 659 wm8750_write(sc, LOUT2VOL_REG, LOUT2VOL_LO2VU | LOUT2VOL_LO2ZC | 660 LOUT2VOL_SET_LOUT2VOL(sc->sc_volume[ZAUDIO_OP_SPKR].left >> 1)); 661 wm8750_write(sc, ROUT2VOL_REG, ROUT2VOL_RO2VU | ROUT2VOL_RO2ZC | 662 ROUT2VOL_SET_ROUT2VOL(sc->sc_volume[ZAUDIO_OP_SPKR].left >> 1)); 663 break; 664 665 case ZAUDIO_OP_HP: 666 wm8750_write(sc, LOUT1VOL_REG, LOUT1VOL_LO1VU | LOUT1VOL_LO1ZC | 667 LOUT1VOL_SET_LOUT1VOL(sc->sc_volume[ZAUDIO_OP_HP].left >> 1)); 668 wm8750_write(sc, ROUT1VOL_REG, ROUT1VOL_RO1VU | ROUT1VOL_RO1ZC | 669 ROUT1VOL_SET_ROUT1VOL(sc->sc_volume[ZAUDIO_OP_HP].right >> 1)); 670 break; 671 672 case ZAUDIO_OP_MIC: 673 wm8750_write(sc, LINVOL_REG, LINVOL_LIVU | 674 LINVOL_SET_LINVOL(sc->sc_volume[ZAUDIO_OP_MIC].left >> 2)); 675 wm8750_write(sc, RINVOL_REG, RINVOL_RIVU | 676 RINVOL_SET_RINVOL(sc->sc_volume[ZAUDIO_OP_MIC].left >> 2)); 677 break; 678 } 679 } 680 681 static void 682 zaudio_update_mutes(struct zaudio_softc *sc, int mask) 683 { 684 uint16_t val; 685 686 /* playback */ 687 if (mask & 1) { 688 val = PWRMGMT2_DACL | PWRMGMT2_DACR; 689 if (sc->sc_unmute[ZAUDIO_OP_SPKR]) 690 val |= PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2; 691 if (sc->sc_unmute[ZAUDIO_OP_HP]) 692 val |= PWRMGMT2_LOUT1 | PWRMGMT2_ROUT1; 693 wm8750_write(sc, PWRMGMT2_REG, val); 694 scoop_set_headphone(sc->sc_unmute[ZAUDIO_OP_HP]); 695 } 696 697 /* record */ 698 if (mask & 2) { 699 val = PWRMGMT1_SET_VMIDSEL(1) | PWRMGMT1_VREF; 700 if (sc->sc_unmute[ZAUDIO_OP_MIC]) { 701 val |= PWRMGMT1_AINL | PWRMGMT1_AINR 702 | PWRMGMT1_ADCL | PWRMGMT1_ADCR | PWRMGMT1_MICB; 703 } 704 wm8750_write(sc, PWRMGMT1_REG, val); 705 if (ZAURUS_ISC1000) 706 ioexp_set_mic_bias(sc->sc_unmute[ZAUDIO_OP_MIC]); 707 else 708 scoop_set_mic_bias(sc->sc_unmute[ZAUDIO_OP_MIC]); 709 } 710 } 711 712 static void 713 zaudio_play_setup(struct zaudio_softc *sc) 714 { 715 int i; 716 717 iic_acquire_bus(sc->sc_i2c, 0); 718 719 /* Program the codec with playback settings */ 720 for (i = 0; playback_regs[i][0] != 0xffff; i++) { 721 wm8750_write(sc, playback_regs[i][0], playback_regs[i][1]); 722 } 723 zaudio_update_mutes(sc, 1); 724 725 iic_release_bus(sc->sc_i2c, 0); 726 } 727 728 /*static*/ void 729 zaudio_record_setup(struct zaudio_softc *sc) 730 { 731 int i; 732 733 iic_acquire_bus(sc->sc_i2c, 0); 734 735 /* Program the codec with playback settings */ 736 for (i = 0; record_regs[i][0] != 0xffff; i++) { 737 wm8750_write(sc, record_regs[i][0], record_regs[i][1]); 738 } 739 zaudio_update_mutes(sc, 2); 740 741 iic_release_bus(sc->sc_i2c, 0); 742 } 743 744 /* 745 * audio operation functions. 746 */ 747 static int 748 zaudio_open(void *hdl, int flags) 749 { 750 struct zaudio_softc *sc = hdl; 751 752 /* Power on the I2S bus and codec */ 753 pxa2x0_i2s_open(&sc->sc_i2s); 754 755 return 0; 756 } 757 758 static void 759 zaudio_close(void *hdl) 760 { 761 struct zaudio_softc *sc = hdl; 762 763 /* Power off the I2S bus and codec */ 764 pxa2x0_i2s_close(&sc->sc_i2s); 765 } 766 767 static int 768 zaudio_query_encoding(void *hdl, struct audio_encoding *aep) 769 { 770 771 switch (aep->index) { 772 case 0: 773 strlcpy(aep->name, AudioEulinear, sizeof(aep->name)); 774 aep->encoding = AUDIO_ENCODING_ULINEAR; 775 aep->precision = 8; 776 aep->flags = 0; 777 break; 778 779 case 1: 780 strlcpy(aep->name, AudioEmulaw, sizeof(aep->name)); 781 aep->encoding = AUDIO_ENCODING_ULAW; 782 aep->precision = 8; 783 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 784 break; 785 786 case 2: 787 strlcpy(aep->name, AudioEalaw, sizeof(aep->name)); 788 aep->encoding = AUDIO_ENCODING_ALAW; 789 aep->precision = 8; 790 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 791 break; 792 793 case 3: 794 strlcpy(aep->name, AudioEslinear, sizeof(aep->name)); 795 aep->encoding = AUDIO_ENCODING_SLINEAR; 796 aep->precision = 8; 797 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 798 break; 799 800 case 4: 801 strlcpy(aep->name, AudioEslinear_le, sizeof(aep->name)); 802 aep->encoding = AUDIO_ENCODING_SLINEAR_LE; 803 aep->precision = 16; 804 aep->flags = 0; 805 break; 806 807 case 5: 808 strlcpy(aep->name, AudioEulinear_le, sizeof(aep->name)); 809 aep->encoding = AUDIO_ENCODING_ULINEAR_LE; 810 aep->precision = 16; 811 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 812 break; 813 814 case 6: 815 strlcpy(aep->name, AudioEslinear_be, sizeof(aep->name)); 816 aep->encoding = AUDIO_ENCODING_SLINEAR_BE; 817 aep->precision = 16; 818 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 819 break; 820 821 case 7: 822 strlcpy(aep->name, AudioEulinear_be, sizeof(aep->name)); 823 aep->encoding = AUDIO_ENCODING_ULINEAR_BE; 824 aep->precision = 16; 825 aep->flags = AUDIO_ENCODINGFLAG_EMULATED; 826 break; 827 828 default: 829 return EINVAL; 830 } 831 832 return 0; 833 } 834 835 static int 836 zaudio_set_params(void *hdl, int setmode, int usemode, audio_params_t *play, 837 audio_params_t *rec, stream_filter_list_t *pfil, stream_filter_list_t *rfil) 838 { 839 struct zaudio_softc *sc = hdl; 840 struct audio_params *p; 841 stream_filter_list_t *fil; 842 int mode, i; 843 844 if (play->sample_rate != rec->sample_rate && 845 usemode == (AUMODE_PLAY | AUMODE_RECORD)) { 846 if (setmode == AUMODE_PLAY) { 847 rec->sample_rate = play->sample_rate; 848 setmode |= AUMODE_RECORD; 849 } else if (setmode == AUMODE_RECORD) { 850 play->sample_rate = rec->sample_rate; 851 setmode |= AUMODE_PLAY; 852 } else 853 return EINVAL; 854 } 855 856 for (mode = AUMODE_RECORD; mode != -1; 857 mode = (mode == AUMODE_RECORD) ? AUMODE_PLAY : -1) { 858 if ((setmode & mode) == 0) 859 continue; 860 861 p = (mode == AUMODE_PLAY) ? play : rec; 862 863 if (p->sample_rate < 4000 || p->sample_rate > 48000 || 864 (p->precision != 8 && p->precision != 16) || 865 (p->channels != 1 && p->channels != 2)) 866 return EINVAL; 867 868 fil = (mode == AUMODE_PLAY) ? pfil : rfil; 869 i = auconv_set_converter(zaudio_formats, zaudio_nformats, 870 mode, p, false, fil); 871 if (i < 0) 872 return EINVAL; 873 } 874 875 if (setmode == AUMODE_RECORD) 876 pxa2x0_i2s_setspeed(&sc->sc_i2s, &rec->sample_rate); 877 else 878 pxa2x0_i2s_setspeed(&sc->sc_i2s, &play->sample_rate); 879 880 return 0; 881 } 882 883 static int 884 zaudio_round_blocksize(void *hdl, int bs, int mode, const audio_params_t *param) 885 { 886 struct zaudio_softc *sc = hdl; 887 888 return pxa2x0_i2s_round_blocksize(&sc->sc_i2s, bs, mode, param); 889 } 890 891 static int 892 zaudio_halt_output(void *hdl) 893 { 894 struct zaudio_softc *sc = hdl; 895 int rv; 896 897 rv = pxa2x0_i2s_halt_output(&sc->sc_i2s); 898 if (!sc->sc_recording) 899 zaudio_standby(sc); 900 sc->sc_playing = 0; 901 902 return rv; 903 } 904 905 static int 906 zaudio_halt_input(void *hdl) 907 { 908 struct zaudio_softc *sc = hdl; 909 int rv; 910 911 rv = pxa2x0_i2s_halt_input(&sc->sc_i2s); 912 if (!sc->sc_playing) 913 zaudio_standby(sc); 914 sc->sc_recording = 0; 915 916 return rv; 917 } 918 919 static int 920 zaudio_getdev(void *hdl, struct audio_device *ret) 921 { 922 923 *ret = wm8750_device; 924 return 0; 925 } 926 927 #define ZAUDIO_SPKR_LVL 0 928 #define ZAUDIO_SPKR_MUTE 1 929 #define ZAUDIO_HP_LVL 2 930 #define ZAUDIO_HP_MUTE 3 931 #define ZAUDIO_MIC_LVL 4 932 #define ZAUDIO_MIC_MUTE 5 933 #define ZAUDIO_RECORD_SOURCE 6 934 #define ZAUDIO_OUTPUT_CLASS 7 935 #define ZAUDIO_INPUT_CLASS 8 936 #define ZAUDIO_RECORD_CLASS 9 937 938 static int 939 zaudio_set_port(void *hdl, struct mixer_ctrl *mc) 940 { 941 struct zaudio_softc *sc = hdl; 942 int error = EINVAL; 943 int s; 944 945 s = splbio(); 946 iic_acquire_bus(sc->sc_i2c, 0); 947 948 switch (mc->dev) { 949 case ZAUDIO_SPKR_LVL: 950 if (mc->type != AUDIO_MIXER_VALUE) 951 break; 952 if (mc->un.value.num_channels == 1) 953 sc->sc_volume[ZAUDIO_OP_SPKR].left = 954 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 955 else 956 break; 957 zaudio_update_volume(sc, ZAUDIO_OP_SPKR); 958 error = 0; 959 break; 960 961 case ZAUDIO_SPKR_MUTE: 962 if (mc->type != AUDIO_MIXER_ENUM) 963 break; 964 UNMUTE(sc, ZAUDIO_OP_SPKR, mc->un.ord ? 1 : 0); 965 zaudio_update_mutes(sc, 1); 966 error = 0; 967 break; 968 969 case ZAUDIO_HP_LVL: 970 if (mc->type != AUDIO_MIXER_VALUE) 971 break; 972 if (mc->un.value.num_channels == 1) { 973 sc->sc_volume[ZAUDIO_OP_HP].left = 974 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 975 sc->sc_volume[ZAUDIO_OP_HP].right = 976 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 977 } else if (mc->un.value.num_channels == 2) { 978 sc->sc_volume[ZAUDIO_OP_HP].left = 979 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]; 980 sc->sc_volume[ZAUDIO_OP_HP].right = 981 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]; 982 } 983 else 984 break; 985 zaudio_update_volume(sc, ZAUDIO_OP_HP); 986 error = 0; 987 break; 988 989 case ZAUDIO_HP_MUTE: 990 if (mc->type != AUDIO_MIXER_ENUM) 991 break; 992 UNMUTE(sc, ZAUDIO_OP_HP, mc->un.ord ? 1 : 0); 993 zaudio_update_mutes(sc, 1); 994 error = 0; 995 break; 996 997 case ZAUDIO_MIC_LVL: 998 if (mc->type != AUDIO_MIXER_VALUE) 999 break; 1000 if (mc->un.value.num_channels == 1) 1001 sc->sc_volume[ZAUDIO_OP_MIC].left = 1002 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO]; 1003 else 1004 break; 1005 zaudio_update_volume(sc, ZAUDIO_OP_MIC); 1006 error = 0; 1007 break; 1008 1009 case ZAUDIO_MIC_MUTE: 1010 if (mc->type != AUDIO_MIXER_ENUM) 1011 break; 1012 UNMUTE(sc, ZAUDIO_OP_MIC, mc->un.ord ? 1 : 0); 1013 zaudio_update_mutes(sc, 2); 1014 error = 0; 1015 break; 1016 1017 case ZAUDIO_RECORD_SOURCE: 1018 if (mc->type != AUDIO_MIXER_ENUM) 1019 break; 1020 if (mc->un.ord != 0) 1021 break; 1022 /* MIC only */ 1023 error = 0; 1024 break; 1025 } 1026 1027 iic_release_bus(sc->sc_i2c, 0); 1028 splx(s); 1029 1030 return error; 1031 } 1032 1033 static int 1034 zaudio_get_port(void *hdl, struct mixer_ctrl *mc) 1035 { 1036 struct zaudio_softc *sc = hdl; 1037 int error = EINVAL; 1038 1039 switch (mc->dev) { 1040 case ZAUDIO_SPKR_LVL: 1041 if (mc->type != AUDIO_MIXER_VALUE) 1042 break; 1043 if (mc->un.value.num_channels == 1) 1044 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 1045 sc->sc_volume[ZAUDIO_OP_SPKR].left; 1046 else 1047 break; 1048 error = 0; 1049 break; 1050 1051 case ZAUDIO_SPKR_MUTE: 1052 if (mc->type != AUDIO_MIXER_ENUM) 1053 break; 1054 mc->un.ord = sc->sc_unmute[ZAUDIO_OP_SPKR] ? 1 : 0; 1055 error = 0; 1056 break; 1057 1058 case ZAUDIO_HP_LVL: 1059 if (mc->type != AUDIO_MIXER_VALUE) 1060 break; 1061 if (mc->un.value.num_channels == 1) 1062 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 1063 sc->sc_volume[ZAUDIO_OP_HP].left; 1064 else if (mc->un.value.num_channels == 2) { 1065 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 1066 sc->sc_volume[ZAUDIO_OP_HP].left; 1067 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 1068 sc->sc_volume[ZAUDIO_OP_HP].right; 1069 } 1070 else 1071 break; 1072 error = 0; 1073 break; 1074 1075 case ZAUDIO_HP_MUTE: 1076 if (mc->type != AUDIO_MIXER_ENUM) 1077 break; 1078 mc->un.ord = sc->sc_unmute[ZAUDIO_OP_HP] ? 1 : 0; 1079 error = 0; 1080 break; 1081 1082 case ZAUDIO_MIC_LVL: 1083 if (mc->type != AUDIO_MIXER_VALUE) 1084 break; 1085 if (mc->un.value.num_channels == 1) 1086 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = 1087 sc->sc_volume[ZAUDIO_OP_MIC].left; 1088 else 1089 break; 1090 error = 0; 1091 break; 1092 1093 case ZAUDIO_MIC_MUTE: 1094 if (mc->type != AUDIO_MIXER_ENUM) 1095 break; 1096 mc->un.ord = sc->sc_unmute[ZAUDIO_OP_MIC] ? 1 : 0; 1097 error = 0; 1098 break; 1099 1100 case ZAUDIO_RECORD_SOURCE: 1101 if (mc->type != AUDIO_MIXER_ENUM) 1102 break; 1103 mc->un.ord = 0; /* MIC only */ 1104 error = 0; 1105 break; 1106 } 1107 1108 return error; 1109 } 1110 1111 /*ARGSUSED*/ 1112 static int 1113 zaudio_query_devinfo(void *hdl, struct mixer_devinfo *di) 1114 { 1115 1116 switch (di->index) { 1117 case ZAUDIO_SPKR_LVL: 1118 di->type = AUDIO_MIXER_VALUE; 1119 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1120 di->prev = AUDIO_MIXER_LAST; 1121 di->next = ZAUDIO_SPKR_MUTE; 1122 strlcpy(di->label.name, AudioNspeaker, sizeof(di->label.name)); 1123 strlcpy(di->un.v.units.name, AudioNvolume, 1124 sizeof(di->un.v.units.name)); 1125 di->un.v.num_channels = 1; 1126 break; 1127 1128 case ZAUDIO_SPKR_MUTE: 1129 di->type = AUDIO_MIXER_ENUM; 1130 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1131 di->prev = ZAUDIO_SPKR_LVL; 1132 di->next = AUDIO_MIXER_LAST; 1133 goto mute; 1134 1135 case ZAUDIO_HP_LVL: 1136 di->type = AUDIO_MIXER_VALUE; 1137 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1138 di->prev = AUDIO_MIXER_LAST; 1139 di->next = ZAUDIO_HP_MUTE; 1140 strlcpy(di->label.name, AudioNheadphone, 1141 sizeof(di->label.name)); 1142 di->un.v.num_channels = 1; 1143 strlcpy(di->un.v.units.name, AudioNvolume, 1144 sizeof(di->un.v.units.name)); 1145 break; 1146 1147 case ZAUDIO_HP_MUTE: 1148 di->type = AUDIO_MIXER_ENUM; 1149 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1150 di->prev = ZAUDIO_HP_LVL; 1151 di->next = AUDIO_MIXER_LAST; 1152 mute: 1153 strlcpy(di->label.name, AudioNmute, sizeof(di->label.name)); 1154 di->un.e.num_mem = 2; 1155 strlcpy(di->un.e.member[0].label.name, AudioNon, 1156 sizeof(di->un.e.member[0].label.name)); 1157 di->un.e.member[0].ord = 0; 1158 strlcpy(di->un.e.member[1].label.name, AudioNoff, 1159 sizeof(di->un.e.member[1].label.name)); 1160 di->un.e.member[1].ord = 1; 1161 break; 1162 1163 case ZAUDIO_MIC_LVL: 1164 di->type = AUDIO_MIXER_VALUE; 1165 di->mixer_class = ZAUDIO_INPUT_CLASS; 1166 di->prev = AUDIO_MIXER_LAST; 1167 di->next = ZAUDIO_MIC_MUTE; 1168 strlcpy(di->label.name, AudioNmicrophone, 1169 sizeof(di->label.name)); 1170 strlcpy(di->un.v.units.name, AudioNvolume, 1171 sizeof(di->un.v.units.name)); 1172 di->un.v.num_channels = 1; 1173 break; 1174 1175 case ZAUDIO_MIC_MUTE: 1176 di->type = AUDIO_MIXER_ENUM; 1177 di->mixer_class = ZAUDIO_INPUT_CLASS; 1178 di->prev = ZAUDIO_MIC_LVL; 1179 di->next = AUDIO_MIXER_LAST; 1180 goto mute; 1181 1182 case ZAUDIO_RECORD_SOURCE: 1183 di->type = AUDIO_MIXER_ENUM; 1184 di->mixer_class = ZAUDIO_RECORD_CLASS; 1185 di->prev = AUDIO_MIXER_LAST; 1186 di->next = AUDIO_MIXER_LAST; 1187 strlcpy(di->label.name, AudioNsource, sizeof(di->label.name)); 1188 di->un.e.num_mem = 1; 1189 strlcpy(di->un.e.member[0].label.name, AudioNmicrophone, 1190 sizeof(di->un.e.member[0].label.name)); 1191 di->un.e.member[0].ord = 0; 1192 break; 1193 1194 case ZAUDIO_OUTPUT_CLASS: 1195 di->type = AUDIO_MIXER_CLASS; 1196 di->mixer_class = ZAUDIO_OUTPUT_CLASS; 1197 di->prev = AUDIO_MIXER_LAST; 1198 di->next = AUDIO_MIXER_LAST; 1199 strlcpy(di->label.name, AudioCoutputs, sizeof(di->label.name)); 1200 break; 1201 1202 case ZAUDIO_INPUT_CLASS: 1203 di->type = AUDIO_MIXER_CLASS; 1204 di->mixer_class = ZAUDIO_INPUT_CLASS; 1205 di->prev = AUDIO_MIXER_LAST; 1206 di->next = AUDIO_MIXER_LAST; 1207 strlcpy(di->label.name, AudioCinputs, sizeof(di->label.name)); 1208 break; 1209 1210 case ZAUDIO_RECORD_CLASS: 1211 di->type = AUDIO_MIXER_CLASS; 1212 di->mixer_class = ZAUDIO_RECORD_CLASS; 1213 di->prev = AUDIO_MIXER_LAST; 1214 di->next = AUDIO_MIXER_LAST; 1215 strlcpy(di->label.name, AudioCinputs, sizeof(di->label.name)); 1216 break; 1217 1218 default: 1219 return ENXIO; 1220 } 1221 1222 return 0; 1223 } 1224 1225 static void * 1226 zaudio_allocm(void *hdl, int direction, size_t size) 1227 { 1228 struct zaudio_softc *sc = hdl; 1229 1230 return pxa2x0_i2s_allocm(&sc->sc_i2s, direction, size); 1231 } 1232 1233 static void 1234 zaudio_freem(void *hdl, void *ptr, size_t size) 1235 { 1236 struct zaudio_softc *sc = hdl; 1237 1238 return pxa2x0_i2s_freem(&sc->sc_i2s, ptr, size); 1239 } 1240 1241 static size_t 1242 zaudio_round_buffersize(void *hdl, int direction, size_t bufsize) 1243 { 1244 struct zaudio_softc *sc = hdl; 1245 1246 return pxa2x0_i2s_round_buffersize(&sc->sc_i2s, direction, bufsize); 1247 } 1248 1249 static paddr_t 1250 zaudio_mappage(void *hdl, void *mem, off_t off, int prot) 1251 { 1252 struct zaudio_softc *sc = hdl; 1253 1254 return pxa2x0_i2s_mappage(&sc->sc_i2s, mem, off, prot); 1255 } 1256 1257 static int 1258 zaudio_get_props(void *hdl) 1259 { 1260 1261 return AUDIO_PROP_MMAP|AUDIO_PROP_INDEPENDENT; 1262 } 1263 1264 static int 1265 zaudio_start_output(void *hdl, void *block, int bsize, void (*intr)(void *), 1266 void *intrarg) 1267 { 1268 struct zaudio_softc *sc = hdl; 1269 int rv; 1270 1271 /* Power up codec if we are not already playing. */ 1272 if (!sc->sc_playing) { 1273 sc->sc_playing = 1; 1274 zaudio_play_setup(sc); 1275 } 1276 1277 /* Start DMA via I2S */ 1278 rv = pxa2x0_i2s_start_output(&sc->sc_i2s, block, bsize, intr, intrarg); 1279 if (rv) { 1280 if (!sc->sc_recording) 1281 zaudio_standby(sc); 1282 sc->sc_playing = 0; 1283 } 1284 1285 return rv; 1286 } 1287 1288 static int 1289 zaudio_start_input(void *hdl, void *block, int bsize, void (*intr)(void *), 1290 void *intrarg) 1291 { 1292 struct zaudio_softc *sc = hdl; 1293 int rv; 1294 1295 /* Power up codec if we are not already recording. */ 1296 if (!sc->sc_recording) { 1297 sc->sc_recording = 1; 1298 zaudio_record_setup(sc); 1299 } 1300 1301 /* Start DMA via I2S */ 1302 rv = pxa2x0_i2s_start_input(&sc->sc_i2s, block, bsize, intr, intrarg); 1303 if (rv) { 1304 if (!sc->sc_playing) 1305 zaudio_standby(sc); 1306 sc->sc_recording = 0; 1307 } 1308 return rv; 1309 } 1310 1311 static void 1312 zaudio_get_locks(void *hdl, kmutex_t **intr, kmutex_t **thread) 1313 { 1314 struct zaudio_softc *sc = hdl; 1315 1316 *intr = &sc->sc_intr_lock; 1317 *thread = &sc->sc_lock; 1318 } 1319
Indexes created Tue Sep 30 07:10:03 GMT 2025