![[BACK]](/icons/back.gif){kind=icon}
Return to zaurus_audio.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / zaurus / dev|
Return to zaurus_audio.c CVS log | Up to [local] / sys / arch / zaurus / dev |
1.1 ! nbrk 1: /* $OpenBSD: zaurus_audio.c,v 1.8 2005/08/18 13:23:02 robert Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2005 Christopher Pascoe <pascoe@openbsd.org>
! 5: *
! 6: * Permission to use, copy, modify, and distribute this software for any
! 7: * purpose with or without fee is hereby granted, provided that the above
! 8: * copyright notice and this permission notice appear in all copies.
! 9: *
! 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 17: */
! 18:
! 19: /*
! 20: * TODO:
! 21: * - powerhooks (currently only works until first suspend)
! 22: * - record support
! 23: */
! 24:
! 25: #include <sys/param.h>
! 26: #include <sys/systm.h>
! 27: #include <sys/timeout.h>
! 28: #include <sys/device.h>
! 29: #include <sys/malloc.h>
! 30: #include <sys/kernel.h>
! 31: #include <sys/audioio.h>
! 32:
! 33: #include <machine/intr.h>
! 34: #include <machine/bus.h>
! 35:
! 36: #include <arm/xscale/pxa2x0reg.h>
! 37: #include <arm/xscale/pxa2x0var.h>
! 38: #include <arm/xscale/pxa2x0_i2c.h>
! 39: #include <arm/xscale/pxa2x0_i2s.h>
! 40: #include <arm/xscale/pxa2x0_dmac.h>
! 41: #include <arm/xscale/pxa2x0_gpio.h>
! 42:
! 43: #include <zaurus/dev/zaurus_scoopvar.h>
! 44: #include <dev/i2c/wm8750reg.h>
! 45:
! 46: #include <dev/audio_if.h>
! 47: #include <dev/mulaw.h>
! 48: #include <dev/auconv.h>
! 49:
! 50: #define WM8750_ADDRESS 0x1B
! 51: #define SPKR_VOLUME 112
! 52:
! 53: #define wm8750_write(sc, reg, val) pxa2x0_i2c_write_2(&sc->sc_i2c, \
! 54: WM8750_ADDRESS, (((reg) << 9) | ((val) & 0x1ff)))
! 55:
! 56: int zaudio_match(struct device *, void *, void *);
! 57: void zaudio_attach(struct device *, struct device *, void *);
! 58: int zaudio_detach(struct device *, int);
! 59: void zaudio_power(int, void *);
! 60:
! 61: #define ZAUDIO_OP_SPKR 0
! 62: #define ZAUDIO_OP_HP 1
! 63:
! 64: #define ZAUDIO_JACK_STATE_OUT 0
! 65: #define ZAUDIO_JACK_STATE_IN 1
! 66: #define ZAUDIO_JACK_STATE_INS 2
! 67: #define ZAUDIO_JACK_STATE_REM 3
! 68:
! 69: /* GPIO pins */
! 70: #define GPIO_HP_IN_C3000 116
! 71:
! 72: struct zaudio_volume {
! 73: u_int8_t left;
! 74: u_int8_t right;
! 75: };
! 76:
! 77: struct zaudio_softc {
! 78: struct device sc_dev;
! 79:
! 80: /* i2s device softc */
! 81: /* NB: pxa2x0_i2s requires this to be the second struct member */
! 82: struct pxa2x0_i2s_softc sc_i2s;
! 83:
! 84: /* i2c device softc */
! 85: struct pxa2x0_i2c_softc sc_i2c;
! 86:
! 87: void *sc_powerhook;
! 88: int sc_playing;
! 89:
! 90: struct zaudio_volume sc_volume[2];
! 91: char sc_unmute[2];
! 92:
! 93: int sc_state;
! 94: int sc_icount;
! 95: struct timeout sc_to;
! 96: };
! 97:
! 98: struct cfattach zaudio_ca = {
! 99: sizeof(struct zaudio_softc), zaudio_match, zaudio_attach,
! 100: zaudio_detach
! 101: };
! 102:
! 103: struct cfdriver zaudio_cd = {
! 104: NULL, "zaudio", DV_DULL
! 105: };
! 106:
! 107: struct audio_device wm8750_device = {
! 108: "WM8750",
! 109: "1.0",
! 110: "wm"
! 111: };
! 112:
! 113: void zaudio_init(struct zaudio_softc *);
! 114: int zaudio_jack_intr(void *);
! 115: void zaudio_jack(void *);
! 116: void zaudio_standby(struct zaudio_softc *);
! 117: void zaudio_update_volume(struct zaudio_softc *, int);
! 118: void zaudio_update_mutes(struct zaudio_softc *);
! 119: void zaudio_play_setup(struct zaudio_softc *);
! 120: int zaudio_open(void *, int);
! 121: void zaudio_close(void *);
! 122: int zaudio_query_encoding(void *, struct audio_encoding *);
! 123: int zaudio_set_params(void *, int, int, struct audio_params *,
! 124: struct audio_params *);
! 125: int zaudio_halt_output(void *);
! 126: int zaudio_halt_input(void *);
! 127: int zaudio_getdev(void *, struct audio_device *);
! 128: int zaudio_set_port(void *, struct mixer_ctrl *);
! 129: int zaudio_get_port(void *, struct mixer_ctrl *);
! 130: int zaudio_query_devinfo(void *, struct mixer_devinfo *);
! 131: int zaudio_get_props(void *);
! 132: int zaudio_start_output(void *, void *, int, void (*)(void *), void *);
! 133: int zaudio_start_input(void *, void *, int, void (*)(void *), void *);
! 134:
! 135: struct audio_hw_if wm8750_hw_if = {
! 136: zaudio_open,
! 137: zaudio_close,
! 138: NULL /* zaudio_drain */,
! 139: zaudio_query_encoding,
! 140: zaudio_set_params,
! 141: pxa2x0_i2s_round_blocksize,
! 142: NULL /* zaudio_commit_settings */,
! 143: NULL /* zaudio_init_output */,
! 144: NULL /* zaudio_init_input */,
! 145: zaudio_start_output,
! 146: zaudio_start_input,
! 147: zaudio_halt_output,
! 148: zaudio_halt_input,
! 149: NULL /* zaudio_speaker_ctl */,
! 150: zaudio_getdev,
! 151: NULL /* zaudio_setfd */,
! 152: zaudio_set_port,
! 153: zaudio_get_port,
! 154: zaudio_query_devinfo,
! 155: pxa2x0_i2s_allocm,
! 156: pxa2x0_i2s_freem,
! 157: pxa2x0_i2s_round_buffersize,
! 158: pxa2x0_i2s_mappage,
! 159: zaudio_get_props,
! 160: NULL /* zaudio_trigger_output */,
! 161: NULL /* zaudio_trigger_input */
! 162: };
! 163:
! 164: static const unsigned short playback_registers[][2] = {
! 165: /* Unmute DAC */
! 166: { ADCDACCTL_REG, 0x000 },
! 167:
! 168: /* 16 bit audio words */
! 169: { AUDINT_REG, AUDINT_SET_FORMAT(2) },
! 170:
! 171: /* Enable thermal protection, power */
! 172: { ADCTL1_REG, ADCTL1_TSDEN | ADCTL1_SET_VSEL(3) },
! 173:
! 174: /* Enable speaker driver, DAC oversampling */
! 175: { ADCTL2_REG, ADCTL2_ROUT2INV | ADCTL2_DACOSR },
! 176:
! 177: /* Set DAC voltage references */
! 178: { PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(1) | PWRMGMT1_VREF },
! 179:
! 180: /* Direct DACs to output mixers */
! 181: { LOUTMIX1_REG, LOUTMIX1_LD2LO },
! 182: { ROUTMIX2_REG, ROUTMIX2_RD2RO },
! 183:
! 184: /* End of list */
! 185: { 0xffff, 0xffff }
! 186: };
! 187:
! 188: int
! 189: zaudio_match(struct device *parent, void *match, void *aux)
! 190: {
! 191: return (1);
! 192: }
! 193:
! 194: void
! 195: zaudio_attach(struct device *parent, struct device *self, void *aux)
! 196: {
! 197: struct zaudio_softc *sc = (struct zaudio_softc *)self;
! 198: struct pxaip_attach_args *pxa = aux;
! 199: int err;
! 200:
! 201: sc->sc_powerhook = powerhook_establish(zaudio_power, sc);
! 202: if (sc->sc_powerhook == NULL) {
! 203: printf(": unable to establish powerhook\n");
! 204: return;
! 205: }
! 206:
! 207: sc->sc_i2s.sc_iot = pxa->pxa_iot;
! 208: sc->sc_i2s.sc_dmat = pxa->pxa_dmat;
! 209: sc->sc_i2s.sc_size = PXA2X0_I2S_SIZE;
! 210: if (pxa2x0_i2s_attach_sub(&sc->sc_i2s)) {
! 211: printf(": unable to attach I2S\n");
! 212: goto fail_i2s;
! 213: }
! 214:
! 215: sc->sc_i2c.sc_iot = pxa->pxa_iot;
! 216: sc->sc_i2c.sc_size = PXA2X0_I2C_SIZE;
! 217: if (pxa2x0_i2c_attach_sub(&sc->sc_i2c)) {
! 218: printf(": unable to attach I2C\n");
! 219: goto fail_i2c;
! 220: }
! 221:
! 222: /* Check for an I2C response from the wm8750 */
! 223: pxa2x0_i2c_open(&sc->sc_i2c);
! 224: err = wm8750_write(sc, RESET_REG, 0);
! 225: pxa2x0_i2c_close(&sc->sc_i2c);
! 226:
! 227: if (err) {
! 228: printf(": codec failed to respond\n");
! 229: goto fail_probe;
! 230: }
! 231: delay(100);
! 232:
! 233: /* Speaker on, headphones off by default. */
! 234: sc->sc_volume[ZAUDIO_OP_SPKR].left = 240;
! 235: sc->sc_unmute[ZAUDIO_OP_SPKR] = 1;
! 236: sc->sc_volume[ZAUDIO_OP_HP].left = 180;
! 237: sc->sc_volume[ZAUDIO_OP_HP].right = 180;
! 238: sc->sc_unmute[ZAUDIO_OP_HP] = 0;
! 239:
! 240: /* Configure headphone jack state change handling. */
! 241: timeout_set(&sc->sc_to, zaudio_jack, sc);
! 242: pxa2x0_gpio_set_function(GPIO_HP_IN_C3000, GPIO_IN);
! 243: (void)pxa2x0_gpio_intr_establish(GPIO_HP_IN_C3000,
! 244: IST_EDGE_BOTH, IPL_BIO, zaudio_jack_intr, sc, "hpjk");
! 245:
! 246: zaudio_init(sc);
! 247:
! 248: printf(": I2C, I2S, WM8750 Audio\n");
! 249:
! 250: audio_attach_mi(&wm8750_hw_if, sc, &sc->sc_dev);
! 251:
! 252: return;
! 253:
! 254: fail_probe:
! 255: pxa2x0_i2c_detach_sub(&sc->sc_i2c);
! 256: fail_i2c:
! 257: pxa2x0_i2s_detach_sub(&sc->sc_i2s);
! 258: fail_i2s:
! 259: powerhook_disestablish(sc->sc_powerhook);
! 260: }
! 261:
! 262: int
! 263: zaudio_detach(struct device *self, int flags)
! 264: {
! 265: struct zaudio_softc *sc = (struct zaudio_softc *)self;
! 266:
! 267: if (sc->sc_powerhook != NULL) {
! 268: powerhook_disestablish(sc->sc_powerhook);
! 269: sc->sc_powerhook = NULL;
! 270: }
! 271:
! 272: pxa2x0_i2c_detach_sub(&sc->sc_i2c);
! 273: pxa2x0_i2s_detach_sub(&sc->sc_i2s);
! 274:
! 275: return (0);
! 276: }
! 277:
! 278: void
! 279: zaudio_power(int why, void *arg)
! 280: {
! 281: struct zaudio_softc *sc = arg;
! 282:
! 283: switch (why) {
! 284: case PWR_STANDBY:
! 285: case PWR_SUSPEND:
! 286: timeout_del(&sc->sc_to);
! 287: zaudio_standby(sc);
! 288: break;
! 289:
! 290: case PWR_RESUME:
! 291: pxa2x0_i2s_init(&sc->sc_i2s);
! 292: pxa2x0_i2c_init(&sc->sc_i2c);
! 293: zaudio_init(sc);
! 294: break;
! 295: }
! 296: }
! 297:
! 298: void
! 299: zaudio_init(struct zaudio_softc *sc)
! 300: {
! 301: pxa2x0_i2c_open(&sc->sc_i2c);
! 302:
! 303: /* Reset the codec */
! 304: wm8750_write(sc, RESET_REG, 0);
! 305: delay(100);
! 306:
! 307: /* Switch to standby power only */
! 308: wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2));
! 309: wm8750_write(sc, PWRMGMT2_REG, 0);
! 310:
! 311: /* Configure digital interface for I2S */
! 312: wm8750_write(sc, AUDINT_REG, AUDINT_SET_FORMAT(2));
! 313:
! 314: /* Initialise volume levels */
! 315: zaudio_update_volume(sc, ZAUDIO_OP_SPKR);
! 316: zaudio_update_volume(sc, ZAUDIO_OP_HP);
! 317: scoop_set_headphone(0);
! 318:
! 319: pxa2x0_i2c_close(&sc->sc_i2c);
! 320:
! 321: /* Assume that the jack state has changed. */
! 322: zaudio_jack(sc);
! 323:
! 324: }
! 325:
! 326: int
! 327: zaudio_jack_intr(void *v)
! 328: {
! 329: struct zaudio_softc *sc = v;
! 330:
! 331: if (!timeout_triggered(&sc->sc_to))
! 332: zaudio_jack(sc);
! 333:
! 334: return (1);
! 335: }
! 336:
! 337: void
! 338: zaudio_jack(void *v)
! 339: {
! 340: struct zaudio_softc *sc = v;
! 341:
! 342: switch (sc->sc_state) {
! 343: case ZAUDIO_JACK_STATE_OUT:
! 344: if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) {
! 345: sc->sc_state = ZAUDIO_JACK_STATE_INS;
! 346: sc->sc_icount = 0;
! 347: }
! 348: break;
! 349: case ZAUDIO_JACK_STATE_INS:
! 350: if (sc->sc_icount++ > 2) {
! 351: if (pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) {
! 352: sc->sc_state = ZAUDIO_JACK_STATE_IN;
! 353: sc->sc_unmute[ZAUDIO_OP_SPKR] = 0;
! 354: sc->sc_unmute[ZAUDIO_OP_HP] = 1;
! 355: goto update_mutes;
! 356: } else
! 357: sc->sc_state = ZAUDIO_JACK_STATE_OUT;
! 358: }
! 359: break;
! 360: case ZAUDIO_JACK_STATE_IN:
! 361: if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) {
! 362: sc->sc_state = ZAUDIO_JACK_STATE_REM;
! 363: sc->sc_icount = 0;
! 364: }
! 365: break;
! 366: case ZAUDIO_JACK_STATE_REM:
! 367: if (sc->sc_icount++ > 2) {
! 368: if (!pxa2x0_gpio_get_bit(GPIO_HP_IN_C3000)) {
! 369: sc->sc_state = ZAUDIO_JACK_STATE_OUT;
! 370: sc->sc_unmute[ZAUDIO_OP_SPKR] = 1;
! 371: sc->sc_unmute[ZAUDIO_OP_HP] = 0;
! 372: goto update_mutes;
! 373: } else
! 374: sc->sc_state = ZAUDIO_JACK_STATE_IN;
! 375: }
! 376: break;
! 377: }
! 378:
! 379: timeout_add(&sc->sc_to, hz/4);
! 380: return;
! 381:
! 382: update_mutes:
! 383: timeout_del(&sc->sc_to);
! 384:
! 385: if (sc->sc_playing) {
! 386: pxa2x0_i2c_open(&sc->sc_i2c);
! 387: zaudio_update_mutes(sc);
! 388: pxa2x0_i2c_close(&sc->sc_i2c);
! 389: }
! 390: }
! 391:
! 392: void
! 393: zaudio_standby(struct zaudio_softc *sc)
! 394: {
! 395: pxa2x0_i2c_open(&sc->sc_i2c);
! 396:
! 397: /* Switch codec to standby power only */
! 398: wm8750_write(sc, PWRMGMT1_REG, PWRMGMT1_SET_VMIDSEL(2));
! 399: wm8750_write(sc, PWRMGMT2_REG, 0);
! 400:
! 401: scoop_set_headphone(0);
! 402:
! 403: pxa2x0_i2c_close(&sc->sc_i2c);
! 404: }
! 405:
! 406: void
! 407: zaudio_update_volume(struct zaudio_softc *sc, int output)
! 408: {
! 409: switch(output) {
! 410: case ZAUDIO_OP_SPKR:
! 411: wm8750_write(sc, LOUT2VOL_REG, LOUT2VOL_LO2VU | LOUT2VOL_LO2ZC |
! 412: LOUT2VOL_SET_LOUT2VOL(sc->sc_volume[ZAUDIO_OP_SPKR
! 413: ].left >> 1));
! 414: wm8750_write(sc, ROUT2VOL_REG, ROUT2VOL_RO2VU | ROUT2VOL_RO2ZC |
! 415: ROUT2VOL_SET_ROUT2VOL(sc->sc_volume[ZAUDIO_OP_SPKR
! 416: ].left >> 1));
! 417: break;
! 418: case ZAUDIO_OP_HP:
! 419: wm8750_write(sc, LOUT1VOL_REG, LOUT1VOL_LO1VU | LOUT1VOL_LO1ZC |
! 420: LOUT1VOL_SET_LOUT1VOL(sc->sc_volume[ZAUDIO_OP_HP
! 421: ].left >> 1));
! 422: wm8750_write(sc, ROUT1VOL_REG, ROUT1VOL_RO1VU | ROUT1VOL_RO1ZC |
! 423: ROUT1VOL_SET_ROUT1VOL(sc->sc_volume[ZAUDIO_OP_HP
! 424: ].right >> 1));
! 425: break;
! 426: }
! 427: }
! 428:
! 429: void
! 430: zaudio_update_mutes(struct zaudio_softc *sc)
! 431: {
! 432: unsigned short val;
! 433:
! 434: val = PWRMGMT2_DACL | PWRMGMT2_DACR;
! 435:
! 436: if (sc->sc_unmute[ZAUDIO_OP_SPKR])
! 437: val |= PWRMGMT2_LOUT2 | PWRMGMT2_ROUT2;
! 438:
! 439: if (sc->sc_unmute[ZAUDIO_OP_HP])
! 440: val |= PWRMGMT2_LOUT1 | PWRMGMT2_ROUT1;
! 441:
! 442: wm8750_write(sc, PWRMGMT2_REG, val);
! 443:
! 444: scoop_set_headphone(sc->sc_unmute[ZAUDIO_OP_HP]);
! 445: }
! 446:
! 447: void
! 448: zaudio_play_setup(struct zaudio_softc *sc)
! 449: {
! 450: int i = 0;
! 451:
! 452: pxa2x0_i2c_open(&sc->sc_i2c);
! 453:
! 454: /* Program the codec with playback settings */
! 455: while (playback_registers[i][0] != 0xffff) {
! 456: wm8750_write(sc, playback_registers[i][0],
! 457: playback_registers[i][1]);
! 458: i++;
! 459: }
! 460: zaudio_update_mutes(sc);
! 461:
! 462: pxa2x0_i2c_close(&sc->sc_i2c);
! 463: }
! 464:
! 465: int
! 466: zaudio_open(void *hdl, int flags)
! 467: {
! 468: struct zaudio_softc *sc = hdl;
! 469:
! 470: /* Power on the I2S bus and codec */
! 471: pxa2x0_i2s_open(&sc->sc_i2s);
! 472:
! 473: return 0;
! 474: }
! 475:
! 476: void
! 477: zaudio_close(void *hdl)
! 478: {
! 479: struct zaudio_softc *sc = hdl;
! 480:
! 481: /* Power off the I2S bus and codec */
! 482: pxa2x0_i2s_close(&sc->sc_i2s);
! 483: }
! 484:
! 485: int
! 486: zaudio_query_encoding(void *hdl, struct audio_encoding *aep)
! 487: {
! 488: switch (aep->index) {
! 489: case 0:
! 490: strlcpy(aep->name, AudioEulinear, sizeof(aep->name));
! 491: aep->encoding = AUDIO_ENCODING_ULINEAR;
! 492: aep->precision = 8;
! 493: aep->flags = 0;
! 494: return (0);
! 495: case 1:
! 496: strlcpy(aep->name, AudioEmulaw, sizeof(aep->name));
! 497: aep->encoding = AUDIO_ENCODING_ULAW;
! 498: aep->precision = 8;
! 499: aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 500: return (0);
! 501: case 2:
! 502: strlcpy(aep->name, AudioEalaw, sizeof(aep->name));
! 503: aep->encoding = AUDIO_ENCODING_ALAW;
! 504: aep->precision = 8;
! 505: aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 506: return (0);
! 507: case 3:
! 508: strlcpy(aep->name, AudioEslinear, sizeof(aep->name));
! 509: aep->encoding = AUDIO_ENCODING_SLINEAR;
! 510: aep->precision = 8;
! 511: aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 512: return (0);
! 513: case 4:
! 514: strlcpy(aep->name, AudioEslinear_le, sizeof(aep->name));
! 515: aep->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 516: aep->precision = 16;
! 517: aep->flags = 0;
! 518: return (0);
! 519: case 5:
! 520: strlcpy(aep->name, AudioEulinear_le, sizeof(aep->name));
! 521: aep->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 522: aep->precision = 16;
! 523: aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 524: return (0);
! 525: case 6:
! 526: strlcpy(aep->name, AudioEslinear_be, sizeof(aep->name));
! 527: aep->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 528: aep->precision = 16;
! 529: aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 530: return (0);
! 531: case 7:
! 532: strlcpy(aep->name, AudioEulinear_be, sizeof(aep->name));
! 533: aep->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 534: aep->precision = 16;
! 535: aep->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 536: return (0);
! 537: default:
! 538: return (EINVAL);
! 539: }
! 540: }
! 541:
! 542: int
! 543: zaudio_set_params(void *hdl, int setmode, int usemode,
! 544: struct audio_params *play, struct audio_params *rec)
! 545: {
! 546: struct zaudio_softc *sc = hdl;
! 547:
! 548: if (setmode & AUMODE_PLAY) {
! 549: play->factor = 1;
! 550: play->sw_code = NULL;
! 551: switch(play->encoding) {
! 552: case AUDIO_ENCODING_ULAW:
! 553: switch (play->channels) {
! 554: case 1:
! 555: play->factor = 4;
! 556: play->sw_code = mulaw_to_slinear16_mts;
! 557: break;
! 558: case 2:
! 559: play->factor = 2;
! 560: play->sw_code = mulaw_to_slinear16;
! 561: break;
! 562: default:
! 563: return (EINVAL);
! 564: }
! 565: break;
! 566: case AUDIO_ENCODING_SLINEAR_LE:
! 567: switch (play->precision) {
! 568: case 8:
! 569: switch (play->channels) {
! 570: case 1:
! 571: play->factor = 4;
! 572: play->sw_code = linear8_to_linear16_mts;
! 573: break;
! 574: case 2:
! 575: play->factor = 2;
! 576: play->sw_code = linear8_to_linear16;
! 577: break;
! 578: default:
! 579: return (EINVAL);
! 580: }
! 581: break;
! 582: case 16:
! 583: switch (play->channels) {
! 584: case 1:
! 585: play->factor = 2;
! 586: play->sw_code = noswap_bytes_mts;
! 587: break;
! 588: case 2:
! 589: break;
! 590: default:
! 591: return (EINVAL);
! 592: }
! 593: break;
! 594: default:
! 595: return (EINVAL);
! 596: }
! 597: break;
! 598: case AUDIO_ENCODING_ULINEAR_LE:
! 599: switch (play->precision) {
! 600: case 8:
! 601: switch (play->channels) {
! 602: case 1:
! 603: play->factor = 4;
! 604: play->sw_code =
! 605: ulinear8_to_linear16_mts;
! 606: break;
! 607: case 2:
! 608: play->factor = 2;
! 609: play->sw_code = ulinear8_to_linear16;
! 610: break;
! 611: default:
! 612: return (EINVAL);
! 613: }
! 614: break;
! 615: case 16:
! 616: switch (play->channels) {
! 617: case 1:
! 618: play->factor = 2;
! 619: play->sw_code = change_sign16_mts;
! 620: break;
! 621: case 2:
! 622: play->sw_code = change_sign16;
! 623: break;
! 624: default:
! 625: return (EINVAL);
! 626: }
! 627: break;
! 628: default:
! 629: return (EINVAL);
! 630: }
! 631: break;
! 632: case AUDIO_ENCODING_ALAW:
! 633: switch (play->channels) {
! 634: case 1:
! 635: play->factor = 4;
! 636: play->sw_code = alaw_to_slinear16_mts;
! 637: case 2:
! 638: play->factor = 2;
! 639: play->sw_code = alaw_to_slinear16;
! 640: default:
! 641: return (EINVAL);
! 642: }
! 643: break;
! 644: case AUDIO_ENCODING_SLINEAR_BE:
! 645: switch (play->precision) {
! 646: case 8:
! 647: switch (play->channels) {
! 648: case 1:
! 649: play->factor = 4;
! 650: play->sw_code =
! 651: linear8_to_linear16_mts;
! 652: break;
! 653: case 2:
! 654: play->factor = 2;
! 655: play->sw_code = linear8_to_linear16;
! 656: break;
! 657: default:
! 658: return (EINVAL);
! 659: }
! 660: break;
! 661: case 16:
! 662: switch (play->channels) {
! 663: case 1:
! 664: play->factor = 2;
! 665: play->sw_code = swap_bytes_mts;
! 666: break;
! 667: case 2:
! 668: play->sw_code = swap_bytes;
! 669: break;
! 670: default:
! 671: return (EINVAL);
! 672: }
! 673: break;
! 674: default:
! 675: return (EINVAL);
! 676: }
! 677: break;
! 678: case AUDIO_ENCODING_ULINEAR_BE:
! 679: switch (play->precision) {
! 680: case 8:
! 681: switch (play->channels) {
! 682: case 1:
! 683: play->factor = 4;
! 684: play->sw_code =
! 685: ulinear8_to_linear16_mts;
! 686: break;
! 687: case 2:
! 688: play->factor = 2;
! 689: play->sw_code = ulinear8_to_linear16;
! 690: break;
! 691: default:
! 692: return (EINVAL);
! 693: }
! 694: break;
! 695: case 16:
! 696: switch (play->channels) {
! 697: case 1:
! 698: play->factor = 2;
! 699: play->sw_code =
! 700: change_sign16_swap_bytes_mts;
! 701: break;
! 702: case 2:
! 703: play->sw_code =
! 704: change_sign16_swap_bytes;
! 705: break;
! 706: default:
! 707: return (EINVAL);
! 708: }
! 709: break;
! 710: default:
! 711: return (EINVAL);
! 712: }
! 713: break;
! 714: default:
! 715: return (EINVAL);
! 716: }
! 717:
! 718: pxa2x0_i2s_setspeed(&sc->sc_i2s, &play->sample_rate);
! 719: }
! 720:
! 721: #if RECORD_XXX_NOT_YET
! 722: if (setmode & AUMODE_RECORD) {
! 723: rec->factor = 1;
! 724: rec->sw_code = NULL;
! 725: switch(rec->encoding) {
! 726: case AUDIO_ENCODING_ULAW:
! 727: rec->sw_code = ulinear8_to_mulaw;
! 728: break;
! 729: case AUDIO_ENCODING_SLINEAR_LE:
! 730: if (rec->precision == 8)
! 731: rec->sw_code = change_sign8;
! 732: break;
! 733: case AUDIO_ENCODING_ULINEAR_LE:
! 734: if (rec->precision == 16)
! 735: rec->sw_code = change_sign16;
! 736: break;
! 737: case AUDIO_ENCODING_ALAW:
! 738: rec->sw_code = ulinear8_to_alaw;
! 739: break;
! 740: case AUDIO_ENCODING_SLINEAR_BE:
! 741: if (rec->precision == 16)
! 742: rec->sw_code = swap_bytes;
! 743: else
! 744: rec->sw_code = change_sign8;
! 745: break;
! 746: case AUDIO_ENCODING_ULINEAR_BE:
! 747: if (rec->precision == 16)
! 748: rec->sw_code = swap_bytes_change_sign16;
! 749: break;
! 750: default:
! 751: return (EINVAL);
! 752: }
! 753:
! 754: pxa2x0_i2s_setspeed(sc, &rec->sample_rate);
! 755: }
! 756: #endif
! 757:
! 758: return (0);
! 759: }
! 760:
! 761: int
! 762: zaudio_halt_output(void *hdl)
! 763: {
! 764: struct zaudio_softc *sc = hdl;
! 765:
! 766: /* XXX forcibly stop output DMA? */
! 767:
! 768: zaudio_standby(sc);
! 769: sc->sc_playing = 0;
! 770:
! 771: return 0;
! 772: }
! 773:
! 774: int
! 775: zaudio_halt_input(void *hdl)
! 776: {
! 777: /* struct zaudio_softc *sc = hdl; */
! 778:
! 779: return 0;
! 780: }
! 781:
! 782: int
! 783: zaudio_getdev(void *hdl, struct audio_device *ret)
! 784: {
! 785: /* struct zaudio_softc *sc = hdl; */
! 786:
! 787: *ret = wm8750_device;
! 788: return 0;
! 789: }
! 790:
! 791: #define ZAUDIO_SPKR_LVL 0
! 792: #define ZAUDIO_SPKR_MUTE 1
! 793: #define ZAUDIO_HP_LVL 2
! 794: #define ZAUDIO_HP_MUTE 3
! 795: #define ZAUDIO_OUTPUT_CLASS 4
! 796:
! 797: int
! 798: zaudio_set_port(void *hdl, struct mixer_ctrl *mc)
! 799: {
! 800: struct zaudio_softc *sc = hdl;
! 801: int error = EINVAL, s;
! 802:
! 803: s = splbio();
! 804: pxa2x0_i2c_open(&sc->sc_i2c);
! 805:
! 806: switch (mc->dev) {
! 807: case ZAUDIO_SPKR_LVL:
! 808: if (mc->type != AUDIO_MIXER_VALUE)
! 809: break;
! 810: if (mc->un.value.num_channels == 1)
! 811: sc->sc_volume[ZAUDIO_OP_SPKR].left =
! 812: mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 813: else
! 814: break;
! 815: zaudio_update_volume(sc, ZAUDIO_OP_SPKR);
! 816: error = 0;
! 817: break;
! 818: case ZAUDIO_SPKR_MUTE:
! 819: if (mc->type != AUDIO_MIXER_ENUM)
! 820: break;
! 821: sc->sc_unmute[ZAUDIO_OP_SPKR] = mc->un.ord ? 1 : 0;
! 822: zaudio_update_mutes(sc);
! 823: error = 0;
! 824: break;
! 825: case ZAUDIO_HP_LVL:
! 826: if (mc->type != AUDIO_MIXER_VALUE)
! 827: break;
! 828: if (mc->un.value.num_channels == 1) {
! 829: sc->sc_volume[ZAUDIO_OP_HP].left =
! 830: mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 831: sc->sc_volume[ZAUDIO_OP_HP].right =
! 832: mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 833: } else if (mc->un.value.num_channels == 2) {
! 834: sc->sc_volume[ZAUDIO_OP_HP].left =
! 835: mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
! 836: sc->sc_volume[ZAUDIO_OP_HP].right =
! 837: mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
! 838: }
! 839: else
! 840: break;
! 841: zaudio_update_volume(sc, ZAUDIO_OP_HP);
! 842: error = 0;
! 843: break;
! 844: case ZAUDIO_HP_MUTE:
! 845: if (mc->type != AUDIO_MIXER_ENUM)
! 846: break;
! 847: sc->sc_unmute[ZAUDIO_OP_HP] = mc->un.ord ? 1 : 0;
! 848: zaudio_update_mutes(sc);
! 849: error = 0;
! 850: break;
! 851: }
! 852:
! 853: pxa2x0_i2c_close(&sc->sc_i2c);
! 854: splx(s);
! 855:
! 856: return error;
! 857: }
! 858:
! 859: int
! 860: zaudio_get_port(void *hdl, struct mixer_ctrl *mc)
! 861: {
! 862: struct zaudio_softc *sc = hdl;
! 863: int error = EINVAL;
! 864:
! 865: switch (mc->dev) {
! 866: case ZAUDIO_SPKR_LVL:
! 867: if (mc->type != AUDIO_MIXER_VALUE)
! 868: break;
! 869: if (mc->un.value.num_channels == 1)
! 870: mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 871: sc->sc_volume[ZAUDIO_OP_SPKR].left;
! 872: else
! 873: break;
! 874: error = 0;
! 875: break;
! 876: case ZAUDIO_SPKR_MUTE:
! 877: if (mc->type != AUDIO_MIXER_ENUM)
! 878: break;
! 879: mc->un.ord = sc->sc_unmute[ZAUDIO_OP_SPKR] ? 1 : 0;
! 880: error = 0;
! 881: break;
! 882: case ZAUDIO_HP_LVL:
! 883: if (mc->type != AUDIO_MIXER_VALUE)
! 884: break;
! 885: if (mc->un.value.num_channels == 1)
! 886: mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 887: sc->sc_volume[ZAUDIO_OP_HP].left;
! 888: else if (mc->un.value.num_channels == 2) {
! 889: mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 890: sc->sc_volume[ZAUDIO_OP_HP].left;
! 891: mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 892: sc->sc_volume[ZAUDIO_OP_HP].right;
! 893: }
! 894: else
! 895: break;
! 896: error = 0;
! 897: break;
! 898: case ZAUDIO_HP_MUTE:
! 899: if (mc->type != AUDIO_MIXER_ENUM)
! 900: break;
! 901: mc->un.ord = sc->sc_unmute[ZAUDIO_OP_HP] ? 1 : 0;
! 902: error = 0;
! 903: break;
! 904: }
! 905:
! 906: return error;
! 907: }
! 908:
! 909: int
! 910: zaudio_query_devinfo(void *hdl, struct mixer_devinfo *di)
! 911: {
! 912: /* struct zaudio_softc *sc = hdl; */
! 913:
! 914: switch (di->index) {
! 915: case ZAUDIO_SPKR_LVL:
! 916: di->type = AUDIO_MIXER_VALUE;
! 917: di->mixer_class = ZAUDIO_OUTPUT_CLASS;
! 918: di->prev = AUDIO_MIXER_LAST;
! 919: di->next = ZAUDIO_SPKR_MUTE;
! 920: strlcpy(di->label.name, AudioNspeaker,
! 921: sizeof(di->label.name));
! 922: strlcpy(di->un.v.units.name, AudioNvolume,
! 923: sizeof(di->un.v.units.name));
! 924: di->un.v.num_channels = 1;
! 925: break;
! 926: case ZAUDIO_SPKR_MUTE:
! 927: di->type = AUDIO_MIXER_ENUM;
! 928: di->mixer_class = ZAUDIO_OUTPUT_CLASS;
! 929: di->prev = ZAUDIO_SPKR_LVL;
! 930: di->next = AUDIO_MIXER_LAST;
! 931: goto mute;
! 932: case ZAUDIO_HP_LVL:
! 933: di->type = AUDIO_MIXER_VALUE;
! 934: di->mixer_class = ZAUDIO_OUTPUT_CLASS;
! 935: di->prev = AUDIO_MIXER_LAST;
! 936: di->next = ZAUDIO_HP_MUTE;
! 937: strlcpy(di->label.name, AudioNheadphone,
! 938: sizeof(di->label.name));
! 939: di->un.v.num_channels = 1;
! 940: strlcpy(di->un.v.units.name, AudioNvolume,
! 941: sizeof(di->un.v.units.name));
! 942: break;
! 943: case ZAUDIO_HP_MUTE:
! 944: di->type = AUDIO_MIXER_ENUM;
! 945: di->mixer_class = ZAUDIO_OUTPUT_CLASS;
! 946: di->prev = ZAUDIO_HP_LVL;
! 947: di->next = AUDIO_MIXER_LAST;
! 948: mute:
! 949: strlcpy(di->label.name, AudioNmute, sizeof(di->label.name));
! 950: di->un.e.num_mem = 2;
! 951: strlcpy(di->un.e.member[0].label.name, AudioNon,
! 952: sizeof(di->un.e.member[0].label.name));
! 953: di->un.e.member[0].ord = 0;
! 954: strlcpy(di->un.e.member[1].label.name, AudioNoff,
! 955: sizeof(di->un.e.member[1].label.name));
! 956: di->un.e.member[1].ord = 1;
! 957: break;
! 958: case ZAUDIO_OUTPUT_CLASS:
! 959: di->type = AUDIO_MIXER_CLASS;
! 960: di->mixer_class = ZAUDIO_OUTPUT_CLASS;
! 961: di->prev = AUDIO_MIXER_LAST;
! 962: di->next = AUDIO_MIXER_LAST;
! 963: strlcpy(di->label.name, AudioCoutputs,
! 964: sizeof(di->label.name));
! 965: break;
! 966: default:
! 967: return ENXIO;
! 968: }
! 969:
! 970: return 0;
! 971: }
! 972:
! 973: int
! 974: zaudio_get_props(void *hdl)
! 975: {
! 976: return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
! 977: }
! 978:
! 979: int
! 980: zaudio_start_output(void *hdl, void *block, int bsize, void (*intr)(void *),
! 981: void *intrarg)
! 982: {
! 983: struct zaudio_softc *sc = hdl;
! 984: int err;
! 985:
! 986: /* Power up codec if we are not already playing. */
! 987: if (!sc->sc_playing) {
! 988: sc->sc_playing = 1;
! 989: zaudio_play_setup(sc);
! 990: }
! 991:
! 992: /* Start DMA via I2S */
! 993: err = pxa2x0_i2s_start_output(&sc->sc_i2s, block, bsize, intr, intrarg);
! 994: if (err) {
! 995: zaudio_standby(sc);
! 996: sc->sc_playing = 0;
! 997: }
! 998: return err;
! 999: }
! 1000:
! 1001: int
! 1002: zaudio_start_input(void *hdl, void *block, int bsize, void (*intr)(void *),
! 1003: void *intrarg)
! 1004: {
! 1005: return ENXIO;
! 1006: }