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