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