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